The most powerful and modular diffusion model GUI, api and backend with a graph/nodes interface. The fastest local inference engine in the world.
[feat] Add ImageStitch node for concatenating images (#8369)
Christian Byrned062fcc5c0bf
diff --git a/comfy_extras/nodes_images.py b/comfy_extras/nodes_images.pyindex 29a5d5b61..6ebf1dbd8 100644--- a/comfy_extras/nodes_images.py+++ b/comfy_extras/nodes_images.py@@ -14,6 +14,7 @@ import refrom io import BytesIOfrom inspect import cleandocimport torch+import comfy.utilsfrom comfy.comfy_types import FileLocator@@ -229,6 +230,186 @@ class SVG:all_svgs_list.extend(svg_item.data)return SVG(all_svgs_list)++class ImageStitch:+ """Upstreamed from https://github.com/kijai/ComfyUI-KJNodes"""++ @classmethod+ def INPUT_TYPES(s):+ return {+ "required": {+ "image1": ("IMAGE",),+ "direction": (["right", "down", "left", "up"], {"default": "right"}),+ "match_image_size": ("BOOLEAN", {"default": True}),+ "spacing_width": (+ "INT",+ {"default": 0, "min": 0, "max": 1024, "step": 2},+ ),+ "spacing_color": (+ ["white", "black", "red", "green", "blue"],+ {"default": "white"},+ ),+ },+ "optional": {+ "image2": ("IMAGE",),+ },+ }++ RETURN_TYPES = ("IMAGE",)+ FUNCTION = "stitch"+ CATEGORY = "image/transform"+ DESCRIPTION = """+Stitches image2 to image1 in the specified direction.+If image2 is not provided, returns image1 unchanged.+Optional spacing can be added between images.+"""++ def stitch(+ self,+ image1,+ direction,+ match_image_size,+ spacing_width,+ spacing_color,+ image2=None,+ ):+ if image2 is None:+ return (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)++ # 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]++ 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=0.0)+ 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=0.0)+ 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=0.0)+ 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=0.0)++ # 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++ 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]++ 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 (torch.cat(images, dim=concat_dim),)++class SaveSVGNode:"""Save SVG files on disk.@@ -318,4 +499,5 @@ NODE_CLASS_MAPPINGS = {"SaveAnimatedWEBP": SaveAnimatedWEBP,"SaveAnimatedPNG": SaveAnimatedPNG,"SaveSVGNode": SaveSVGNode,+ "ImageStitch": ImageStitch,}diff --git a/nodes.py b/nodes.pyindex 2d499051e..67360e7da 100644--- a/nodes.py+++ b/nodes.py@@ -2061,6 +2061,7 @@ NODE_DISPLAY_NAME_MAPPINGS = {"ImagePadForOutpaint": "Pad Image for Outpainting","ImageBatch": "Batch Images","ImageCrop": "Image Crop",+ "ImageStitch": "Image Stitch","ImageBlend": "Image Blend","ImageBlur": "Image Blur","ImageQuantize": "Image Quantize",diff --git a/tests-unit/comfy_extras_test/__init__.py b/tests-unit/comfy_extras_test/__init__.pynew file mode 100644index 000000000..e69de29bbdiff --git a/tests-unit/comfy_extras_test/image_stitch_test.py b/tests-unit/comfy_extras_test/image_stitch_test.pynew file mode 100644index 000000000..fbaef756c--- /dev/null+++ b/tests-unit/comfy_extras_test/image_stitch_test.py@@ -0,0 +1,240 @@+import torch+from unittest.mock import patch, MagicMock++# Mock nodes module to prevent CUDA initialization during import+mock_nodes = MagicMock()+mock_nodes.MAX_RESOLUTION = 16384++with patch.dict('sys.modules', {'nodes': mock_nodes}):+ from comfy_extras.nodes_images import ImageStitch+++class TestImageStitch:++ def create_test_image(self, batch_size=1, height=64, width=64, channels=3):+ """Helper to create test images with specific dimensions"""+ return torch.rand(batch_size, height, width, channels)++ def test_no_image2_passthrough(self):+ """Test that when image2 is None, image1 is returned unchanged"""+ node = ImageStitch()+ image1 = self.create_test_image()++ result = node.stitch(image1, "right", True, 0, "white", image2=None)++ assert len(result) == 1+ assert torch.equal(result[0], image1)++ def test_basic_horizontal_stitch_right(self):+ """Test basic horizontal stitching to the right"""+ node = ImageStitch()+ image1 = self.create_test_image(height=32, width=32)+ image2 = self.create_test_image(height=32, width=24)++ result = node.stitch(image1, "right", False, 0, "white", image2)++ assert result[0].shape == (1, 32, 56, 3) # 32 + 24 width++ def test_basic_horizontal_stitch_left(self):+ """Test basic horizontal stitching to the left"""+ node = ImageStitch()+ image1 = self.create_test_image(height=32, width=32)+ image2 = self.create_test_image(height=32, width=24)++ result = node.stitch(image1, "left", False, 0, "white", image2)++ assert result[0].shape == (1, 32, 56, 3) # 24 + 32 width++ def test_basic_vertical_stitch_down(self):+ """Test basic vertical stitching downward"""+ node = ImageStitch()+ image1 = self.create_test_image(height=32, width=32)+ image2 = self.create_test_image(height=24, width=32)++ result = node.stitch(image1, "down", False, 0, "white", image2)++ assert result[0].shape == (1, 56, 32, 3) # 32 + 24 height++ def test_basic_vertical_stitch_up(self):+ """Test basic vertical stitching upward"""+ node = ImageStitch()+ image1 = self.create_test_image(height=32, width=32)+ image2 = self.create_test_image(height=24, width=32)++ result = node.stitch(image1, "up", False, 0, "white", image2)++ assert result[0].shape == (1, 56, 32, 3) # 24 + 32 height++ def test_size_matching_horizontal(self):+ """Test size matching for horizontal concatenation"""+ node = ImageStitch()+ image1 = self.create_test_image(height=64, width=64)+ image2 = self.create_test_image(height=32, width=32) # Different aspect ratio++ result = node.stitch(image1, "right", True, 0, "white", image2)++ # image2 should be resized to match image1's height (64) with preserved aspect ratio+ expected_width = 64 + 64 # original + resized (32*64/32 = 64)+ assert result[0].shape == (1, 64, expected_width, 3)++ def test_size_matching_vertical(self):+ """Test size matching for vertical concatenation"""+ node = ImageStitch()+ image1 = self.create_test_image(height=64, width=64)+ image2 = self.create_test_image(height=32, width=32)++ result = node.stitch(image1, "down", True, 0, "white", image2)++ # image2 should be resized to match image1's width (64) with preserved aspect ratio+ expected_height = 64 + 64 # original + resized (32*64/32 = 64)+ assert result[0].shape == (1, expected_height, 64, 3)++ def test_padding_for_mismatched_heights_horizontal(self):+ """Test padding when heights don't match in horizontal concatenation"""+ node = ImageStitch()+ image1 = self.create_test_image(height=64, width=32)+ image2 = self.create_test_image(height=48, width=24) # Shorter height++ result = node.stitch(image1, "right", False, 0, "white", image2)++ # Both images should be padded to height 64+ assert result[0].shape == (1, 64, 56, 3) # 32 + 24 width, max(64,48) height++ def test_padding_for_mismatched_widths_vertical(self):+ """Test padding when widths don't match in vertical concatenation"""+ node = ImageStitch()+ image1 = self.create_test_image(height=32, width=64)+ image2 = self.create_test_image(height=24, width=48) # Narrower width++ result = node.stitch(image1, "down", False, 0, "white", image2)++ # Both images should be padded to width 64+ assert result[0].shape == (1, 56, 64, 3) # 32 + 24 height, max(64,48) width++ def test_spacing_horizontal(self):+ """Test spacing addition in horizontal concatenation"""+ node = ImageStitch()+ image1 = self.create_test_image(height=32, width=32)+ image2 = self.create_test_image(height=32, width=24)+ spacing_width = 16++ result = node.stitch(image1, "right", False, spacing_width, "white", image2)++ # Expected width: 32 + 16 (spacing) + 24 = 72+ assert result[0].shape == (1, 32, 72, 3)++ def test_spacing_vertical(self):+ """Test spacing addition in vertical concatenation"""+ node = ImageStitch()+ image1 = self.create_test_image(height=32, width=32)+ image2 = self.create_test_image(height=24, width=32)+ spacing_width = 16++ result = node.stitch(image1, "down", False, spacing_width, "white", image2)++ # Expected height: 32 + 16 (spacing) + 24 = 72+ assert result[0].shape == (1, 72, 32, 3)++ def test_spacing_color_values(self):+ """Test that spacing colors are applied correctly"""+ node = ImageStitch()+ image1 = self.create_test_image(height=32, width=32)+ image2 = self.create_test_image(height=32, width=32)++ # Test white spacing+ result_white = node.stitch(image1, "right", False, 16, "white", image2)+ # Check that spacing region contains white values (close to 1.0)+ spacing_region = result_white[0][:, :, 32:48, :] # Middle 16 pixels+ assert torch.all(spacing_region >= 0.9) # Should be close to white++ # Test black spacing+ result_black = node.stitch(image1, "right", False, 16, "black", image2)+ spacing_region = result_black[0][:, :, 32:48, :]+ assert torch.all(spacing_region <= 0.1) # Should be close to black++ def test_odd_spacing_width_made_even(self):+ """Test that odd spacing widths are made even"""+ node = ImageStitch()+ image1 = self.create_test_image(height=32, width=32)+ image2 = self.create_test_image(height=32, width=32)++ # Use odd spacing width+ result = node.stitch(image1, "right", False, 15, "white", image2)++ # Should be made even (16), so total width = 32 + 16 + 32 = 80+ assert result[0].shape == (1, 32, 80, 3)++ def test_batch_size_matching(self):+ """Test that different batch sizes are handled correctly"""+ node = ImageStitch()+ image1 = self.create_test_image(batch_size=2, height=32, width=32)+ image2 = self.create_test_image(batch_size=1, height=32, width=32)++ result = node.stitch(image1, "right", False, 0, "white", image2)++ # Should match larger batch size+ assert result[0].shape == (2, 32, 64, 3)++ def test_channel_matching_rgb_to_rgba(self):+ """Test that channel differences are handled (RGB + alpha)"""+ node = ImageStitch()+ image1 = self.create_test_image(channels=3) # RGB+ image2 = self.create_test_image(channels=4) # RGBA++ result = node.stitch(image1, "right", False, 0, "white", image2)++ # Should have 4 channels (RGBA)+ assert result[0].shape[-1] == 4++ def test_channel_matching_rgba_to_rgb(self):+ """Test that channel differences are handled (RGBA + RGB)"""+ node = ImageStitch()+ image1 = self.create_test_image(channels=4) # RGBA+ image2 = self.create_test_image(channels=3) # RGB++ result = node.stitch(image1, "right", False, 0, "white", image2)++ # Should have 4 channels (RGBA)+ assert result[0].shape[-1] == 4++ def test_all_color_options(self):+ """Test all available color options"""+ node = ImageStitch()+ image1 = self.create_test_image(height=32, width=32)+ image2 = self.create_test_image(height=32, width=32)++ colors = ["white", "black", "red", "green", "blue"]++ for color in colors:+ result = node.stitch(image1, "right", False, 16, color, image2)+ assert result[0].shape == (1, 32, 80, 3) # Basic shape check++ def test_all_directions(self):+ """Test all direction options"""+ node = ImageStitch()+ image1 = self.create_test_image(height=32, width=32)+ image2 = self.create_test_image(height=32, width=32)++ directions = ["right", "left", "up", "down"]++ for direction in directions:+ result = node.stitch(image1, direction, False, 0, "white", image2)+ assert result[0].shape == (1, 32, 64, 3) if direction in ["right", "left"] else (1, 64, 32, 3)++ def test_batch_size_channel_spacing_integration(self):+ """Test integration of batch matching, channel matching, size matching, and spacings"""+ node = ImageStitch()+ image1 = self.create_test_image(batch_size=2, height=64, width=48, channels=3)+ image2 = self.create_test_image(batch_size=1, height=32, width=32, channels=4)++ result = node.stitch(image1, "right", True, 8, "red", image2)++ # Should handle: batch matching, size matching, channel matching, spacing+ assert result[0].shape[0] == 2 # Batch size matched+ assert result[0].shape[-1] == 4 # Channels matched to max+ assert result[0].shape[1] == 64 # Height from image1 (size matching)+ # Width should be: 48 + 8 (spacing) + resized_image2_width+ expected_image2_width = int(64 * (32/32)) # Resized to height 64+ expected_total_width = 48 + 8 + expected_image2_width+ assert result[0].shape[2] == expected_total_width+