Add files using upload-large-folder tool

.gitattributes

@@ -153,3 +153,32 @@ comfyui_layerstyle/image/icmask_example.jpg filter=lfs diff=lfs merge=lfs -text
 comfyui_layerstyle/image/if_example.jpg filter=lfs diff=lfs merge=lfs -text
 comfyui_layerstyle/image/image_auto_crop_v2_node.jpg filter=lfs diff=lfs merge=lfs -text
 comfyui_layerstyle/image/image_auto_crop_example.jpg filter=lfs diff=lfs merge=lfs -text
+comfyui_layerstyle/image/image_auto_crop_v3_node.jpg filter=lfs diff=lfs merge=lfs -text
+comfyui_layerstyle/image/image_auto_crop_node.jpg filter=lfs diff=lfs merge=lfs -text
+comfyui_layerstyle/image/image_blend_advance_node.jpg filter=lfs diff=lfs merge=lfs -text
+comfyui_layerstyle/image/image_blend_example.jpg filter=lfs diff=lfs merge=lfs -text
+comfyui_layerstyle/image/image_blend_advance_example.jpg filter=lfs diff=lfs merge=lfs -text
+comfyui_layerstyle/image/image_shift_node.jpg filter=lfs diff=lfs merge=lfs -text
+comfyui_layerstyle/image/image_scale_restore_example.jpg filter=lfs diff=lfs merge=lfs -text
+comfyui_layerstyle/image/image_shift_example.jpg filter=lfs diff=lfs merge=lfs -text
+comfyui_layerstyle/image/image_tagger_save_example.jpg filter=lfs diff=lfs merge=lfs -text
+comfyui_layerstyle/image/image_to_mask_example.jpg filter=lfs diff=lfs merge=lfs -text
+comfyui_layerstyle/image/image_mask_scale_as_v2_example.jpg filter=lfs diff=lfs merge=lfs -text
+comfyui_layerstyle/image/image_mask_scale_as_v2_node.jpg filter=lfs diff=lfs merge=lfs -text
+comfyui_layerstyle/image/image_reel_composit_node.jpg filter=lfs diff=lfs merge=lfs -text
+comfyui_layerstyle/image/image_remove_alpha_example.jpg filter=lfs diff=lfs merge=lfs -text
+comfyui_layerstyle/image/image_reel_example.jpg filter=lfs diff=lfs merge=lfs -text
+comfyui_layerstyle/image/layerutility_nodes.jpg filter=lfs diff=lfs merge=lfs -text
+comfyui_layerstyle/image/image_scale_by_aspect_ratio_example.jpg filter=lfs diff=lfs merge=lfs -text
+comfyui_layerstyle/image/layer_image_transform_example.jpg filter=lfs diff=lfs merge=lfs -text
+comfyui_layerstyle/image/layerstyle_nodes.jpg filter=lfs diff=lfs merge=lfs -text
+comfyui_layerstyle/image/layerstyle_title.jpg filter=lfs diff=lfs merge=lfs -text
+comfyui_layerstyle/image/layer_image_transform_node.jpg filter=lfs diff=lfs merge=lfs -text
+comfyui_layerstyle/image/layer_mask_transform_node.jpg filter=lfs diff=lfs merge=lfs -text
+comfyui_layerstyle/image/levels_example.jpg filter=lfs diff=lfs merge=lfs -text
+comfyui_layerstyle/image/inner_glow_example.jpg filter=lfs diff=lfs merge=lfs -text
+comfyui_layerstyle/image/light_leak_example.jpg filter=lfs diff=lfs merge=lfs -text
+comfyui_layerstyle/image/inner_shadow_example.jpg filter=lfs diff=lfs merge=lfs -text
+comfyui_layerstyle/image/layercolor_title.jpg filter=lfs diff=lfs merge=lfs -text
+comfyui_layerstyle/image/layermask_nodes.jpg filter=lfs diff=lfs merge=lfs -text
+comfyui_layerstyle/image/layerfilter_nodes.jpg filter=lfs diff=lfs merge=lfs -text

comfyui_layerstyle/py/image_hub.py

@@ -0,0 +1,152 @@
+import torch
+import random
+from .imagefunc import log
+
+
+
+class ImageHub:
+
+    def __init__(self):
+        self.NODE_NAME = 'ImageHub'
+
+    @classmethod
+    def INPUT_TYPES(self):
+
+        return {
+            "required": {
+                "output":  ("INT", {"default": 1, "min": 1, "max": 9, "step": 1}),
+                "random_output": ("BOOLEAN", {"default": False}),
+            },
+            "optional": {
+                "input1_image": ("IMAGE",),
+                "input1_mask": ("MASK",),
+                "input2_image": ("IMAGE",),
+                "input2_mask": ("MASK",),
+                "input3_image": ("IMAGE",),
+                "input3_mask": ("MASK",),
+                "input4_image": ("IMAGE",),
+                "input4_mask": ("MASK",),
+                "input5_image": ("IMAGE",),
+                "input5_mask": ("MASK",),
+                "input6_image": ("IMAGE",),
+                "input6_mask": ("MASK",),
+                "input7_image": ("IMAGE",),
+                "input7_mask": ("MASK",),
+                "input8_image": ("IMAGE",),
+                "input8_mask": ("MASK",),
+                "input9_image": ("IMAGE",),
+                "input9_mask": ("MASK",),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE", "MASK",)
+    RETURN_NAMES = ("image", "mask")
+    FUNCTION = 'image_hub'
+    CATEGORY = '😺dzNodes/LayerUtility'
+
+    def image_hub(self, output, random_output,
+                  input1_image=None, input1_mask=None,
+                  input2_image=None, input2_mask=None,
+                  input3_image=None, input3_mask=None,
+                  input4_image=None, input4_mask=None,
+                  input5_image=None, input5_mask=None,
+                  input6_image=None, input6_mask=None,
+                  input7_image=None, input7_mask=None,
+                  input8_image=None, input8_mask=None,
+                  input9_image=None, input9_mask=None,
+                  ):
+
+        output_list = []
+        if input1_image is not None or input1_mask is not None:
+            output_list.append(1)
+        if input2_image is not None or input2_mask is not None:
+            output_list.append(2)
+        if input3_image is not None or input3_mask is not None:
+            output_list.append(3)
+        if input4_image is not None or input4_mask is not None:
+            output_list.append(4)
+        if input5_image is not None or input5_mask is not None:
+            output_list.append(5)
+        if input6_image is not None or input6_mask is not None:
+            output_list.append(6)
+        if input7_image is not None or input7_mask is not None:
+            output_list.append(7)
+        if input8_image is not None or input8_mask is not None:
+            output_list.append(8)
+        if input9_image is not None or input9_mask is not None:
+            output_list.append(9)
+
+        log(f"output_list={output_list}")
+        if len(output_list) == 0:
+            log(f"{self.NODE_NAME} is skip, because No Input.", message_type='error')
+            return (None, None)
+
+        if random_output:
+            index = random.randint(1, len(output_list))
+            output = output_list[index - 1]
+
+        ret_image = None
+        ret_mask = None
+        if output == 1:
+            if input1_image is not None:
+                ret_image = input1_image
+            if input1_mask is not None:
+                ret_mask = input1_mask
+        elif output == 2:
+            if input2_image is not None:
+                ret_image = input2_image
+            if input2_mask is not None:
+                ret_mask = input2_mask
+        elif output == 3:
+            if input3_image is not None:
+                ret_image = input3_image
+            if input3_mask is not None:
+                ret_mask = input3_mask
+        elif output == 4:
+            if input4_image is not None:
+                ret_image = input4_image
+            if input4_mask is not None:
+                ret_mask = input4_mask
+        elif output == 5:
+            if input5_image is not None:
+                ret_image = input5_image
+            if input5_mask is not None:
+                ret_mask = input5_mask
+        elif output == 6:
+            if input6_image is not None:
+                ret_image = input6_image
+            if input6_mask is not None:
+                ret_mask = input6_mask
+        elif output == 7:
+            if input7_image is not None:
+                ret_image = input7_image
+            if input7_mask is not None:
+                ret_mask = input7_mask
+        elif output == 8:
+            if input8_image is not None:
+                ret_image = input8_image
+            if input8_mask is not None:
+                ret_mask = input8_mask
+        else:
+            if input9_image is not None:
+                ret_image = input9_image
+            if input9_mask is not None:
+                ret_mask = input9_mask
+
+        if ret_image is None and ret_mask is None:
+            log(f"{self.NODE_NAME} have {output_list} inputs, output is {output}, but there is no corresponding input.", message_type="error")
+        elif ret_image is None:
+            log(f"{self.NODE_NAME} have {output_list} inputs, output is {output}, but image is None.", message_type='finish')
+        elif ret_mask is None:
+            log(f"{self.NODE_NAME} have {output_list} inputs, output is {output}, but mask is None.", message_type='finish')
+        else:
+            log(f"{self.NODE_NAME} have {output_list} inputs, output is {output}.", message_type='finish')
+
+        return (ret_image, ret_mask)
+NODE_CLASS_MAPPINGS = {
+    "LayerUtility: ImageHub": ImageHub
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "LayerUtility: ImageHub": "LayerUtility: ImageHub"
+}

comfyui_layerstyle/py/image_mask_scale_as.py

@@ -0,0 +1,189 @@
+import torch
+from PIL import Image
+from .imagefunc import AnyType, log, tensor2pil, pil2tensor, image2mask, fit_resize_image
+
+
+
+any = AnyType("*")
+
+class ImageMaskScaleAs:
+
+    def __init__(self):
+        self.NODE_NAME = 'ImageMaskScaleAs'
+
+    @classmethod
+    def INPUT_TYPES(self):
+
+        fit_mode = ['letterbox', 'crop', 'fill']
+        method_mode = ['lanczos', 'bicubic', 'hamming', 'bilinear', 'box', 'nearest']
+
+        return {
+            "required": {
+                "scale_as": (any, {}),
+                "fit": (fit_mode,),
+                "method": (method_mode,),
+            },
+            "optional": {
+                "image": ("IMAGE",),  #
+                "mask": ("MASK",),  #
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE", "MASK", "BOX", "INT", "INT")
+    RETURN_NAMES = ("image", "mask", "original_size", "widht", "height",)
+    FUNCTION = 'image_mask_scale_as'
+    CATEGORY = '😺dzNodes/LayerUtility'
+
+    def image_mask_scale_as(self, scale_as, fit, method,
+                            image=None, mask = None,
+                            ):
+        if scale_as.shape[0] > 0:
+            _asimage = tensor2pil(scale_as[0])
+        else:
+            _asimage = tensor2pil(scale_as)
+        target_width, target_height = _asimage.size
+        _mask = Image.new('L', size=_asimage.size, color='black')
+        _image = Image.new('RGB', size=_asimage.size, color='black')
+        orig_width = 4
+        orig_height = 4
+        resize_sampler = Image.LANCZOS
+        if method == "bicubic":
+            resize_sampler = Image.BICUBIC
+        elif method == "hamming":
+            resize_sampler = Image.HAMMING
+        elif method == "bilinear":
+            resize_sampler = Image.BILINEAR
+        elif method == "box":
+            resize_sampler = Image.BOX
+        elif method == "nearest":
+            resize_sampler = Image.NEAREST
+
+        ret_images = []
+        ret_masks = []
+        
+        if image is not None:
+            for i in image:
+                i = torch.unsqueeze(i, 0)
+                _image = tensor2pil(i).convert('RGB')
+                orig_width, orig_height = _image.size
+                _image = fit_resize_image(_image, target_width, target_height, fit, resize_sampler)
+                ret_images.append(pil2tensor(_image))
+        if mask is not None:
+            if mask.dim() == 2:
+                mask = torch.unsqueeze(mask, 0)
+            for m in mask:
+                m = torch.unsqueeze(m, 0)
+                _mask = tensor2pil(m).convert('L')
+                orig_width, orig_height = _mask.size
+                _mask = fit_resize_image(_mask, target_width, target_height, fit, resize_sampler).convert('L')
+                ret_masks.append(image2mask(_mask))
+        if len(ret_images) > 0 and len(ret_masks) >0:
+            log(f"{self.NODE_NAME} Processed {len(ret_images)} image(s).", message_type='finish')
+            return (torch.cat(ret_images, dim=0), torch.cat(ret_masks, dim=0), [orig_width, orig_height],target_width, target_height,)
+        elif len(ret_images) > 0 and len(ret_masks) == 0:
+            log(f"{self.NODE_NAME} Processed {len(ret_images)} image(s).", message_type='finish')
+            return (torch.cat(ret_images, dim=0), None, [orig_width, orig_height],target_width, target_height,)
+        elif len(ret_images) == 0 and len(ret_masks) > 0:
+            log(f"{self.NODE_NAME} Processed {len(ret_masks)} image(s).", message_type='finish')
+            return (None, torch.cat(ret_masks, dim=0), [orig_width, orig_height], target_width, target_height,)
+        else:
+            log(f"Error: {self.NODE_NAME} skipped, because the available image or mask is not found.", message_type='error')
+            return (None, None, [orig_width, orig_height], 0, 0,)
+
+
+class LS_ImageMaskScaleAsV2:
+
+    def __init__(self):
+        self.NODE_NAME = 'ImageMaskScaleAsV2'
+
+    @classmethod
+    def INPUT_TYPES(self):
+
+        fit_mode = ['letterbox', 'crop', 'fill']
+        method_mode = ['lanczos', 'bicubic', 'hamming', 'bilinear', 'box', 'nearest']
+
+        return {
+            "required": {
+                "scale_as": (any, {}),
+                "fit": (fit_mode,),
+                "method": (method_mode,),
+                "background_color": ("STRING", {"default": "#FFFFFF"},),
+            },
+            "optional": {
+                "image": ("IMAGE",),  #
+                "mask": ("MASK",),  #
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE", "MASK", "BOX", "INT", "INT")
+    RETURN_NAMES = ("image", "mask", "original_size", "widht", "height",)
+    FUNCTION = 'image_mask_scale_as_v2'
+    CATEGORY = '😺dzNodes/LayerUtility'
+
+    def image_mask_scale_as_v2(self, scale_as, fit, method, background_color,
+                            image=None, mask=None,
+                            ):
+        if scale_as.shape[0] > 0:
+            _asimage = tensor2pil(scale_as[0])
+        else:
+            _asimage = tensor2pil(scale_as)
+        target_width, target_height = _asimage.size
+        _mask = Image.new('L', size=_asimage.size, color='black')
+        _image = Image.new('RGB', size=_asimage.size, color=background_color)
+        orig_width = 4
+        orig_height = 4
+        resize_sampler = Image.LANCZOS
+        if method == "bicubic":
+            resize_sampler = Image.BICUBIC
+        elif method == "hamming":
+            resize_sampler = Image.HAMMING
+        elif method == "bilinear":
+            resize_sampler = Image.BILINEAR
+        elif method == "box":
+            resize_sampler = Image.BOX
+        elif method == "nearest":
+            resize_sampler = Image.NEAREST
+
+        ret_images = []
+        ret_masks = []
+
+        if image is not None:
+            for i in image:
+                i = torch.unsqueeze(i, 0)
+                _image = tensor2pil(i).convert('RGB')
+                orig_width, orig_height = _image.size
+                _image = fit_resize_image(_image, target_width, target_height, fit, resize_sampler, background_color=background_color)
+                ret_images.append(pil2tensor(_image))
+        if mask is not None:
+            if mask.dim() == 2:
+                mask = torch.unsqueeze(mask, 0)
+            for m in mask:
+                m = torch.unsqueeze(m, 0)
+                _mask = tensor2pil(m).convert('L')
+                orig_width, orig_height = _mask.size
+                _mask = fit_resize_image(_mask, target_width, target_height, fit, resize_sampler, background_color=background_color).convert('L')
+                ret_masks.append(image2mask(_mask))
+        if len(ret_images) > 0 and len(ret_masks) > 0:
+            log(f"{self.NODE_NAME} Processed {len(ret_images)} image(s).", message_type='finish')
+            return (torch.cat(ret_images, dim=0), torch.cat(ret_masks, dim=0), [orig_width, orig_height], target_width,
+                    target_height,)
+        elif len(ret_images) > 0 and len(ret_masks) == 0:
+            log(f"{self.NODE_NAME} Processed {len(ret_images)} image(s).", message_type='finish')
+            return (torch.cat(ret_images, dim=0), None, [orig_width, orig_height], target_width, target_height,)
+        elif len(ret_images) == 0 and len(ret_masks) > 0:
+            log(f"{self.NODE_NAME} Processed {len(ret_masks)} image(s).", message_type='finish')
+            return (None, torch.cat(ret_masks, dim=0), [orig_width, orig_height], target_width, target_height,)
+        else:
+            log(f"Error: {self.NODE_NAME} skipped, because the available image or mask is not found.",
+                message_type='error')
+            return (None, None, [orig_width, orig_height], 0, 0,)
+
+NODE_CLASS_MAPPINGS = {
+    "LayerUtility: ImageMaskScaleAs": ImageMaskScaleAs,
+    "LayerUtility: ImageMaskScaleAsV2": LS_ImageMaskScaleAsV2,
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "LayerUtility: ImageMaskScaleAs": "LayerUtility: Image Mask Scale As",
+    "LayerUtility: ImageMaskScaleAsV2": "LayerUtility: Image Mask Scale As V2",
+}

comfyui_layerstyle/py/image_opacity.py

@@ -0,0 +1,87 @@
+import torch
+from PIL import Image, ImageChops
+from .imagefunc import log, tensor2pil, pil2tensor, image2mask
+
+
+
+class ImageOpacity:
+
+    def __init__(self):
+        self.NODE_NAME = 'ImageOpacity'
+
+    @classmethod
+    def INPUT_TYPES(self):
+
+        return {
+            "required": {
+                "image": ("IMAGE", ),  #
+                "opacity": ("INT", {"default": 100, "min": 0, "max": 100, "step": 1}),  # 透明度
+                "invert_mask": ("BOOLEAN", {"default": True}),  # 反转mask
+            },
+            "optional": {
+                "mask": ("MASK",),  #
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE", "MASK",)
+    RETURN_NAMES = ("image", "mask",)
+    FUNCTION = 'image_opacity'
+    CATEGORY = '😺dzNodes/LayerUtility'
+
+    def image_opacity(self, image, opacity, invert_mask,
+                      mask=None,
+                      ):
+
+        ret_images = []
+        ret_masks = []
+        l_images = []
+        l_masks = []
+        for l in image:
+            l_images.append(torch.unsqueeze(l, 0))
+            m = tensor2pil(l)
+            if m.mode == 'RGBA':
+                l_masks.append(m.split()[-1])
+            else:
+                l_masks.append(Image.new('L', size=m.size, color='white'))
+
+        if mask is not None:
+            if mask.dim() == 2:
+                mask = torch.unsqueeze(mask, 0)
+            l_masks = []
+            for m in mask:
+                if invert_mask:
+                    m = 1 - m
+                l_masks.append(tensor2pil(torch.unsqueeze(m, 0)).convert('L'))
+
+        max_batch = max(len(l_images), len(l_masks))
+
+        for i in range(max_batch):
+            _image = l_images[i] if i < len(l_images) else l_images[-1]
+            _image = tensor2pil(_image)
+            _mask = l_masks[i] if i < len(l_masks) else l_masks[-1]
+            if invert_mask:
+                _color = Image.new("L", _image.size, color=('white'))
+                _mask = ImageChops.invert(_mask)
+            else:
+                _color = Image.new("L", _image.size, color=('black'))
+
+            alpha = 1 - opacity / 100.0
+            ret_mask = Image.blend(_mask, _color, alpha)
+            R, G, B, = _image.convert('RGB').split()
+            if invert_mask:
+                ret_mask = ImageChops.invert(ret_mask)
+            ret_image = Image.merge('RGBA', (R, G, B, ret_mask))
+
+            ret_images.append(pil2tensor(ret_image))
+            ret_masks.append(image2mask(ret_mask))
+
+        log(f"{self.NODE_NAME} Processed {len(ret_images)} image(s).", message_type='finish')
+        return (torch.cat(ret_images, dim=0), torch.cat(ret_masks, dim=0),)
+
+NODE_CLASS_MAPPINGS = {
+    "LayerUtility: ImageOpacity": ImageOpacity
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "LayerUtility: ImageOpacity": "LayerUtility: ImageOpacity"
+}

comfyui_layerstyle/py/image_reel.py

@@ -0,0 +1,224 @@
+import torch
+from PIL import Image, ImageFont, ImageDraw
+from .imagefunc import log, tensor2pil, pil2tensor, gaussian_blur, adjust_levels, get_resource_dir
+
+class ImageReelPipeline:
+    def __init__(self):
+        self.image = None
+        self.texts = {}
+        self.reel_height = 0
+        self.reel_border = 0
+
+Reel = ImageReelPipeline()
+class ImageReel:
+
+    def __init__(self):
+        self.NODE_NAME = 'ImageReel'
+
+    @classmethod
+    def INPUT_TYPES(self):
+        return {
+            "required": {
+                "image1": ("IMAGE",),
+                "image1_text": ("STRING", {"multiline": False, "default": "image1"}),
+                "image2_text": ("STRING", {"multiline": False, "default": "image2"}),
+                "image3_text": ("STRING", {"multiline": False, "default": "image3"}),
+                "image4_text": ("STRING", {"multiline": False, "default": "image4"}),
+                "reel_height": ("INT", {"default": 512, "min": 64, "max": 2048}),
+                "border": ("INT", {"default": 32, "min": 8, "max": 512}),
+            },
+            "optional": {
+                "image2": ("IMAGE",),
+                "image3": ("IMAGE",),
+                "image4": ("IMAGE",),
+            }
+        }
+
+    RETURN_TYPES = ("Reel",)
+    RETURN_NAMES = ("reel",)
+    FUNCTION = 'image_reel'
+    CATEGORY = '😺dzNodes/LayerUtility'
+
+    def image_reel(self, image1, image1_text, image2_text, image3_text, image4_text,
+                            reel_height, border,
+                            image2=None, image3=None, image4=None,):
+
+        image_list = []
+        texts = []
+        for img in image1:
+            i = self.resize_image_to_height(tensor2pil(img.unsqueeze(0)),reel_height)
+            image_list.append(i)
+            texts.append([image1_text,i.width])
+        if image2 is not None:
+            for img in image2:
+                i = self.resize_image_to_height(tensor2pil(img.unsqueeze(0)),reel_height)
+                image_list.append(i)
+                texts.append([image2_text,i.width])
+        if image3 is not None:
+            for img in image3:
+                i = self.resize_image_to_height(tensor2pil(img.unsqueeze(0)),reel_height)
+                image_list.append(i)
+                texts.append([image3_text,i.width])
+        if image4 is not None:
+            for img in image4:
+                i = self.resize_image_to_height(tensor2pil(img.unsqueeze(0)),reel_height)
+                image_list.append(i)
+                texts.append([image4_text,i.width])
+
+        reel = ImageReel()
+        reel.image = self.draw_reel_image(image_list, border, reel_height)
+        reel.texts = texts
+        reel.reel_height = reel_height
+        reel.reel_border = border
+        return (reel,)
+
+    def resize_image_to_height(self, image, target_height) -> Image:
+        w = int(target_height / image.height * image.width)
+        return image.resize((w, target_height), Image.LANCZOS)
+
+    def draw_reel_image(self, image_list, border, reel_height) -> Image:
+        reel_width = 0
+        for img in image_list:
+            reel_width += img.width + border
+        reel_img = Image.new('RGBA', (reel_width, reel_height + border), color=(0, 0, 0, 0))
+        #paste images
+        w = border // 2
+        for img in image_list:
+            reel_img.paste(img, (w, border // 2))
+            w += img.width + border
+        return reel_img
+
+
+class ImageReelComposit:
+
+    def __init__(self):
+        self.NODE_NAME = 'ImageReelComposit'
+        (_, self.FONT_DICT) = get_resource_dir()
+        self.FONT_LIST = list(self.FONT_DICT.keys())
+
+    @classmethod
+    def INPUT_TYPES(self):
+        (LUT_DICT, FONT_DICT) = get_resource_dir()
+        FONT_LIST = list(FONT_DICT.keys())
+        LUT_LIST = list(LUT_DICT.keys())
+
+        color_theme_list = ['light', 'dark']
+        return {
+            "required": {
+                "reel_1": ("Reel",),
+                "font_file": (FONT_LIST,),
+                "font_size": ("INT", {"default": 40, "min": 4, "max": 1024}),
+                "border": ("INT", {"default": 32, "min": 8, "max": 512}),
+                "color_theme": (color_theme_list,),
+            },
+            "optional": {
+                "reel_2": ("Reel",),
+                "reel_3": ("Reel",),
+                "reel_4": ("Reel",),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    RETURN_NAMES = ("image1",)
+    FUNCTION = 'image_reel_composit'
+    CATEGORY = '😺dzNodes/LayerUtility'
+
+    def image_reel_composit(self, reel_1, font_file, font_size, border, color_theme, reel_2=None, reel_3=None, reel_4=None,):
+
+
+        ret_images = []
+
+        if color_theme == 'light':
+            bg_color = "#E5E5E5"
+            text_color = "#121212"
+        else:
+            bg_color = "#121212"
+            text_color = "#E5E5E5"
+
+
+        font_space = int(font_size * 1.5)
+        width = reel_1.image.width
+        height = reel_1.image.height + font_space + border
+        if reel_2 is not None:
+            width = max(width, reel_2.image.width)
+            height += reel_2.image.height + font_space + border
+        if reel_3 is not None:
+            width = max(width, reel_3.image.width)
+            height += reel_3.image.height + font_space + border
+        if reel_4 is not None:
+            width = max(width, reel_4.image.width)
+            height += reel_4.image.height + font_space + border
+
+        ret_image = Image.new('RGB', (width, height), color=bg_color)
+        paste_y = 0
+        reel1_text_image = self.draw_reel_text(reel_1, font_file, font_size, text_color)
+        shadow_size = reel_1.image.height // 80
+        ret_image = self.paste_drop_shadow(ret_image, reel_1.image, reel1_text_image, ((width - reel_1.image.width) // 2, paste_y),
+                                           shadow_size, text_color)
+
+        paste_y += reel_1.image.height + font_space + border
+        if reel_2 is not None:
+            reel2_text_image = self.draw_reel_text(reel_2, font_file, font_size, text_color)
+            shadow_size = reel_2.image.height // 80
+            ret_image = self.paste_drop_shadow(ret_image, reel_2.image, reel2_text_image, ((width - reel_2.image.width) // 2, paste_y),
+                                               shadow_size, text_color)
+            paste_y += reel_2.image.height + font_space + border
+        if reel_3 is not None:
+            reel3_text_image = self.draw_reel_text(reel_3, font_file, font_size, text_color)
+            shadow_size = reel_3.image.height // 80
+            ret_image = self.paste_drop_shadow(ret_image, reel_3.image, reel3_text_image,((width - reel_3.image.width) // 2, paste_y),
+                                               shadow_size, text_color)
+            paste_y += reel_3.image.height + font_space + border
+        if reel_4 is not None:
+            reel4_text_image = self.draw_reel_text(reel_4, font_file, font_size, text_color)
+            shadow_size = reel_4.image.height // 80
+            ret_image = self.paste_drop_shadow(ret_image, reel_4.image, reel4_text_image,((width - reel_4.image.width) // 2, paste_y),
+                                               shadow_size, text_color)
+
+        ret_images.append(pil2tensor(ret_image))
+
+        log(f"{self.NODE_NAME} Processed {len(ret_images)} image(s).", message_type='finish')
+        return (torch.cat(ret_images, dim=0),)
+
+    def paste_drop_shadow(self, background_image, image, text_image, box, shadow_size, text_color) -> Image:
+        # drop shadow
+        _mask = image.split()[3]
+        _blured_mask = gaussian_blur(_mask, shadow_size//1.3)
+        _blured_mask = adjust_levels(_blured_mask, 0, 255, 0.5, 0, output_white=54).convert('L')
+        background_image.paste(Image.new('RGBA', image.size, color="black"), (box[0]+shadow_size, box[1]+shadow_size), mask=_blured_mask)
+        background_image.paste(image, box, mask=_mask)
+        background_image.paste(Image.new('RGB', text_image.size, color=text_color), (box[0], box[1] + image.height), mask=text_image.split()[3])
+        return background_image
+
+    def draw_reel_text(self, reel, font_file, font_size, text_color) -> Image:
+
+        font_path = self.FONT_DICT.get(font_file)
+        font = ImageFont.truetype(font_path, font_size)
+        texts = reel.texts
+        text_image = Image.new('RGBA', (reel.image.width, reel.reel_border + int(font_size * 1.5)), color=(0, 0, 0, 0))
+        draw = ImageDraw.Draw(text_image)
+        x = reel.reel_border
+        for t in texts:
+            text = t[0]
+            width = t[1]
+            text_width = font.getbbox(text)[2]
+            draw.text(
+                xy=(x + width // 2 - text_width//2, reel.reel_border//4),
+                text=text,
+                fill=text_color,
+                font=font,
+            )
+            x += width + reel.reel_border
+        return text_image
+
+
+
+NODE_CLASS_MAPPINGS = {
+    "LayerUtility: ImageReel": ImageReel,
+    "LayerUtility: ImageReelComposit": ImageReelComposit
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "LayerUtility: ImageReel": "LayerUtility: Image Reel",
+    "LayerUtility: ImageReelComposit": "LayerUtility: Image Reel Composit"
+}

comfyui_layerstyle/py/image_remove_alpha.py

@@ -0,0 +1,64 @@
+import torch
+from PIL import Image
+from .imagefunc import log, tensor2pil, pil2tensor
+
+
+
+class ImageRemoveAlpha:
+
+    def __init__(self):
+        self.NODE_NAME = 'ImageRemoveAlpha'
+
+    @classmethod
+    def INPUT_TYPES(self):
+
+        return {
+            "required": {
+                "RGBA_image": ("IMAGE", ),  #
+                "fill_background": ("BOOLEAN", {"default": False}),
+                "background_color": ("STRING", {"default": "#000000"}),
+            },
+            "optional": {
+                "mask": ("MASK",),  #
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE", )
+    RETURN_NAMES = ("RGB_image", )
+    FUNCTION = 'image_remove_alpha'
+    CATEGORY = '😺dzNodes/LayerUtility'
+
+    def image_remove_alpha(self, RGBA_image, fill_background, background_color, mask=None):
+
+        ret_images = []
+
+        for index, img in enumerate(RGBA_image):
+            _image = tensor2pil(img)
+
+            if fill_background:
+                if mask is not None:
+                    m = mask[index].unsqueeze(0) if index < len(mask) else mask[-1].unsqueeze(0)
+                    alpha = tensor2pil(m).convert('L')
+                elif _image.mode == "RGBA":
+                    alpha = _image.split()[-1]
+                else:
+                    log(f"Error: {self.NODE_NAME} skipped, because the input image is not RGBA and mask is None.",
+                        message_type='error')
+                    return (RGBA_image,)
+                ret_image = Image.new('RGB', size=_image.size, color=background_color)
+                ret_image.paste(_image, mask=alpha)
+                ret_images.append(pil2tensor(ret_image))
+
+            else:
+                ret_images.append(pil2tensor(tensor2pil(img).convert('RGB')))
+
+        log(f"{self.NODE_NAME} Processed {len(ret_images)} image(s).", message_type='finish')
+        return (torch.cat(ret_images, dim=0), )
+
+NODE_CLASS_MAPPINGS = {
+    "LayerUtility: ImageRemoveAlpha": ImageRemoveAlpha
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "LayerUtility: ImageRemoveAlpha": "LayerUtility: ImageRemoveAlpha"
+}

comfyui_layerstyle/py/image_scale_by_aspect_ratio.py

@@ -0,0 +1,158 @@
+import torch
+from PIL import Image
+import math
+from .imagefunc import log, tensor2pil, pil2tensor, image2mask, num_round_up_to_multiple, fit_resize_image
+
+
+
+class ImageScaleByAspectRatio:
+
+    def __init__(self):
+        self.NODE_NAME = 'ImageScaleByAspectRatio'
+
+    @classmethod
+    def INPUT_TYPES(self):
+        ratio_list = ['original', 'custom', '1:1', '3:2', '4:3', '16:9', '2:3', '3:4', '9:16']
+        fit_mode = ['letterbox', 'crop', 'fill']
+        method_mode = ['lanczos', 'bicubic', 'hamming', 'bilinear', 'box', 'nearest']
+        multiple_list = ['8', '16', '32', '64', '128', '256', '512', 'None']
+
+        return {
+            "required": {
+                "aspect_ratio": (ratio_list,),
+                "proportional_width": ("INT", {"default": 2, "min": 1, "max": 999, "step": 1}),
+                "proportional_height": ("INT", {"default": 1, "min": 1, "max": 999, "step": 1}),
+                "fit": (fit_mode,),
+                "method": (method_mode,),
+                "round_to_multiple": (multiple_list,),
+                "scale_to_longest_side": ("BOOLEAN", {"default": False}),  # 是否按长边缩放
+                "longest_side": ("INT", {"default": 1024, "min": 4, "max": 999999, "step": 1}),
+            },
+            "optional": {
+                "image": ("IMAGE",),  #
+                "mask": ("MASK",),  #
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE", "MASK", "BOX", "INT", "INT",)
+    RETURN_NAMES = ("image", "mask", "original_size", "width", "height",)
+    FUNCTION = 'image_scale_by_aspect_ratio'
+    CATEGORY = '😺dzNodes/LayerUtility'
+
+    def image_scale_by_aspect_ratio(self, aspect_ratio, proportional_width, proportional_height,
+                                    fit, method, round_to_multiple, scale_to_longest_side, longest_side,
+                                    image=None, mask = None,
+                                    ):
+        orig_images = []
+        orig_masks = []
+        orig_width = 0
+        orig_height = 0
+        target_width = 0
+        target_height = 0
+        ratio = 1.0
+        ret_images = []
+        ret_masks = []
+        if image is not None:
+            for i in image:
+                i = torch.unsqueeze(i, 0)
+                orig_images.append(i)
+            orig_width, orig_height = tensor2pil(orig_images[0]).size
+        if mask is not None:
+            if mask.dim() == 2:
+                mask = torch.unsqueeze(mask, 0)
+            for m in mask:
+                m = torch.unsqueeze(m, 0)
+                orig_masks.append(m)
+            _width, _height = tensor2pil(orig_masks[0]).size
+            if (orig_width > 0 and orig_width != _width) or (orig_height > 0 and orig_height != _height):
+                log(f"Error: {self.NODE_NAME} skipped, because the mask is does'nt match image.", message_type='error')
+                return (None, None, None, 0, 0,)
+            elif orig_width + orig_height == 0:
+                orig_width = _width
+                orig_height = _height
+
+        if orig_width + orig_height == 0:
+            log(f"Error: {self.NODE_NAME} skipped, because the image or mask at least one must be input.", message_type='error')
+            return (None, None, None, 0, 0,)
+
+        if aspect_ratio == 'original':
+            ratio = orig_width / orig_height
+        elif aspect_ratio == 'custom':
+            ratio = proportional_width / proportional_height
+        else:
+            s = aspect_ratio.split(":")
+            ratio = int(s[0]) / int(s[1])
+
+        # calculate target width and height
+        if orig_width > orig_height:
+            if scale_to_longest_side:
+                target_width = longest_side
+            else:
+                target_width = orig_width
+            target_height = int(target_width  / ratio)
+        else:
+            if scale_to_longest_side:
+                target_height = longest_side
+            else:
+                target_height = orig_height
+            target_width = int(target_height * ratio)
+
+        if ratio < 1:
+            if scale_to_longest_side:
+                _r = longest_side / target_height
+                target_height = longest_side
+            else:
+                _r = orig_height / target_height
+                target_height = orig_height
+            target_width = int(target_width * _r)
+
+        if round_to_multiple != 'None':
+            multiple = int(round_to_multiple)
+            target_width = num_round_up_to_multiple(target_width, multiple)
+            target_height = num_round_up_to_multiple(target_height, multiple)
+
+        _mask = Image.new('L', size=(target_width, target_height), color='black')
+        _image = Image.new('RGB', size=(target_width, target_height), color='black')
+
+        resize_sampler = Image.LANCZOS
+        if method == "bicubic":
+            resize_sampler = Image.BICUBIC
+        elif method == "hamming":
+            resize_sampler = Image.HAMMING
+        elif method == "bilinear":
+            resize_sampler = Image.BILINEAR
+        elif method == "box":
+            resize_sampler = Image.BOX
+        elif method == "nearest":
+            resize_sampler = Image.NEAREST
+
+        if len(orig_images) > 0:
+            for i in orig_images:
+                _image = tensor2pil(i).convert('RGB')
+                _image = fit_resize_image(_image, target_width, target_height, fit, resize_sampler)
+                ret_images.append(pil2tensor(_image))
+        if len(orig_masks) > 0:
+            for m in orig_masks:
+                _mask = tensor2pil(m).convert('L')
+                _mask = fit_resize_image(_mask, target_width, target_height, fit, resize_sampler).convert('L')
+                ret_masks.append(image2mask(_mask))
+        if len(ret_images) > 0 and len(ret_masks) >0:
+            log(f"{self.NODE_NAME} Processed {len(ret_images)} image(s).", message_type='finish')
+            return (torch.cat(ret_images, dim=0), torch.cat(ret_masks, dim=0),[orig_width, orig_height], target_width, target_height,)
+        elif len(ret_images) > 0 and len(ret_masks) == 0:
+            log(f"{self.NODE_NAME} Processed {len(ret_images)} image(s).", message_type='finish')
+            return (torch.cat(ret_images, dim=0), None,[orig_width, orig_height], target_width, target_height,)
+        elif len(ret_images) == 0 and len(ret_masks) > 0:
+            log(f"{self.NODE_NAME} Processed {len(ret_masks)} image(s).", message_type='finish')
+            return (None, torch.cat(ret_masks, dim=0),[orig_width, orig_height], target_width, target_height,)
+        else:
+            log(f"Error: {self.NODE_NAME} skipped, because the available image or mask is not found.", message_type='error')
+            return (None, None, None, 0, 0,)
+
+NODE_CLASS_MAPPINGS = {
+    "LayerUtility: ImageScaleByAspectRatio": ImageScaleByAspectRatio
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "LayerUtility: ImageScaleByAspectRatio": "LayerUtility: ImageScaleByAspectRatio"
+}

comfyui_layerstyle/py/image_scale_by_aspect_ratio_v2.py

@@ -0,0 +1,186 @@
+import torch
+from PIL import Image
+import math
+from .imagefunc import log, tensor2pil, pil2tensor, image2mask, num_round_up_to_multiple, fit_resize_image, is_valid_mask
+
+
+
+class ImageScaleByAspectRatioV2:
+
+    def __init__(self):
+        self.NODE_NAME = 'ImageScaleByAspectRatio V2'
+
+    @classmethod
+    def INPUT_TYPES(self):
+        ratio_list = ['original', 'custom', '1:1', '3:2', '4:3', '16:9', '2:3', '3:4', '9:16']
+        fit_mode = ['letterbox', 'crop', 'fill']
+        method_mode = ['lanczos', 'bicubic', 'hamming', 'bilinear', 'box', 'nearest']
+        multiple_list = ['8', '16', '32', '64', '128', '256', '512', 'None']
+        scale_to_list = ['None', 'longest', 'shortest', 'width', 'height', 'total_pixel(kilo pixel)']
+        return {
+            "required": {
+                "aspect_ratio": (ratio_list,),
+                "proportional_width": ("INT", {"default": 1, "min": 1, "max": 1e8, "step": 1}),
+                "proportional_height": ("INT", {"default": 1, "min": 1, "max": 1e8, "step": 1}),
+                "fit": (fit_mode,),
+                "method": (method_mode,),
+                "round_to_multiple": (multiple_list,),
+                "scale_to_side": (scale_to_list,),  # 是否按长边缩放
+                "scale_to_length": ("INT", {"default": 1024, "min": 4, "max": 1e8, "step": 1}),
+                "background_color": ("STRING", {"default": "#000000"}),  # 背景颜色
+            },
+            "optional": {
+                "image": ("IMAGE",),  #
+                "mask": ("MASK",),  #
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE", "MASK", "BOX", "INT", "INT",)
+    RETURN_NAMES = ("image", "mask", "original_size", "width", "height",)
+    FUNCTION = 'image_scale_by_aspect_ratio'
+    CATEGORY = '😺dzNodes/LayerUtility'
+
+    def image_scale_by_aspect_ratio(self, aspect_ratio, proportional_width, proportional_height,
+                                    fit, method, round_to_multiple, scale_to_side, scale_to_length,
+                                    background_color,
+                                    image=None, mask = None,
+                                    ):
+        orig_images = []
+        orig_masks = []
+        orig_width = 0
+        orig_height = 0
+        target_width = 0
+        target_height = 0
+        ratio = 1.0
+        ret_images = []
+        ret_masks = []
+        if image is not None:
+            for i in image:
+                i = torch.unsqueeze(i, 0)
+                orig_images.append(i)
+            orig_width, orig_height = tensor2pil(orig_images[0]).size
+        if mask is not None:
+            if mask.dim() == 2:
+                mask = torch.unsqueeze(mask, 0)
+            for m in mask:
+                m = torch.unsqueeze(m, 0)
+                if not is_valid_mask(m) and m.shape==torch.Size([1,64,64]):
+                    log(f"Warning: {self.NODE_NAME} input mask is empty, ignore it.", message_type='warning')
+                else:
+                    orig_masks.append(m)
+
+            if len(orig_masks) > 0:
+                _width, _height = tensor2pil(orig_masks[0]).size
+                if (orig_width > 0 and orig_width != _width) or (orig_height > 0 and orig_height != _height):
+                    log(f"Error: {self.NODE_NAME} execute failed, because the mask is does'nt match image.", message_type='error')
+                    return (None, None, None, 0, 0,)
+                elif orig_width + orig_height == 0:
+                    orig_width = _width
+                    orig_height = _height
+
+        if orig_width + orig_height == 0:
+            log(f"Error: {self.NODE_NAME} execute failed, because the image or mask at least one must be input.", message_type='error')
+            return (None, None, None, 0, 0,)
+
+        if aspect_ratio == 'original':
+            ratio = orig_width / orig_height
+        elif aspect_ratio == 'custom':
+            ratio = proportional_width / proportional_height
+        else:
+            s = aspect_ratio.split(":")
+            ratio = int(s[0]) / int(s[1])
+
+        # calculate target width and height
+        if ratio > 1:
+            if scale_to_side == 'longest':
+                target_width = scale_to_length
+                target_height = int(target_width / ratio)
+            elif scale_to_side == 'shortest':
+                target_height = scale_to_length
+                target_width = int(target_height * ratio)
+            elif scale_to_side == 'width':
+                target_width = scale_to_length
+                target_height = int(target_width / ratio)
+            elif scale_to_side == 'height':
+                target_height = scale_to_length
+                target_width = int(target_height * ratio)
+            elif scale_to_side == 'total_pixel(kilo pixel)':
+                target_width = math.sqrt(ratio * scale_to_length * 1000)
+                target_height = target_width / ratio
+                target_width = int(target_width)
+                target_height = int(target_height)
+            else:
+                target_width = orig_width
+                target_height = int(target_width / ratio)
+        else:
+            if scale_to_side == 'longest':
+                target_height = scale_to_length
+                target_width = int(target_height * ratio)
+            elif scale_to_side == 'shortest':
+                target_width = scale_to_length
+                target_height = int(target_width / ratio)
+            elif scale_to_side == 'width':
+                target_width = scale_to_length
+                target_height = int(target_width / ratio)
+            elif scale_to_side == 'height':
+                target_height = scale_to_length
+                target_width = int(target_height * ratio)
+            elif scale_to_side == 'total_pixel(kilo pixel)':
+                target_width = math.sqrt(ratio * scale_to_length * 1000)
+                target_height = target_width / ratio
+                target_width = int(target_width)
+                target_height = int(target_height)
+            else:
+                target_height = orig_height
+                target_width = int(target_height * ratio)
+
+        if round_to_multiple != 'None':
+            multiple = int(round_to_multiple)
+            target_width = num_round_up_to_multiple(target_width, multiple)
+            target_height = num_round_up_to_multiple(target_height, multiple)
+
+        _mask = Image.new('L', size=(target_width, target_height), color='black')
+        _image = Image.new('RGB', size=(target_width, target_height), color='black')
+
+        resize_sampler = Image.LANCZOS
+        if method == "bicubic":
+            resize_sampler = Image.BICUBIC
+        elif method == "hamming":
+            resize_sampler = Image.HAMMING
+        elif method == "bilinear":
+            resize_sampler = Image.BILINEAR
+        elif method == "box":
+            resize_sampler = Image.BOX
+        elif method == "nearest":
+            resize_sampler = Image.NEAREST
+
+        if len(orig_images) > 0:
+            for i in orig_images:
+                _image = tensor2pil(i).convert('RGB')
+                _image = fit_resize_image(_image, target_width, target_height, fit, resize_sampler, background_color)
+                ret_images.append(pil2tensor(_image))
+        if len(orig_masks) > 0:
+            for m in orig_masks:
+                _mask = tensor2pil(m).convert('L')
+                _mask = fit_resize_image(_mask, target_width, target_height, fit, resize_sampler).convert('L')
+                ret_masks.append(image2mask(_mask))
+        if len(ret_images) > 0 and len(ret_masks) >0:
+            log(f"{self.NODE_NAME} Processed {len(ret_images)} image(s).", message_type='finish')
+            return (torch.cat(ret_images, dim=0), torch.cat(ret_masks, dim=0),[orig_width, orig_height], target_width, target_height,)
+        elif len(ret_images) > 0 and len(ret_masks) == 0:
+            log(f"{self.NODE_NAME} Processed {len(ret_images)} image(s).", message_type='finish')
+            return (torch.cat(ret_images, dim=0), None, [orig_width, orig_height], target_width, target_height,)
+        elif len(ret_images) == 0 and len(ret_masks) > 0:
+            log(f"{self.NODE_NAME} Processed {len(ret_masks)} image(s).", message_type='finish')
+            return (None, torch.cat(ret_masks, dim=0), [orig_width, orig_height], target_width, target_height,)
+        else:
+            log(f"Error: {self.NODE_NAME} skipped, because the available image or mask is not found.", message_type='error')
+            return (None, None, None, 0, 0,)
+
+NODE_CLASS_MAPPINGS = {
+    "LayerUtility: ImageScaleByAspectRatio V2": ImageScaleByAspectRatioV2
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "LayerUtility: ImageScaleByAspectRatio V2": "LayerUtility: ImageScaleByAspectRatio V2"
+}

comfyui_layerstyle/py/image_scale_restore.py

@@ -0,0 +1,112 @@
+import torch
+from PIL import Image
+from .imagefunc import log, tensor2pil, pil2tensor, image2mask
+
+
+
+class ImageScaleRestore:
+
+    def __init__(self):
+        self.NODE_NAME = 'ImageScaleRestore'
+
+    @classmethod
+    def INPUT_TYPES(self):
+        method_mode = ['lanczos', 'bicubic', 'hamming', 'bilinear', 'box', 'nearest']
+        return {
+            "required": {
+                "image": ("IMAGE", ),  #
+                "scale": ("FLOAT", {"default": 1, "min": 0.01, "max": 100, "step": 0.01}),
+                "method": (method_mode,),
+                "scale_by_longest_side": ("BOOLEAN", {"default": False}),  # 是否按长边缩放
+                "longest_side": ("INT", {"default": 1024, "min": 4, "max": 999999, "step": 1}),
+            },
+            "optional": {
+                "mask": ("MASK",),  #
+                "original_size": ("BOX",),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE", "MASK", "BOX", "INT", "INT")
+    RETURN_NAMES = ("image", "mask", "original_size", "width", "height",)
+    FUNCTION = 'image_scale_restore'
+    CATEGORY = '😺dzNodes/LayerUtility'
+
+    def image_scale_restore(self, image, scale, method,
+                            scale_by_longest_side, longest_side,
+                            mask = None,  original_size = None
+                            ):
+
+        l_images = []
+        l_masks = []
+        ret_images = []
+        ret_masks = []
+        for l in image:
+            l_images.append(torch.unsqueeze(l, 0))
+            m = tensor2pil(l)
+            if m.mode == 'RGBA':
+                l_masks.append(m.split()[-1])
+
+        if mask is not None:
+            if mask.dim() == 2:
+                mask = torch.unsqueeze(mask, 0)
+            l_masks = []
+            for m in mask:
+                l_masks.append(tensor2pil(torch.unsqueeze(m, 0)).convert('L'))
+
+        max_batch = max(len(l_images), len(l_masks))
+
+        orig_width, orig_height = tensor2pil(l_images[0]).size
+        if original_size is not None:
+            target_width = original_size[0]
+            target_height = original_size[1]
+        else:
+            target_width = int(orig_width * scale)
+            target_height = int(orig_height * scale)
+            if scale_by_longest_side:
+                if orig_width > orig_height:
+                    target_width = longest_side
+                    target_height = int(target_width * orig_height / orig_width)
+                else:
+                    target_height = longest_side
+                    target_width = int(target_height * orig_width / orig_height)
+        if target_width < 4:
+            target_width = 4
+        if target_height < 4:
+            target_height = 4
+        resize_sampler = Image.LANCZOS
+        if method == "bicubic":
+            resize_sampler = Image.BICUBIC
+        elif method == "hamming":
+            resize_sampler = Image.HAMMING
+        elif method == "bilinear":
+            resize_sampler = Image.BILINEAR
+        elif method == "box":
+            resize_sampler = Image.BOX
+        elif method == "nearest":
+            resize_sampler = Image.NEAREST
+
+        for i in range(max_batch):
+
+            _image = l_images[i] if i < len(l_images) else l_images[-1]
+
+            _canvas = tensor2pil(_image).convert('RGB')
+            ret_image = _canvas.resize((target_width, target_height), resize_sampler)
+            ret_mask = Image.new('L', size=ret_image.size, color='white')
+            if mask is not None:
+                _mask = l_masks[i] if i < len(l_masks) else l_masks[-1]
+                ret_mask = _mask.resize((target_width, target_height), resize_sampler)
+
+            ret_images.append(pil2tensor(ret_image))
+            ret_masks.append(image2mask(ret_mask))
+
+        log(f"{self.NODE_NAME} Processed {len(ret_images)} image(s).", message_type='finish')
+        return (torch.cat(ret_images, dim=0), torch.cat(ret_masks, dim=0), [orig_width, orig_height], target_width, target_height,)
+
+
+NODE_CLASS_MAPPINGS = {
+    "LayerUtility: ImageScaleRestore": ImageScaleRestore
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "LayerUtility: ImageScaleRestore": "LayerUtility: ImageScaleRestore"
+}

comfyui_layerstyle/py/image_scale_restore_v2.py

@@ -0,0 +1,132 @@
+import math
+import torch
+from PIL import Image
+from .imagefunc import log, tensor2pil, pil2tensor, image2mask
+
+
+class ImageScaleRestoreV2:
+
+    def __init__(self):
+        self.NODE_NAME = 'ImageScaleRestore V2'
+
+    @classmethod
+    def INPUT_TYPES(self):
+        method_mode = ['lanczos', 'bicubic', 'hamming', 'bilinear', 'box', 'nearest']
+        scale_by_list = ['by_scale', 'longest', 'shortest', 'width', 'height', 'total_pixel(kilo pixel)']
+        return {
+            "required": {
+                "image": ("IMAGE", ),  #
+                "scale": ("FLOAT", {"default": 1, "min": 0.01, "max": 100, "step": 0.01}),
+                "method": (method_mode,),
+                "scale_by": (scale_by_list,),  # 是否按长边缩放
+                "scale_by_length": ("INT", {"default": 1024, "min": 4, "max": 99999999, "step": 1}),
+            },
+            "optional": {
+                "mask": ("MASK",),  #
+                "original_size": ("BOX",),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE", "MASK", "BOX", "INT", "INT")
+    RETURN_NAMES = ("image", "mask", "original_size", "width", "height",)
+    FUNCTION = 'image_scale_restore'
+    CATEGORY = '😺dzNodes/LayerUtility'
+
+    def image_scale_restore(self, image, scale, method,
+                            scale_by, scale_by_length,
+                            mask = None,  original_size = None
+                            ):
+
+        l_images = []
+        l_masks = []
+        ret_images = []
+        ret_masks = []
+        for l in image:
+            l_images.append(torch.unsqueeze(l, 0))
+            m = tensor2pil(l)
+            if m.mode == 'RGBA':
+                l_masks.append(m.split()[-1])
+
+        if mask is not None:
+            if mask.dim() == 2:
+                mask = torch.unsqueeze(mask, 0)
+            l_masks = []
+            for m in mask:
+                l_masks.append(tensor2pil(torch.unsqueeze(m, 0)).convert('L'))
+
+        max_batch = max(len(l_images), len(l_masks))
+
+        orig_width, orig_height = tensor2pil(l_images[0]).size
+        if original_size is not None:
+            target_width = original_size[0]
+            target_height = original_size[1]
+        else:
+            target_width = int(orig_width * scale)
+            target_height = int(orig_height * scale)
+            if scale_by == 'longest':
+                if orig_width > orig_height:
+                    target_width = scale_by_length
+                    target_height = int(target_width * orig_height / orig_width)
+                else:
+                    target_height = scale_by_length
+                    target_width = int(target_height * orig_width / orig_height)
+            if scale_by == 'shortest':
+                if orig_width < orig_height:
+                    target_width = scale_by_length
+                    target_height = int(target_width * orig_height / orig_width)
+                else:
+                    target_height = scale_by_length
+                    target_width = int(target_height * orig_width / orig_height)
+            if scale_by == 'width':
+                target_width = scale_by_length
+                target_height = int(target_width * orig_height / orig_width)
+            if scale_by == 'height':
+                target_height = scale_by_length
+                target_width = int(target_height * orig_width / orig_height)
+            if scale_by == 'total_pixel(kilo pixel)':
+                r = orig_width / orig_height
+                target_width = math.sqrt(r * scale_by_length * 1000)
+                target_height = target_width / r
+                target_width = int(target_width)
+                target_height = int(target_height)
+        if target_width < 4:
+            target_width = 4
+        if target_height < 4:
+            target_height = 4
+        resize_sampler = Image.LANCZOS
+        if method == "bicubic":
+            resize_sampler = Image.BICUBIC
+        elif method == "hamming":
+            resize_sampler = Image.HAMMING
+        elif method == "bilinear":
+            resize_sampler = Image.BILINEAR
+        elif method == "box":
+            resize_sampler = Image.BOX
+        elif method == "nearest":
+            resize_sampler = Image.NEAREST
+
+        for i in range(max_batch):
+
+            _image = l_images[i] if i < len(l_images) else l_images[-1]
+
+            _canvas = tensor2pil(_image).convert('RGB')
+            ret_image = _canvas.resize((target_width, target_height), resize_sampler)
+            ret_mask = Image.new('L', size=ret_image.size, color='white')
+            if mask is not None:
+                _mask = l_masks[i] if i < len(l_masks) else l_masks[-1]
+                ret_mask = _mask.resize((target_width, target_height), resize_sampler)
+
+            ret_images.append(pil2tensor(ret_image))
+            ret_masks.append(image2mask(ret_mask))
+
+        log(f"{self.NODE_NAME} Processed {len(ret_images)} image(s).", message_type='finish')
+        return (torch.cat(ret_images, dim=0), torch.cat(ret_masks, dim=0), [orig_width, orig_height], target_width, target_height,)
+
+
+NODE_CLASS_MAPPINGS = {
+    "LayerUtility: ImageScaleRestore V2": ImageScaleRestoreV2
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "LayerUtility: ImageScaleRestore V2": "LayerUtility: ImageScaleRestore V2"
+}

comfyui_layerstyle/py/image_shift.py

@@ -0,0 +1,88 @@
+import torch
+from PIL import Image
+from .imagefunc import log, tensor2pil, pil2tensor, image2mask, draw_border, gaussian_blur, shift_image
+
+
+class ImageShift:
+
+    def __init__(self):
+        self.NODE_NAME = 'ImageShift'
+
+    @classmethod
+    def INPUT_TYPES(self):
+
+        return {
+            "required": {
+                "image": ("IMAGE", ),  #
+                "shift_x": ("INT", {"default": 256, "min": -9999, "max": 9999, "step": 1}),
+                "shift_y": ("INT", {"default": 256, "min": -9999, "max": 9999, "step": 1}),
+                "cyclic": ("BOOLEAN", {"default": True}),  # 是否循环重复
+                "background_color": ("STRING", {"default": "#000000"}),
+                "border_mask_width": ("INT", {"default": 20, "min": 0, "max": 999, "step": 1}),
+                "border_mask_blur": ("INT", {"default": 12, "min": 0, "max": 999, "step": 1}),
+            },
+            "optional": {
+                "mask": ("MASK",),  #
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE", "MASK", "MASK",)
+    RETURN_NAMES = ("image", "mask", "border_mask")
+    FUNCTION = 'image_shift'
+    CATEGORY = '😺dzNodes/LayerUtility'
+
+    def image_shift(self, image, shift_x, shift_y,
+                    cyclic, background_color,
+                    border_mask_width, border_mask_blur,
+                    mask=None
+                    ):
+
+        ret_images = []
+        ret_masks = []
+        ret_border_masks = []
+
+        l_images = []
+        l_masks = []
+
+
+        for l in image:
+            l_images.append(torch.unsqueeze(l, 0))
+            m = tensor2pil(l)
+            if m.mode == 'RGBA':
+                l_masks.append(m.split()[-1])
+            else:
+                l_masks.append(Image.new('L', size=m.size, color='white'))
+        if mask is not None:
+            if mask.dim() == 2:
+                mask = torch.unsqueeze(mask, 0)
+            l_masks = []
+            for m in mask:
+                l_masks.append(tensor2pil(torch.unsqueeze(m, 0)).convert('L'))
+
+        shift_x, shift_y = -shift_x, -shift_y
+        for i in range(len(l_images)):
+            _image = l_images[i]
+            _canvas = tensor2pil(_image).convert('RGB')
+            _mask = l_masks[i] if len(l_masks) < i else l_masks[-1]
+            _border =  Image.new('L', size=_canvas.size, color='black')
+            _border = draw_border(_border, border_width=border_mask_width, color='#FFFFFF')
+            _border = _border.resize(_canvas.size)
+            _canvas = shift_image(_canvas, shift_x, shift_y, background_color=background_color, cyclic=cyclic)
+            _mask = shift_image(_mask, shift_x, shift_y, background_color='#000000', cyclic=cyclic)
+            _border = shift_image(_border, shift_x, shift_y, background_color='#000000', cyclic=cyclic)
+            _border = gaussian_blur(_border, border_mask_blur)
+
+            ret_images.append(pil2tensor(_canvas))
+            ret_masks.append(image2mask(_mask))
+            ret_border_masks.append(image2mask(_border))
+
+        log(f"{self.NODE_NAME} Processed {len(ret_images)} image(s).", message_type='finish')
+        return (torch.cat(ret_images, dim=0), torch.cat(ret_masks, dim=0), torch.cat(ret_border_masks, dim=0),)
+
+NODE_CLASS_MAPPINGS = {
+    "LayerUtility: ImageShift": ImageShift
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "LayerUtility: ImageShift": "LayerUtility: ImageShift"
+}

comfyui_layerstyle/py/image_tagger_save.py

@@ -0,0 +1,142 @@
+import os.path
+import shutil
+from PIL import Image
+from PIL.PngImagePlugin import PngInfo
+import datetime
+import torch
+import numpy as np
+import folder_paths
+from .imagefunc import log, generate_random_name, remove_empty_lines
+
+
+
+class LSImageTaggerSave:
+    def __init__(self):
+        self.output_dir = folder_paths.get_output_directory()
+        self.type = "output"
+        self.prefix_append = ""
+        self.compress_level = 4
+        self.NODE_NAME = 'ImageTaggerSave'
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required":
+                    {"image": ("IMAGE", ),
+                     "tag_text": ("STRING", {"default": "", "forceInput":True}),
+                     "custom_path": ("STRING", {"default": ""}),
+                     "filename_prefix": ("STRING", {"default": "comfyui"}),
+                     "timestamp": (["None", "second", "millisecond"],),
+                     "format": (["png", "jpg"],),
+                     "quality": ("INT", {"default": 80, "min": 10, "max": 100, "step": 1}),
+                     "preview": ("BOOLEAN", {"default": True}),
+                     },
+                "hidden": {"prompt": "PROMPT", "extra_pnginfo": "EXTRA_PNGINFO"},
+                }
+
+    RETURN_TYPES = ()
+    FUNCTION = "image_tagger_save"
+    OUTPUT_NODE = True
+    CATEGORY = '😺dzNodes/LayerUtility/SystemIO'
+
+    def image_tagger_save(self, image, tag_text, custom_path, filename_prefix, timestamp, format, quality,
+                           preview,
+                           prompt=None, extra_pnginfo=None):
+
+        now = datetime.datetime.now()
+        custom_path = custom_path.replace("%date", now.strftime("%Y-%m-%d"))
+        custom_path = custom_path.replace("%time", now.strftime("%H-%M-%S"))
+        filename_prefix = filename_prefix.replace("%date", now.strftime("%Y-%m-%d"))
+        filename_prefix = filename_prefix.replace("%time", now.strftime("%H-%M-%S"))
+        filename_prefix += self.prefix_append
+        full_output_folder, filename, counter, subfolder, filename_prefix = folder_paths.get_save_image_path(filename_prefix, self.output_dir, image[0].shape[1], image[0].shape[0])
+        results = list()
+        temp_sub_dir = generate_random_name('_savepreview_', '_temp', 16)
+        temp_dir = os.path.join(folder_paths.get_temp_directory(), temp_sub_dir)
+        metadata = None
+        i = 255. * image[0].cpu().numpy()
+        img = Image.fromarray(np.clip(i, 0, 255).astype(np.uint8))
+
+        if timestamp == "millisecond":
+            file = f'{filename}_{now.strftime("%Y-%m-%d_%H-%M-%S-%f")[:-3]}'
+        elif timestamp == "second":
+            file = f'{filename}_{now.strftime("%Y-%m-%d_%H-%M-%S")}'
+        else:
+            file = f'{filename}_{counter:08}'
+
+        preview_filename = ""
+        if custom_path != "":
+            if not os.path.exists(custom_path):
+                try:
+                    os.makedirs(custom_path)
+                except Exception as e:
+                    log(f"Error: {self.NODE_NAME} skipped, because unable to create temporary folder.",
+                        message_type='warning')
+                    raise FileNotFoundError(f"cannot create custom_path {custom_path}, {e}")
+        else:
+            custom_path = folder_paths.get_output_directory()
+
+        full_output_folder = os.path.normpath(custom_path)
+        # save preview image to temp_dir
+        if os.path.isdir(temp_dir):
+            shutil.rmtree(temp_dir)
+        try:
+            os.makedirs(temp_dir)
+        except Exception as e:
+            print(e)
+            log(f"Error: {self.NODE_NAME} skipped, because unable to create temporary folder.",
+                message_type='warning')
+        try:
+            preview_filename = os.path.join(generate_random_name('saveimage_preview_', '_temp', 16) + '.png')
+            img.save(os.path.join(temp_dir, preview_filename))
+        except Exception as e:
+            print(e)
+            log(f"Error: {self.NODE_NAME} skipped, because unable to create temporary file.", message_type='warning')
+
+        # check if file exists, change filename
+        while os.path.isfile(os.path.join(full_output_folder, f"{file}.{format}")):
+            counter += 1
+            if timestamp == "millisecond":
+                file = f'{filename}_{now.strftime("%Y-%m-%d_%H-%M-%S-%f")[:-3]}_{counter:08}'
+            elif timestamp == "second":
+                file = f'{filename}_{now.strftime("%Y-%m-%d_%H-%M-%S")}_{counter:08}'
+            else:
+                file = f"{filename}_{counter:08}"
+
+        image_file_name = os.path.join(full_output_folder, f"{file}.{format}")
+        tag_file_name = os.path.join(full_output_folder, f"{file}.txt")
+
+        if format == "png":
+            img.save(image_file_name, pnginfo=metadata, compress_level= (100 - quality) // 10)
+        else:
+            if img.mode == "RGBA":
+                img = img.convert("RGB")
+            img.save(image_file_name, quality=quality)
+        with open(tag_file_name, "w", encoding="utf-8") as f:
+            f.write(remove_empty_lines(tag_text))
+        log(f"{self.NODE_NAME} -> Saving image to {image_file_name}")
+
+        if preview:
+            if custom_path == "":
+                results.append({
+                    "filename": f"{file}.{format}",
+                    "subfolder": subfolder,
+                    "type": self.type
+                })
+            else:
+                results.append({
+                    "filename": preview_filename,
+                    "subfolder": temp_sub_dir,
+                    "type": "temp"
+                })
+
+        counter += 1
+
+        return { "ui": { "images": results } }
+
+NODE_CLASS_MAPPINGS = {
+    "LayerUtility: ImageTaggerSave": LSImageTaggerSave
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "LayerUtility: ImageTaggerSave": "LayerUtility: Image Tagger Save"
+}

comfyui_layerstyle/py/image_to_mask.py

@@ -0,0 +1,111 @@
+import torch
+from PIL import Image, ImageChops
+from .imagefunc import log, tensor2pil, image2mask, image_channel_split, normalize_gray, adjust_levels
+
+
+
+class ImageToMask:
+    def __init__(self):
+        self.NODE_NAME = 'ImageToMask'
+    @classmethod
+    def INPUT_TYPES(s):
+        channel_list = ["L(LAB)", "A(Lab)", "B(Lab)",
+                        "R(RGB)", "G(RGB)", "B(RGB)", "alpha",
+                        "Y(YUV)", "U(YUV)", "V(YUV)",
+                        "H(HSV)", "S(HSV", "V(HSV)"]
+        return {
+            "required": {
+                "image": ("IMAGE", ),
+                "channel": (channel_list,),
+                "black_point": ("INT", {"default": 0, "min": 0, "max": 255, "step": 1, "display": "slider"}),
+                "white_point": ("INT", {"default": 255, "min": 0, "max": 255, "step": 1, "display": "slider"}),
+                "gray_point": ("FLOAT", {"default": 1.0, "min": 0.01, "max": 9.99, "step": 0.01}),
+                "invert_output_mask": ("BOOLEAN", {"default": False}),  # 反转mask
+            },
+            "optional": {
+                "mask": ("MASK",),  #
+            }
+        }
+
+    RETURN_TYPES = ("MASK",)
+    RETURN_NAMES = ("mask",)
+    FUNCTION = "image_to_mask"
+    CATEGORY = '😺dzNodes/LayerMask'
+
+    def image_to_mask(self, image, channel,
+                      black_point, white_point, gray_point,
+                      invert_output_mask, mask=None
+                      ):
+
+        ret_masks = []
+        l_images = []
+        l_masks = []
+
+        for l in image:
+            l_images.append(torch.unsqueeze(l, 0))
+            m = tensor2pil(l)
+            if m.mode == 'RGBA':
+                l_masks.append(m.split()[-1])
+            else:
+                l_masks.append(Image.new('L', m.size, 'white'))
+        if mask is not None:
+            if mask.dim() == 2:
+                mask = torch.unsqueeze(mask, 0)
+            l_masks = []
+            for m in mask:
+                l_masks.append(tensor2pil(torch.unsqueeze(m, 0)).convert('L'))
+
+        for i in range(len(l_images)):
+            orig_image = l_images[i] if i < len(l_images) else l_images[-1]
+            orig_image = tensor2pil(orig_image)
+            orig_mask = l_masks[i] if i < len(l_masks) else l_masks[-1]
+
+            mask = Image.new('L', orig_image.size, 'black')
+            if channel == "L(LAB)":
+                mask, _, _, _ = image_channel_split(orig_image, 'LAB')
+            elif channel == "A(Lab)":
+                _, mask, _, _ = image_channel_split(orig_image, 'LAB')
+            elif channel == "B(Lab)":
+                _, _, mask, _ = image_channel_split(orig_image, 'LAB')
+            elif channel == "R(RGB)":
+                mask, _, _, _ = image_channel_split(orig_image, 'RGB')
+            elif channel == "G(RGB)":
+                _, mask, _, _ = image_channel_split(orig_image, 'RGB')
+            elif channel == "B(RGB)":
+                _, _, mask, _ = image_channel_split(orig_image, 'RGB')
+            elif channel == "alpha":
+                _, _, _, mask = image_channel_split(orig_image, 'RGBA')
+            elif channel == "Y(YUV)":
+                mask, _, _, _ = image_channel_split(orig_image, 'YCbCr')
+            elif channel == "U(YUV)":
+                _, mask, _, _ = image_channel_split(orig_image, 'YCbCr')
+            elif channel == "V(YUV)":
+                _, _, mask, _ = image_channel_split(orig_image, 'YCbCr')
+            elif channel == "H(HSV)":
+                mask, _, _, _ = image_channel_split(orig_image, 'HSV')
+            elif channel == "S(HSV)":
+                _, mask, _, _ = image_channel_split(orig_image, 'HSV')
+            elif channel == "V(HSV)":
+                _, _, mask, _ = image_channel_split(orig_image, 'HSV')
+            mask = normalize_gray(mask)
+            mask = adjust_levels(mask, black_point, white_point, gray_point,
+                          0, 255)
+            if invert_output_mask:
+                mask =  ImageChops.invert(mask)
+            ret_mask = Image.new('L', mask.size, 'black')
+            ret_mask.paste(mask, mask=orig_mask)
+
+            ret_mask = image2mask(ret_mask)
+
+            ret_masks.append(ret_mask)
+
+        return (torch.cat(ret_masks, dim=0), )
+
+
+NODE_CLASS_MAPPINGS = {
+    "LayerMask: ImageToMask": ImageToMask
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "LayerMask: ImageToMask": "LayerMask: Image To Mask"
+}

comfyui_layerstyle/py/inner_glow.py

@@ -0,0 +1,107 @@
+import torch
+from PIL import Image, ImageChops
+from .imagefunc import log, tensor2pil, pil2tensor, image2mask, step_color, expand_mask, mask_invert, chop_mode, chop_image, step_value
+
+
+class InnerGlow:
+
+    def __init__(self):
+        self.NODE_NAME = 'InnerGlow'
+
+    @classmethod
+    def INPUT_TYPES(self):
+        chop_mode = ['screen', 'add', 'lighter', 'normal', 'multply', 'subtract','difference','darker',
+                     'color_burn', 'color_dodge', 'linear_burn', 'linear_dodge', 'overlay',
+                     'soft_light', 'hard_light', 'vivid_light', 'pin_light', 'linear_light', 'hard_mix']
+        return {
+            "required": {
+                "background_image": ("IMAGE", ),  #
+                "layer_image": ("IMAGE",),  #
+                "invert_mask": ("BOOLEAN", {"default": True}),  # 反转mask
+                "blend_mode": (chop_mode,),  # 混合模式
+                "opacity": ("INT", {"default": 100, "min": 0, "max": 100, "step": 1}),  # 透明度
+                "brightness": ("INT", {"default": 5, "min": 2, "max": 20, "step": 1}),  # 迭代
+                "glow_range": ("INT", {"default": 48, "min": -9999, "max": 9999, "step": 1}),  # 扩张
+                "blur": ("INT", {"default": 25, "min": 0, "max": 9999, "step": 1}),  # 扩张
+                "light_color": ("STRING", {"default": "#FFBF30"}),  # 光源中心颜色
+                "glow_color": ("STRING", {"default": "#FE0000"}),  # 辉光外围颜色
+            },
+            "optional": {
+                "layer_mask": ("MASK",),  #
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    RETURN_NAMES = ("image",)
+    FUNCTION = 'inner_glow'
+    CATEGORY = '😺dzNodes/LayerStyle'
+
+    def inner_glow(self, background_image, layer_image,
+                  invert_mask, blend_mode, opacity,
+                  brightness, glow_range, blur, light_color, glow_color,
+                  layer_mask=None
+                  ):
+
+        b_images = []
+        l_images = []
+        l_masks = []
+        ret_images = []
+        for b in background_image:
+            b_images.append(torch.unsqueeze(b, 0))
+        for l in layer_image:
+            l_images.append(torch.unsqueeze(l, 0))
+            m = tensor2pil(l)
+            if m.mode == 'RGBA':
+                l_masks.append(m.split()[-1])
+        if layer_mask is not None:
+            if layer_mask.dim() == 2:
+                layer_mask = torch.unsqueeze(layer_mask, 0)
+            l_masks = []
+            for m in layer_mask:
+                if invert_mask:
+                    m = 1 - m
+                l_masks.append(tensor2pil(torch.unsqueeze(m, 0)).convert('L'))
+        if len(l_masks) == 0:
+            log(f"Error: {self.NODE_NAME} skipped, because the available mask is not found.", message_type='error')
+            return (background_image,)
+        max_batch = max(len(b_images), len(l_images), len(l_masks))
+        for i in range(max_batch):
+            background_image = b_images[i] if i < len(b_images) else b_images[-1]
+            layer_image = l_images[i] if i < len(l_images) else l_images[-1]
+            _mask = l_masks[i] if i < len(l_masks) else l_masks[-1]
+            # preprocess
+            _canvas = tensor2pil(background_image).convert('RGB')
+            _layer = tensor2pil(layer_image).convert('RGB')
+
+            if _mask.size != _layer.size:
+                _mask = Image.new('L', _layer.size, 'white')
+                log(f"Warning: {self.NODE_NAME} mask mismatch, dropped!", message_type='warning')
+
+            blur_factor = blur / 20.0
+            grow = glow_range
+            inner_mask = _mask
+            for x in range(brightness):
+                blur = int(grow * blur_factor)
+                _color = step_color(glow_color, light_color, brightness, x)
+                glow_mask = expand_mask(image2mask(inner_mask), -grow, blur)  #扩张，模糊
+                # 合成glow
+                color_image = Image.new("RGB", _layer.size, color=_color)
+                alpha = tensor2pil(mask_invert(glow_mask)).convert('L')
+                _glow = chop_image(_layer, color_image, blend_mode, int(step_value(1, opacity, brightness, x)))
+                _layer.paste(_glow, mask=alpha)
+                grow = grow - int(glow_range/brightness)
+            # 合成layer
+            _layer.paste(_canvas, mask=ImageChops.invert(_mask))
+            ret_images.append(pil2tensor(_layer))
+
+        log(f"{self.NODE_NAME} Processed {len(ret_images)} image(s).", message_type='finish')
+        return (torch.cat(ret_images, dim=0),)
+
+
+NODE_CLASS_MAPPINGS = {
+    "LayerStyle: InnerGlow": InnerGlow
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "LayerStyle: InnerGlow": "LayerStyle: InnerGlow"
+}

comfyui_layerstyle/py/inner_glow_v2.py

@@ -0,0 +1,114 @@
+import copy
+import torch
+from PIL import Image, ImageChops
+from .imagefunc import log, tensor2pil, pil2tensor, image2mask, step_color, expand_mask, mask_invert, chop_mode_v2, chop_image_v2, BLEND_MODES, step_value
+
+
+
+
+class InnerGlowV2:
+
+    def __init__(self):
+        self.NODE_NAME = 'InnerGlowV2'
+
+    @classmethod
+    def INPUT_TYPES(self):
+
+        modes = copy.copy(BLEND_MODES)
+        chop_mode_list = ["screen", "linear dodge(add)", "color dodge", "lighten", "dodge", "hard light", "linear light"]
+        for i in chop_mode_list:
+            modes.pop(i)
+        chop_mode_list.extend(list(modes.keys()))
+
+        return {
+            "required": {
+                "background_image": ("IMAGE", ),  #
+                "layer_image": ("IMAGE",),  #
+                "invert_mask": ("BOOLEAN", {"default": True}),  # 反转mask
+                "blend_mode": (chop_mode_list,),  # 混合模式
+                "opacity": ("INT", {"default": 100, "min": 0, "max": 100, "step": 1}),  # 透明度
+                "brightness": ("INT", {"default": 5, "min": 2, "max": 20, "step": 1}),  # 迭代
+                "glow_range": ("INT", {"default": 48, "min": -9999, "max": 9999, "step": 1}),  # 扩张
+                "blur": ("INT", {"default": 25, "min": 0, "max": 9999, "step": 1}),  # 扩张
+                "light_color": ("STRING", {"default": "#FFBF30"}),  # 光源中心颜色
+                "glow_color": ("STRING", {"default": "#FE0000"}),  # 辉光外围颜色
+            },
+            "optional": {
+                "layer_mask": ("MASK",),  #
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    RETURN_NAMES = ("image",)
+    FUNCTION = 'inner_glow_v2'
+    CATEGORY = '😺dzNodes/LayerStyle'
+
+    def inner_glow_v2(self, background_image, layer_image,
+                  invert_mask, blend_mode, opacity,
+                  brightness, glow_range, blur, light_color, glow_color,
+                  layer_mask=None
+                  ):
+
+        b_images = []
+        l_images = []
+        l_masks = []
+        ret_images = []
+        for b in background_image:
+            b_images.append(torch.unsqueeze(b, 0))
+        for l in layer_image:
+            l_images.append(torch.unsqueeze(l, 0))
+            m = tensor2pil(l)
+            if m.mode == 'RGBA':
+                l_masks.append(m.split()[-1])
+        if layer_mask is not None:
+            if layer_mask.dim() == 2:
+                layer_mask = torch.unsqueeze(layer_mask, 0)
+            l_masks = []
+            for m in layer_mask:
+                if invert_mask:
+                    m = 1 - m
+                l_masks.append(tensor2pil(torch.unsqueeze(m, 0)).convert('L'))
+        if len(l_masks) == 0:
+            log(f"Error: {self.NODE_NAME} skipped, because the available mask is not found.", message_type='error')
+            return (background_image,)
+        max_batch = max(len(b_images), len(l_images), len(l_masks))
+        for i in range(max_batch):
+            background_image = b_images[i] if i < len(b_images) else b_images[-1]
+            layer_image = l_images[i] if i < len(l_images) else l_images[-1]
+            _mask = l_masks[i] if i < len(l_masks) else l_masks[-1]
+            # preprocess
+            _canvas = tensor2pil(background_image).convert('RGB')
+            _layer = tensor2pil(layer_image).convert('RGB')
+
+            if _mask.size != _layer.size:
+                _mask = Image.new('L', _layer.size, 'white')
+                log(f"Warning: {self.NODE_NAME} mask mismatch, dropped!", message_type='warning')
+
+            blur_factor = blur / 20.0
+            grow = glow_range
+            inner_mask = _mask
+            for x in range(brightness):
+                blur = int(grow * blur_factor)
+                _color = step_color(glow_color, light_color, brightness, x)
+                glow_mask = expand_mask(image2mask(inner_mask), -grow, blur)  #扩张，模糊
+                # 合成glow
+                color_image = Image.new("RGB", _layer.size, color=_color)
+                alpha = tensor2pil(mask_invert(glow_mask)).convert('L')
+                _glow = chop_image_v2(_layer, color_image, blend_mode, int(step_value(1, opacity, brightness, x)))
+                _layer.paste(_glow, mask=alpha)
+                grow = grow - int(glow_range/brightness)
+            # 合成layer
+            _layer.paste(_canvas, mask=ImageChops.invert(_mask))
+            ret_images.append(pil2tensor(_layer))
+
+        log(f"{self.NODE_NAME} Processed {len(ret_images)} image(s).", message_type='finish')
+        return (torch.cat(ret_images, dim=0),)
+
+
+NODE_CLASS_MAPPINGS = {
+    "LayerStyle: InnerGlow V2": InnerGlowV2
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "LayerStyle: InnerGlow V2": "LayerStyle: InnerGlow V2"
+}

comfyui_layerstyle/py/inner_shadow.py

@@ -0,0 +1,102 @@
+import torch
+from PIL import Image, ImageChops
+from .imagefunc import log, tensor2pil, pil2tensor, image2mask, shift_image, expand_mask, chop_image, chop_mode
+
+
+class InnerShadow:
+
+    def __init__(self):
+        self.NODE_NAME = 'InnerShadow'
+
+    @classmethod
+    def INPUT_TYPES(self):
+
+        return {
+            "required": {
+                "background_image": ("IMAGE", ),  #
+                "layer_image": ("IMAGE",),  #
+                "invert_mask": ("BOOLEAN", {"default": True}),  # 反转mask
+                "blend_mode": (chop_mode,),  # 混合模式
+                "opacity": ("INT", {"default": 50, "min": 0, "max": 100, "step": 1}),  # 透明度
+                "distance_x": ("INT", {"default": 5, "min": -9999, "max": 9999, "step": 1}),  # x_偏移
+                "distance_y": ("INT", {"default": 5, "min": -9999, "max": 9999, "step": 1}),  # y_偏移
+                "grow": ("INT", {"default": 2, "min": -9999, "max": 9999, "step": 1}),  # 扩张
+                "blur": ("INT", {"default": 15, "min": 0, "max": 100, "step": 1}),  # 模糊
+                "shadow_color": ("STRING", {"default": "#000000"}),  # 背景颜色
+            },
+            "optional": {
+                "layer_mask": ("MASK",),  #
+            }
+        }
+
+
+    RETURN_TYPES = ("IMAGE",)
+    RETURN_NAMES = ("image",)
+    FUNCTION = 'inner_shadow'
+    CATEGORY = '😺dzNodes/LayerStyle'
+
+    def inner_shadow(self, background_image, layer_image,
+                  invert_mask, blend_mode, opacity, distance_x, distance_y,
+                  grow, blur, shadow_color,
+                  layer_mask=None
+                  ):
+
+        b_images = []
+        l_images = []
+        l_masks = []
+        ret_images = []
+        for b in background_image:
+            b_images.append(torch.unsqueeze(b, 0))
+        for l in layer_image:
+            l_images.append(torch.unsqueeze(l, 0))
+            m = tensor2pil(l)
+            if m.mode == 'RGBA':
+                l_masks.append(m.split()[-1])
+        if layer_mask is not None:
+            if layer_mask.dim() == 2:
+                layer_mask = torch.unsqueeze(layer_mask, 0)
+            l_masks = []
+            for m in layer_mask:
+                if invert_mask:
+                    m = 1 - m
+                l_masks.append(tensor2pil(torch.unsqueeze(m, 0)).convert('L'))
+        if len(l_masks) == 0:
+            log(f"Error: {self.NODE_NAME} skipped, because the available mask is not found.", message_type='error')
+            return (background_image,)
+        max_batch = max(len(b_images), len(l_images), len(l_masks))
+        distance_x = -distance_x
+        distance_y = -distance_y
+        shadow_color = Image.new("RGB", tensor2pil(l_images[0]).size, color=shadow_color)
+        for i in range(max_batch):
+            background_image = b_images[i] if i < len(b_images) else b_images[-1]
+            layer_image = l_images[i] if i < len(l_images) else l_images[-1]
+            _mask = l_masks[i] if i < len(l_masks) else l_masks[-1]
+            # preprocess
+            _canvas = tensor2pil(background_image).convert('RGB')
+            _layer = tensor2pil(layer_image).convert('RGB')
+            if _mask.size != _layer.size:
+                _mask = Image.new('L', _layer.size, 'white')
+                log(f"Warning: {self.NODE_NAME} mask mismatch, dropped!", message_type='warning')
+
+            if distance_x != 0 or distance_y != 0:
+                __mask = shift_image(_mask, distance_x, distance_y)  # 位移
+            shadow_mask = expand_mask(image2mask(__mask), grow, blur)  #扩张，模糊
+            # 合成阴影
+            alpha = tensor2pil(shadow_mask).convert('L')
+            _shadow = chop_image(_layer, shadow_color, blend_mode, opacity)
+            _layer.paste(_shadow, mask=ImageChops.invert(alpha))
+            # 合成layer
+            _canvas.paste(_layer, mask=_mask)
+
+            ret_images.append(pil2tensor(_canvas))
+
+        log(f"{self.NODE_NAME} Processed {len(ret_images)} image(s).", message_type='finish')
+        return (torch.cat(ret_images, dim=0),)
+
+NODE_CLASS_MAPPINGS = {
+    "LayerStyle: InnerShadow": InnerShadow
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "LayerStyle: InnerShadow": "LayerStyle: InnerShadow"
+}

comfyui_layerstyle/py/inner_shadow_v2.py

@@ -0,0 +1,103 @@
+import torch
+from PIL import Image, ImageChops
+from .imagefunc import log, tensor2pil, pil2tensor, image2mask, shift_image, expand_mask, chop_image_v2, chop_mode_v2
+
+
+
+class InnerShadowV2:
+
+    def __init__(self):
+        self.NODE_NAME = 'InnerShadowV2'
+
+    @classmethod
+    def INPUT_TYPES(self):
+
+        return {
+            "required": {
+                "background_image": ("IMAGE", ),  #
+                "layer_image": ("IMAGE",),  #
+                "invert_mask": ("BOOLEAN", {"default": True}),  # 反转mask
+                "blend_mode": (chop_mode_v2,),  # 混合模式
+                "opacity": ("INT", {"default": 50, "min": 0, "max": 100, "step": 1}),  # 透明度
+                "distance_x": ("INT", {"default": 5, "min": -9999, "max": 9999, "step": 1}),  # x_偏移
+                "distance_y": ("INT", {"default": 5, "min": -9999, "max": 9999, "step": 1}),  # y_偏移
+                "grow": ("INT", {"default": 2, "min": -9999, "max": 9999, "step": 1}),  # 扩张
+                "blur": ("INT", {"default": 15, "min": 0, "max": 100, "step": 1}),  # 模糊
+                "shadow_color": ("STRING", {"default": "#000000"}),  # 背景颜色
+            },
+            "optional": {
+                "layer_mask": ("MASK",),  #
+            }
+        }
+
+
+    RETURN_TYPES = ("IMAGE",)
+    RETURN_NAMES = ("image",)
+    FUNCTION = 'inner_shadow_v2'
+    CATEGORY = '😺dzNodes/LayerStyle'
+
+    def inner_shadow_v2(self, background_image, layer_image,
+                  invert_mask, blend_mode, opacity, distance_x, distance_y,
+                  grow, blur, shadow_color,
+                  layer_mask=None
+                  ):
+
+        b_images = []
+        l_images = []
+        l_masks = []
+        ret_images = []
+        for b in background_image:
+            b_images.append(torch.unsqueeze(b, 0))
+        for l in layer_image:
+            l_images.append(torch.unsqueeze(l, 0))
+            m = tensor2pil(l)
+            if m.mode == 'RGBA':
+                l_masks.append(m.split()[-1])
+        if layer_mask is not None:
+            if layer_mask.dim() == 2:
+                layer_mask = torch.unsqueeze(layer_mask, 0)
+            l_masks = []
+            for m in layer_mask:
+                if invert_mask:
+                    m = 1 - m
+                l_masks.append(tensor2pil(torch.unsqueeze(m, 0)).convert('L'))
+        if len(l_masks) == 0:
+            log(f"Error: {self.NODE_NAME} skipped, because the available mask is not found.", message_type='error')
+            return (background_image,)
+        max_batch = max(len(b_images), len(l_images), len(l_masks))
+        distance_x = -distance_x
+        distance_y = -distance_y
+        shadow_color = Image.new("RGB", tensor2pil(l_images[0]).size, color=shadow_color)
+        for i in range(max_batch):
+            background_image = b_images[i] if i < len(b_images) else b_images[-1]
+            layer_image = l_images[i] if i < len(l_images) else l_images[-1]
+            _mask = l_masks[i] if i < len(l_masks) else l_masks[-1]
+            # preprocess
+            _canvas = tensor2pil(background_image).convert('RGB')
+            _layer = tensor2pil(layer_image).convert('RGB')
+            if _mask.size != _layer.size:
+                _mask = Image.new('L', _layer.size, 'white')
+                log(f"Warning: {self.NODE_NAME} mask mismatch, dropped!", message_type='warning')
+
+            if distance_x != 0 or distance_y != 0:
+                __mask = shift_image(_mask, distance_x, distance_y)  # 位移
+            shadow_mask = expand_mask(image2mask(__mask), grow, blur)  #扩张，模糊
+            # 合成阴影
+            alpha = tensor2pil(shadow_mask).convert('L')
+            _shadow = chop_image_v2(_layer, shadow_color, blend_mode, opacity)
+            _layer.paste(_shadow, mask=ImageChops.invert(alpha))
+            # 合成layer
+            _canvas.paste(_layer, mask=_mask)
+
+            ret_images.append(pil2tensor(_canvas))
+
+        log(f"{self.NODE_NAME} Processed {len(ret_images)} image(s).", message_type='finish')
+        return (torch.cat(ret_images, dim=0),)
+
+NODE_CLASS_MAPPINGS = {
+    "LayerStyle: InnerShadow V2": InnerShadowV2
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "LayerStyle: InnerShadow V2": "LayerStyle: InnerShadow V2"
+}

comfyui_layerstyle/py/layer_image_transform.py

@@ -0,0 +1,94 @@
+import torch
+from PIL import Image
+from .imagefunc import log, tensor2pil, pil2tensor, image_rotate_extend_with_alpha, RGB2RGBA
+
+
+class LayerImageTransform:
+
+    def __init__(self):
+        self.NODE_NAME = 'LayerImageTransform'
+
+    @classmethod
+    def INPUT_TYPES(self):
+        mirror_mode = ['None', 'horizontal', 'vertical']
+        method_mode = ['lanczos', 'bicubic', 'hamming', 'bilinear', 'box', 'nearest']
+        return {
+            "required": {
+                "image": ("IMAGE",),  #
+                "x": ("INT", {"default": 0, "min": -99999, "max": 99999, "step": 1}),
+                "y": ("INT", {"default": 0, "min": -99999, "max": 99999, "step": 1}),
+                "mirror": (mirror_mode,),  # 镜像翻转
+                "scale": ("FLOAT", {"default": 1, "min": 0.01, "max": 100, "step": 0.01}),
+                "aspect_ratio": ("FLOAT", {"default": 1, "min": 0.01, "max": 100, "step": 0.01}),
+                "rotate": ("FLOAT", {"default": 0, "min": -999999, "max": 999999, "step": 0.01}),
+                "transform_method": (method_mode,),
+                "anti_aliasing": ("INT", {"default": 2, "min": 0, "max": 16, "step": 1}),
+            },
+            "optional": {
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    RETURN_NAMES = ("image",)
+    FUNCTION = 'layer_image_transform'
+    CATEGORY = '😺dzNodes/LayerUtility'
+
+    def layer_image_transform(self, image, x, y, mirror, scale, aspect_ratio, rotate,
+                            transform_method, anti_aliasing,
+                  ):
+
+        l_images = []
+        l_masks = []
+        ret_images = []
+
+        for l in image:
+            l_images.append(torch.unsqueeze(l, 0))
+            m = tensor2pil(l)
+            if m.mode == 'RGBA':
+                l_masks.append(m.split()[-1])
+
+        for i in range(len(l_images)):
+            layer_image = l_images[i] if i < len(l_images) else l_images[-1]
+            _image = tensor2pil(layer_image).convert('RGB')
+            if i < len(l_masks):
+                _mask = l_masks[i]
+            else:
+                _mask = Image.new('L', size=_image.size, color='white')
+            _image_canvas = Image.new('RGB', size=_image.size, color='black')
+            _mask_canvas = Image.new('L', size=_mask.size, color='black')
+            orig_layer_width = _image.width
+            orig_layer_height = _image.height
+            target_layer_width = int(orig_layer_width * scale)
+            target_layer_height = int(orig_layer_height * scale * aspect_ratio)
+            # mirror
+            if mirror == 'horizontal':
+                _image = _image.transpose(Image.FLIP_LEFT_RIGHT)
+                _mask = _mask.transpose(Image.FLIP_LEFT_RIGHT)
+            elif mirror == 'vertical':
+                _image = _image.transpose(Image.FLIP_TOP_BOTTOM)
+                _mask = _mask.transpose(Image.FLIP_TOP_BOTTOM)
+            # scale
+            _image = _image.resize((target_layer_width, target_layer_height))
+            _mask = _mask.resize((target_layer_width, target_layer_height))
+            # rotate
+            _image, _mask, _ = image_rotate_extend_with_alpha(_image, rotate, _mask, transform_method, anti_aliasing)
+            # composit layer
+            paste_x = (orig_layer_width - _image.width) // 2 + x
+            paste_y = (orig_layer_height - _image.height) // 2 + y
+            _image_canvas.paste(_image, (paste_x, paste_y))
+            _mask_canvas.paste(_mask, (paste_x, paste_y))
+            if tensor2pil(layer_image).mode == 'RGBA':
+                _image_canvas = RGB2RGBA(_image_canvas, _mask_canvas)
+
+            ret_images.append(pil2tensor(_image_canvas))
+
+        log(f"{self.NODE_NAME} Processed {len(l_images)} image(s).", message_type='finish')
+        return (torch.cat(ret_images, dim=0),)
+
+NODE_CLASS_MAPPINGS = {
+    "LayerUtility: LayerImageTransform": LayerImageTransform
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "LayerUtility: LayerImageTransform": "LayerUtility: LayerImageTransform"
+}

comfyui_layerstyle/py/layer_mask_transform.py

@@ -0,0 +1,81 @@
+import torch
+from PIL import Image
+from .imagefunc import log, tensor2pil, pil2tensor, image2mask, image_rotate_extend_with_alpha, RGB2RGBA
+
+
+
+class LayerMaskTransform:
+
+    def __init__(self):
+        self.NODE_NAME = 'LayerMaskTransform'
+
+    @classmethod
+    def INPUT_TYPES(self):
+        mirror_mode = ['None', 'horizontal', 'vertical']
+        method_mode = ['lanczos', 'bicubic', 'hamming', 'bilinear', 'box', 'nearest']
+        return {
+            "required": {
+                "mask": ("MASK",),  #
+                "x": ("INT", {"default": 0, "min": -99999, "max": 99999, "step": 1}),
+                "y": ("INT", {"default": 0, "min": -99999, "max": 99999, "step": 1}),
+                "mirror": (mirror_mode,),  # 镜像翻转
+                "scale": ("FLOAT", {"default": 1, "min": 0.01, "max": 100, "step": 0.01}),
+                "aspect_ratio": ("FLOAT", {"default": 1, "min": 0.01, "max": 100, "step": 0.01}),
+                "rotate": ("FLOAT", {"default": 0, "min": -999999, "max": 999999, "step": 0.01}),
+                "transform_method": (method_mode,),
+                "anti_aliasing": ("INT", {"default": 2, "min": 0, "max": 16, "step": 1}),
+            },
+            "optional": {
+            }
+        }
+
+    RETURN_TYPES = ("MASK",)
+    RETURN_NAMES = ("mask",)
+    FUNCTION = 'layer_mask_transform'
+    CATEGORY = '😺dzNodes/LayerUtility'
+
+    def layer_mask_transform(self, mask, x, y, mirror, scale, aspect_ratio, rotate,
+                            transform_method, anti_aliasing,
+                  ):
+
+        l_masks = []
+        ret_masks = []
+
+        if mask.dim() == 2:
+            mask = torch.unsqueeze(mask, 0)
+        for m in mask:
+            l_masks.append(torch.unsqueeze(m, 0))
+        for i in range(len(l_masks)):
+            _mask = l_masks[i] if i < len(l_masks) else l_masks[-1]
+            _mask = tensor2pil(_mask).convert('L')
+            _mask_canvas = Image.new('L', size=_mask.size, color='black')
+            orig_width = _mask.width
+            orig_height = _mask.height
+            target_layer_width = int(orig_width * scale)
+            target_layer_height = int(orig_height * scale * aspect_ratio)
+            # mirror
+            if mirror == 'horizontal':
+                _mask = _mask.transpose(Image.FLIP_LEFT_RIGHT)
+            elif mirror == 'vertical':
+                _mask = _mask.transpose(Image.FLIP_TOP_BOTTOM)
+            # scale
+            _mask = _mask.resize((target_layer_width, target_layer_height))
+            # rotate
+            _, _mask, _ = image_rotate_extend_with_alpha(_mask.convert('RGB'), rotate, _mask, transform_method, anti_aliasing)
+            paste_x = (orig_width - _mask.width) // 2 + x
+            paste_y = (orig_height - _mask.height) // 2 + y
+            # composit layer
+            _mask_canvas.paste(_mask, (paste_x, paste_y))
+
+            ret_masks.append(image2mask(_mask_canvas))
+
+        log(f"{self.NODE_NAME} Processed {len(l_masks)} mask(s).", message_type='finish')
+        return (torch.cat(ret_masks, dim=0),)
+
+NODE_CLASS_MAPPINGS = {
+    "LayerUtility: LayerMaskTransform": LayerMaskTransform
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "LayerUtility: LayerMaskTransform": "LayerUtility: LayerMaskTransform"
+}

comfyui_layerstyle/py/light_leak.py

@@ -0,0 +1,85 @@
+import os.path
+import random
+import time
+import torch
+from PIL import Image
+from .imagefunc import log, tensor2pil, pil2tensor, load_light_leak_images, image_hue_offset, image_gray_offset, image_channel_merge, fit_resize_image, chop_image
+
+
+
+blend_mode = 'screen'
+
+class LightLeak:
+
+    def __init__(self):
+        self.NODE_NAME = 'LightLeak'
+
+    @classmethod
+    def INPUT_TYPES(self):
+        light_list = ['random', '1', '2', '3', '4', '5', '6', '7', '8', '9', '10',
+                      '11', '12', '13', '14', '15', '16', '17', '18', '19', '20',
+                      '21', '22', '23', '24', '25', '26', '27', '28', '29', '30',
+                      '31', '32']
+        corner_list = ['left_top', 'right_top', 'left_bottom', 'right_bottom']
+        return {
+            "required": {
+                "image": ("IMAGE", ),
+                "light": (light_list,),
+                "corner": (corner_list,),
+                "hue": ("INT", {"default": 0, "min": -255, "max": 255, "step": 1}),
+                "saturation": ("INT", {"default": 0, "min": -255, "max": 255, "step": 1}),
+                "opacity": ("INT", {"default": 100, "min": 0, "max": 100, "step": 1})
+            },
+            "optional": {
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    RETURN_NAMES = ("image",)
+    FUNCTION = 'light_leak'
+    CATEGORY = '😺dzNodes/LayerFilter'
+
+    def light_leak(self, image, light, corner, hue, saturation, opacity):
+
+        ret_images = []
+        light_leak_images = load_light_leak_images()
+        if light == 'random':
+            random.seed(time.time())
+            light_index = random.randint(0,31)
+        else:
+            light_index = int(light) - 1
+
+        for i in image:
+            i = torch.unsqueeze(i, 0)
+            _canvas = tensor2pil(i).convert('RGB')
+            _light = light_leak_images[light_index]
+            if _canvas.width < _canvas.height:
+                _light = _light.transpose(Image.ROTATE_90).transpose(Image.FLIP_TOP_BOTTOM)
+            if corner == 'right_top':
+                _light = _light.transpose(Image.FLIP_LEFT_RIGHT)
+            elif corner == 'left_bottom':
+                _light = _light.transpose(Image.FLIP_TOP_BOTTOM)
+            elif corner == 'right_bottom':
+                _light = _light.transpose(Image.ROTATE_180)
+            if hue != 0 or saturation != 0:
+                _h, _s, _v = _light.convert('HSV').split()
+                if hue != 0:
+                    _h = image_hue_offset(_h, hue)
+                if saturation != 0:
+                    _s = image_gray_offset(_s, saturation)
+                _light = image_channel_merge((_h, _s, _v), 'HSV')
+            resize_sampler = Image.BILINEAR
+            _light = fit_resize_image(_light, _canvas.width, _canvas.height, fit='crop', resize_sampler=resize_sampler)
+            ret_image = chop_image(_canvas, _light, blend_mode=blend_mode, opacity = opacity)
+            ret_images.append(pil2tensor(ret_image))
+            
+        log(f"{self.NODE_NAME} Processed {len(ret_images)} image(s).", message_type='finish')
+        return (torch.cat(ret_images, dim=0),)
+
+NODE_CLASS_MAPPINGS = {
+    "LayerFilter: LightLeak": LightLeak
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "LayerFilter: LightLeak": "LayerFilter: LightLeak"
+}

comfyui_layerstyle/py/mask_box_detect.py

@@ -0,0 +1,78 @@
+import torch
+from PIL import Image
+from .imagefunc import log, tensor2pil, pil2tensor, gaussian_blur, mask2image
+from .imagefunc import min_bounding_rect, max_inscribed_rect, mask_area, draw_rect
+
+
+class MaskBoxDetect:
+
+    def __init__(self):
+        self.NODE_NAME = 'MaskBoxDetect'
+    
+    @classmethod
+    def INPUT_TYPES(self):
+        detect_mode = ['min_bounding_rect', 'max_inscribed_rect', 'mask_area']
+        return {
+            "required": {
+                "mask": ("MASK", ),
+                "detect": (detect_mode,),  # 探测类型：最小外接矩形/最大内接矩形
+                "x_adjust": ("INT", {"default": 0, "min": -9999, "max": 9999, "step": 1}),  # x轴修正
+                "y_adjust": ("INT", {"default": 0, "min": -9999, "max": 9999, "step": 1}),  # y轴修正
+                "scale_adjust": ("FLOAT", {"default": 1.0, "min": 0.01, "max": 100, "step": 0.01}), # 比例修正
+            },
+            "optional": {
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE", "FLOAT", "FLOAT", "INT", "INT", "INT", "INT",)
+    RETURN_NAMES = ("box_preview", "x_percent", "y_percent", "width", "height", "x", "y",)
+    FUNCTION = 'mask_box_detect'
+    CATEGORY = '😺dzNodes/LayerMask'
+
+    def mask_box_detect(self,mask, detect, x_adjust, y_adjust, scale_adjust):
+
+        if mask.dim() == 2:
+            mask = torch.unsqueeze(mask, 0)
+
+        if mask.shape[0] > 0:
+            mask = torch.unsqueeze(mask[0], 0)
+
+        _mask = mask2image(mask).convert('RGB')
+
+        _mask = gaussian_blur(_mask, 20).convert('L')
+        x = 0
+        y = 0
+        width = 0
+        height = 0
+
+        if detect == "min_bounding_rect":
+            (x, y, width, height) = min_bounding_rect(_mask)
+        elif detect == "max_inscribed_rect":
+            (x, y, width, height) = max_inscribed_rect(_mask)
+        else:
+            (x, y, width, height) = mask_area(_mask)
+        log(f"{self.NODE_NAME}: Box detected. x={x},y={y},width={width},height={height}")
+        _width = width
+        _height = height
+        if scale_adjust != 1.0:
+            _width = int(width * scale_adjust)
+            _height = int(height * scale_adjust)
+            x = x - int((_width - width) / 2)
+            y = y - int((_height - height) / 2)
+        x += x_adjust
+        y += y_adjust
+        x_percent = (x + _width / 2) / _mask.width * 100
+        y_percent = (y + _height / 2) / _mask.height * 100
+        preview_image = tensor2pil(mask).convert('RGB')
+        preview_image = draw_rect(preview_image, x - x_adjust, y - y_adjust, width, height, line_color="#F00000", line_width=int(preview_image.height / 60))
+        preview_image = draw_rect(preview_image, x, y, width, height, line_color="#00F000", line_width=int(preview_image.height / 40))
+        log(f"{self.NODE_NAME} Processed.", message_type='finish')
+        return ( pil2tensor(preview_image), round(x_percent, 2), round(y_percent, 2), _width, _height, x, y,)
+
+NODE_CLASS_MAPPINGS = {
+    "LayerMask: MaskBoxDetect": MaskBoxDetect
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "LayerMask: MaskBoxDetect": "LayerMask: MaskBoxDetect"
+}

comfyui_layerstyle/py/mask_by_color.py

@@ -0,0 +1,84 @@
+import torch
+from PIL import Image
+from .imagefunc import log, tensor2pil, pil2tensor, image2mask, create_mask_from_color_tensor, mask_fix
+
+
+
+
+class MaskByColor:
+
+    def __init__(self):
+        self.NODE_NAME = 'MaskByColor'
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE", ),
+                "color": ("COLOR", {"default": "#FFFFFF"},),
+                "color_in_HEX": ("STRING", {"default": ""}),
+                "threshold": ("INT", { "default": 50, "min": 0, "max": 100, "step": 1, }),
+                "fix_gap": ("INT", {"default": 2, "min": 0, "max": 32, "step": 1}),
+                "fix_threshold": ("FLOAT", {"default": 0.75, "min": 0.01, "max": 0.99, "step": 0.01}),
+                "invert_mask": ("BOOLEAN", {"default": False}),  # 反转mask
+            },
+            "optional": {
+                "mask": ("MASK",),  #
+            }
+        }
+
+    RETURN_TYPES = ("MASK",)
+    RETURN_NAMES = ("mask",)
+    FUNCTION = "mask_by_color"
+    CATEGORY = '😺dzNodes/LayerMask'
+
+    def mask_by_color(self, image, color, color_in_HEX, threshold,
+                      fix_gap, fix_threshold, invert_mask, mask=None):
+
+        if color_in_HEX != "" and color_in_HEX.startswith('#') and len(color_in_HEX) == 7:
+            color = color_in_HEX
+
+        ret_masks = []
+        l_images = []
+        l_masks = []
+
+        for l in image:
+            l_images.append(torch.unsqueeze(l, 0))
+            m = tensor2pil(l)
+            if m.mode == 'RGBA':
+                l_masks.append(m.split()[-1])
+            else:
+                l_masks.append(Image.new('L', m.size, 'white'))
+        if mask is not None:
+            if mask.dim() == 2:
+                mask = torch.unsqueeze(mask, 0)
+            l_masks = []
+            for m in mask:
+                if invert_mask:
+                    m = 1 - m
+                l_masks.append(tensor2pil(torch.unsqueeze(m, 0)).convert('L'))
+
+        for i in range(len(l_images)):
+            img = l_images[i] if i < len(l_images) else l_images[-1]
+            img = tensor2pil(img)
+            _mask = l_masks[i] if i < len(l_masks) else l_masks[-1]
+
+            mask = Image.new('L', _mask.size, 'black')
+            mask.paste(create_mask_from_color_tensor(img, color, threshold), mask=_mask)
+            mask = image2mask(mask)
+            if invert_mask:
+                mask = 1 - mask
+            if fix_gap:
+                mask = mask_fix(mask, 1, fix_gap, fix_threshold, fix_threshold)
+            ret_masks.append(mask)
+
+        return (torch.cat(ret_masks, dim=0), )
+
+
+NODE_CLASS_MAPPINGS = {
+    "LayerMask: MaskByColor": MaskByColor
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "LayerMask: MaskByColor": "LayerMask: Mask by Color"
+}

comfyui_layerstyle/py/mask_edge_shrink.py

@@ -0,0 +1,81 @@
+import torch
+from PIL import Image, ImageChops
+from .imagefunc import log, tensor2pil, pil2tensor, image2mask, mask_invert, step_color, expand_mask, step_value, chop_image
+
+
+
+class MaskEdgeShrink:
+
+    def __init__(self):
+        self.NODE_NAME = 'MaskEdgeShrink'
+
+    @classmethod
+    def INPUT_TYPES(self):
+
+        return {
+            "required": {
+                "mask": ("MASK", ),  #
+                "invert_mask": ("BOOLEAN", {"default": True}),  # 反转mask
+                "shrink_level": ("INT", {"default": 4, "min": 0, "max": 16, "step": 1}),
+                "soft": ("INT", {"default": 6, "min": 0, "max": 64, "step": 1}),
+                "edge_shrink": ("INT", {"default": 1, "min": 0, "max": 999, "step": 1}),
+                "edge_reserve": ("INT", {"default": 25, "min": 0, "max": 100, "step": 1}),  # 透明度
+            },
+            "optional": {
+            }
+        }
+
+    RETURN_TYPES = ("MASK",)
+    RETURN_NAMES = ("mask",)
+    FUNCTION = 'mask_edge_shrink'
+    CATEGORY = '😺dzNodes/LayerMask'
+
+    def mask_edge_shrink(self, mask, invert_mask, shrink_level, soft, edge_shrink, edge_reserve):
+
+        l_masks = []
+        ret_masks = []
+
+        if mask.dim() == 2:
+            mask = torch.unsqueeze(mask, 0)
+
+        for m in mask:
+            if invert_mask:
+                m = 1 - m
+            l_masks.append(tensor2pil(torch.unsqueeze(m, 0)).convert('L'))
+
+        glow_range = shrink_level * soft
+        blur = 12
+
+        for i in range(len(l_masks)):
+            _mask = l_masks[i]
+            _canvas = Image.new('RGB', size=_mask.size, color='black')
+            _layer = Image.new('RGB', size=_mask.size, color='white')
+            loop_grow = glow_range
+            inner_mask = _mask
+            for x in range(shrink_level):
+                _color = step_color('#FFFFFF', '#000000', shrink_level, x)
+                glow_mask = expand_mask(image2mask(inner_mask), -loop_grow, blur / (x+0.1))  #扩张，模糊
+                # 合成
+                color_image = Image.new("RGB", _layer.size, color=_color)
+                alpha = tensor2pil(mask_invert(glow_mask)).convert('L')
+                _glow = chop_image(_layer, color_image, 'subtract', int(step_value(1, 100, shrink_level, x)))
+                _layer.paste(_glow, mask=alpha)
+                loop_grow = loop_grow - int(glow_range / shrink_level)
+            # 合成layer
+            _edge = tensor2pil(expand_mask(image2mask(_mask), -edge_shrink, 0)).convert('RGB')
+            _layer = chop_image(_layer, _edge, 'normal', edge_reserve)
+            _layer.paste(_canvas, mask=ImageChops.invert(_mask))
+
+            ret_masks.append(image2mask(_layer))
+
+        log(f"{self.NODE_NAME} Processed {len(ret_masks)} mask(s).", message_type='finish')
+        return (torch.cat(ret_masks, dim=0),)
+
+
+NODE_CLASS_MAPPINGS = {
+    "LayerMask: MaskEdgeShrink": MaskEdgeShrink
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "LayerMask: MaskEdgeShrink": "LayerMask: MaskEdgeShrink"
+}