v 2.1.0

Add `ImageCombineNode`
Add `ImagesGridByColumnsNode`
Add `ImagesGridByRowsNode`
Add `create_image_grid_by_rows` util
Add `create_image_grid_by_columns` util
Add `create_image_grid` util
Refactor code
Update workflows
Update images
Update link in README.md
Rename project

Author: LEv145

README.md

@@ -1,10 +1,10 @@
-# XYPlot: Comfy plugin
+# ImagesGrid: Comfy plugin
 
 
-![Image](./workflows/xy_plot_mini.png)
-[Workflows](./workflows/xy_plot_mini.json)
-![Image](./workflows/xy_plot_base.png)
-[Workflows](./workflows/xy_plot_base.json)
+![Image](./workflows/mini.png)
+[Workflows](./workflows/mini.json)
+![Image](./workflows/base.png)
+[Workflows](./workflows/base.json)
 
 
 ## How to use
@@ -13,11 +13,11 @@
 
 ```
 cd custom_nodes  # From comfy path
-git clone https://github.com/LEv145/XY-plot-comfy-plugin XYPlot
+git clone https://github.com/LEv145/images-grid-comfy-plugin ImagesGrid
 ```
 ### Update
 
 ```
-cd custom_nodes/XYPlot
+cd custom_nodes/ImagesGrid
 git pull
 ```

__init__.py

@@ -1,7 +1,9 @@
-from .src import LatentCombineNode, XYPlotNode
+from .src import LatentCombineNode, ImagesGridByColumnsNode, ImagesGridByRowsNode, ImageCombineNode
 
 
 NODE_CLASS_MAPPINGS = {
-    "XYPlot": XYPlotNode,
     "LatentCombine": LatentCombineNode,
+    "ImagesGridByColumns": ImagesGridByColumnsNode,
+    "ImagesGridByRows": ImagesGridByRowsNode,
+    "ImageCombine": ImageCombineNode,
 }

src/__init__.py

@@ -1,2 +1,3 @@
-from .nodes.xy_plot import XYPlotNode
+from .nodes.images_grid import ImagesGridByColumnsNode, ImagesGridByRowsNode
 from .nodes.latent_combine import LatentCombineNode
+from .nodes.image_combine import ImageCombineNode

src/base.py

@@ -1,16 +1,9 @@
 import typing as t
-from dataclasses import dataclass
 
 
-class BasePlotNode():
-    CATEGORY: str = "XYPlot"
+class BaseNode():
+    CATEGORY: str = "ImagesGrid"
     FUNCTION: str = "execute"
 
 
-@dataclass
-class KSamplerXYPlotInput():
-    setting: str
-    value: int
-
-
 Image = t.Any

src/nodes/image_combine.py

@@ -0,0 +1,32 @@
+import typing as t
+
+import torch
+
+from ..base import BaseNode, Image
+
+
+class ImageCombineNode(BaseNode):
+    RETURN_TYPES: t.Tuple[str] = ("IMAGE",)
+
+    @classmethod
+    def INPUT_TYPES(cls) -> t.Dict[str, t.Any]:
+        return {
+            "required": {
+                "image_1": ("IMAGE",),
+                "image_2": ("IMAGE",),
+            },
+        }
+
+    def execute(
+        self,
+        image_1: Image,
+        image_2: Image,
+    ) -> t.Tuple[Image]:
+        print(image_1.size())
+        print(image_2.size())
+        print(image_1)
+
+        result = torch.cat((image_1, image_2), 0)
+        print(result.size())
+
+        return (result,)

src/nodes/images_grid.py

@@ -0,0 +1,48 @@
+import typing as t
+
+from ..base import BaseNode, Image
+from ..utils import (
+    tensor_to_pillow,
+    pillow_to_tensor,
+    create_image_grid_by_columns,
+    create_image_grid_by_rows,
+)
+
+
+class BaseImagesGridNode(BaseNode):
+    RETURN_TYPES: t.Tuple[str] = ("IMAGE",)
+
+    @classmethod
+    def _create_input_types(cls, coordinate_name: str) -> t.Dict[str, t.Any]:
+        return {
+            "required": {
+                "images": ("IMAGE",),
+                "gap": ("INT", {"default": 0, "min": 0}),
+                coordinate_name: ("INT", {"default": 1, "min": 1}),
+            }
+        }
+
+    def _create_execute(self, images, function, function_kw) -> t.Tuple[Image]:
+        pillow_images = [tensor_to_pillow(i) for i in images]
+        pillow_grid = function(images=pillow_images, **function_kw)
+        tensor_grid = pillow_to_tensor(pillow_grid)
+
+        return (tensor_grid,)
+
+
+class ImagesGridByColumnsNode(BaseImagesGridNode):
+    @classmethod
+    def INPUT_TYPES(cls) -> t.Dict[str, t.Any]:
+        return cls._create_input_types("max_columns")
+
+    def execute(self, images: Image, **kw) -> tuple[Image]:
+        return self._create_execute(images, create_image_grid_by_columns, kw)
+
+
+class ImagesGridByRowsNode(BaseImagesGridNode):
+    @classmethod
+    def INPUT_TYPES(cls) -> t.Dict[str, t.Any]:
+        return cls._create_input_types("max_rows")
+
+    def execute(self, images: Image, **kw) -> tuple[Image]:
+        return self._create_execute(images, create_image_grid_by_rows, kw)

src/nodes/latent_combine.py

@@ -2,10 +2,10 @@
 
 import torch
 
-from ..base import BasePlotNode, Image
+from ..base import BaseNode, Image
 
 
-class LatentCombineNode(BasePlotNode):
+class LatentCombineNode(BaseNode):
     RETURN_TYPES: t.Tuple[str] = ("LATENT",)
 
     @classmethod
@@ -22,8 +22,6 @@ def execute(
         latent_1: t.Dict[str, t.Any],
         latent_2: t.Dict[str, t.Any],
     ) -> t.Tuple[t.Dict[str, t.Any]]:
-        latent_1_samples = latent_1["samples"]
-        latent_2_samples = latent_2["samples"]
-        samples = torch.cat((latent_1_samples, latent_2_samples), 0)
+        samples = torch.cat((latent_1["samples"], latent_2["samples"]), 0)
 
         return ({"samples": samples},)

src/nodes/xy_plot.py

@@ -13,27 +13,41 @@ def pillow_to_tensor(image):
     return torch.from_numpy(np.array(image).astype(np.float32) / 255.0).unsqueeze(0)
 
 
-def create_image_grid(images: t.List[Image.Image], gap: int, ncol: int):
-    # Calculate the number of rows needed based on the number of images and columns
-    nrow = (len(images) + ncol - 1) // ncol
-
-    # Get the size of the first image to use as a template for the grid
+def create_image_grid_by_columns(
+    images: t.List[Image.Image],
+    gap: int,
+    max_columns: int,
+) -> Image.Image:
+    max_rows = (len(images) + max_columns - 1) // max_columns
+    return create_image_grid(images=images, gap=gap, max_columns=max_columns, max_rows=max_rows)
+
+
+def create_image_grid_by_rows(
+    images: t.List[Image.Image],
+    gap: int,
+    max_rows: int,
+) -> Image.Image:
+    max_columns = (len(images) + max_rows - 1) // max_rows
+    return create_image_grid(images=images, gap=gap, max_columns=max_columns, max_rows=max_rows)
+
+
+def create_image_grid(
+    images: t.List[Image.Image],
+    gap: int,
+    max_columns: int,
+    max_rows: int,
+) -> Image.Image:
     size = images[0].size
 
-    # Calculate the total size of the grid with gaps
-    width = size[0] * ncol + gap * (ncol - 1)
-    height = size[1] * nrow + gap * (nrow - 1)
+    width = size[0] * max_columns + (max_columns - 1) * gap
+    height = size[1] * max_rows + (max_rows - 1) * gap
 
-    # Create a new image for the grid
     grid_image = Image.new("RGB", (width, height), color="white")
 
-    # Iterate over each image and paste it into the grid
     for i, image in enumerate(images):
-        # Calculate the position of the image in the grid
-        x = (i % ncol) * (size[0] + gap)
-        y = (i // ncol) * (size[1] + gap)
+        x = (i % max_columns) * (size[0] + gap)
+        y = (i // max_columns) * (size[1] + gap)
 
-        # Paste the image into the grid
         grid_image.paste(image, (x, y))
 
     return grid_image