@classmethod

def define_schema(cls):

return IO.Schema(

node_id="ImageCrop",

search_aliases=["trim"],

display_name="Crop Image (DEPRECATED)",

category="image/transform",

is_deprecated=True,

essentials_category="Image Tools",

inputs=[

IO.Image.Input("image"),

IO.Int.Input("width", default=512, min=1, max=nodes.MAX_RESOLUTION, step=1),

IO.Int.Input("height", default=512, min=1, max=nodes.MAX_RESOLUTION, step=1),

IO.Int.Input("x", default=0, min=0, max=nodes.MAX_RESOLUTION, step=1),

IO.Int.Input("y", default=0, min=0, max=nodes.MAX_RESOLUTION, step=1),

],

outputs=[IO.Image.Output()],

)

@classmethod

def execute(cls, image, width, height, x, y) -> IO.NodeOutput:

x = min(x, image.shape[2] - 1)

y = min(y, image.shape[1] - 1)

to_x = width + x

to_y = height + y

img = image[:,y:to_y, x:to_x, :]

return IO.NodeOutput(img)

@classmethod

def define_schema(cls):

return IO.Schema(

node_id="ImageCropV2",

search_aliases=["crop", "cut", "trim"],

display_name="Crop Image",

category="image/transform",

description = "Crop an image to the specified dimensions.",

essentials_category="Image Tools",

has_intermediate_output=True,

inputs=[

IO.Image.Input("image"),

IO.BoundingBox.Input("crop_region", component="ImageCrop"),

],

outputs=[IO.Image.Output()],

)

@classmethod

def execute(cls, image, crop_region) -> IO.NodeOutput:

x = crop_region.get("x", 0)

y = crop_region.get("y", 0)

width = crop_region.get("width", 512)

height = crop_region.get("height", 512)

x = min(x, image.shape[2] - 1)

y = min(y, image.shape[1] - 1)

to_x = width + x

to_y = height + y

img = image[:,y:to_y, x:to_x, :]

mask_offset=0, mask_threshold=0.05, bg_rgb=(0.0, 0.0, 0.0),

aspect_ratio=1.0):

img = item_image.permute(2, 0, 1).unsqueeze(0).cpu().float().clamp(0, 1)

mask = item_mask.unsqueeze(0).unsqueeze(0).cpu().float().clamp(0, 1)

# Detect and correct an inverted mask, only when border and center have opposite polarity.

m2d = mask[0, 0]

h, w = m2d.shape

border = torch.cat([m2d[0, :], m2d[-1, :], m2d[:, 0], m2d[:, -1]])

center = m2d[h // 4:h - h // 4, w // 4:w - w // 4]

if float(border.mean()) > 0.5 and float(center.mean()) < 0.5:

mask = 1.0 - mask

if mask_offset > 0:

r = mask_offset

mask = torch.nn.functional.max_pool2d(mask, kernel_size=2 * r + 1, stride=1, padding=r)

elif mask_offset < 0:

r = -mask_offset

mask = 1.0 - torch.nn.functional.max_pool2d(1.0 - mask, kernel_size=2 * r + 1, stride=1, padding=r)

if mask_threshold > 0.0:

mask = torch.where(mask < mask_threshold, torch.zeros_like(mask), mask)

H, W = img.shape[-2:]

if max(H, W) > max_image_size:

scale = max_image_size / max(H, W)

new_w, new_h = int(W * scale), int(H * scale)

img = comfy.utils.common_upscale(img, new_w, new_h, "lanczos", "disabled")

mask = comfy.utils.common_upscale(mask, new_w, new_h, "lanczos", "disabled")

# common_upscale's lanczos path drops the singleton channel dim for masks (utils.py:1062).

if mask.ndim == 3:

mask = mask.unsqueeze(1)

H, W = new_h, new_w

scene_size = (W, H)

alpha_u8 = (mask[0, 0].clamp(0, 1) * 255.0).to(torch.uint8)

fg_pixels = (alpha_u8 > 204).nonzero()

if fg_pixels.numel() == 0:

# Try the inverted mask — auto-invert above may have been too conservative.

inv_fg = ((255 - alpha_u8) > 204).nonzero()

if inv_fg.numel() > 0:

logging.info("Trellis2 preprocess: mask bbox empty, using inverted mask.")

mask = 1.0 - mask

fg_pixels = inv_fg

if fg_pixels.numel() > 0:

y_min, x_min = fg_pixels.min(dim=0).values.tolist()

y_max, x_max = fg_pixels.max(dim=0).values.tolist()

center_y, center_x = (y_min + y_max) / 2.0, (x_min + x_max) / 2.0

bw = x_max - x_min + 1

bh = y_max - y_min + 1

# Grow the bbox so its aspect matches `aspect_ratio` (width/height),

# anchored on the max side. Then apply pad_factor.

if bw / max(bh, 1) >= aspect_ratio:

crop_w = int(bw * pad_factor)

crop_h = int(bw / aspect_ratio * pad_factor)

else:

crop_h = int(bh * pad_factor)

crop_w = int(bh * aspect_ratio * pad_factor)

half_w, half_h = math.ceil(crop_w / 2), math.ceil(crop_h / 2)

crop_x1 = int(center_x - half_w)

crop_y1 = int(center_y - half_h)

crop_x2 = crop_x1 + 2 * half_w

crop_y2 = crop_y1 + 2 * half_h

else:

logging.warning("Mask for the image is empty; a clean foreground mask is required for best quality.")

crop_x1, crop_y1, crop_x2, crop_y2 = 0, 0, W, H

crop_bbox = (crop_x1, crop_y1, crop_x2, crop_y2)

# Zero-pad out-of-bounds slice (PIL.crop semantics).

pad_l = max(0, -crop_x1)

pad_t = max(0, -crop_y1)

pad_r = max(0, crop_x2 - W)

pad_b = max(0, crop_y2 - H)

if pad_l or pad_t or pad_r or pad_b:

img = torch.nn.functional.pad(img, (pad_l, pad_r, pad_t, pad_b), value=0.0)

mask = torch.nn.functional.pad(mask, (pad_l, pad_r, pad_t, pad_b), value=0.0)

crop_x1 += pad_l

crop_x2 += pad_l

crop_y1 += pad_t

crop_y2 += pad_t

cropped_img = img [..., crop_y1:crop_y2, crop_x1:crop_x2]

cropped_mask = mask[..., crop_y1:crop_y2, crop_x1:crop_x2]

bg = torch.tensor(bg_rgb, dtype=cropped_img.dtype, device=cropped_img.device).view(1, 3, 1, 1)

composite = (cropped_img * cropped_mask + bg * (1.0 - cropped_mask)).clamp(0, 1)

"""Crop an image to its mask's bounding box (centered square, with pad_factor

@classmethod

def define_schema(cls):

return IO.Schema(

node_id="ImageCropToMask",

display_name="Crop Image to Mask",

category="image/transform",

search_aliases=["crop to mask", "mask crop", "crop mask", "mask crop resize", "crop mask resize", "trellis2", "pixal3d"],

inputs=[

IO.Image.Input("images"),

IO.Mask.Input("masks"),

IO.Int.Input("width", default=1024, min=64, max=4096, step=8, tooltip="Output width in pixels."),

IO.Int.Input("height", default=1024, min=64, max=4096, step=8, tooltip="Output height in pixels."),

IO.Float.Input("pad_factor", default=1.0, min=1.0, max=2.0, step=0.01, tooltip="Extra margin around the mask bounding box as a multiplier."),

IO.Int.Input("grow_mask", default=0, min=-32, max=32, step=1, tooltip="Grow or shrink the mask by this many pixels before cropping."),

IO.Color.Input("background", default="#000000", tooltip="Background color behind the masked subject."),

],

outputs=[IO.Image.Output(display_name="images")],

)

@classmethod

def execute(cls, images, masks, width, height, pad_factor, grow_mask, background) -> IO.NodeOutput:

h = background.lstrip("#")

bg_rgb = (int(h[0:2], 16) / 255.0, int(h[2:4], 16) / 255.0, int(h[4:6], 16) / 255.0) if len(h) == 6 else (0.0, 0.0, 0.0)

images = images[..., :3]

batch_size = images.shape[0]

if masks.shape[0] == 1 and batch_size > 1:

masks = masks.expand(batch_size, -1, -1)

elif masks.shape[0] != batch_size:

raise ValueError(f"Mask batch {masks.shape[0]} does not match image batch {batch_size}")

if masks.shape[-2:] != images.shape[1:3]:

masks = comfy.utils.common_upscale(masks.unsqueeze(1).float(), images.shape[2], images.shape[1], "bilinear", "disabled").squeeze(1)

out_images = []

for b in range(batch_size):

composite, _, _ = _crop_image_with_mask(

images[b], masks[b], max_image_size=max(width, height), pad_factor=pad_factor,

mask_offset=grow_mask, bg_rgb=bg_rgb, aspect_ratio=width / height,

)

composite = comfy.utils.common_upscale(composite, width, height, "lanczos", "disabled")

out_images.append(composite.movedim(-3, -1))

result = torch.cat(out_images, dim=0).to(

device=comfy.model_management.intermediate_device(),

dtype=comfy.model_management.intermediate_dtype(),

)

@classmethod

def define_schema(cls):

return IO.Schema(

node_id="PrimitiveBoundingBox",

display_name="Bounding Box",

category="utilities/primitive",

inputs=[

IO.Int.Input("x", default=0, min=0, max=MAX_RESOLUTION),

IO.Int.Input("y", default=0, min=0, max=MAX_RESOLUTION),

IO.Int.Input("width", default=512, min=1, max=MAX_RESOLUTION),

IO.Int.Input("height", default=512, min=1, max=MAX_RESOLUTION),

],

outputs=[IO.BoundingBox.Output()],

)

@classmethod

def execute(cls, x, y, width, height) -> IO.NodeOutput:

@classmethod

def define_schema(cls):

return IO.Schema(

node_id="RepeatImageBatch",

search_aliases=["duplicate image", "clone image"],

display_name="Repeat Image Batch",

category="image/batch",

inputs=[

IO.Image.Input("image"),

IO.Int.Input("amount", default=1, min=1, max=4096),

],

outputs=[IO.Image.Output()],

)

@classmethod

def execute(cls, image, amount) -> IO.NodeOutput:

s = image.repeat((amount, 1,1,1))

return IO.NodeOutput(s)

@classmethod

def define_schema(cls):

return IO.Schema(

node_id="ImageFromBatch",

search_aliases=["select image", "pick from batch", "extract image"],

display_name="Get Image from Batch",

category="image/batch",

inputs=[

IO.Image.Input("image"),

IO.Int.Input("batch_index", default=0, min=-MAX_RESOLUTION, max=MAX_RESOLUTION),

IO.Int.Input("length", default=1, min=1, max=4096),

],

outputs=[IO.Image.Output()],

)

@classmethod

def execute(cls, image, batch_index, length) -> IO.NodeOutput:

s_in = image

if batch_index < 0:

batch_index += s_in.shape[0]

batch_index = max(0, min(s_in.shape[0] - 1, batch_index))

length = min(s_in.shape[0] - batch_index, length)

s = s_in[batch_index:batch_index + length].clone()

return IO.NodeOutput(s)

@classmethod

def define_schema(cls):

return IO.Schema(

node_id="ImageAddNoise",

search_aliases=["film grain"],

display_name="Add Noise to Image",

category="image/filters",

inputs=[

IO.Image.Input("image"),

IO.Int.Input(

"seed",

default=0,

min=0,

max=0xFFFFFFFFFFFFFFFF,

control_after_generate=True,

tooltip="The random seed used for creating the noise.",

),

IO.Float.Input("strength", default=0.5, min=0.0, max=1.0, step=0.01),

],

outputs=[IO.Image.Output()],

)

@classmethod

def execute(cls, image, seed, strength) -> IO.NodeOutput:

generator = torch.manual_seed(seed)

s = torch.clip((image + strength * torch.randn(image.size(), generator=generator, device="cpu").to(image)), min=0.0, max=1.0)

if image.shape[-1] == 4: # alpha stores transparency, not color

s[..., 3] = image[..., 3]

return IO.NodeOutput(s)

COMPRESS_METHODS = {"default": 4, "fastest": 0, "slowest": 6}

@classmethod

def define_schema(cls):

return IO.Schema(

node_id="SaveAnimatedWEBP",

display_name="Save Animated WEBP",

category="image",

inputs=[

IO.Image.Input("images"),

IO.String.Input("filename_prefix", default="ComfyUI"),

IO.Float.Input("fps", default=6.0, min=0.01, max=1000.0, step=0.01),

IO.Boolean.Input("lossless", default=True),

IO.Int.Input("quality", default=80, min=0, max=100),

IO.Combo.Input("method", options=list(cls.COMPRESS_METHODS.keys())),

# "num_frames": ("INT", {"default": 0, "min": 0, "max": 8192}),

],

hidden=[IO.Hidden.prompt, IO.Hidden.extra_pnginfo],

is_output_node=True,

outputs=[IO.Image.Output(display_name="images")]

)

@classmethod

def execute(cls, images, fps, filename_prefix, lossless, quality, method, num_frames=0) -> IO.NodeOutput:

return IO.NodeOutput(

images,

ui=UI.ImageSaveHelper.get_save_animated_webp_ui(

images=images,

filename_prefix=filename_prefix,

cls=cls,

fps=fps,

lossless=lossless,

quality=quality,

method=cls.COMPRESS_METHODS.get(method)

)

@classmethod

def define_schema(cls):

return IO.Schema(

node_id="SaveAnimatedPNG",

display_name="Save Animated PNG",

category="image",

inputs=[

IO.Image.Input("images"),

IO.String.Input("filename_prefix", default="ComfyUI"),

IO.Float.Input("fps", default=6.0, min=0.01, max=1000.0, step=0.01),

IO.Int.Input("compress_level", default=4, min=0, max=9, advanced=True),

],

hidden=[IO.Hidden.prompt, IO.Hidden.extra_pnginfo],

is_output_node=True,

outputs=[IO.Image.Output(display_name="images")]

)

@classmethod

def execute(cls, images, fps, compress_level, filename_prefix="ComfyUI") -> IO.NodeOutput:

return IO.NodeOutput(

images,

ui=UI.ImageSaveHelper.get_save_animated_png_ui(

images=images,

filename_prefix=filename_prefix,

cls=cls,

fps=fps,

compress_level=compress_level,

)

"""Upstreamed from https://github.com/kijai/ComfyUI-KJNodes"""

@classmethod

def define_schema(cls):

return IO.Schema(

node_id="ImageStitch",

search_aliases=["combine images", "join images", "concatenate images", "side by side"],

display_name="Stitch Images",

description="Stitches image2 to image1 in the specified direction.\n"

"If image2 is not provided, returns image1 unchanged.\n"

"Optional spacing can be added between images.",

category="image/transform",

inputs=[

IO.Image.Input("image1"),

IO.Combo.Input("direction", options=["right", "down", "left", "up"], default="right"),

IO.Boolean.Input("match_image_size", default=True),

IO.Int.Input("spacing_width", default=0, min=0, max=1024, step=2, advanced=True),

IO.Combo.Input("spacing_color", options=["white", "black", "red", "green", "blue"], default="white", advanced=True),

IO.Image.Input("image2", optional=True),

],

outputs=[IO.Image.Output()],

)

@classmethod

def execute(

cls,

image1,

direction,

match_image_size,

spacing_width,

spacing_color,

image2=None,

) -> IO.NodeOutput:

if image2 is None:

return IO.NodeOutput(image1)

# Handle batch size differences

if image1.shape[0] != image2.shape[0]:

max_batch = max(image1.shape[0], image2.shape[0])

if image1.shape[0] < max_batch:

image1 = torch.cat(

[image1, image1[-1:].repeat(max_batch - image1.shape[0], 1, 1, 1)]

)

if image2.shape[0] < max_batch:

image2 = torch.cat(

[image2, image2[-1:].repeat(max_batch - image2.shape[0], 1, 1, 1)]

)

# Match image sizes if requested

if match_image_size:

h1, w1 = image1.shape[1:3]

h2, w2 = image2.shape[1:3]

aspect_ratio = w2 / h2

if direction in ["left", "right"]:

target_h, target_w = h1, int(h1 * aspect_ratio)

else: # up, down

target_w, target_h = w1, int(w1 / aspect_ratio)

image2 = comfy.utils.common_upscale(

image2.movedim(-1, 1), target_w, target_h, "lanczos", "disabled"

).movedim(1, -1)

color_map = {

"white": 1.0,

"black": 0.0,

"red": (1.0, 0.0, 0.0),

"green": (0.0, 1.0, 0.0),

"blue": (0.0, 0.0, 1.0),

}

color_val = color_map[spacing_color]

# When not matching sizes, pad to align non-concat dimensions

if not match_image_size:

h1, w1 = image1.shape[1:3]

h2, w2 = image2.shape[1:3]

pad_value = 0.0

if not isinstance(color_val, tuple):

pad_value = color_val

if direction in ["left", "right"]:

# For horizontal concat, pad heights to match

if h1 != h2:

target_h = max(h1, h2)

if h1 < target_h:

pad_h = target_h - h1

pad_top, pad_bottom = pad_h // 2, pad_h - pad_h // 2

image1 = torch.nn.functional.pad(image1, (0, 0, 0, 0, pad_top, pad_bottom), mode='constant', value=pad_value)

if h2 < target_h:

pad_h = target_h - h2

pad_top, pad_bottom = pad_h // 2, pad_h - pad_h // 2

image2 = torch.nn.functional.pad(image2, (0, 0, 0, 0, pad_top, pad_bottom), mode='constant', value=pad_value)

else: # up, down

# For vertical concat, pad widths to match

if w1 != w2:

target_w = max(w1, w2)

if w1 < target_w:

pad_w = target_w - w1

pad_left, pad_right = pad_w // 2, pad_w - pad_w // 2

image1 = torch.nn.functional.pad(image1, (0, 0, pad_left, pad_right), mode='constant', value=pad_value)

if w2 < target_w:

pad_w = target_w - w2

pad_left, pad_right = pad_w // 2, pad_w - pad_w // 2

image2 = torch.nn.functional.pad(image2, (0, 0, pad_left, pad_right), mode='constant', value=pad_value)

# Ensure same number of channels

if image1.shape[-1] != image2.shape[-1]:

max_channels = max(image1.shape[-1], image2.shape[-1])

if image1.shape[-1] < max_channels:

image1 = torch.cat(

[

image1,

torch.ones(

*image1.shape[:-1],

max_channels - image1.shape[-1],

device=image1.device,

),

],

dim=-1,

)

if image2.shape[-1] < max_channels:

image2 = torch.cat(

[

image2,

torch.ones(

*image2.shape[:-1],

max_channels - image2.shape[-1],

device=image2.device,

),

],

dim=-1,

)

# Add spacing if specified

if spacing_width > 0:

spacing_width = spacing_width + (spacing_width % 2) # Ensure even

if direction in ["left", "right"]:

spacing_shape = (

image1.shape[0],

max(image1.shape[1], image2.shape[1]),

spacing_width,

image1.shape[-1],

)

else:

spacing_shape = (

image1.shape[0],

spacing_width,

max(image1.shape[2], image2.shape[2]),

image1.shape[-1],

)

spacing = torch.full(spacing_shape, 0.0, device=image1.device)

if isinstance(color_val, tuple):

for i, c in enumerate(color_val):

if i < spacing.shape[-1]:

spacing[..., i] = c

if spacing.shape[-1] == 4: # Add alpha

spacing[..., 3] = 1.0

else:

spacing[..., : min(3, spacing.shape[-1])] = color_val

if spacing.shape[-1] == 4:

spacing[..., 3] = 1.0

# Concatenate images

images = [image2, image1] if direction in ["left", "up"] else [image1, image2]

if spacing_width > 0:

images.insert(1, spacing)

concat_dim = 2 if direction in ["left", "right"] else 1

return IO.NodeOutput(torch.cat(images, dim=concat_dim))

@classmethod

def define_schema(cls):

return IO.Schema(

node_id="ResizeAndPadImage",

search_aliases=["fit to size"],

display_name="Resize And Pad Image",

category="image/transform",

inputs=[

IO.Image.Input("image"),

IO.Int.Input("target_width", default=512, min=1, max=nodes.MAX_RESOLUTION, step=1),

IO.Int.Input("target_height", default=512, min=1, max=nodes.MAX_RESOLUTION, step=1),

IO.Combo.Input("padding_color", options=["white", "black"], advanced=True),

IO.Combo.Input("interpolation", options=["area", "bicubic", "nearest-exact", "bilinear", "lanczos"], advanced=True),

],

outputs=[IO.Image.Output()],

)

@classmethod

def execute(cls, image, target_width, target_height, padding_color, interpolation) -> IO.NodeOutput:

batch_size, orig_height, orig_width, channels = image.shape

scale_w = target_width / orig_width

scale_h = target_height / orig_height

scale = min(scale_w, scale_h)

new_width = int(orig_width * scale)

new_height = int(orig_height * scale)

image_permuted = image.permute(0, 3, 1, 2)

resized = comfy.utils.common_upscale(image_permuted, new_width, new_height, interpolation, "disabled")

pad_value = 0.0 if padding_color == "black" else 1.0

padded = torch.full(

(batch_size, channels, target_height, target_width),

pad_value,

dtype=image.dtype,

device=image.device

)

y_offset = (target_height - new_height) // 2

x_offset = (target_width - new_width) // 2

padded[:, :, y_offset:y_offset + new_height, x_offset:x_offset + new_width] = resized

output = padded.permute(0, 2, 3, 1)

return IO.NodeOutput(output)

@classmethod

def define_schema(cls):

return IO.Schema(

node_id="SaveSVGNode",

search_aliases=["export vector", "save vector graphics"],

display_name="Save SVG",

description="Save SVG files on disk.",

category="image",

inputs=[

IO.SVG.Input("svg"),

IO.String.Input(

"filename_prefix",

default="svg/ComfyUI",

tooltip="The prefix for the file to save. This may include formatting information such as %date:yyyy-MM-dd% or %Empty Latent Image.width% to include values from nodes.",

),

],

hidden=[IO.Hidden.prompt, IO.Hidden.extra_pnginfo],

is_output_node=True,

outputs=[IO.SVG.Output("svg")],

)

@classmethod

def execute(cls, svg: IO.SVG.Type, filename_prefix="svg/ComfyUI") -> IO.NodeOutput:

full_output_folder, filename, counter, subfolder, filename_prefix = folder_paths.get_save_image_path(filename_prefix, folder_paths.get_output_directory())

results: list[UI.SavedResult] = []

# Prepare metadata JSON

metadata_dict = {}

if cls.hidden.prompt is not None:

metadata_dict["prompt"] = cls.hidden.prompt

if cls.hidden.extra_pnginfo is not None:

metadata_dict.update(cls.hidden.extra_pnginfo)

# Convert metadata to JSON string

metadata_json = json.dumps(metadata_dict, indent=2) if metadata_dict else None

for batch_number, svg_bytes in enumerate(svg.data):

filename_with_batch_num = filename.replace("%batch_num%", str(batch_number))

file = f"{filename_with_batch_num}_{counter:05}_.svg"

# Read SVG content

svg_bytes.seek(0)

svg_content = svg_bytes.read().decode('utf-8')

# Inject metadata if available

if metadata_json:

# Create metadata element with CDATA section

metadata_element = f""" <metadata>

# Insert metadata after opening svg tag using regex with a replacement function

def replacement(match):

# match.group(1) contains the captured <svg> tag

return match.group(1) + '\n' + metadata_element

# Apply the substitution

svg_content = re.sub(r'(<svg[^>]*>)', replacement, svg_content, flags=re.UNICODE)

# Write the modified SVG to file

with open(os.path.join(full_output_folder, file), 'wb') as svg_file:

svg_file.write(svg_content.encode('utf-8'))

results.append(UI.SavedResult(filename=file, subfolder=subfolder, type=IO.FolderType.output))

counter += 1

@classmethod

def define_schema(cls):

return IO.Schema(

node_id="GetImageSize",

search_aliases=["dimensions", "resolution", "image info"],

display_name="Get Image Size",

description="Returns the width, height, and batch size of the image.",

category="image",

inputs=[

IO.Image.Input("image"),

],

outputs=[

IO.Int.Output(display_name="width"),

IO.Int.Output(display_name="height"),

IO.Int.Output(display_name="batch_size"),

],

hidden=[IO.Hidden.unique_id],

)

@classmethod

def execute(cls, image) -> IO.NodeOutput:

height = image.shape[1]

width = image.shape[2]

batch_size = image.shape[0]

# Send progress text to display size on the node

if cls.hidden.unique_id:

PromptServer.instance.send_progress_text(f"width: {width}, height: {height}\n batch size: {batch_size}", cls.hidden.unique_id)

return IO.NodeOutput(width, height, batch_size)

@classmethod

def define_schema(cls):

return IO.Schema(

node_id="ImageRotate",

display_name="Rotate Image",

search_aliases=["turn", "flip orientation"],

category="image/transform",

essentials_category="Image Tools",

inputs=[

IO.Image.Input("image"),

IO.Combo.Input("rotation", options=["none", "90 degrees", "180 degrees", "270 degrees"]),

],

outputs=[IO.Image.Output()],

)

@classmethod

def execute(cls, image, rotation) -> IO.NodeOutput:

rotate_by = 0

if rotation.startswith("90"):

rotate_by = 1

elif rotation.startswith("180"):

rotate_by = 2

elif rotation.startswith("270"):

rotate_by = 3

image = torch.rot90(image, k=rotate_by, dims=[2, 1])

return IO.NodeOutput(image)

@classmethod

def define_schema(cls):

return IO.Schema(

node_id="ImageFlip",

search_aliases=["mirror", "reflect"],

display_name="Flip Image",

category="image/transform",

inputs=[

IO.Image.Input("image"),

IO.Combo.Input("flip_method", options=["x-axis: vertically", "y-axis: horizontally"]),

],

outputs=[IO.Image.Output()],

)

@classmethod

def execute(cls, image, flip_method) -> IO.NodeOutput:

if flip_method.startswith("x"):

image = torch.flip(image, dims=[1])

elif flip_method.startswith("y"):

image = torch.flip(image, dims=[2])

return IO.NodeOutput(image)

@classmethod

def define_schema(cls):

return IO.Schema(

node_id="ImageScaleToMaxDimension",

display_name="Scale Image to Max Dimension",

category="image/upscaling",

inputs=[

IO.Image.Input("image"),

IO.Combo.Input(

"upscale_method",

options=["area", "lanczos", "bilinear", "nearest-exact", "bilinear", "bicubic"],

),

IO.Int.Input("largest_size", default=512, min=0, max=MAX_RESOLUTION, step=1),

],

outputs=[IO.Image.Output()],

)

@classmethod

def execute(cls, image, upscale_method, largest_size) -> IO.NodeOutput:

height = image.shape[1]

width = image.shape[2]

if height > width:

width = round((width / height) * largest_size)

height = largest_size

elif width > height:

height = round((height / width) * largest_size)

width = largest_size

else:

height = largest_size

width = largest_size

samples = image.movedim(-1, 1)

s = comfy.utils.common_upscale(samples, width, height, upscale_method, "disabled")

s = s.movedim(1, -1)

return IO.NodeOutput(s)

@classmethod

def define_schema(cls):

return IO.Schema(

node_id="SplitImageToTileList",

category="image/batch",

search_aliases=["split image", "tile image", "slice image"],

display_name="Split Image into List of Tiles",

description="Splits an image into a batched list of tiles with a specified overlap.",

inputs=[

IO.Image.Input("image"),

IO.Int.Input("tile_width", default=1024, min=64, max=MAX_RESOLUTION),

IO.Int.Input("tile_height", default=1024, min=64, max=MAX_RESOLUTION),

IO.Int.Input("overlap", default=128, min=0, max=4096),

],

outputs=[

IO.Image.Output(is_output_list=True),

],

)

@staticmethod

def get_grid_coords(width, height, tile_width, tile_height, overlap):

coords = []

stride_x = round(max(tile_width * 0.25, tile_width - overlap))

stride_y = round(max(tile_height * 0.25, tile_height - overlap))

y = 0

while y < height:

x = 0

y_end = min(y + tile_height, height)

y_start = max(0, y_end - tile_height)

while x < width:

x_end = min(x + tile_width, width)

x_start = max(0, x_end - tile_width)

coords.append((x_start, y_start, x_end, y_end))