15 |
16 | ## Nodes Design
17 |
18 | 
19 |
20 | ## New Nodes:
21 |
22 | * Image resize
23 | * Image Extend
24 | * Image Filter
25 | * Image Overlay
26 | * Image Add/Extract Metadata
27 | * Image extract Palette
28 | * Image Apply Palette
29 |
30 |
--------------------------------------------------------------------------------
/nodes/set_text_node.py:
--------------------------------------------------------------------------------
1 | class SetText:
2 | @classmethod
3 | def INPUT_TYPES(cls):
4 | # Define the input types for your node. In this case, we need a string input.
5 | return {
6 | "required": {
7 | "user_input": ("STRING", {"default": "My Text", "multiline":True})
8 | }
9 | }
10 |
11 | RETURN_TYPES = ("STRING",)
12 | RETURN_NAMES = ("Output String",)
13 | FUNCTION = "process_string"
14 | CATEGORY = "utils"
15 |
16 | def process_string(self, user_input):
17 | # This function will be called to process the user input string.
18 | return (user_input,)
19 |
20 | NODE_CLASS_MAPPINGS = {
21 | "Set Text": SetText,
22 | }
23 |
24 | NODE_DISPLAY_NAME_MAPPINGS = {
25 | "Set Text": "🛡️Set Text",
26 | }
--------------------------------------------------------------------------------
/nodes/image_flip_node.py:
--------------------------------------------------------------------------------
1 | import torch
2 |
3 | class ImageFlip:
4 | @classmethod
5 | def INPUT_TYPES(cls):
6 | return {
7 | "required": {
8 | "image": ("IMAGE",),
9 | "axis": (["x", "y", "xy"],),
10 | }
11 | }
12 |
13 | RETURN_TYPES = ("IMAGE",)
14 | FUNCTION = "flip"
15 |
16 | CATEGORY = "image/transform"
17 | DESCRIPTION = """
18 | Transform the input image along the specified axis.
19 | """
20 |
21 | def flip(self, image, axis):
22 | dim = ()
23 | if "y" in axis:
24 | dim += (1,)
25 | if "x" in axis:
26 | dim += (2,)
27 | image = torch.flip(image, dim)
28 |
29 | return(image,)
30 |
31 | NODE_CLASS_MAPPINGS = {
32 | "ImageFlip": ImageFlip,
33 | }
34 |
35 | NODE_DISPLAY_NAME_MAPPINGS = {
36 | "ImageFlip": "🌅Image Flip",
37 | }
--------------------------------------------------------------------------------
/nodes/note_extended_node.py:
--------------------------------------------------------------------------------
1 | class NoteAdvanced:
2 | @classmethod
3 | def INPUT_TYPES(cls):
4 | # Define the input types for your node. In this case, we need a string input.
5 | return {
6 | "required": {
7 | "user_note": ("STRING", {"default": "Note", "multiline":True}),
8 | "user_comment": ("STRING", {"default": "Comment", "multiline":True}),
9 | }
10 | }
11 |
12 | RETURN_TYPES = ()
13 | OUTPUT_NODE = False
14 | FUNCTION = "note_advanced"
15 | CATEGORY = "utils"
16 |
17 | def note_advanced(self, user_note,user_comment):
18 | # This function will be called to process the user input string.
19 | return (user_note,user_comment,)
20 |
21 | NODE_CLASS_MAPPINGS = {
22 | "NoteAdvanced": NoteAdvanced,
23 | }
24 |
25 | NODE_DISPLAY_NAME_MAPPINGS = {
26 | "NoteAdvanced": "🛡️Note Advanced",
27 | }
--------------------------------------------------------------------------------
/nodes/image_contrast_node.py:
--------------------------------------------------------------------------------
1 | import numpy as np
2 | import torch
3 | from torch import Tensor
4 | from PIL import Image, ImageEnhance, ImageFilter
5 |
6 | def tensor2pil(image: Tensor) -> Image.Image:
7 | return Image.fromarray(np.clip(255. * image.cpu().numpy().squeeze(), 0, 255).astype(np.uint8))
8 |
9 | def pil2tensor(image: Image.Image) -> Tensor:
10 | return torch.from_numpy(np.array(image).astype(np.float32) / 255.0).unsqueeze(0)
11 |
12 | class ImageContrast:
13 | CATEGORY = "image/postprocessing"
14 | @classmethod
15 | def INPUT_TYPES(cls):
16 | return {
17 | "required": {
18 | "image": ("IMAGE",),
19 | "contrast_factor": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 2.0, "step":0.1})
20 | }
21 | }
22 |
23 | RETURN_TYPES = ("IMAGE",)
24 | FUNCTION = "apply_brightness"
25 | OUTPUT_NODE = True
26 |
27 | def apply_brightness(self, image, contrast_factor):
28 | pil_image = tensor2pil(image)
29 | #pil_image = pil_image.convert("RGB")
30 | pil_image = ImageEnhance.Contrast(pil_image).enhance(contrast_factor)
31 | pil_image = pil_image.convert("RGB")
32 |
33 | return (pil2tensor(pil_image),)
34 |
35 | NODE_CLASS_MAPPINGS = {
36 | "Contrast Image": ImageContrast,
37 | }
38 |
39 | NODE_DISPLAY_NAME_MAPPINGS = {
40 | "Contrast Image": "🌅Image Contrast",
41 | }
--------------------------------------------------------------------------------
/nodes/image_brightness_node.py:
--------------------------------------------------------------------------------
1 | import numpy as np
2 | import torch
3 | from torch import Tensor
4 | from PIL import Image, ImageEnhance, ImageFilter
5 |
6 | def tensor2pil(image: Tensor) -> Image.Image:
7 | return Image.fromarray(np.clip(255. * image.cpu().numpy().squeeze(), 0, 255).astype(np.uint8))
8 |
9 | def pil2tensor(image: Image.Image) -> Tensor:
10 | return torch.from_numpy(np.array(image).astype(np.float32) / 255.0).unsqueeze(0)
11 |
12 | class ImageBrightness:
13 | CATEGORY = "image/postprocessing"
14 | @classmethod
15 | def INPUT_TYPES(cls):
16 | return {
17 | "required": {
18 | "image": ("IMAGE",),
19 | "brightness_factor": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 2.0, "step":0.1})
20 | }
21 | }
22 |
23 | RETURN_TYPES = ("IMAGE",)
24 | FUNCTION = "apply_brightness"
25 | OUTPUT_NODE = True
26 |
27 | def apply_brightness(self, image, brightness_factor):
28 | pil_image = tensor2pil(image)
29 | #pil_image = pil_image.convert("RGB")
30 | pil_image = ImageEnhance.Brightness(pil_image).enhance(brightness_factor)
31 | pil_image = pil_image.convert("RGB")
32 |
33 | return (pil2tensor(pil_image),)
34 |
35 | NODE_CLASS_MAPPINGS = {
36 | "Brightness Image": ImageBrightness,
37 | }
38 |
39 | NODE_DISPLAY_NAME_MAPPINGS = {
40 | "Brightness Image": "🌅Image Brightness",
41 | }
--------------------------------------------------------------------------------
/nodes/image_difference_node.py:
--------------------------------------------------------------------------------
1 | import numpy as np
2 | import torch
3 | from torch import Tensor
4 | from PIL import Image, ImageEnhance, ImageChops
5 |
6 | def tensor2pil(image: Tensor) -> Image.Image:
7 | return Image.fromarray(np.clip(255. * image.cpu().numpy().squeeze(), 0, 255).astype(np.uint8))
8 |
9 | def pil2tensor(image: Image.Image) -> Tensor:
10 | return torch.from_numpy(np.array(image).astype(np.float32) / 255.0).unsqueeze(0)
11 |
12 | class ImageDifference:
13 | @classmethod
14 | def INPUT_TYPES(cls):
15 | return {
16 | "required": {
17 | "image": ("IMAGE",),
18 | "image2": ("IMAGE",),
19 | #"factor": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 5.0, "step":0.1})
20 | }
21 | }
22 |
23 | RETURN_TYPES = ("IMAGE",)
24 | FUNCTION = "apply_difference"
25 | OUTPUT_NODE = True
26 |
27 | CATEGORY = "image/postprocessing"
28 |
29 | def apply_difference(self, image, image2):
30 | pil_image1 = tensor2pil(image)
31 | pil_image2 = tensor2pil(image2)
32 |
33 | diff = ImageChops.difference(pil_image1, pil_image2)
34 |
35 |
36 | #pil_image = pil_image.convert("RGB")
37 | # pil_image = ImageEnhance.Contrast(pil_image).enhance(factor)
38 | # pil_image = pil_image.convert("RGB")
39 |
40 | return (pil2tensor(diff),)
41 |
42 | NODE_CLASS_MAPPINGS = {
43 | "Image Difference": ImageDifference,
44 | }
45 |
46 | NODE_DISPLAY_NAME_MAPPINGS = {
47 | "Image Difference": "🌅Image Difference",
48 | }
--------------------------------------------------------------------------------
/nodes/image_desaturate_node.py:
--------------------------------------------------------------------------------
1 | import numpy as np
2 | import torch
3 | from torch import Tensor
4 | from PIL import Image, ImageEnhance, ImageFilter
5 |
6 | def tensor2pil(image: Tensor) -> Image.Image:
7 | return Image.fromarray(np.clip(255. * image.cpu().numpy().squeeze(), 0, 255).astype(np.uint8))
8 |
9 | def pil2tensor(image: Image.Image) -> Tensor:
10 | return torch.from_numpy(np.array(image).astype(np.float32) / 255.0).unsqueeze(0)
11 |
12 | class ImageDesaturate:
13 | @classmethod
14 | def INPUT_TYPES(cls):
15 | return {
16 | "required": {
17 | "image": ("IMAGE",),
18 | "brightness": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 5.0, "step":0.1}),
19 | "contrast": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 5.0, "step":0.1}),
20 | },
21 | }
22 |
23 | RETURN_TYPES = ("IMAGE",)
24 | FUNCTION = "image_greyscale"
25 |
26 | CATEGORY = "image/postprocessing"
27 |
28 | def image_greyscale(self, image, brightness, contrast):
29 | pil_image = tensor2pil(image)
30 | greyscaled_image = pil_image.convert("L")
31 | greyscaled_image = ImageEnhance.Brightness(greyscaled_image).enhance(brightness)
32 | greyscaled_image = ImageEnhance.Contrast(greyscaled_image).enhance(contrast)
33 | greyscaled_image = greyscaled_image.convert("RGB")
34 | return (pil2tensor(greyscaled_image),)
35 |
36 | # REG
37 | NODE_CLASS_MAPPINGS = {
38 | "ImageDesaturate": ImageDesaturate,
39 | }
40 |
41 | NODE_DISPLAY_NAME_MAPPINGS = {
42 | "ImageDesaturate": "➡️ Image Desaturate",
43 | }
--------------------------------------------------------------------------------
/nodes/get_text_node.py:
--------------------------------------------------------------------------------
1 | class GetText:
2 | @classmethod
3 | def INPUT_TYPES(s):
4 | return {
5 | "required": {
6 | "text": ("STRING", {"forceInput": True,"name":"DD"}),
7 | },
8 | "hidden": {
9 | "unique_id": "UNIQUE_ID",
10 | "extra_pnginfo": "EXTRA_PNGINFO",
11 | },
12 | }
13 |
14 | INPUT_IS_LIST = True
15 | # INPUT_NAMES = ("Input String",)
16 |
17 | RETURN_TYPES = ()
18 | FUNCTION = "get_text"
19 | OUTPUT_NODE = True
20 | OUTPUT_IS_LIST = (True,)
21 |
22 | # RESPECT THE MAIN CATEGORIES!!!
23 | CATEGORY = "utils"
24 |
25 | def get_text(self, text, unique_id=None, extra_pnginfo=None):
26 | if unique_id is not None and extra_pnginfo is not None:
27 | if not isinstance(extra_pnginfo, list):
28 | print("Error: extra_pnginfo is not a list")
29 | elif (
30 | not isinstance(extra_pnginfo[0], dict)
31 | or "workflow" not in extra_pnginfo[0]
32 | ):
33 | print("Error: extra_pnginfo[0] is not a dict or missing 'workflow' key")
34 | else:
35 | workflow = extra_pnginfo[0]["workflow"]
36 | node = next(
37 | (x for x in workflow["nodes"] if str(x["id"]) == str(unique_id[0])),
38 | None,
39 | )
40 | if node:
41 | node["widgets_values"] = [text]
42 |
43 | return {"ui": {"text": text}, "result": (text,)}
44 |
45 |
46 | NODE_CLASS_MAPPINGS = {
47 | "Get Text": GetText,
48 | }
49 |
50 | NODE_DISPLAY_NAME_MAPPINGS = {
51 | "Get Text": "🛡️Get Text",
52 | }
53 |
--------------------------------------------------------------------------------
/web/js/GetText.js:
--------------------------------------------------------------------------------
1 | import { app } from "../../../scripts/app.js";
2 | import { ComfyWidgets } from "../../../scripts/widgets.js";
3 |
4 | // Displays input text on a node
5 | app.registerExtension({
6 | name: "nai.GetText",
7 | async beforeRegisterNodeDef(nodeType, nodeData, app) {
8 | if (nodeData.name === "Get Text") {
9 | function populate(text) {
10 | if (this.widgets) {
11 | for (let i = 1; i < this.widgets.length; i++) {
12 | this.widgets[i].onRemove?.();
13 | }
14 | this.widgets.length = 1;
15 | }
16 |
17 | const v = [...text];
18 | if (!v[0]) {
19 | v.shift();
20 | }
21 | for (const list of v) {
22 | const w = ComfyWidgets["STRING"](this, "text2", ["STRING", { multiline: true }], app).widget;
23 | w.inputEl.readOnly = true;
24 | w.inputEl.style.opacity = 0.6;
25 | w.value = list;
26 | }
27 |
28 | requestAnimationFrame(() => {
29 | const sz = this.computeSize();
30 | if (sz[0] < this.size[0]) {
31 | sz[0] = this.size[0];
32 | }
33 | if (sz[1] < this.size[1]) {
34 | sz[1] = this.size[1];
35 | }
36 | this.onResize?.(sz);
37 | app.graph.setDirtyCanvas(true, false);
38 | });
39 | }
40 |
41 | // When the node is executed we will be sent the input text, display this in the widget
42 | const onExecuted = nodeType.prototype.onExecuted;
43 | nodeType.prototype.onExecuted = function (message) {
44 | onExecuted?.apply(this, arguments);
45 | populate.call(this, message.text);
46 | };
47 |
48 | const onConfigure = nodeType.prototype.onConfigure;
49 | nodeType.prototype.onConfigure = function () {
50 | onConfigure?.apply(this, arguments);
51 | if (this.widgets_values?.length) {
52 | populate.call(this, this.widgets_values.slice(+this.widgets_values.length > 1));
53 | }
54 | };
55 | }
56 | },
57 | });
58 |
--------------------------------------------------------------------------------
/__init__.py:
--------------------------------------------------------------------------------
1 | import importlib.util
2 | import glob
3 | import os
4 | import sys
5 | from .nai import init
6 | #from .nai import init, get_ext_dir
7 |
8 | NODE_CLASS_MAPPINGS = {}
9 | NODE_DISPLAY_NAME_MAPPINGS = {}
10 |
11 | # --------------------
12 | def get_ext_dir(subpath=None, mkdir=False):
13 | dir = os.path.dirname(__file__)
14 | if subpath is not None:
15 | dir = os.path.join(dir, subpath)
16 |
17 | dir = os.path.abspath(dir)
18 |
19 | if mkdir and not os.path.exists(dir):
20 | os.makedirs(dir)
21 | return dir
22 |
23 | # --------------------
24 |
25 | if init():
26 | # CHECK FOR NODES DIRECTORY
27 | py = get_ext_dir("nodes")
28 | # CHECK FOR FILES
29 | files = glob.glob(os.path.join(py, "*.py"), recursive=False)
30 |
31 | for file in files:
32 | name = os.path.splitext(file)[0]
33 | spec = importlib.util.spec_from_file_location(name, file)
34 | module = importlib.util.module_from_spec(spec)
35 | sys.modules[name] = module
36 | spec.loader.exec_module(module)
37 | # Console list of all the nodes files
38 | #print("🛡️ComfyUI Compositing Nodes Pack: Loading " + name)
39 | # Register and update each class from the files
40 | if hasattr(module, "NODE_CLASS_MAPPINGS") and getattr(module, "NODE_CLASS_MAPPINGS") is not None:
41 | NODE_CLASS_MAPPINGS.update(module.NODE_CLASS_MAPPINGS)
42 | if hasattr(module, "NODE_DISPLAY_NAME_MAPPINGS") and getattr(module, "NODE_DISPLAY_NAME_MAPPINGS") is not None:
43 | NODE_DISPLAY_NAME_MAPPINGS.update(module.NODE_DISPLAY_NAME_MAPPINGS)
44 |
45 | print("")
46 | print("🛡️ ComfyUI Compositing Nodes Pack......................[LOADED]")
47 | print("")
48 |
49 | WEB_DIRECTORY = "./web"
50 |
51 | __all__ = ["NODE_CLASS_MAPPINGS", "NODE_DISPLAY_NAME_MAPPINGS", "WEB_DIRECTORY"]
52 |
--------------------------------------------------------------------------------
/nodes/image_rotate_node.py:
--------------------------------------------------------------------------------
1 | import numpy as np
2 | import torch
3 | from PIL import Image
4 | from torch import Tensor
5 | from math import sin, cos, radians
6 |
7 | def tensor2pil(image: Tensor) -> Image.Image:
8 | return Image.fromarray(np.clip(255. * image.cpu().numpy().squeeze(), 0, 255).astype(np.uint8))
9 |
10 |
11 | def pil2tensor(image: Image.Image) -> Tensor:
12 | return torch.from_numpy(np.array(image).astype(np.float32) / 255.0).unsqueeze(0)
13 |
14 |
15 | class ImageRotate:
16 | @classmethod
17 | def INPUT_TYPES(cls):
18 | return {
19 | "required": {
20 | "image": ("IMAGE",),
21 | "rotation": ("INT", {"default": 0, "min": 0, "max": 360, "step": 1}),
22 | },
23 | }
24 |
25 | RETURN_TYPES = ("IMAGE",)
26 | FUNCTION = "rotate"
27 |
28 | CATEGORY = "image/transform"
29 |
30 | def rotate(self, image, rotation):
31 | pil_image = tensor2pil(image)
32 |
33 | # Calculate new dimensions
34 | angle_rad = radians(rotation)
35 | #new_width = abs(pil_image.width * cos(angle_rad)) + abs(pil_image.height * sin(angle_rad))
36 | #new_height = abs(pil_image.height * cos(angle_rad)) + abs(pil_image.width * sin(angle_rad))
37 |
38 | # Rotate the image using PIL's rotate function
39 | angle = rotation # Change this to the desired angle
40 | center_x = pil_image.width / 2
41 | center_y = pil_image.height / 2
42 |
43 | #converted_image = pil_image.convert("RGBA")
44 | rotated_image = pil_image.rotate(
45 | angle, resample=Image.NEAREST, center=(center_x, center_y), expand=False
46 | )
47 |
48 | # Crop the image to the new dimensions
49 | """ left = (rotated_image.width - new_width) / 2
50 | top = (rotated_image.height - new_height) / 2
51 | right = (rotated_image.width + new_width) / 2
52 | bottom = (rotated_image.height + new_height) / 2
53 | cropped_image = rotated_image.crop((left, top, right, bottom)) """
54 |
55 | # Convert the rotated image back to a tensor
56 | return (pil2tensor(rotated_image),)
57 |
58 |
59 |
60 | NODE_CLASS_MAPPINGS = {
61 | "ImageRotate": ImageRotate,
62 | }
63 |
64 | NODE_DISPLAY_NAME_MAPPINGS = {
65 | "ImageRotate": "🌅Image Rotate",
66 | }
--------------------------------------------------------------------------------
/workflows/Image Brightness Contrast.json:
--------------------------------------------------------------------------------
1 | {"last_node_id":18,"last_link_id":17,"nodes":[{"id":10,"type":"LoadImage","pos":{"0":0,"1":32},"size":[288,384],"flags":{},"order":0,"mode":0,"inputs":[],"outputs":[{"name":"IMAGE","type":"IMAGE","links":[10,11,13,14],"slot_index":0},{"name":"MASK","type":"MASK","links":null}],"properties":{"Node name for S&R":"LoadImage"},"widgets_values":["ComfyUI_00020_.png","image"],"shape":1},{"id":11,"type":"PreviewImage","pos":{"0":928,"1":-128},"size":[224,256],"flags":{},"order":1,"mode":0,"inputs":[{"name":"images","type":"IMAGE","link":10}],"outputs":[],"properties":{"Node name for S&R":"PreviewImage"},"shape":1},{"id":16,"type":"PreviewImage","pos":{"0":1184,"1":-64},"size":[224,256],"flags":{},"order":5,"mode":0,"inputs":[{"name":"images","type":"IMAGE","link":15}],"outputs":[],"properties":{"Node name for S&R":"PreviewImage"},"shape":1},{"id":17,"type":"PreviewImage","pos":{"0":1440,"1":-32},"size":[224,256],"flags":{},"order":6,"mode":0,"inputs":[{"name":"images","type":"IMAGE","link":16}],"outputs":[],"properties":{"Node name for S&R":"PreviewImage"},"shape":1},{"id":18,"type":"PreviewImage","pos":{"0":1696,"1":32},"size":[224,256],"flags":{},"order":8,"mode":0,"inputs":[{"name":"images","type":"IMAGE","link":17}],"outputs":[],"properties":{"Node name for S&R":"PreviewImage"},"shape":1},{"id":12,"type":"Brightness Image","pos":{"0":544,"1":160},"size":{"0":315,"1":58},"flags":{},"order":2,"mode":0,"inputs":[{"name":"image","type":"IMAGE","link":11}],"outputs":[{"name":"IMAGE","type":"IMAGE","links":[15],"slot_index":0}],"properties":{"Node name for S&R":"Brightness Image"},"widgets_values":[1.6000000000000005],"shape":1},{"id":13,"type":"Contrast Image","pos":{"0":544,"1":288},"size":{"0":315,"1":58},"flags":{},"order":3,"mode":0,"inputs":[{"name":"image","type":"IMAGE","link":13}],"outputs":[{"name":"IMAGE","type":"IMAGE","links":[16],"slot_index":0}],"properties":{"Node name for S&R":"Contrast Image"},"widgets_values":[1.4799987792968754],"shape":1},{"id":14,"type":"Brightness Image","pos":{"0":544,"1":416},"size":{"0":315,"1":58},"flags":{},"order":4,"mode":0,"inputs":[{"name":"image","type":"IMAGE","link":14}],"outputs":[{"name":"IMAGE","type":"IMAGE","links":[12],"slot_index":0}],"properties":{"Node name for S&R":"Brightness Image"},"widgets_values":[1.6000000000000005],"shape":1},{"id":15,"type":"Contrast Image","pos":{"0":896,"1":416},"size":{"0":315,"1":58},"flags":{},"order":7,"mode":0,"inputs":[{"name":"image","type":"IMAGE","link":12}],"outputs":[{"name":"IMAGE","type":"IMAGE","links":[17],"slot_index":0}],"properties":{"Node name for S&R":"Contrast Image"},"widgets_values":[0.9],"shape":1}],"links":[[10,10,0,11,0,"IMAGE"],[11,10,0,12,0,"IMAGE"],[12,14,0,15,0,"IMAGE"],[13,10,0,13,0,"IMAGE"],[14,10,0,14,0,"IMAGE"],[15,12,0,16,0,"IMAGE"],[16,13,0,17,0,"IMAGE"],[17,15,0,18,0,"IMAGE"]],"groups":[],"config":{},"extra":{"workspace_info":{"id":"G3fgmviT5wbz4_hENWI7T"},"ds":{"scale":0.6303940863128499,"offset":[243.5463059392189,347.7096371987762]}},"version":0.4}
--------------------------------------------------------------------------------
/nodes/image_extend_node.py:
--------------------------------------------------------------------------------
1 | import numpy as np
2 | import time
3 | import torch
4 | import torch.nn.functional as F
5 | import torchvision.transforms as T
6 | import io
7 | import base64
8 | import random
9 | import math
10 | import os
11 | import re
12 | import json
13 | from PIL.PngImagePlugin import PngInfo
14 | from PIL import ImageColor,ImageGrab, ImageDraw, ImageFont, Image, ImageSequence, ImageOps
15 | from nodes import MAX_RESOLUTION
16 |
17 | class ImageExtend:
18 |
19 | @classmethod
20 | def INPUT_TYPES(s):
21 | return {
22 | "required": {
23 | "image": ("IMAGE",),
24 | "left_px": ("INT", {"default": 0, "min": 0, "max": MAX_RESOLUTION, "step": 1}),
25 | "top_px": ("INT", {"default": 0, "min": 0, "max": MAX_RESOLUTION, "step": 1}),
26 | "right_px": ("INT", {"default": 0, "min": 0, "max": MAX_RESOLUTION, "step": 1}),
27 | "bottom_px": ("INT", {"default": 0, "min": 0, "max": MAX_RESOLUTION, "step": 1}),
28 | "background_white": ("FLOAT", {"default": 0.00, "min": 0.00, "max": 1.00, "step": 0.00}),
29 | },
30 | "optional": {
31 | "mask": ("MASK",),
32 | }
33 | }
34 |
35 | RETURN_TYPES = ("IMAGE", "MASK")
36 | FUNCTION = "expand_image"
37 |
38 | CATEGORY = "image/transform"
39 |
40 | def expand_image(self, image, left_px, top_px, right_px, bottom_px, background_white, mask=None):
41 | if mask is not None:
42 | if torch.allclose(mask, torch.zeros_like(mask)):
43 | print("Warning: The incoming mask is fully black. Handling it as None.")
44 | mask = None
45 | B, H, W, C = image.size()
46 |
47 | new_image = torch.ones(
48 | (B, H + top_px + bottom_px, W + left_px + right_px, C),
49 | dtype=torch.float32,
50 | ) * background_white
51 |
52 | new_image[:, top_px:top_px + H, left_px:left_px + W, :] = image
53 |
54 | if mask is None:
55 | new_mask = torch.ones(
56 | (B, H + top_px + bottom_px, W + left_px + right_px),
57 | dtype=torch.float32,
58 | )
59 |
60 | t = torch.zeros(
61 | (B, H, W),
62 | dtype=torch.float32
63 | )
64 | else:
65 | # If a mask is provided, pad it to fit the new image size
66 | mask = F.pad(mask, (left_px, right_px, top_px, bottom_px), mode='constant', value=0)
67 | mask = 1 - mask
68 | t = torch.zeros_like(mask)
69 |
70 | if mask is None:
71 | new_mask[:, top_px:top_px + H, left_px:left_px + W] = t
72 | return (new_image, new_mask,)
73 | else:
74 | return (new_image, mask,)
75 |
76 | NODE_CLASS_MAPPINGS = {
77 | "ImageExtend": ImageExtend,
78 | }
79 |
80 | NODE_DISPLAY_NAME_MAPPINGS = {
81 | "ImageExtend": "🌅Image Extend",
82 | }
--------------------------------------------------------------------------------
/nodes/math_operation_node.py:
--------------------------------------------------------------------------------
1 | class mathOperationNode:
2 | @classmethod
3 | def INPUT_TYPES(cls):
4 | return {
5 | "required": {
6 | "a": ("FLOAT", {"default": 0.0}),
7 | "b": ("FLOAT", {"default": 0.0}),
8 | "operation": (["add", "subtract", "multiply", "divide", "modulo", "power"],),
9 | "use_float": ("BOOLEAN", {"default": False, "label_on": "Float", "label_off": "Integer"}),
10 | },
11 | }
12 |
13 | RETURN_TYPES = ("INT", "FLOAT", "STRING")
14 | RETURN_NAMES = ("Integer", "Float", "Text")
15 | FUNCTION = "perform_operation"
16 | CATEGORY = "utils"
17 |
18 | def perform_operation(self, a, b, operation, use_float):
19 | if not use_float:
20 | a = int(a)
21 | b = int(b)
22 |
23 | if operation == "add":
24 | result = a + b
25 | elif operation == "subtract":
26 | result = a - b
27 | elif operation == "multiply":
28 | result = a * b
29 | elif operation == "divide":
30 | if b == 0:
31 | raise ValueError("Cannot divide by zero")
32 | result = a / b if use_float else a // b
33 | elif operation == "modulo":
34 | if b == 0:
35 | raise ValueError("Cannot perform modulo by zero")
36 | result = a % b
37 | elif operation == "power":
38 | result = a ** b
39 |
40 | # Return the result based on the use_float boolean
41 | if use_float:
42 | return (None, result, str(result))
43 | else:
44 | return (result, None, str(result))
45 |
46 | NODE_CLASS_MAPPINGS = {"Math Operation": mathOperationNode,}
47 | NODE_DISPLAY_NAME_MAPPINGS = {"Math Operation": "🛡️Math Operation",}
48 |
49 |
50 | """ class mathFloatOperation:
51 | def __init__(self):
52 | pass
53 |
54 | @classmethod
55 | def INPUT_TYPES(cls):
56 | return {
57 | "required": {
58 | "a": ("FLOAT", {"default": 0, "min": -999999999999.0, "max": 999999999999.0, "step": 0.01}),
59 | "b": ("FLOAT", {"default": 0, "min": -999999999999.0, "max": 999999999999.0, "step": 0.01}),
60 | "operation": (["add", "subtract", "multiply", "divide", "modulo", "power"],),
61 | },
62 | }
63 |
64 | RETURN_TYPES = ("FLOAT",)
65 | FUNCTION = "float_math_operation"
66 |
67 | CATEGORY = "EasyUse/Logic/Math"
68 |
69 | def float_math_operation(self, a, b, operation):
70 | if operation == "add":
71 | return (a + b,)
72 | elif operation == "subtract":
73 | return (a - b,)
74 | elif operation == "multiply":
75 | return (a * b,)
76 | elif operation == "divide":
77 | return (a // b,)
78 | elif operation == "modulo":
79 | return (a % b,)
80 | elif operation == "power":
81 | return (a ** b,) """
--------------------------------------------------------------------------------
/nodes/image_apply_color_palette_node.py:
--------------------------------------------------------------------------------
1 | import numpy as np
2 | import time
3 | import torch
4 | import torch.nn.functional as F
5 | import torchvision.transforms as T
6 | import io
7 | import base64
8 | import random
9 | import math
10 | import os
11 | import re
12 | import json
13 | from PIL.PngImagePlugin import PngInfo
14 | from PIL import ImageGrab, ImageDraw, ImageFont, Image, ImageSequence, ImageOps
15 |
16 |
17 | class ColorMatch2:
18 | @classmethod
19 | def INPUT_TYPES(cls):
20 | return {
21 | "required": {
22 | "image_ref": ("IMAGE",),
23 | "image_target": ("IMAGE",),
24 | "method": (
25 | [
26 | 'mkl',
27 | 'hm',
28 | 'reinhard',
29 | 'mvgd',
30 | 'hm-mvgd-hm',
31 | 'hm-mkl-hm',
32 | ], {
33 | "default": 'mkl'
34 | }),
35 | },
36 | "optional": {
37 | "strength": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 10.0, "step": 0.01}),
38 | }
39 | }
40 |
41 | CATEGORY = "image/compositing"
42 |
43 | RETURN_TYPES = ("IMAGE",)
44 | RETURN_NAMES = ("image",)
45 | FUNCTION = "colormatch"
46 | DESCRIPTION = """
47 | color-matcher enables color transfer across images which comes in handy for automatic
48 | color-grading of photographs, paintings and film sequences as well as light-field
49 | and stopmotion corrections.
50 |
51 | The methods behind the mappings are based on the approach from Reinhard et al.,
52 | the Monge-Kantorovich Linearization (MKL) as proposed by Pitie et al. and our analytical solution
53 | to a Multi-Variate Gaussian Distribution (MVGD) transfer in conjunction with classical histogram
54 | matching. As shown below our HM-MVGD-HM compound outperforms existing methods.
55 | https://github.com/hahnec/color-matcher/
56 |
57 | """
58 |
59 | def colormatch(self, image_ref, image_target, method, strength=1.0):
60 | try:
61 | from color_matcher import ColorMatcher
62 | except:
63 | raise Exception("Can't import color-matcher, did you install requirements.txt? Manual install: pip install color-matcher")
64 | cm = ColorMatcher()
65 | image_ref = image_ref.cpu()
66 | image_target = image_target.cpu()
67 | batch_size = image_target.size(0)
68 | out = []
69 | images_target = image_target.squeeze()
70 | images_ref = image_ref.squeeze()
71 |
72 | image_ref_np = images_ref.numpy()
73 | images_target_np = images_target.numpy()
74 |
75 | if image_ref.size(0) > 1 and image_ref.size(0) != batch_size:
76 | raise ValueError("ColorMatch: Use either single reference image or a matching batch of reference images.")
77 |
78 | for i in range(batch_size):
79 | image_target_np = images_target_np if batch_size == 1 else images_target[i].numpy()
80 | image_ref_np_i = image_ref_np if image_ref.size(0) == 1 else images_ref[i].numpy()
81 | try:
82 | image_result = cm.transfer(src=image_target_np, ref=image_ref_np_i, method=method)
83 | except BaseException as e:
84 | print(f"Error occurred during transfer: {e}")
85 | break
86 | # Apply the strength multiplier
87 | image_result = image_target_np + strength * (image_result - image_target_np)
88 | out.append(torch.from_numpy(image_result))
89 |
90 | out = torch.stack(out, dim=0).to(torch.float32)
91 | out.clamp_(0, 1)
92 | return (out,)
93 |
94 |
95 | NODE_CLASS_MAPPINGS = {
96 | "ColorMatch2": ColorMatch2,
97 | }
98 |
99 | NODE_DISPLAY_NAME_MAPPINGS = {
100 | "ColorMatch2": "🌅Apply Color Palette",
101 | }
--------------------------------------------------------------------------------
/nodes/image_load_node.py:
--------------------------------------------------------------------------------
1 | import torch
2 |
3 | import os
4 | import sys
5 | import json
6 | import hashlib
7 | import traceback
8 | import math
9 | import time
10 | import random
11 | import logging
12 |
13 | from PIL import Image, ImageOps, ImageSequence, ImageFile
14 | from PIL.PngImagePlugin import PngInfo
15 |
16 | import numpy as np
17 | import importlib
18 | import folder_paths
19 | import node_helpers
20 |
21 | class LoadImageNai:
22 | @classmethod
23 | def INPUT_TYPES(s):
24 | input_dir = folder_paths.get_input_directory()
25 | files = [f for f in os.listdir(input_dir) if os.path.isfile(os.path.join(input_dir, f))]
26 | return {"required":{
27 | "image_target": ("IMAGE",),
28 | "method": (
29 | [
30 | 'mkl',
31 | 'hm',
32 | 'reinhard',
33 | 'mvgd',
34 | 'hm-mvgd-hm',
35 | 'hm-mkl-hm',
36 | ], {
37 | "default": 'mkl'
38 | }),
39 | "strength": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 10.0, "step": 0.01}),
40 | "image": (sorted(files), {"image_upload": True}),
41 | },
42 | "optional": {
43 | "strength": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 10.0, "step": 0.01}),
44 | }
45 | }
46 |
47 | CATEGORY = "experimental/image"
48 |
49 | RETURN_TYPES = ("IMAGE", "MASK", "IMAGE", "STRING", "STRING")
50 | RETURN_NAMES = ("IMAGE", "MASK", "LAYER", "Image Path", "Image Size")
51 | FUNCTION = "load_image"
52 |
53 | def colormatch(self, image, image_target, method, strength=1.0):
54 | try:
55 | from color_matcher import ColorMatcher
56 | except:
57 | raise Exception("Can't import color-matcher, did you install requirements.txt? Manual install: pip install color-matcher")
58 | cm = ColorMatcher()
59 | image = image.cpu()
60 | image_target = image_target.cpu()
61 | batch_size = image_target.size(0)
62 | out = []
63 | images_target = image_target.squeeze()
64 | images_ref = image.squeeze()
65 |
66 | image_np = images_ref.numpy()
67 | images_target_np = images_target.numpy()
68 |
69 | if image.size(0) > 1 and image.size(0) != batch_size:
70 | raise ValueError("ColorMatch: Use either single reference image or a matching batch of reference images.")
71 |
72 | for i in range(batch_size):
73 | image_target_np = images_target_np if batch_size == 1 else images_target[i].numpy()
74 | image_np_i = image_np if image.size(0) == 1 else images_ref[i].numpy()
75 | try:
76 | image_result = cm.transfer(src=image_target_np, ref=image_np_i, method=method)
77 | except BaseException as e:
78 | print(f"Error occurred during transfer: {e}")
79 | break
80 | # Apply the strength multiplier
81 | image_result = image_target_np + strength * (image_result - image_target_np)
82 | out.append(torch.from_numpy(image_result))
83 |
84 | out = torch.stack(out, dim=0).to(torch.float32)
85 | out.clamp_(0, 1)
86 | return (out,)
87 |
88 |
89 | def load_image(self, image, image_target, method, strength=1.0):
90 | image_path = folder_paths.get_annotated_filepath(image)
91 |
92 | img = node_helpers.pillow(Image.open, image_path)
93 |
94 | output_images = []
95 | output_masks = []
96 | w, h = None, None
97 |
98 | excluded_formats = ['MPO']
99 |
100 | for i in ImageSequence.Iterator(img):
101 | i = node_helpers.pillow(ImageOps.exif_transpose, i)
102 |
103 | if i.mode == 'I':
104 | i = i.point(lambda i: i * (1 / 255))
105 | image = i.convert("RGB")
106 |
107 | if len(output_images) == 0:
108 | w = image.size[0]
109 | h = image.size[1]
110 |
111 | if image.size[0] != w or image.size[1] != h:
112 | continue
113 |
114 | image = np.array(image).astype(np.float32) / 255.0
115 | image = torch.from_numpy(image)[None,]
116 | if 'A' in i.getbands():
117 | mask = np.array(i.getchannel('A')).astype(np.float32) / 255.0
118 | mask = 1. - torch.from_numpy(mask)
119 | else:
120 | mask = torch.zeros((64,64), dtype=torch.float32, device="cpu")
121 | output_images.append(image)
122 | output_masks.append(mask.unsqueeze(0))
123 |
124 | if len(output_images) > 1 and img.format not in excluded_formats:
125 | output_image = torch.cat(output_images, dim=0)
126 | output_mask = torch.cat(output_masks, dim=0)
127 | else:
128 | output_image = output_images[0]
129 | output_mask = output_masks[0]
130 |
131 | print(str(image_path))
132 | string_size = str(w) + " x " + str(h)
133 | #output_matched = output_image.colormatch(image_target, output_image, method, strength)
134 |
135 | return (output_image, output_mask, image_target, str(image_path), string_size)
136 |
137 | @classmethod
138 | def IS_CHANGED(s, image):
139 | image_path = folder_paths.get_annotated_filepath(image)
140 | m = hashlib.sha256()
141 | with open(image_path, 'rb') as f:
142 | m.update(f.read())
143 | return m.digest().hex()
144 |
145 | @classmethod
146 | def VALIDATE_INPUTS(s, image):
147 | if not folder_paths.exists_annotated_filepath(image):
148 | return "Invalid image file: {}".format(image)
149 |
150 | return True
151 |
152 | NODE_CLASS_MAPPINGS = {
153 | "LoadImageNai": LoadImageNai
154 | }
155 |
156 | NODE_DISPLAY_NAME_MAPPINGS = {
157 | "LoadImageNai": "Load Image Node"
158 | }
159 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # ComfyUI Production Nodes Pack
2 |
3 | 
4 | ```py
5 | VERSION: Pre-Alpha Release: 0.1 - Licensed under GNU General Public License V3
6 | NOTE: This project is supported by our community > linkedin.com/groups/13109092/
7 | USER: https://github.com/KoreTeknology
8 | ```
9 |
10 | ## !!! WORK IN PROGRESS !!! (Stay tuned)
11 |
12 | This is set of custom nodes for your ComfyUI[^1] production setup. It offers the very basic nodes that are missing in the official "Vanilla" package.
13 | It is a research Node based project on *Artificial Intelligence* using ComfyUI visual editor. This repository also includes a set of workflows to test the nodes.
14 |
15 | 
16 |
17 | ## 🛡️ Custom Nodes
18 |
19 | Here is an overview of the nodes available in this first version of the pack. These correspond to those that I use every day, during my work or in my classes. Others will follow when they are tested and validated. I was inspired by many other developers to create these nodes, even if I had to rewrite most of the scripts myself, for the sake of consistency and integration into comfyUI.
20 |
21 | ### Image Transform
22 |
23 | | Nodes | Values | State |
|---|---|---|
| Image Flip | x / y / xy | ✔️ |
| Image Rotate | Degree /Step: 1) | ✔️ |
| Image Concatenate | Inputs number, Direction, Match size | ✔️ |
| Image Extend | Left, Right, Top, bottom, BG White % | ✔️ |
| Nodes | Values | State |
|---|---|---|
| Image Brigthness | 0.0>5.0 / Step: 0.1 | ✔️ |
| Image Contrast | 0.0>5.0 / Step: 0.1 | ✔️ |
| Image Greyscale | No value | ✔️ |
| Image RGB | Red,Green, Blue (0-255 /Step: 1) | ✔️ |
| Image Difference | 2 input images, no value | ✔️ |
| Apply Color Palette | 2 input images, intensity, lightness | ⚠️ |
| Extract Color Palette | number of colors, line/square | ⚠️ |
| Nodes | Values | State |
|---|---|---|
| Add Image Layer | 2 input images, x, y, alpha (RGBA) | ⚠️ |
| Add Text Layer | String, x, y, width, color | ⚠️ |
| Nodes | Values | State |
|---|---|---|
| Set Text | String | ✔️ |
| Get Text | String | ✔️ |
| Note Advanced | String, String | ✔️ |
| Math Operation | a, b, Mode, Type | ✔️ |
67 |
68 | ## 🛡️ Settings
69 |
70 | One of the next planned update is to add a dedicated panel into comfyUI settings window to activate/desactivate each node from the pack.
71 |
72 | > [!IMPORTANT]
73 | > User may use these settings if he wants tu use an alternative node from his installed ones. this avoid getting to much "doubles" into the main node menu.
74 |
75 | ---
76 |
77 | ## 🛡️ ComfyUI Installation and Custom Nodes
78 |
79 | After installing [**ComfyUI**](https://github.com/comfyanonymous/ComfyUI) services with your prefered plateform (i am suggesting the use of [**Stability Matrix**](https://github.com/LykosAI/StabilityMatrix) as it is easy to install and give a lot of controls), make sure you install the additional and necessary custom nodes. Then you need to install [GIT software](https://git-scm.com/) (if it is not done already) on your computer. To install these custom nodes, open a CMD window in the \ComfyUI\custom_nodes folder. And "git clone" the Compositing Pack. Or you can use the integrated manager:
80 |
81 | - [ComfyUi-Manager](https://github.com/ltdrdata/ComfyUI-Manager)
82 |
83 | > [!TIP]
84 | > If you have already ComfyUI installed and working, you can simply copy and paste the **Compositing nodes Pack** into the custom nodes folder. Enjoy!
85 |
86 | ---
87 |
88 | ## 🛡️ Development Plan
89 |
90 | I'm currently working on a series of new nodes that will be added progressively to this pack. These are mainly oriented towards compositing and post-processing, using either the PIL library or OpenCV.
91 | If you want to follow the progress or/and participate, I invite you to connect with me on [LINKEDIN](https://www.linkedin.com/in/urieldeveaud/) and [ComfyUI For AI Media Production](https://www.linkedin.com/groups/13109092/), a group of users passionate about AI.
92 |
93 | ### PRIORITY LEVEL
94 | * Config JS extension panel (activate/desactivate individual nodes
95 | * Property panel with description, tips,etc...
96 | * Help options
97 | * refactoring for 1.2 release
98 |
99 | Follow the development: [Here](DEV.md)
100 |
101 | ---
102 | ## 🛡️ Infos
103 |
104 | * Author: **Uriel Deveaud** [NAI-00] - [Kore Teknology](https://github.com/KoreTeknology)
105 | * Partners: **Techman Studio MX** - [techmanstudio.com](https://techmanstudio.com.mx/)
106 | * License: This project is released under the Apache 2.0 License.
107 | * This work is dedicated to all ComfyUI users and to all our students ;)
108 |
109 | [^1]: **ComfyUI** is the free and open source AI creation suite. Please, visit [ComfyUI Github page](https://github.com/comfyanonymous/ComfyUI) for more infos.
110 |
--------------------------------------------------------------------------------
/nodes/image_concat_node.py:
--------------------------------------------------------------------------------
1 | import numpy as np
2 | import time
3 | import torch
4 | import torch.nn.functional as F
5 | import torchvision.transforms as T
6 | import io
7 | import base64
8 | import random
9 | import math
10 | import os
11 | import re
12 | import json
13 | from PIL.PngImagePlugin import PngInfo
14 | from PIL import ImageGrab, ImageDraw, ImageFont, Image, ImageSequence, ImageOps
15 | # from nodes import MAX_RESOLUTION
16 |
17 | from nodes import MAX_RESOLUTION, SaveImage
18 | from comfy_extras.nodes_mask import ImageCompositeMasked
19 | from comfy.cli_args import args
20 | from comfy.utils import ProgressBar, common_upscale
21 | import folder_paths
22 | import model_management
23 |
24 | class ImageConcanate:
25 | @classmethod
26 | def INPUT_TYPES(s):
27 | return {"required": {
28 | "image1": ("IMAGE",),
29 | "image2": ("IMAGE",),
30 | "direction": (
31 | [ 'right',
32 | 'down',
33 | 'left',
34 | 'up',
35 | ],
36 | {
37 | "default": 'right'
38 | }),
39 | "match_image_size": ("BOOLEAN", {"default": True}),
40 | }}
41 |
42 | RETURN_TYPES = ("IMAGE",)
43 | FUNCTION = "concanate"
44 | CATEGORY = "KJNodes/image"
45 | DESCRIPTION = """
46 | Concatenates the image2 to image1 in the specified direction.
47 | """
48 |
49 | def concanate(self, image1, image2, direction, match_image_size, first_image_shape=None):
50 | # Check if the batch sizes are different
51 | batch_size1 = image1.shape[0]
52 | batch_size2 = image2.shape[0]
53 |
54 | if batch_size1 != batch_size2:
55 | # Calculate the number of repetitions needed
56 | max_batch_size = max(batch_size1, batch_size2)
57 | repeats1 = max_batch_size // batch_size1
58 | repeats2 = max_batch_size // batch_size2
59 |
60 | # Repeat the images to match the largest batch size
61 | image1 = image1.repeat(repeats1, 1, 1, 1)
62 | image2 = image2.repeat(repeats2, 1, 1, 1)
63 |
64 | if match_image_size:
65 | # Use first_image_shape if provided; otherwise, default to image1's shape
66 | target_shape = first_image_shape if first_image_shape is not None else image1.shape
67 |
68 | original_height = image2.shape[1]
69 | original_width = image2.shape[2]
70 | original_aspect_ratio = original_width / original_height
71 |
72 | if direction in ['left', 'right']:
73 | # Match the height and adjust the width to preserve aspect ratio
74 | target_height = target_shape[1] # B, H, W, C format
75 | target_width = int(target_height * original_aspect_ratio)
76 | elif direction in ['up', 'down']:
77 | # Match the width and adjust the height to preserve aspect ratio
78 | target_width = target_shape[2] # B, H, W, C format
79 | target_height = int(target_width / original_aspect_ratio)
80 |
81 | # Adjust image2 to the expected format for common_upscale
82 | image2_for_upscale = image2.movedim(-1, 1) # Move C to the second position (B, C, H, W)
83 |
84 | # Resize image2 to match the target size while preserving aspect ratio
85 | image2_resized = common_upscale(image2_for_upscale, target_width, target_height, "lanczos", "disabled")
86 |
87 | # Adjust image2 back to the original format (B, H, W, C) after resizing
88 | image2_resized = image2_resized.movedim(1, -1)
89 | else:
90 | image2_resized = image2
91 |
92 | # Ensure both images have the same number of channels
93 | channels_image1 = image1.shape[-1]
94 | channels_image2 = image2_resized.shape[-1]
95 |
96 | if channels_image1 != channels_image2:
97 | if channels_image1 < channels_image2:
98 | # Add alpha channel to image1 if image2 has it
99 | alpha_channel = torch.ones((*image1.shape[:-1], channels_image2 - channels_image1), device=image1.device)
100 | image1 = torch.cat((image1, alpha_channel), dim=-1)
101 | else:
102 | # Add alpha channel to image2 if image1 has it
103 | alpha_channel = torch.ones((*image2_resized.shape[:-1], channels_image1 - channels_image2), device=image2_resized.device)
104 | image2_resized = torch.cat((image2_resized, alpha_channel), dim=-1)
105 |
106 |
107 | # Concatenate based on the specified direction
108 | if direction == 'right':
109 | concatenated_image = torch.cat((image1, image2_resized), dim=2) # Concatenate along width
110 | elif direction == 'down':
111 | concatenated_image = torch.cat((image1, image2_resized), dim=1) # Concatenate along height
112 | elif direction == 'left':
113 | concatenated_image = torch.cat((image2_resized, image1), dim=2) # Concatenate along width
114 | elif direction == 'up':
115 | concatenated_image = torch.cat((image2_resized, image1), dim=1) # Concatenate along height
116 | return concatenated_image,
117 |
118 | import torch # Make sure you have PyTorch installed
119 |
120 | class ImageConcatenate:
121 | @classmethod
122 | def INPUT_TYPES(s):
123 | return {
124 | "required": {
125 | "inputcount": ("INT", {"default": 2, "min": 2, "max": 1000, "step": 1}),
126 | "image_1": ("IMAGE", ),
127 | "image_2": ("IMAGE", ),
128 | "direction": (
129 | [ 'right',
130 | 'down',
131 | 'left',
132 | 'up',
133 | ],
134 | {
135 | "default": 'right'
136 | }),
137 | "match_image_size": ("BOOLEAN", {"default": False}),
138 | },
139 | }
140 |
141 | RETURN_TYPES = ("IMAGE",)
142 | RETURN_NAMES = ("images",)
143 | FUNCTION = "combine"
144 | CATEGORY = "image/transform"
145 | DESCRIPTION = """
146 | Creates an image from multiple images.
147 | You can set how many inputs the node has,
148 | with the **inputcount** and clicking update.
149 | """
150 |
151 | def combine(self, inputcount, direction, match_image_size, **kwargs):
152 | image = kwargs["image_1"]
153 | first_image_shape = None
154 | if first_image_shape is None:
155 | first_image_shape = image.shape
156 | for c in range(1, inputcount):
157 | new_image = kwargs[f"image_{c + 1}"]
158 | image, = ImageConcanate.concanate(self, image, new_image, direction, match_image_size, first_image_shape=first_image_shape)
159 | first_image_shape = None
160 | return (image,)
161 |
162 | NODE_CLASS_MAPPINGS = {
163 | "ImageConcatenate": ImageConcatenate,
164 | }
165 |
166 | NODE_DISPLAY_NAME_MAPPINGS = {
167 | "ImageConcatenate": "🌅Image Concatenate",
168 | }
--------------------------------------------------------------------------------
/nai.py:
--------------------------------------------------------------------------------
1 | # import asyncio
2 | import os
3 | import json
4 | import shutil
5 | import inspect
6 | # import aiohttp
7 | from server import PromptServer
8 | # Import TQDM -> loops show a smart progress meter
9 | # from tqdm import tqdm
10 |
11 | config = None
12 |
13 | # --------
14 | # LOGGING
15 | # --------
16 |
17 | def is_logging_enabled():
18 | config = get_extension_config()
19 | if "logging" not in config:
20 | return False
21 | return config["logging"]
22 |
23 |
24 | def log(message, type=None, always=False, name=None):
25 | if not always and not is_logging_enabled():
26 | return
27 |
28 | if type is not None:
29 | message = f"[{type}] {message}"
30 |
31 | if name is None:
32 | name = get_extension_config()["name"]
33 |
34 | print(f"(NAI:{name}) {message}")
35 |
36 | # --------
37 | # DIR PATHS
38 | # --------
39 |
40 | def get_ext_dir(subpath=None, mkdir=False):
41 | dir = os.path.dirname(__file__)
42 | if subpath is not None:
43 | dir = os.path.join(dir, subpath)
44 |
45 | dir = os.path.abspath(dir)
46 |
47 | if mkdir and not os.path.exists(dir):
48 | os.makedirs(dir)
49 | return dir
50 |
51 |
52 | def get_comfy_dir(subpath=None, mkdir=False):
53 | dir = os.path.dirname(inspect.getfile(PromptServer))
54 | if subpath is not None:
55 | dir = os.path.join(dir, subpath)
56 |
57 | dir = os.path.abspath(dir)
58 |
59 | if mkdir and not os.path.exists(dir):
60 | os.makedirs(dir)
61 | return dir
62 |
63 | # Create Folder in Main comfyui Extension directory
64 | def get_web_ext_dir():
65 | config = get_extension_config()
66 | name = config["name"]
67 | dir = get_comfy_dir("web/extensions/compositing")
68 | if not os.path.exists(dir):
69 | os.makedirs(dir)
70 | dir = os.path.join(dir, name)
71 | return dir
72 |
73 | # --------
74 | # Compositing CONFIG FILE -> JSON
75 | # --------
76 |
77 | def get_extension_config(reload=False):
78 | global config
79 | if reload == False and config is not None:
80 | return config
81 |
82 | config_path = get_ext_dir("config.json")
83 | default_config_path = get_ext_dir("config.default.json")
84 | if not os.path.exists(config_path):
85 | if os.path.exists(default_config_path):
86 | shutil.copy(default_config_path, config_path)
87 | if not os.path.exists(config_path):
88 | log(f"Failed to create config at {config_path}", type="ERROR", always=True, name="???")
89 | print(f"Extension path: {get_ext_dir()}")
90 | return {"name": "Unknown", "version": -1}
91 |
92 | else:
93 | log("Missing config.default.json, this extension may not work correctly. Please reinstall the extension.",
94 | type="ERROR", always=True, name="???")
95 | print(f"Extension path: {get_ext_dir()}")
96 | return {"name": "Unknown", "version": -1}
97 |
98 | with open(config_path, "r") as f:
99 | config = json.loads(f.read())
100 | return config
101 |
102 | # --------
103 | # Symlink
104 | # --------
105 |
106 | def link_js(src, dst):
107 | src = os.path.abspath(src)
108 | dst = os.path.abspath(dst)
109 | if os.name == "nt":
110 | try:
111 | import _winapi
112 | _winapi.CreateJunction(src, dst)
113 | return True
114 | except:
115 | pass
116 | try:
117 | os.symlink(src, dst)
118 | return True
119 | except:
120 | import logging
121 | logging.exception('')
122 | return False
123 |
124 |
125 | def is_junction(path):
126 | if os.name != "nt":
127 | return False
128 | try:
129 | return bool(os.readlink(path))
130 | except OSError:
131 | return False
132 |
133 | # --------
134 | # JS DIRECTORY
135 | # --------
136 |
137 | def install_js():
138 | src_dir = get_ext_dir("web/js")
139 | if not os.path.exists(src_dir):
140 | log("No JS")
141 | return
142 |
143 | should_install = should_install_js()
144 | if should_install:
145 | log("it looks like you're running an old version of ComfyUI that requires manual setup of web files, it is recommended you update your installation.", "warning", True)
146 | dst_dir = get_web_ext_dir()
147 | linked = os.path.islink(dst_dir) or is_junction(dst_dir)
148 | if linked or os.path.exists(dst_dir):
149 | if linked:
150 | if should_install:
151 | log("JS already linked")
152 | else:
153 | os.unlink(dst_dir)
154 | log("JS unlinked, PromptServer will serve extension")
155 | elif not should_install:
156 | shutil.rmtree(dst_dir)
157 | log("JS deleted, PromptServer will serve extension")
158 | return
159 |
160 | if not should_install:
161 | log("JS skipped, PromptServer will serve extension")
162 | return
163 |
164 | if link_js(src_dir, dst_dir):
165 | log("JS linked")
166 | return
167 |
168 | log("Copying JS files")
169 | shutil.copytree(src_dir, dst_dir, dirs_exist_ok=True)
170 |
171 |
172 | def should_install_js():
173 | return not hasattr(PromptServer.instance, "supports") or "custom_nodes_from_web" not in PromptServer.instance.supports
174 |
175 |
176 | # --------
177 | # IMPORT LIBS
178 | # --------
179 |
180 | def init(check_imports=None):
181 | log("Init")
182 | if check_imports is not None:
183 | import importlib.util
184 | for imp in check_imports:
185 | spec = importlib.util.find_spec(imp)
186 | if spec is None:
187 | log(f"{imp} is required, please check requirements are installed.",
188 | type="ERROR", always=True)
189 | return False
190 |
191 | install_js()
192 | return True
193 |
194 | # --------
195 | # async
196 | # --------
197 |
198 | """ def get_async_loop():
199 | loop = None
200 | try:
201 | loop = asyncio.get_event_loop()
202 | except:
203 | loop = asyncio.new_event_loop()
204 | asyncio.set_event_loop(loop)
205 | return loop
206 |
207 |
208 | def get_http_session():
209 | loop = get_async_loop()
210 | return aiohttp.ClientSession(loop=loop)
211 |
212 |
213 | async def download(url, stream, update_callback=None, session=None):
214 | close_session = False
215 | if session is None:
216 | close_session = True
217 | session = get_http_session()
218 | try:
219 | async with session.get(url) as response:
220 | size = int(response.headers.get('content-length', 0)) or None
221 |
222 | with tqdm(
223 | unit='B', unit_scale=True, miniters=1, desc=url.split('/')[-1], total=size,
224 | ) as progressbar:
225 | perc = 0
226 | async for chunk in response.content.iter_chunked(2048):
227 | stream.write(chunk)
228 | progressbar.update(len(chunk))
229 | if update_callback is not None and progressbar.total is not None and progressbar.total != 0:
230 | last = perc
231 | perc = round(progressbar.n / progressbar.total, 2)
232 | if perc != last:
233 | last = perc
234 | await update_callback(perc)
235 | finally:
236 | if close_session and session is not None:
237 | await session.close()
238 |
239 |
240 | async def download_to_file(url, destination, update_callback=None, is_ext_subpath=True, session=None):
241 | if is_ext_subpath:
242 | destination = get_ext_dir(destination)
243 | with open(destination, mode='wb') as f:
244 | download(url, f, update_callback, session)
245 |
246 |
247 | def wait_for_async(async_fn, loop=None):
248 | res = []
249 |
250 | async def run_async():
251 | r = await async_fn()
252 | res.append(r)
253 |
254 | if loop is None:
255 | try:
256 | loop = asyncio.get_event_loop()
257 | except:
258 | loop = asyncio.new_event_loop()
259 | asyncio.set_event_loop(loop)
260 |
261 | loop.run_until_complete(run_async())
262 |
263 | return res[0] """
264 |
265 | # --------
266 | # UPDATE
267 | # --------
268 |
269 | """ def update_node_status(client_id, node, text, progress=None):
270 | if client_id is None:
271 | client_id = PromptServer.instance.client_id
272 |
273 | if client_id is None:
274 | return
275 |
276 | PromptServer.instance.send_sync("pysssss/update_status", {
277 | "node": node,
278 | "progress": progress,
279 | "text": text
280 | }, client_id)
281 |
282 |
283 | async def update_node_status_async(client_id, node, text, progress=None):
284 | if client_id is None:
285 | client_id = PromptServer.instance.client_id
286 |
287 | if client_id is None:
288 | return
289 |
290 | await PromptServer.instance.send("pysssss/update_status", {
291 | "node": node,
292 | "progress": progress,
293 | "text": text
294 | }, client_id)
295 |
296 |
297 | def get_config_value(key, default=None, throw=False):
298 | split = key.split(".")
299 | obj = get_extension_config()
300 | for s in split:
301 | if s in obj:
302 | obj = obj[s]
303 | else:
304 | if throw:
305 | raise KeyError("Configuration key missing: " + key)
306 | else:
307 | return default
308 | return obj """
309 |
310 | # --------
311 | # DIR EXTRA
312 | # --------
313 |
314 | """ def is_inside_dir(root_dir, check_path):
315 | root_dir = os.path.abspath(root_dir)
316 | if not os.path.isabs(check_path):
317 | check_path = os.path.abspath(os.path.join(root_dir, check_path))
318 | return os.path.commonpath([check_path, root_dir]) == root_dir
319 |
320 |
321 | def get_child_dir(root_dir, child_path, throw_if_outside=True):
322 | child_path = os.path.abspath(os.path.join(root_dir, child_path))
323 | if is_inside_dir(root_dir, child_path):
324 | return child_path
325 | if throw_if_outside:
326 | raise NotADirectoryError(
327 | "Saving outside the target folder is not allowed.")
328 | return None """
329 |
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | GNU GENERAL PUBLIC LICENSE
2 | Version 3, 29 June 2007
3 |
4 | Copyright (C) 2007 Free Software Foundation, Inc.