Upload 5 files

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Wladimir Palant
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,51 @@
+# Image Resize for ComfyUI
+
+This custom node provides various tools for resizing images. The goal is resizing without distorting proportions, yet without having to perform any calculations with the size of the original image. If a mask is present, it is resized and modified along with the image.
+
+![A ComfyUI node titled “Image resize” with inputs pixels and mask_optional, outputs IMAGE and MASK as well as a variety of widgets: action, smaller_side, larger_side, scale_factor, resize_mode, side_ratio, crop_pad_position, pad_feathering](image_resize.png)
+
+## Installation
+
+To install, clone this repository into `ComfyUI/custom_nodes` folder with `git clone https://github.com/palant/image-resize-comfyui` and restart ComfyUI.
+
+## Node configuration
+
+### action
+
+In the `resize only` mode, the image will only be resized while keeping its side ratio. The `side_ratio` setting is ignored then.
+
+In the `crop to ratio` mode, parts of the image will be removed after resizing as necessary to make its side ratio match `side_ratio` setting.
+
+In the `pad to ratio` mode, transparent padding will be added to the image after resizing as necessary to make its side ratio match `side_ratio` setting.
+
+### smaller_side, larger_side, scale_factor
+
+These settings determine the image’s target size. Only one of these settings can be enabled (set to a non-zero value).
+
+With `smaller_side` set, the target size is determined by the smaller side of the image. E.g. with the `action` being `resize only` and the original image being 512x768 pixels large, `smaller_side` set to 1024 will resize the image to 1024x1536 pixels.
+
+With `larger_side` set, the target size is determined by the larger side of the image. E.g. with the `action` being `resize only` and the original image being 512x768 pixels large, `larger_side` set to 1024 will resize the image to 683x1024 pixels.
+
+Finally, `scale_factor` can be set as an explicit scaling factor. Values below 1.0 will reduce image size, above 1.0 increase it.
+
+If neither setting is set, the image is not resized but merely cropped/padded as necessary.
+
+### resize_mode
+
+In the `reduce size only` mode, images already smaller than the target size will not be resized. In the `increase size only` mode, images already larger than the target size will not be resized. The `any` mode causes the image to be always resized, regardless of whether downscaling or upscaling is required.
+
+### side_ratio
+
+If the `action` setting enables cropping or padding of the image, this setting determines the required side ratio of the image. The format is `width:height`, e.g. `4:3` or `2:3`.
+
+In case you want to resize the image to an explicit size, you can also set this size here, e.g. `512:768`. You then set `smaller_side` setting to `512` and the resulting image will always be 512x768 pixels large.
+
+### crop_pad_position
+
+If the image is cropped, this setting determines which side is cropped. The value `0.0` means that only the right/bottom side is cropped. The value `1.0` means that only left/top side is cropped. The value `0.3` means that 30% are being cropped on the left/top side and 70% on the right/top side.
+
+If the image is padded, this setting determines where the padding is being inserted. The value `0.0` means that all padding is inserted on the right/bottom side. The value `1.0` means that all padding is inserted on the left/top side. The value `0.3` means that 30% of the padding are inserted on the left/top side and 70% on the right/top side.
+
+### pad_feathering
+
+If the image is padded, this setting causes mask transparency to partially expand into the original image for the given number of pixels. This helps avoid borders if the image is later inpainted.

__init__.py

@@ -0,0 +1,3 @@
+from .image_resize import NODE_CLASS_MAPPINGS, NODE_DISPLAY_NAME_MAPPINGS
+
+__all__ = ['NODE_CLASS_MAPPINGS', 'NODE_DISPLAY_NAME_MAPPINGS']

image_resize.py

@@ -0,0 +1,163 @@
+import torch
+
+class ImageResize:
+    def __init__(self):
+        pass
+
+
+    ACTION_TYPE_RESIZE = "resize only"
+    ACTION_TYPE_CROP = "crop to ratio"
+    ACTION_TYPE_PAD = "pad to ratio"
+    RESIZE_MODE_DOWNSCALE = "reduce size only"
+    RESIZE_MODE_UPSCALE = "increase size only"
+    RESIZE_MODE_ANY = "any"
+    RETURN_TYPES = ("IMAGE", "MASK",)
+    FUNCTION = "resize"
+    CATEGORY = "image"
+
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "pixels": ("IMAGE",),
+                "action": ([s.ACTION_TYPE_RESIZE, s.ACTION_TYPE_CROP, s.ACTION_TYPE_PAD],),
+                "smaller_side": ("INT", {"default": 0, "min": 0, "max": 8192, "step": 8}),
+                "larger_side": ("INT", {"default": 0, "min": 0, "max": 8192, "step": 8}),
+                "scale_factor": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 10.0, "step": 0.1}),
+                "resize_mode": ([s.RESIZE_MODE_DOWNSCALE, s.RESIZE_MODE_UPSCALE, s.RESIZE_MODE_ANY],),
+                "side_ratio": ("STRING", {"default": "4:3"}),
+                "crop_pad_position": ("FLOAT", {"default": 0.5, "min": 0.0, "max": 1.0, "step": 0.01}),
+                "pad_feathering": ("INT", {"default": 20, "min": 0, "max": 8192, "step": 1}),
+            },
+            "optional": {
+                "mask_optional": ("MASK",),
+            },
+        }
+
+
+    @classmethod
+    def VALIDATE_INPUTS(s, action, smaller_side, larger_side, scale_factor, resize_mode, side_ratio, **_):
+        if side_ratio is not None:
+            if action != s.ACTION_TYPE_RESIZE and s.parse_side_ratio(side_ratio) is None:
+                return f"Invalid side ratio: {side_ratio}"
+
+        if smaller_side is not None and larger_side is not None and scale_factor is not None:
+            if int(smaller_side > 0) + int(larger_side > 0) + int(scale_factor > 0) > 1:
+                return f"At most one scaling rule (smaller_side, larger_side, scale_factor) should be enabled by setting a non-zero value"
+
+        if scale_factor is not None:
+            if resize_mode == s.RESIZE_MODE_DOWNSCALE and scale_factor > 1.0:
+                return f"For resize_mode {s.RESIZE_MODE_DOWNSCALE}, scale_factor should be less than one but got {scale_factor}"
+            if resize_mode == s.RESIZE_MODE_UPSCALE and scale_factor > 0.0 and scale_factor < 1.0:
+                return f"For resize_mode {s.RESIZE_MODE_UPSCALE}, scale_factor should be larger than one but got {scale_factor}"
+
+        return True
+
+
+    @classmethod
+    def parse_side_ratio(s, side_ratio):
+        try:
+            x, y = map(int, side_ratio.split(":", 1))
+            if x < 1 or y < 1:
+                raise Exception("Ratio factors have to be positive numbers")
+            return float(x) / float(y)
+        except:
+            return None
+
+
+    def resize(self, pixels, action, smaller_side, larger_side, scale_factor, resize_mode, side_ratio, crop_pad_position, pad_feathering, mask_optional=None):
+        validity = self.VALIDATE_INPUTS(action, smaller_side, larger_side, scale_factor, resize_mode, side_ratio)
+        if validity is not True:
+            raise Exception(validity)
+
+        height, width = pixels.shape[1:3]
+        if mask_optional is None:
+            mask = torch.zeros(1, height, width, dtype=torch.float32)
+        else:
+            mask = mask_optional
+            if mask.shape[1] != height or mask.shape[2] != width:
+                mask = torch.nn.functional.interpolate(mask.unsqueeze(0), size=(height, width), mode="bicubic").squeeze(0).clamp(0.0, 1.0)
+
+        crop_x, crop_y, pad_x, pad_y = (0.0, 0.0, 0.0, 0.0)
+        if action == self.ACTION_TYPE_CROP:
+            target_ratio = self.parse_side_ratio(side_ratio)
+            if height * target_ratio < width:
+                crop_x = width - height * target_ratio
+            else:
+                crop_y = height - width / target_ratio
+        elif action == self.ACTION_TYPE_PAD:
+            target_ratio = self.parse_side_ratio(side_ratio)
+            if height * target_ratio > width:
+                pad_x = height * target_ratio - width
+            else:
+                pad_y = width / target_ratio - height
+
+        if smaller_side > 0:
+            if width + pad_x - crop_x > height + pad_y - crop_y:
+                scale_factor = float(smaller_side) / (height + pad_y - crop_y)
+            else:
+                scale_factor = float(smaller_side) / (width + pad_x - crop_x)
+        if larger_side > 0:
+            if width + pad_x - crop_x > height + pad_y - crop_y:
+                scale_factor = float(larger_side) / (width + pad_x - crop_x)
+            else:
+                scale_factor = float(larger_side) / (height + pad_y - crop_y)
+
+        if (resize_mode == self.RESIZE_MODE_DOWNSCALE and scale_factor >= 1.0) or (resize_mode == self.RESIZE_MODE_UPSCALE and scale_factor <= 1.0):
+            scale_factor = 0.0
+
+        if scale_factor > 0.0:
+            pixels = torch.nn.functional.interpolate(pixels.movedim(-1, 1), scale_factor=scale_factor, mode="bicubic", antialias=True).movedim(1, -1).clamp(0.0, 1.0)
+            mask = torch.nn.functional.interpolate(mask.unsqueeze(0), scale_factor=scale_factor, mode="bicubic", antialias=True).squeeze(0).clamp(0.0, 1.0)
+            height, width = pixels.shape[1:3]
+
+            crop_x *= scale_factor
+            crop_y *= scale_factor
+            pad_x *= scale_factor
+            pad_y *= scale_factor
+
+        if crop_x > 0.0 or crop_y > 0.0:
+            remove_x = (round(crop_x * crop_pad_position), round(crop_x * (1 - crop_pad_position))) if crop_x > 0.0 else (0, 0)
+            remove_y = (round(crop_y * crop_pad_position), round(crop_y * (1 - crop_pad_position))) if crop_y > 0.0 else (0, 0)
+            pixels = pixels[:, remove_y[0]:height - remove_y[1], remove_x[0]:width - remove_x[1], :]
+            mask = mask[:, remove_y[0]:height - remove_y[1], remove_x[0]:width - remove_x[1]]
+        elif pad_x > 0.0 or pad_y > 0.0:
+            add_x = (round(pad_x * crop_pad_position), round(pad_x * (1 - crop_pad_position))) if pad_x > 0.0 else (0, 0)
+            add_y = (round(pad_y * crop_pad_position), round(pad_y * (1 - crop_pad_position))) if pad_y > 0.0 else (0, 0)
+
+            new_pixels = torch.zeros(pixels.shape[0], height + add_y[0] + add_y[1], width + add_x[0] + add_x[1], pixels.shape[3], dtype=torch.float32)
+            new_pixels[:, add_y[0]:height + add_y[0], add_x[0]:width + add_x[0], :] = pixels
+            pixels = new_pixels
+
+            new_mask = torch.ones(mask.shape[0], height + add_y[0] + add_y[1], width + add_x[0] + add_x[1], dtype=torch.float32)
+            new_mask[:, add_y[0]:height + add_y[0], add_x[0]:width + add_x[0]] = mask
+            mask = new_mask
+
+            if pad_feathering > 0:
+                for i in range(mask.shape[0]):
+                    for j in range(pad_feathering):
+                        feather_strength = (1 - j / pad_feathering) * (1 - j / pad_feathering)
+                        if add_x[0] > 0 and j < width:
+                            for k in range(height):
+                                mask[i, k, add_x[0] + j] = max(mask[i, k, add_x[0] + j], feather_strength)
+                        if add_x[1] > 0 and j < width:
+                            for k in range(height):
+                                mask[i, k, width + add_x[0] - j - 1] = max(mask[i, k, width + add_x[0] - j - 1], feather_strength)
+                        if add_y[0] > 0 and j < height:
+                            for k in range(width):
+                                mask[i, add_y[0] + j, k] = max(mask[i, add_y[0] + j, k], feather_strength)
+                        if add_y[1] > 0 and j < height:
+                            for k in range(width):
+                                mask[i, height + add_y[0] - j - 1, k] = max(mask[i, height + add_y[0] - j - 1, k], feather_strength)
+
+        return (pixels, mask)
+
+
+NODE_CLASS_MAPPINGS = {
+    "ImageResize": ImageResize
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "ImageResize": "Image Resize"
+}