0.3.0

v0.3.0 🚀🚗🚚🏃‍

- Added support for setting proxies: HTTP_PROXY, HTTPS_PROXY, http_proxy, https_proxy ✅

- Added a new Speech feature node, enabling the use of a voice assistant: SpeechRecognition & SpeechSynthesis 🎙️

- Added TextImage node, allowing conversion of text into image format 📷

- Added SvgImage node, enabling layout parsing and poster generation in conjunction with the Layer class node 🖼️

- Added an experimental 3DImage node for loading 3D models 🌟

README.md

@@ -1,15 +1,25 @@
 ## 
+v0.3.0 🚀🚗🚚🏃‍
 
-v0.2.6 🚀🚗🚚🏃‍
+- Added support for setting proxies: HTTP_PROXY, HTTPS_PROXY, http_proxy, https_proxy ✅
 
-- [Add getting camera video stream](./workflow/7-camera-workflow.json)
-- Add a slider to the floating window, which can be used as input for denoise
-- OSupport for calling multiple GPTs
+- Added a new Speech feature node, enabling the use of a voice assistant: SpeechRecognition & SpeechSynthesis 🎙️
+
+- Added TextImage node, allowing conversion of text into image format 📷
+
+- Added SvgImage node, enabling layout parsing and poster generation in conjunction with the Layer class node 🖼️
+
+- Added an experimental 3DImage node for loading 3D models 🌟
 
 
 ![screenshare](./assets/screenshare.png)
 
 
+### SpeechRecognition & SpeechSynthesis
+![f](./assets/audio-workflow.svg)
+
+
+
 ### ScreenShareNode & FloatingVideoNode
 > Now comfyui supports capturing screen pixel streams from any software and can be used for LCM-Lora integration. Let's get started with implementation and design! 💻🌐
 
@@ -33,7 +43,7 @@ https://github.com/shadowcz007/comfyui-mixlab-nodes/assets/12645064/e7e77f90-e43
 
 
 ### GPT
->Support for calling multiple GPTs.ChatGPT、ChatGLM3 , Some code provided by rui. If you are using OpenAI's service, fill in https://api.openai.com/v1 . If you are using a local LLM service, fill in http://127.0.0.1:xxxx/v1 .  Azure OpenAI:https://xxxx.openai.azure.com 
+> Support for calling multiple GPTs.ChatGPT、ChatGLM3 , Some code provided by rui. If you are using OpenAI's service, fill in https://api.openai.com/v1 . If you are using a local LLM service, fill in http://127.0.0.1:xxxx/v1 .  Azure OpenAI:https://xxxx.openai.azure.com 
 
 
 ![gpt-workflow.svg](./assets/gpt-workflow.svg)
@@ -41,38 +51,14 @@ https://github.com/shadowcz007/comfyui-mixlab-nodes/assets/12645064/e7e77f90-e43
 [workflow-5](./workflow/5-gpt-workflow.json)
 
 
-## Installation
+### Layers
+> A new layer class node has been added, allowing you to separate the image into layers. After merging the images, you can input the controlnet for further processing.
 
-manually install, simply clone the repo into the custom_nodes directory with this command:
+![layers](./assets/layers-workflow.svg)
 
-```
-cd ComfyUI/custom_nodes
+![poster](./assets/poster-workflow.svg)
 
-git clone https://github.com/shadowcz007/comfyui-mixlab-nodes.git
-
-```
-
-Install the requirements:
-
-run directly:
-```
-cd ComfyUI_Mixlab
-install.bat
-```
-
-or install the requirements using:
-```
-../../../python_embeded/python.exe -s -m pip install -r requirements.txt
-```
-
-If you are using a venv, make sure you have it activated before installation and use:
-```
-pip3 install -r requirements.txt
-```
-
-
-
-## Nodes
+## Other Nodes
 
 ![main](./assets/all-workflow.svg)
 ![main2](./assets/detect-face-all.png)
@@ -88,9 +74,6 @@ pip3 install -r requirements.txt
 ![TransparentImage](./assets/TransparentImage.png)
 
 
-
-
-
 > Consistency Decoder
 
 [openai Consistency Decoder]( https://github.com/openai/consistencydecoder)
@@ -120,6 +103,42 @@ An improvement has been made to directly redirect to GitHub to search for missin
 <!-- ### Workflow
 [Workflow](./workflow.md) -->
 
+
+
+## Installation
+
+manually install, simply clone the repo into the custom_nodes directory with this command:
+
+```
+cd ComfyUI/custom_nodes
+
+git clone https://github.com/shadowcz007/comfyui-mixlab-nodes.git
+
+```
+
+Install the requirements:
+
+run directly:
+```
+cd ComfyUI/custom_nodes/comfyui-mixlab-nodes
+install.bat
+```
+
+or install the requirements using:
+```
+../../../python_embeded/python.exe -s -m pip install -r requirements.txt
+```
+
+If you are using a venv, make sure you have it activated before installation and use:
+```
+pip3 install -r requirements.txt
+```
+
+#### Chinese community
+访问 [www.mixcomfy.com](https://www.mixcomfy.com)，获得更多内测功能，关注微信公众号：Mixlab无界社区
+
+
+
 #### Thanks:
 [ComfyUI-CLIPSeg](https://github.com/biegert/ComfyUI-CLIPSeg/tree/main)
 
@@ -127,5 +146,6 @@ An improvement has been made to directly redirect to GitHub to search for missin
 [discussions](https://github.com/shadowcz007/comfyui-mixlab-nodes/discussions)
 
 ### TODO:
+- 音频播放节点：带可视化、支持多音轨、可配置音轨音量
 - vector https://github.com/GeorgLegato/stable-diffusion-webui-vectorstudio
 

__init__.py

@@ -168,8 +168,28 @@ def save_workflow_json(data):
         json.dump(data, file)
     return workflow_path
 
+
+# 保存原始的 get 方法
+_original_request = aiohttp.ClientSession._request
+
+# 定义新的 get 方法
+async def new_request(self, method, url, *args, **kwargs):
+   # 检查环境变量以确定是否使用代理
+    proxy = os.environ.get('HTTP_PROXY') or os.environ.get('HTTPS_PROXY') or os.environ.get('http_proxy') or os.environ.get('https_proxy') 
+    # print('Proxy Config:',proxy)
+    if proxy and 'proxy' not in kwargs:
+        kwargs['proxy'] = proxy
+        print('Use Proxy:',proxy)
+    # 调用原始的 _request 方法
+    return await _original_request(self, method, url, *args, **kwargs)
+
+# 应用 Monkey Patch
+aiohttp.ClientSession._request = new_request
+
 # https
 async def new_start(self, address, port, verbose=True, call_on_start=None):
+        
+
         runner = web.AppRunner(self.app, access_log=None)
         await runner.setup()
         site = web.TCPSite(runner, address, port)
@@ -268,11 +288,14 @@ PromptServer.add_routes=new_add_routes
 
 # 导入节点
 from .nodes.PromptNode import RandomPrompt
-from .nodes.ImageNode import TransparentImage,LoadImagesFromPath,AreaToMask,SmoothMask,FeatheredMask,SplitLongMask,ImageCropByAlpha,EnhanceImage,FaceToMask
+from .nodes.ImageNode import TransparentImage,LoadImagesFromPath,TextImage,SvgImage,Image3D,EmptyLayer,ShowLayer,NewLayer,MergeLayers,AreaToMask,SmoothMask,FeatheredMask,SplitLongMask,ImageCropByAlpha,EnhanceImage,FaceToMask
 from .nodes.Vae import VAELoader,VAEDecode
 from .nodes.ScreenShareNode import ScreenShareNode,FloatingVideo
 from .nodes.Clipseg import CLIPSeg,CombineMasks
 from .nodes.ChatGPT import ChatGPTNode,ShowTextForGPT,CharacterInText
+from .nodes.Audio import SpeechRecognition,SpeechSynthesis
+from .nodes.Utils import ColorInput,FontInput
+
 
 # 要导出的所有节点及其名称的字典
 # 注意：名称应全局唯一
@@ -280,7 +303,14 @@ NODE_CLASS_MAPPINGS = {
     "RandomPrompt":RandomPrompt,
     "TransparentImage":TransparentImage,
     "LoadImagesFromPath":LoadImagesFromPath,
+    "TextImage":TextImage,
     "EnhanceImage":EnhanceImage,
+    "SvgImage":SvgImage,
+    "3DImage":Image3D,
+    "EmptyLayer":EmptyLayer,
+    "ShowLayer":ShowLayer,
+    "NewLayer":NewLayer,
+    "MergeLayers":MergeLayers,
     "SplitLongMask":SplitLongMask,
     "FeatheredMask":FeatheredMask,
     "SmoothMask":SmoothMask,
@@ -295,7 +325,11 @@ NODE_CLASS_MAPPINGS = {
     "CombineMasks_":CombineMasks,
     "ChatGPTOpenAI":ChatGPTNode,
     "ShowTextForGPT":ShowTextForGPT,
-    "CharacterInText":CharacterInText
+    "CharacterInText":CharacterInText,
+    "SpeechRecognition":SpeechRecognition,
+    "SpeechSynthesis":SpeechSynthesis,
+    "Color":ColorInput,
+    "Font":FontInput
 }
 
 # 一个包含节点友好/可读的标题的字典
@@ -307,7 +341,10 @@ NODE_DISPLAY_NAME_MAPPINGS = {
     "ScreenShare":"ScreenShare ♾️Mixlab",
     "FloatingVideo":"FloatingVideo ♾️Mixlab",
     "ChatGPTOpenAI":"ChatGPT ♾️Mixlab",
-    "ShowTextForGPT":"ShowTextForGPT ♾️Mixlab"
+    "ShowTextForGPT":"ShowTextForGPT ♾️Mixlab",
+    "MergeLayers":"MergeLayers ♾️Mixlab",
+    "SpeechSynthesis":"SpeechSynthesis ♾️Mixlab",
+    "SpeechRecognition":"SpeechRecognition ♾️Mixlab"
 }
 
 # web ui的节点功能

nodes/Audio.py

@@ -0,0 +1,46 @@
+
+
+
+
+class SpeechRecognition:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": { 
+                    "upload":("AUDIOINPUTMIX",),   },
+                }
+    
+    RETURN_TYPES = ("STRING",)
+    RETURN_NAMES = ("prompt",)
+
+    FUNCTION = "run"
+
+    CATEGORY = "♾️Mixlab/audio"
+
+    INPUT_IS_LIST = False
+    OUTPUT_IS_LIST = (False,)
+
+    def run(self,upload):
+        return (upload,)
+
+
+class SpeechSynthesis:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "text": ("STRING", {"forceInput": True}),
+            }
+        }
+
+    INPUT_IS_LIST = True
+    RETURN_TYPES = ("STRING",)
+    FUNCTION = "run"
+    OUTPUT_NODE = True
+    OUTPUT_IS_LIST = (True,)
+
+    CATEGORY = "♾️Mixlab/audio"
+
+    def run(self, text):
+        # print(session_history)
+        return {"ui": {"text": text}, "result": (text,)}
+    

nodes/ChatGPT.py

@@ -46,7 +46,7 @@ def chat(client, model_name,messages ):
             except (urllib.error.HTTPError, openai.OpenAIError) as ex:
                 if try_count >= 3:
                     raise ex
-                time.sleep(5)
+                time.sleep(3)
                 continue
 
         finish_reason = response.choices[0].finish_reason

nodes/Clipseg.py

@@ -1,3 +1,6 @@
+#### Thanks:
+# [ComfyUI-CLIPSeg](https://github.com/biegert/ComfyUI-CLIPSeg/tree/main)
+
 from transformers import CLIPSegProcessor, CLIPSegForImageSegmentation
 
 from PIL import Image
@@ -252,7 +255,7 @@ class CombineMasks:
 
 # A dictionary that contains all nodes you want to export with their names
 # NOTE: names should be globally unique
-NODE_CLASS_MAPPINGS = {
-    "CLIPSeg": CLIPSeg,
-    "CombineSegMasks": CombineMasks,
-}
+# NODE_CLASS_MAPPINGS = {
+#     "CLIPSeg": CLIPSeg,
+#     "CombineSegMasks": CombineMasks,
+# }

nodes/ImageNode.py

@@ -1,17 +1,18 @@
 import numpy as np
 import torch
-from PIL import Image, ImageOps,ImageFilter,ImageEnhance,ImageDraw,ImageSequence
+from PIL import Image, ImageOps,ImageFilter,ImageEnhance,ImageDraw,ImageSequence, ImageFont
 from PIL.PngImagePlugin import PngInfo
 import base64,os
 from io import BytesIO
 import folder_paths
-import json
+import json,io
 from comfy.cli_args import args
 import cv2 
 
 from .Watcher import FolderWatcher
 
 
+FONT_PATH= os.path.abspath(os.path.join(os.path.dirname(__file__),'../assets/王汉宗颜楷体繁.ttf'))
 
 MAX_RESOLUTION=8192
 
@@ -322,6 +323,117 @@ def areaToMask(x,y,w,h,image):
     return mask
 
 
+# def merge_images(bg_image, layer_image,mask, x, y, width, height):
+#     # 打开底图
+#     # bg_image = Image.open(background)
+#     bg_image=bg_image.convert("RGBA")
+
+#     # 打开图层
+#     layer_image=layer_image.convert("RGBA")
+#     layer_image = layer_image.resize((width, height))
+#     # mask = Image.new("L", layer_image.size, 255)
+#     mask = mask.resize((width, height))
+#     # 在底图上粘贴图层
+#     bg_image.paste(layer_image, (x, y), mask=mask)
+
+#     # 输出合成后的图片
+#     # bg_image.save("output.jpg")
+#     return bg_image
+
+def merge_images(bg_image, layer_image, mask, x, y, width, height, scale_option):
+    # 打开底图
+    bg_image = bg_image.convert("RGBA")
+
+    # 打开图层
+    layer_image = layer_image.convert("RGBA")
+    # layer_image = layer_image.resize((width, height))
+
+    # 根据缩放选项调整图像大小
+    if scale_option == "height":
+        # 按照高度比例缩放
+        original_width, original_height = layer_image.size
+        scale = height / original_height
+        new_width = int(original_width * scale)
+        layer_image = layer_image.resize((new_width, height))
+    elif scale_option == "width":
+        # 按照宽度比例缩放
+        original_width, original_height = layer_image.size
+        scale = width / original_width
+        new_height = int(original_height * scale)
+        layer_image = layer_image.resize((width, new_height))
+    elif scale_option == "overall":
+        # 整体缩放
+        layer_image = layer_image.resize((width, height))
+
+    # 调整mask的大小
+    nw, nh = layer_image.size
+    mask = mask.resize((nw, nh))
+
+    # 在底图上粘贴图层
+    bg_image.paste(layer_image, (x, y), mask=mask)
+
+    # 输出合成后的图片
+    return bg_image
+
+
+
+def generate_text_image(text_list, font_path, font_size, text_color, vertical=True, spacing=0):
+    # Load Chinese font
+    font = ImageFont.truetype(font_path, font_size)
+
+    # Calculate image size based on the number of characters and orientation
+    if vertical:
+        width = font_size + 100
+        height = font_size * len(text_list) + (len(text_list) - 1) * spacing + 100
+    else:
+        width = font_size * len(text_list) + (len(text_list) - 1) * spacing + 100
+        height = font_size + 100
+
+    # Create a blank image
+    image = Image.new('RGBA', (width, height), (255, 255, 255,0))
+    draw = ImageDraw.Draw(image)
+
+    # Draw text
+    if vertical:
+        for i, char in enumerate(text_list):
+            char_position = (50, 50 + i * font_size)
+            draw.text(char_position, char, font=font, fill=text_color)
+    else:
+        for i, char in enumerate(text_list):
+            char_position = (50 + i * (font_size + spacing), 50)
+            draw.text(char_position, char, font=font, fill=text_color)
+
+    # Save the image
+    # image.save(output_image_path)
+
+    # 分离alpha通道
+    alpha_channel = image.split()[3]
+
+    # 创建一个只有alpha通道的新图像
+    alpha_image = Image.new('L', image.size)
+    alpha_image.putdata(alpha_channel.getdata())
+
+    image=image.convert('RGB')
+
+    return (image,alpha_image)
+
+
+def base64_to_image(base64_string):
+    # 去除前缀
+    prefix, base64_data = base64_string.split(",", 1)
+    
+    # 从base64字符串中解码图像数据
+    image_data = base64.b64decode(base64_data)
+    
+    # 创建一个内存流对象
+    image_stream = io.BytesIO(image_data)
+    
+    # 使用PIL的Image模块打开图像数据
+    image = Image.open(image_stream)
+    
+    return image
+
+
 
 class SmoothMask:
     @classmethod
@@ -494,6 +606,7 @@ class TransparentImage:
             }
     
     RETURN_TYPES = ('STRING','IMAGE','RGBA')
+    RETURN_NAMES = ("file_path","IMAGE","RGBA",)
 
     OUTPUT_NODE = True
 
@@ -671,7 +784,7 @@ class LoadImagesFromPath:
             imgs=[imgs[index_variable]] if index_variable < len(imgs) else None
             masks=[masks[index_variable]] if index_variable < len(masks) else None
 
-        print('#prompt::::',prompt)
+        # print('#prompt::::',prompt)
         return (imgs,masks,prompt,)
 
 
@@ -708,6 +821,117 @@ class ImageCropByAlpha:
         return (img,)
 
 
+
+class TextImage:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": { 
+            
+                    "text": ("STRING",{"multiline": False,"default": "龍馬精神迎新歲"}),
+                    "font_path": ("STRING",{"multiline": False,"default": FONT_PATH}),
+                    "font_size": ("INT",{
+                                "default":100, 
+                                "min": 100, #Minimum value
+                                "max": 1000, #Maximum value
+                                "step": 1, #Slider's step
+                                "display": "number" # Cosmetic only: display as "number" or "slider"
+                                }), 
+                    "spacing": ("INT",{
+                                "default":12, 
+                                "min": 1, #Minimum value
+                                "max": 200, #Maximum value
+                                "step": 1, #Slider's step
+                                "display": "number" # Cosmetic only: display as "number" or "slider"
+                                }), 
+                    "text_color":("STRING",{"multiline": False,"default": "#000000"}),
+                    "vertical":("BOOLEAN", {"default": True},),
+                             },
+                }
+    
+    RETURN_TYPES = ("IMAGE","MASK")
+    # RETURN_NAMES = ("WIDTH","HEIGHT","X","Y",)
+
+    FUNCTION = "run"
+
+    CATEGORY = "♾️Mixlab/image"
+
+    INPUT_IS_LIST = False
+    OUTPUT_IS_LIST = (False,False,)
+
+    def run(self,text,font_path,font_size,spacing,text_color,vertical):
+        
+        text_list=list(text)
+
+        img,mask=generate_text_image(text_list,font_path,font_size,text_color,vertical,spacing)
+        
+        img=pil2tensor(img)
+        mask=pil2tensor(mask)
+
+        return (img,mask,)
+
+
+
+class SvgImage:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": { 
+                    "upload":("SVG",),},
+                }
+    
+    RETURN_TYPES = ("IMAGE","LAYER")
+    RETURN_NAMES = ("IMAGE","layers",)
+
+    FUNCTION = "run"
+
+    CATEGORY = "♾️Mixlab/image"
+
+    INPUT_IS_LIST = False
+    OUTPUT_IS_LIST = (False,True,)
+
+    def run(self,upload):
+        layers=[]
+
+        image = base64_to_image(upload['image'])
+        image=image.convert('RGB')
+        image=pil2tensor(image)
+
+        for layer in upload['data']:
+            layers.append(layer)
+    
+        return (image,layers,)
+
+
+
+class Image3D:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": { 
+                    "upload":("THREED",),   },
+                }
+    
+    RETURN_TYPES = ("IMAGE","MASK",)
+    # RETURN_NAMES = ("IMAGE",)
+
+    FUNCTION = "run"
+
+    CATEGORY = "♾️Mixlab/image"
+
+    INPUT_IS_LIST = False
+    OUTPUT_IS_LIST = (False,False,)
+
+    def run(self,upload):
+        # print(upload['image'])
+        image = base64_to_image(upload['image'])
+        image=image.convert('RGB')
+        mask=image.convert('L')
+        
+        mask=pil2tensor(mask)
+        image=pil2tensor(image)
+
+        return (image,mask,)
+
+
+
 class AreaToMask:
     @classmethod
     def INPUT_TYPES(s):
@@ -770,3 +994,292 @@ class FaceToMask:
 
         return (mask,)
 
+
+class EmptyLayer:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": { 
+                "width": ("INT",{
+                    "default":512, 
+                    "min": 1, #Minimum value
+                    "max": 8192, #Maximum value
+                    "step": 1, #Slider's step
+                    "display": "number" # Cosmetic only: display as "number" or "slider"
+                }),
+               "height": ("INT",{
+                    "default": 512, 
+                    "min": 1, #Minimum value
+                    "max": 8192, #Maximum value
+                    "step": 1, #Slider's step
+                    "display": "number" # Cosmetic only: display as "number" or "slider"
+                }),
+            },
+        
+                }
+    
+    RETURN_TYPES = ("LAYER",)
+    RETURN_NAMES = ("layers",)
+
+    FUNCTION = "run"
+
+    CATEGORY = "♾️Mixlab/layer"
+
+    OUTPUT_IS_LIST = (True,)
+
+    def run(self, width,height):
+        blank_image = Image.new("RGB", (width, height))
+        
+        mask=blank_image.convert('L')
+
+        blank_image=pil2tensor(blank_image)
+        mask=pil2tensor(mask)
+
+        layer_n=[{
+            "x":0,
+            "y":0,
+            "width":width,
+            "height":height,
+            "z_index":0,
+            "scale_option":'width',
+            "image":blank_image,
+            "mask":mask
+        }]
+        return (layer_n,)
+
+
+class NewLayer:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            
+            "required": { 
+                "x": ("INT",{
+                    "default": 0, 
+                    "min": -100, #Minimum value
+                    "max": 8192, #Maximum value
+                    "step": 1, #Slider's step
+                    "display": "number" # Cosmetic only: display as "number" or "slider"
+                }),
+                "y": ("INT",{
+                    "default": 0, 
+                    "min": 0, #Minimum value
+                    "max": 8192, #Maximum value
+                    "step": 1, #Slider's step
+                    "display": "number" # Cosmetic only: display as "number" or "slider"
+                }),
+                "width": ("INT",{
+                    "default": 512, 
+                    "min": 1, #Minimum value
+                    "max": 8192, #Maximum value
+                    "step": 1, #Slider's step
+                    "display": "number" # Cosmetic only: display as "number" or "slider"
+                }),
+                "height": ("INT",{
+                    "default": 512, 
+                    "min": 1, #Minimum value
+                    "max": 8192, #Maximum value
+                    "step": 1, #Slider's step
+                    "display": "number" # Cosmetic only: display as "number" or "slider"
+                }),
+                "z_index": ("INT",{
+                    "default": 0, 
+                    "min":0, #Minimum value
+                    "max": 100, #Maximum value
+                    "step": 1, #Slider's step
+                    "display": "number" # Cosmetic only: display as "number" or "slider"
+                }),
+                "scale_option": (["width","height",'overall'],),
+                "image": ("IMAGE",),
+            },
+             "optional":{
+                    "mask": ("MASK",{"default": None}),
+                    "layers": ("LAYER",{"default": None}), 
+                }
+                }
+    
+    RETURN_TYPES = ("LAYER",)
+    RETURN_NAMES = ("layers",)
+
+    FUNCTION = "run"
+
+    CATEGORY = "♾️Mixlab/layer"
+
+    INPUT_IS_LIST = True
+    OUTPUT_IS_LIST = (True,)
+
+    def run(self,x,y,width,height,z_index,scale_option,image,mask,layers):
+        # print(x,y,width,height,z_index,image,mask)
+        
+        if mask==None:
+            im=tensor2pil(image)
+            mask=im.convert('L')
+            mask=pil2tensor(mask)
+        else:
+            mask=mask[0]
+
+        layer_n=[{
+            "x":x[0],
+            "y":y[0],
+            "width":width[0],
+            "height":height[0],
+            "z_index":z_index[0],
+            "scale_option":scale_option[0],
+            "image":image[0],
+            "mask":mask
+        }]
+
+        if layers!=None:
+            layer_n=layer_n+layers
+
+        return (layer_n,)
+
+
+class ShowLayer:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            
+            "required": { 
+                "edit": ("EDIT",),
+               
+                "x": ("INT",{
+                    "default": 0, 
+                    "min": -100, #Minimum value
+                    "max": 8192, #Maximum value
+                    "step": 1, #Slider's step
+                    "display": "number" # Cosmetic only: display as "number" or "slider"
+                }),
+                "y": ("INT",{
+                    "default": 0, 
+                    "min": 0, #Minimum value
+                    "max": 8192, #Maximum value
+                    "step": 1, #Slider's step
+                    "display": "number" # Cosmetic only: display as "number" or "slider"
+                }),
+                "width": ("INT",{
+                    "default": 512, 
+                    "min": 1, #Minimum value
+                    "max": 8192, #Maximum value
+                    "step": 1, #Slider's step
+                    "display": "number" # Cosmetic only: display as "number" or "slider"
+                }),
+                "height": ("INT",{
+                    "default": 512, 
+                    "min": 1, #Minimum value
+                    "max": 8192, #Maximum value
+                    "step": 1, #Slider's step
+                    "display": "number" # Cosmetic only: display as "number" or "slider"
+                }),
+                "z_index": ("INT",{
+                    "default": 0, 
+                    "min":0, #Minimum value
+                    "max": 100, #Maximum value
+                    "step": 1, #Slider's step
+                    "display": "number" # Cosmetic only: display as "number" or "slider"
+                }),
+                "scale_option": (["width","height",'overall'],),
+                # "image": ("IMAGE",),
+            },
+             "optional":{
+                    # "mask": ("MASK",{"default": None}),
+                    "layers": ("LAYER",{"default": None}), 
+                }
+                }
+    
+    RETURN_TYPES = ( )
+    RETURN_NAMES = ( )
+
+    FUNCTION = "run"
+
+    CATEGORY = "♾️Mixlab/layer"
+
+    INPUT_IS_LIST = True
+    # OUTPUT_IS_LIST = (True,)
+
+    def run(self,edit,x,y,width,height,z_index,scale_option,layers):
+        # print(x,y,width,height,z_index,image,mask)
+        
+        # if mask==None:
+        #     im=tensor2pil(image)
+        #     mask=im.convert('L')
+        #     mask=pil2tensor(mask)
+        # else:
+        #     mask=mask[0]
+
+        # layers[edit[0]]={
+        #     "x":x[0],
+        #     "y":y[0],
+        #     "width":width[0],
+        #     "height":height[0],
+        #     "z_index":z_index[0],
+        #     "scale_option":scale_option[0],
+        #     "image":image[0],
+        #     "mask":mask
+        # }
+
+        return ( )
+
+
+class MergeLayers:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": { 
+            "layers": ("LAYER",),
+            "image": ("IMAGE",),
+                             },
+                }
+    
+    RETURN_TYPES = ("IMAGE",)
+    # RETURN_NAMES = ("WIDTH","HEIGHT","X","Y",)
+
+    FUNCTION = "run"
+
+    CATEGORY = "♾️Mixlab/layer"
+
+    INPUT_IS_LIST = True
+    # OUTPUT_IS_LIST = (False,)
+
+    def run(self,layers,image):
+        # print(len(layers),len(image))
+        bg_image=image[0]
+        bg_image=tensor2pil(bg_image)
+        # 按z-index排序
+        layers_new = sorted(layers, key=lambda x: x["z_index"])
+     
+        for layer in layers_new:
+            image=layer['image']
+            mask=layer['mask']
+            if 'type' in layer and layer['type']=='base64' and type(image) == str:
+                im=base64_to_image(image)
+                im=im.convert('RGB')
+                image=pil2tensor(im)
+
+                mask=base64_to_image(mask)
+                mask=mask.convert('L')
+                mask=pil2tensor(mask)
+            
+            
+            layer_image=tensor2pil(image)
+            layer_mask=tensor2pil(mask)
+            bg_image=merge_images(bg_image,
+                                  layer_image,
+                                  layer_mask,
+                                  layer['x'],
+                                  layer['y'],
+                                  layer['width'],
+                                  layer['height'],
+                                  layer['scale_option']
+                                  )
+            
+        mask=bg_image.convert('RGBA')
+        mask=pil2tensor(mask)
+        
+        bg_image=bg_image.convert('RGB')
+        bg_image=pil2tensor(bg_image)
+
+        channels = ["red", "green", "blue", "alpha"]
+        # print(mask,mask.shape)
+        mask = mask[:, :, :, channels.index("green")]
+        
+        return (bg_image,mask,)

nodes/ScreenShareNode.py

@@ -83,11 +83,12 @@ class ScreenShareNode:
           "optional":{
               "prompt": ("PROMPT",),
               "slide": ("SLIDE",),
+              "seed": ("SEED",),
             #   "seed": ("INT", {"default": 1, "min": 0, "max": 0xffffffffffffffff}),
                 } }
     
-    RETURN_TYPES = ('IMAGE','STRING','FLOAT')
-    RETURN_NAMES = ("IMAGE","PROMPT","FLOAT",)
+    RETURN_TYPES = ('IMAGE','STRING','FLOAT',"INT")
+    RETURN_NAMES = ("IMAGE","PROMPT","FLOAT","INT")
     FUNCTION = "run"
 
     CATEGORY = "♾️Mixlab/image"
@@ -96,10 +97,10 @@ class ScreenShareNode:
     OUTPUT_IS_LIST = (False,False,False,False)
   
     # 运行的函数
-    def run(self,image_base64,prompt,slide):
+    def run(self,image_base64,prompt,slide,seed):
         im,mask=base64_save(image_base64)
         # print('##########prompt',prompt)
-        return (im,prompt,slide)
+        return (im,prompt,slide,seed)
     
 
 class FloatingVideo:

nodes/Utils.py

@@ -0,0 +1,81 @@
+import os
+
+# FONT_PATH= os.path.abspath(os.path.join(os.path.dirname(__file__),'../assets/王汉宗颜楷体繁.ttf'))
+import matplotlib.font_manager as fm
+
+
+
+def get_font_files(directory):
+ 
+    font_files = {}
+
+    for file in os.listdir(directory):
+        if file.endswith('.ttf') or file.endswith('.otf'):
+            font_name = os.path.splitext(file)[0]
+            font_path = os.path.join(directory, file)
+            font_files[font_name] = os.path.abspath(font_path)
+
+    try:
+        font_paths = fm.findSystemFonts()
+        for path in font_paths:
+            font_prop = fm.FontProperties(fname=path)
+            font_name = font_prop.get_name()
+            font_files[font_name] = path
+    except ValueError:
+        print("findSystemFonts error")
+
+    
+    return font_files
+
+r_directory = os.path.join(os.path.dirname(__file__), '../assets/')
+
+font_files = get_font_files(r_directory)
+# print(font_files)
+
+
+class ColorInput:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": { 
+             
+                    "color":("TCOLOR",), 
+                             },
+                }
+    
+    RETURN_TYPES = ("STRING",)
+    # RETURN_NAMES = ("WIDTH","HEIGHT","X","Y",)
+
+    FUNCTION = "run"
+
+    CATEGORY = "♾️Mixlab/utils"
+
+    INPUT_IS_LIST = False
+    OUTPUT_IS_LIST = (False,False,)
+
+    def run(self,color):
+        return (color,)
+
+
+
+class FontInput:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": { 
+             
+                    "font": (list(font_files.keys()),),
+                             },
+                }
+    
+    RETURN_TYPES = ("STRING",)
+    # RETURN_NAMES = ("WIDTH","HEIGHT","X","Y",)
+
+    FUNCTION = "run"
+
+    CATEGORY = "♾️Mixlab/utils"
+
+    INPUT_IS_LIST = False
+    OUTPUT_IS_LIST = (False,False,)
+
+    def run(self,font):
+
+        return (font_files[font],)

web/javascript/audio_mixlab.js

@@ -0,0 +1,311 @@
+import { app } from '../../../scripts/app.js'
+// import { api } from '../../../scripts/api.js'
+import { ComfyWidgets } from '../../../scripts/widgets.js'
+import { $el } from '../../../scripts/ui.js'
+
+function get_position_style (ctx, widget_width, y, node_height) {
+  const MARGIN = 4 // the margin around the html element
+
+  /* Create a transform that deals with all the scrolling and zooming */
+  const elRect = ctx.canvas.getBoundingClientRect()
+  const transform = new DOMMatrix()
+    .scaleSelf(
+      elRect.width / ctx.canvas.width,
+      elRect.height / ctx.canvas.height
+    )
+    .multiplySelf(ctx.getTransform())
+    .translateSelf(MARGIN, MARGIN + y)
+
+  return {
+    transformOrigin: '0 0',
+    transform: transform,
+    left: `0`,
+    top: `0`,
+    cursor: 'pointer',
+    position: 'absolute',
+    maxWidth: `${widget_width - MARGIN * 2}px`,
+    // maxHeight: `${node_height - MARGIN * 2}px`, // we're assuming we have the whole height of the node
+    width: `${widget_width - MARGIN * 2}px`,
+    // height: `${node_height * 0.3 - MARGIN * 2}px`,
+    // background: '#EEEEEE',
+    display: 'flex',
+    flexDirection: 'column',
+    // alignItems: 'center',
+    justifyContent: 'space-around'
+  }
+}
+
+const getLocalData = key => {
+  let data = {}
+  try {
+    data = JSON.parse(localStorage.getItem(key)) || {}
+  } catch (error) {
+    return {}
+  }
+  return data
+}
+
+function speakText (text) {
+  const speechMsg = new SpeechSynthesisUtterance()
+  speechMsg.text = text
+
+  // 语音合成结束时触发的事件
+  speechMsg.onend = function (event) {
+    console.log('语音播放结束')
+    window._mixlab_speech_synthesis_onend = true
+  }
+
+  // 语音合成错误时触发的事件
+  speechMsg.onerror = function (event) {
+    console.error('语音播放错误:', event.error)
+  }
+
+  // 使用浏览器默认语音合成器进行语音播放
+  speechSynthesis.speak(speechMsg)
+}
+
+// 调用方法，将文字转换为语音播放
+// speakText('Hello, how are you?');
+//                      #MixCopilot
+
+const start = (element, id, startBtn) => {
+
+  startBtn.className='loading_mixlab'
+
+  window.recognition = new webkitSpeechRecognition()
+
+  window.recognition.continuous = true
+  window.recognition.interimResults = true
+  window.recognition.lang = navigator.language
+
+  let timeoutId, intervalId
+
+  window.recognition.onstart = () => {
+    console.log('开始语音输入', window._mixlab_speech_synthesis_onend)
+    window._mixlab_speech_synthesis_onend = false
+  }
+
+  window.recognition.onresult = function (event) {
+    const result = event.results[event.results.length - 1][0].transcript
+    console.log('识别结果：', result)
+    element.value = result
+
+    let data = getLocalData('_mixlab_speech_recognition')
+    data[id] = result.trim()
+    localStorage.setItem('_mixlab_speech_recognition', JSON.stringify(data))
+
+    if (timeoutId) clearTimeout(timeoutId)
+   
+    if (!window.recognition) return
+
+    timeoutId = setTimeout(function () {
+      console.log('结果传递：：', result)
+      app.queuePrompt(0, 1)
+      window.recognition?.stop()
+      window.recognition = null;
+      startBtn.className=''
+      startBtn.innerText = 'START'
+
+      timeoutId = null
+
+      intervalId = setInterval(() => {
+        if (
+          app.ui.lastQueueSize === 0 &&
+          !window.recognition &&
+          window._mixlab_speech_synthesis_onend
+        ) {
+          start(element, id, startBtn)
+          startBtn.innerText = 'STOP'
+          if (intervalId) {
+            clearInterval(intervalId)
+          }
+        }
+      }, 2200)
+    }, 2000)
+  }
+
+  window.recognition.onend = function () {
+    console.log('语音输入结束')
+  }
+
+  window.recognition.onspeechend = function () {
+    console.log('onspeechend')
+  }
+
+  window.recognition.onerror = function (event) {
+    console.log('Error occurred in recognition: ' + event.error)
+  }
+
+  window.recognition.start()
+}
+
+app.registerExtension({
+  name: 'Mixlab.audio.SpeechRecognition',
+  async getCustomWidgets (app) {
+    return {
+      AUDIOINPUTMIX (node, inputName, inputData, app) {
+        // console.log('##node', node)
+        const widget = {
+          type: inputData[0], // the type, CHEESE
+          name: inputName, // the name, slice
+          size: [128, 32], // a default size
+          draw (ctx, node, width, y) {},
+          computeSize (...args) {
+            return [128, 32] // a method to compute the current size of the widget
+          },
+          async serializeValue (nodeId, widgetIndex) {
+            let data = getLocalData('_mixlab_speech_recognition')
+            return data[node.id] || 'Hello Mixlab'
+          }
+        }
+        //  widget.something = something;          // maybe adds stuff to it
+        node.addCustomWidget(widget) // adds it to the node
+        return widget // and returns it.
+      }
+    }
+  },
+
+  async beforeRegisterNodeDef (nodeType, nodeData, app) {
+    if (nodeType.comfyClass == 'SpeechRecognition') {
+      const orig_nodeCreated = nodeType.prototype.onNodeCreated
+      nodeType.prototype.onNodeCreated = function () {
+        orig_nodeCreated?.apply(this, arguments)
+
+        const widget = {
+          type: 'div',
+          name: 'chatgptdiv',
+          draw (ctx, node, widget_width, y, widget_height) {
+            Object.assign(
+              this.div.style,
+              get_position_style(ctx, widget_width, 44, node.size[1])
+            )
+          }
+        }
+
+        widget.div = $el('div', {})
+
+        document.body.appendChild(widget.div)
+
+        const inputDiv = (key, placeholder) => {
+          let div = document.createElement('div')
+          const startBtn = document.createElement('button')
+          const textArea = document.createElement('textarea')
+
+          textArea.className = `${'comfy-multiline-input'} ${placeholder}`
+
+          textArea.style = `margin-top: 14px;
+          height: 44px;`
+
+          div.style = `flex-direction: column;
+          display: flex;
+          margin: 0px 8px 6px;`
+
+          startBtn.style = `
+            outline: none;
+            border: none;
+            padding: 4px; `
+
+          startBtn.innerText = 'START'
+
+          div.appendChild(startBtn)
+          div.appendChild(textArea)
+
+          startBtn.addEventListener('click', () => {
+            if (window.recognition) {
+              window.recognition.stop()
+              window.recognition = null
+              startBtn.innerText = 'START'
+              startBtn.className=''
+            } else {
+              start(textArea, this.id, startBtn)
+              startBtn.innerText = 'STOP'
+            }
+          })
+
+          return div
+        }
+
+        let inputAudio = inputDiv('_mixlab_speech_recognition', 'audio')
+        widget.div.appendChild(inputAudio)
+
+        this.addCustomWidget(widget)
+
+        const onRemoved = this.onRemoved
+        this.onRemoved = () => {
+          inputAudio.remove()
+          widget.div.remove()
+          return onRemoved?.()
+        }
+
+        this.serialize_widgets = true //需要保存参数
+      }
+    }
+  },
+  async loadedGraphNode (node, app) {
+    if (node.type === 'SpeechRecognition') {
+      let data = getLocalData('_mixlab_speech_recognition')
+      // console.log('_mixlab_speech_recognition', node.widgets)
+      let div = node.widgets.filter(f => f.type === 'div')[0]
+      if (div && data[node.id]) {
+        div.div.querySelector('textarea').value = data[node.id]
+      }
+    }
+  }
+})
+
+app.registerExtension({
+  name: 'Mixlab.audio.SpeechSynthesis',
+  async beforeRegisterNodeDef (nodeType, nodeData, app) {
+    if (nodeData.name === 'SpeechSynthesis') {
+      function populate (text) {
+        // console.log('SpeechSynthesis',this.widgets)
+
+        if (this.widgets) {
+          const pos = this.widgets.findIndex(w => w.name === 'text')
+          if (pos !== -1) {
+            for (let i = pos; i < this.widgets.length; i++) {
+              this.widgets[i].onRemove?.()
+            }
+            this.widgets.length = pos
+          }
+        }
+
+        for (let list of text) {
+          const w = ComfyWidgets['STRING'](
+            this,
+            'text',
+            ['STRING', { multiline: true }],
+            app
+          ).widget
+          w.inputEl.readOnly = true
+          w.inputEl.style.opacity = 0.6
+          w.value = list
+        }
+
+        speakText(text.join('\n'))
+
+        // console.log('ShowTextForGPT',this.widgets.length)
+        requestAnimationFrame(() => {
+          const sz = this.computeSize()
+          if (sz[0] < this.size[0]) {
+            sz[0] = this.size[0]
+          }
+          if (sz[1] < this.size[1]) {
+            sz[1] = this.size[1]
+          }
+          this.onResize?.(sz)
+          app.graph.setDirtyCanvas(true, false)
+        })
+      }
+
+      // When the node is executed we will be sent the input text, display this in the widget
+      const onExecuted = nodeType.prototype.onExecuted
+      nodeType.prototype.onExecuted = function (message) {
+        onExecuted?.apply(this, arguments)
+        populate.call(this, message.text)
+      }
+
+      this.serialize_widgets = true //需要保存参数
+    }
+  }
+})

web/javascript/checkVersion_mixlab.js

@@ -3,7 +3,7 @@ import { app } from '../../../scripts/app.js'
 const repoOwner = 'shadowcz007' // 替换为仓库的所有者
 const repoName = 'comfyui-mixlab-nodes' // 替换为仓库的名称
 
-const version = 'v0.2.6'
+const version = 'v0.3.0'
 
 fetch(`https://api.github.com/repos/${repoOwner}/${repoName}/releases/latest`)
   .then(response => response.json())

web/javascript/gpt_mixlab.js

@@ -65,10 +65,10 @@ app.registerExtension({
         const widget = {
           type: inputData[0], // the type, CHEESE
           name: inputName, // the name, slice
-          size: [128, 24], // a default size
+          size: [128, 32], // a default size
           draw (ctx, node, width, y) {},
           computeSize (...args) {
-            return [128, 24] // a method to compute the current size of the widget
+            return [128,32] // a method to compute the current size of the widget
           },
           async serializeValue (nodeId, widgetIndex) {
             let data = getLocalData('_mixlab_api_key')
@@ -84,12 +84,12 @@ app.registerExtension({
         const widget = {
           type: inputData[0], // the type, CHEESE
           name: inputName, // the name, slice
-          size: [128, 24], // a default size
+          size: [128, 32], // a default size
           draw (ctx, node, width, y) {
             // a method to draw the widget (ctx is a CanvasRenderingContext2D)
           },
           computeSize (...args) {
-            return [128, 24] // a method to compute the current size of the widget
+            return [128, 32] // a method to compute the current size of the widget
           },
           async serializeValue (nodeId, widgetIndex) {
             let data = getLocalData('_mixlab_api_url')
@@ -192,7 +192,7 @@ app.registerExtension({
 
       let id = node.id
 
-      console.log('ChatGPTOpenAI serialize_widgets', this)
+      // console.log('ChatGPTOpenAI serialize_widgets', this)
 
       widget.div.querySelector('.Key').value = apiKey[id] || 'by Mixlab'
       widget.div.querySelector('.URL').value =
@@ -216,12 +216,27 @@ app.registerExtension({
 						this.widgets.length = pos;
 					}
 				}
-        // console.log('ShowTextForGPT',this.widgets.length)
-				for (const list of text) {
+        // console.log('ShowTextForGPT',text)
+				for (let list of text) {
 					const w = ComfyWidgets["STRING"](this, "text", ["STRING", { multiline: true }], app).widget;
 					w.inputEl.readOnly = true;
 					w.inputEl.style.opacity = 0.6;
-					w.value = list;
+
+          try {
+            let data=JSON.parse(list);
+            data=Array.from(data,d=>{
+              return {
+                ...d,
+                content:decodeURIComponent(d.content)
+              }
+            })
+            list=JSON.stringify(data,null,2)
+          } catch (error) {
+            // console.log(error)
+          }
+
+					w.value =list;
+        
 				}
         // console.log('ShowTextForGPT',this.widgets.length)
 				requestAnimationFrame(() => {

web/javascript/image_mixlab.js

@@ -0,0 +1,627 @@
+import { app } from '../../../scripts/app.js'
+import { api } from '../../../scripts/api.js'
+import { ComfyWidgets } from '../../../scripts/widgets.js'
+import { $el } from '../../../scripts/ui.js'
+
+async function uploadImage (blob,fileType='.svg') {
+  // const blob = await (await fetch(src)).blob();
+  const body = new FormData()
+  body.append('image', new File([blob], new Date().getTime() + fileType))
+
+  const resp = await api.fetchApi('/upload/image', {
+    method: 'POST',
+    body
+  })
+
+  // console.log(resp)
+  let data = await resp.json()
+  let { name, subfolder } = data
+  let src = api.apiURL(
+    `/view?filename=${encodeURIComponent(
+      name
+    )}&type=input&subfolder=${subfolder}${app.getPreviewFormatParam()}${app.getRandParam()}`
+  )
+
+  return src
+}
+
+function base64ToBlobFromURL(base64URL, contentType) {
+  return fetch(base64URL)
+    .then(response => response.blob());
+}
+
+function getContentTypeFromBase64 (base64Data) {
+  const regex = /^data:(.+);base64,/
+  const matches = base64Data.match(regex)
+  if (matches && matches.length >= 2) {
+    return matches[1]
+  }
+  return null
+}
+
+// 示例用法
+// const base64Data = 'data:image/jpeg;base64,/9j/4AAQSkZJRgABAQEAAAAAAAD/...'; // 替换为实际的base64图片数据
+// const contentType = getContentTypeFromBase64(base64Data);
+// console.log(contentType);
+
+// // 示例用法
+// const base64Data = '...'; // 替换为实际的base64图片数据
+// const contentType = 'image/jpeg'; // 替换为实际的图片类型
+
+// const blob = base64ToBlob(base64Data, contentType);
+// console.log(blob);
+
+function get_position_style (ctx, widget_width, y, node_height) {
+  const MARGIN = 4 // the margin around the html element
+
+  /* Create a transform that deals with all the scrolling and zooming */
+  const elRect = ctx.canvas.getBoundingClientRect()
+  const transform = new DOMMatrix()
+    .scaleSelf(
+      elRect.width / ctx.canvas.width,
+      elRect.height / ctx.canvas.height
+    )
+    .multiplySelf(ctx.getTransform())
+    .translateSelf(MARGIN, MARGIN + y)
+
+  return {
+    transformOrigin: '0 0',
+    transform: transform,
+    left: `0`,
+    top: `0`,
+    cursor: 'pointer',
+    position: 'absolute',
+    maxWidth: `${widget_width - MARGIN * 2}px`,
+    // maxHeight: `${node_height - MARGIN * 2}px`, // we're assuming we have the whole height of the node
+    width: `${widget_width - MARGIN * 2}px`,
+    // height: `${node_height * 0.3 - MARGIN * 2}px`,
+    // background: '#EEEEEE',
+    display: 'flex',
+    flexDirection: 'column',
+    // alignItems: 'center',
+    justifyContent: 'space-around'
+  }
+}
+
+const getLocalData = key => {
+  let data = {}
+  try {
+    data = JSON.parse(localStorage.getItem(key)) || {}
+  } catch (error) {
+    return {}
+  }
+  return data
+}
+
+const setLocalDataOfWin = (key, value) => {
+  localStorage.setItem(key, JSON.stringify(value))
+  // window[key] = value
+}
+
+function createImage (url) {
+  let im = new Image()
+  return new Promise((res, rej) => {
+    im.onload = () => res(im)
+    im.src = url
+  })
+}
+
+const parseImage = url => {
+  return new Promise((res, rej) => {
+    fetch(url)
+      .then(response => response.blob())
+      .then(blob => {
+        const reader = new FileReader()
+        reader.onloadend = () => {
+          const base64data = reader.result
+          res(base64data)
+          // 在这里可以将base64数据用于进一步处理或显示图片
+        }
+        reader.readAsDataURL(blob)
+      })
+      .catch(error => {
+        console.log('发生错误:', error)
+      })
+  })
+}
+
+const parseSvg = async svgContent => {
+  // 创建一个临时的DOM元素来解析SVG
+  const tempContainer = document.createElement('div')
+  tempContainer.innerHTML = svgContent
+
+  // 提取SVG元素
+  const svgElement = tempContainer.querySelector('svg')
+  if (!svgElement) return
+  // 获取SVG中 rect元素
+  var rectElements = svgElement?.querySelectorAll('rect') || []
+
+  // 定义一个数组来存储处理后的数据
+  var data = []
+
+  Array.from(rectElements, (rectElement, i) => {
+    // 获取rect元素的属性值
+    var x = rectElement.getAttribute('x')
+    var y = rectElement.getAttribute('y')
+    var width = rectElement.getAttribute('width')
+    var height = rectElement.getAttribute('height')
+    if (x != undefined && y != undefined) {
+      // 创建一个新的canvas元素
+      var canvas = document.createElement('canvas')
+      canvas.width = width
+      canvas.height = height
+      var context = canvas.getContext('2d')
+
+      // 填充颜色到canvas
+      var fill = rectElement.getAttribute('fill')
+      context.fillStyle = fill
+      context.fillRect(0, 0, width, height)
+
+      // 将canvas转换为base64格式
+      var base64 = canvas.toDataURL()
+
+      // 将数据转化为指定的JSON格式
+
+      var rectData = {
+        x: parseInt(x),
+        y: parseInt(y),
+        width: parseInt(width),
+        height: parseInt(height),
+        z_index: i + 1,
+        scale_option: 'width',
+        image: base64,
+        mask: base64,
+        type: 'base64'
+      }
+
+      // 将处理后的数据添加到数组中
+      data.push(rectData)
+    }
+  })
+
+  var svgWidth = svgElement.getAttribute('width')
+  var svgHeight = svgElement.getAttribute('height')
+  // 创建一个新的canvas元素
+  var canvas = document.createElement('canvas')
+  canvas.width = svgWidth
+  canvas.height = svgHeight
+  var context = canvas.getContext('2d')
+  // 绘制SVG到canvas
+  var svgString = new XMLSerializer().serializeToString(svgElement)
+  var DOMURL = window.URL || window.webkitURL || window
+
+  var svgBlob = new Blob([svgString], { type: 'image/svg+xml;charset=utf-8' })
+  var url = DOMURL.createObjectURL(svgBlob)
+
+  let img = await createImage(url)
+  context.drawImage(img, 0, 0)
+
+  let base64 = canvas.toDataURL()
+
+  var rectData = {
+    x: 0,
+    y: 0,
+    width: parseInt(svgWidth),
+    height: parseInt(svgHeight),
+    z_index: 0,
+    scale_option: 'width',
+    image: base64,
+    mask: base64,
+    type: 'base64'
+  }
+  data.push(rectData)
+
+  // 打印处理后的数据
+  // console.log({ data, image: base64, svgElement })
+  return { data, image: base64, svgElement }
+}
+
+app.registerExtension({
+  name: 'Mixlab.image.SvgImage',
+  async getCustomWidgets (app) {
+    return {
+      SVG (node, inputName, inputData, app) {
+        // console.log('##node', node, inputName, inputData)
+        const widget = {
+          type: inputData[0], // the type, CHEESE
+          name: inputName, // the name, slice
+          size: [128, 88], // a default size
+          draw (ctx, node, width, y) {},
+          computeSize (...args) {
+            return [128, 88] // a method to compute the current size of the widget
+          },
+          async serializeValue (nodeId, widgetIndex) {
+            let d = getLocalData('_mixlab_svg_image')
+            // console.log('serializeValue',d)
+            if (d) {
+              let url = d[node.id]
+              let dt = await fetch(url)
+              let svgStr = await dt.text()
+              const { data, image } = (await parseSvg(svgStr)) || {}
+              // console.log(data, image)
+              return JSON.parse(JSON.stringify({ data, image }))
+            } else {
+              return
+            }
+          }
+        }
+
+        // console.log('##node',node.serialize)
+        //  widget.something = something;          // maybe adds stuff to it
+        node.addCustomWidget(widget) // adds it to the node
+
+        return widget // and returns it.
+      }
+    }
+  },
+
+  async beforeRegisterNodeDef (nodeType, nodeData, app) {
+    if (nodeType.comfyClass == 'SvgImage') {
+      const orig_nodeCreated = nodeType.prototype.onNodeCreated
+      nodeType.prototype.onNodeCreated = async function () {
+        orig_nodeCreated?.apply(this, arguments)
+
+        const uploadWidget = this.widgets.filter(w => w.name == 'upload')[0]
+        // console.log('SvgImage nodeData',await uploadWidget.serializeValue())
+
+        const widget = {
+          type: 'div',
+          name: 'upload-preview',
+          draw (ctx, node, widget_width, y, widget_height) {
+            Object.assign(
+              this.div.style,
+              get_position_style(ctx, widget_width, 44, node.size[1])
+            )
+          }
+        }
+
+        widget.div = $el('div', {})
+
+        document.body.appendChild(widget.div)
+
+        const inputDiv = (key, placeholder, svgContainer) => {
+          let div = document.createElement('div')
+          const ip = document.createElement('input')
+          ip.type = 'file'
+          ip.className = `${'comfy-multiline-input'} ${placeholder}`
+          div.style = `display: flex;
+          align-items: center; 
+          margin: 6px 8px;
+          margin-top: 0;`
+          ip.placeholder = placeholder
+          // ip.value = value
+
+          ip.style = `outline: none;
+          border: none;
+          padding: 4px;
+          width: 60%;cursor: pointer;
+          height: 32px;`
+          const label = document.createElement('label')
+          label.style = 'font-size: 10px;min-width:32px'
+          label.innerText = placeholder
+          div.appendChild(label)
+          div.appendChild(ip)
+
+          let that = this
+
+          ip.addEventListener('change', event => {
+            const file = event.target.files[0]
+            const reader = new FileReader()
+
+            // 读取文件内容
+            reader.onload = async e => {
+              const svgContent = e.target.result
+
+              var blob = new Blob([svgContent], { type: 'image/svg+xml' })
+              let url = await uploadImage(blob)
+              // console.log(url)
+              const { svgElement, data, image } = await parseSvg(svgContent)
+              // 将提取的SVG元素显示在页面上
+              let dd = getLocalData(key)
+              dd[that.id] = url
+              setLocalDataOfWin(key, dd)
+              // console.log(this.id, ip.value.trim())
+
+              svgElement.style = `width: 90%;padding: 5%;`
+              // 将提取的SVG元素显示在页面上
+
+              svgContainer.innerHTML = ''
+              svgContainer.appendChild(svgElement)
+
+              uploadWidget.value = await uploadWidget.serializeValue()
+            }
+
+            // 以文本形式读取文件
+            reader.readAsText(file)
+          })
+          return div
+        }
+
+        let svg = document.createElement('div')
+        svg.className = 'preview'
+        svg.style = `background:#eee;margin-top: 12px;`
+
+        let upload = inputDiv('_mixlab_svg_image', 'Svg', svg)
+
+        widget.div.appendChild(upload)
+        widget.div.appendChild(svg)
+        this.addCustomWidget(widget)
+
+        const onRemoved = this.onRemoved
+        this.onRemoved = () => {
+          upload.remove()
+          svg.remove()
+          widget.div.remove()
+          return onRemoved?.()
+        }
+
+        if (this.onResize) {
+          this.onResize(this.size)
+        }
+
+        this.serialize_widgets = true //需要保存参数
+      }
+    }
+  },
+  async loadedGraphNode (node, app) {
+    // Fires every time a node is constructed
+    // You can modify widgets/add handlers/etc here
+    const sleep = (t = 1000) => {
+      return new Promise((res, rej) => {
+        setTimeout(() => res(1), t)
+      })
+    }
+    if (node.type === 'SvgImage') {
+      // await sleep(0)
+      let widget = node.widgets.filter(w => w.name === 'upload-preview')[0]
+
+      let dd = getLocalData('_mixlab_svg_image')
+
+      let id = node.id
+      console.log('SvgImage load', node.widgets[0], node.widgets)
+      if (!dd[id]) return
+      let dt = await fetch(dd[id])
+      let svgStr = await dt.text()
+
+      const { svgElement, data, image } = await parseSvg(svgStr)
+      svgElement.style = `width: 90%;padding: 5%;`
+      // 将提取的SVG元素显示在页面上
+
+      widget.div.querySelector('.preview').innerHTML = ''
+      widget.div.querySelector('.preview').appendChild(svgElement)
+
+      const uploadWidget = node.widgets.filter(w => w.name == 'upload')[0]
+      uploadWidget.value = await uploadWidget.serializeValue()
+
+      // let h=~~getComputedStyle(widget.div).height.replace('px','');
+      // let w=~~getComputedStyle(widget.div).width.replace('px','');
+      // // console.log('svg', w,h,node.size)
+      // node.setSize([
+      //   w,h
+      // ])
+      // app.graph.setDirtyCanvas(true)
+
+      // console.log(node.widgets_values)
+    }
+  }
+})
+
+app.registerExtension({
+  name: 'Mixlab.image.3DImage',
+  async getCustomWidgets (app) {
+    return {
+      THREED (node, inputName, inputData, app) {
+        // console.log('##node', node, inputName, inputData)
+        const widget = {
+          type: inputData[0], // the type, CHEESE
+          name: inputName, // the name, slice
+          size: [128, 88], // a default size
+          draw (ctx, node, width, y) {},
+          computeSize (...args) {
+            return [128, 88] // a method to compute the current size of the widget
+          },
+          async serializeValue (nodeId, widgetIndex) {
+            let d = getLocalData('_mixlab_3d_image')
+            // console.log('serializeValue',d)
+            if (d) {
+              let url = d[node.id]
+              let base64 = await parseImage(url)
+
+              return JSON.parse(JSON.stringify({ image: base64 }))
+            } else {
+              return {}
+            }
+          }
+        }
+        node.addCustomWidget(widget)
+        return widget
+      }
+    }
+  },
+
+  async beforeRegisterNodeDef (nodeType, nodeData, app) {
+    if (nodeType.comfyClass == '3DImage') {
+      const orig_nodeCreated = nodeType.prototype.onNodeCreated
+      nodeType.prototype.onNodeCreated = async function () {
+        orig_nodeCreated?.apply(this, arguments)
+
+        const uploadWidget = this.widgets.filter(w => w.name == 'upload')[0]
+        console.log('3d nodeData', this.inputs)
+
+        const widget = {
+          type: 'div',
+          name: 'upload-preview',
+          draw (ctx, node, widget_width, y, widget_height) {
+            Object.assign(
+              this.div.style,
+              get_position_style(ctx, widget_width, 44, node.size[1])
+            )
+          }
+        }
+
+        widget.div = $el('div', {})
+
+        document.body.appendChild(widget.div)
+
+        const inputDiv = (key, placeholder, preview) => {
+          let div = document.createElement('div')
+          const ip = document.createElement('input')
+          ip.type = 'file'
+          ip.className = `${'comfy-multiline-input'} ${placeholder}`
+          div.style = `display: flex;
+          align-items: center; 
+          margin: 6px 8px;
+          margin-top: 0;`
+          ip.placeholder = placeholder
+          // ip.value = value
+
+          ip.style = `outline: none;
+          border: none;
+          padding: 4px;
+          width: 60%;cursor: pointer;
+          height: 32px;`
+          const label = document.createElement('label')
+          label.style = 'font-size: 10px;min-width:32px'
+          label.innerText = placeholder
+          div.appendChild(label)
+          div.appendChild(ip)
+
+          let that = this
+
+          ip.addEventListener('change', event => {
+            const file = event.target.files[0]
+            const reader = new FileReader()
+
+            // 读取文件内容
+            reader.onload = async e => {
+              const fileURL = URL.createObjectURL(file)
+              // console.log('文件URL: ', fileURL)
+              let html = `<model-viewer 
+              alt="Neil Armstrong's Spacesuit from the Smithsonian Digitization Programs Office and National Air and Space Museum"
+               src="${fileURL}" 
+               ar 
+               shadow-intensity="1" 
+               camera-controls 
+               touch-action="pan-y">
+               
+               <div class="controls">
+                <div>Variant: <select class="variant"></select></div>
+                <div><button class="capture">Capture</button></div>
+              </div></model-viewer>`
+
+              preview.innerHTML = html
+
+              const modelViewerVariants = preview.querySelector('model-viewer')
+              const select = preview.querySelector('.variant')
+              const capture = preview.querySelector('.capture')
+
+              modelViewerVariants.addEventListener('load', () => {
+                const names = modelViewerVariants.availableVariants
+                for (const name of names) {
+                  const option = document.createElement('option')
+                  option.value = name
+                  option.textContent = name
+                  select.appendChild(option)
+                }
+                // Adds a default option.
+                const option = document.createElement('option')
+                option.value = 'default'
+                option.textContent = 'Default'
+                select.appendChild(option)
+              })
+
+              select.addEventListener('input', event => {
+                modelViewerVariants.variantName =
+                  event.target.value === 'default' ? null : event.target.value
+              })
+
+              capture.addEventListener('click', async () => {
+                let base64Data = modelViewerVariants.toDataURL()
+
+                const contentType = getContentTypeFromBase64(base64Data)
+
+                const blob =await base64ToBlobFromURL(base64Data, contentType)
+
+                //  const fileBlob = new Blob([e.target.result], { type: file.type });
+                let url = await uploadImage(blob,'.png')
+                console.log(url)
+
+                let dd = getLocalData(key)
+                dd[that.id] = url
+
+                setLocalDataOfWin(key, dd)
+              })
+
+              uploadWidget.value = await uploadWidget.serializeValue()
+            }
+
+            // 以文本形式读取文件
+            reader.readAsDataURL(file)
+          })
+          return div
+        }
+
+        let preview = document.createElement('div')
+        preview.className = 'preview'
+        preview.style = `background:#eee;margin-top: 12px;`
+
+        let upload = inputDiv('_mixlab_3d_image', '3D Model', preview)
+
+        widget.div.appendChild(upload)
+        widget.div.appendChild(preview)
+        this.addCustomWidget(widget)
+
+        const onRemoved = this.onRemoved
+        this.onRemoved = () => {
+          upload.remove()
+          preview.remove()
+          widget.div.remove()
+          return onRemoved?.()
+        }
+
+        if (this.onResize) {
+          this.onResize(this.size)
+        }
+
+        this.serialize_widgets = true //需要保存参数
+      }
+    }
+  },
+  async loadedGraphNode (node, app) {
+    // Fires every time a node is constructed
+    // You can modify widgets/add handlers/etc here
+    const sleep = (t = 1000) => {
+      return new Promise((res, rej) => {
+        setTimeout(() => res(1), t)
+      })
+    }
+    if (node.type === '3DImage') {
+      // await sleep(0)
+      let widget = node.widgets.filter(w => w.name === 'upload-preview')[0]
+
+      let dd = getLocalData('_mixlab_3d_image')
+
+      let id = node.id
+      console.log('3dImage load', node.widgets[0], node.widgets)
+      if (!dd[id]) return
+
+      let url = dd[id]
+      // let base64 = await parseImage(url)
+
+      widget.div.querySelector('.preview').innerHTML = `<img src="${url}"/>` 
+
+      const uploadWidget = node.widgets.filter(w => w.name == 'upload')[0]
+      uploadWidget.value = await uploadWidget.serializeValue()
+
+      // let h=~~getComputedStyle(widget.div).height.replace('px','');
+      // let w=~~getComputedStyle(widget.div).width.replace('px','');
+      // // console.log('svg', w,h,node.size)
+      // node.setSize([
+      //   w,h
+      // ])
+      // app.graph.setDirtyCanvas(true)
+
+      // console.log(node.widgets_values)
+    }
+  }
+})

web/javascript/layer_mixlab.js

@@ -0,0 +1,333 @@
+import { app } from '../../../scripts/app.js'
+// import { api } from '../../../scripts/api.js'
+import { ComfyWidgets } from '../../../scripts/widgets.js'
+import { $el } from '../../../scripts/ui.js'
+
+function get_position_style (ctx, widget_width, y, node_height) {
+  const MARGIN = 4 // the margin around the html element
+
+  /* Create a transform that deals with all the scrolling and zooming */
+  const elRect = ctx.canvas.getBoundingClientRect()
+  const transform = new DOMMatrix()
+    .scaleSelf(
+      elRect.width / ctx.canvas.width,
+      elRect.height / ctx.canvas.height
+    )
+    .multiplySelf(ctx.getTransform())
+    .translateSelf(MARGIN, MARGIN + y)
+
+  return {
+    transformOrigin: '0 0',
+    transform: transform,
+    left: `0`,
+    top: `0`,
+    cursor: 'pointer',
+    position: 'absolute',
+    maxWidth: `${widget_width - MARGIN * 2}px`,
+    // maxHeight: `${node_height - MARGIN * 2}px`, // we're assuming we have the whole height of the node
+    width: `${widget_width - MARGIN * 2}px`,
+    // height: `${node_height * 0.3 - MARGIN * 2}px`,
+    // background: '#EEEEEE',
+    display: 'flex',
+    // flexDirection: 'column',
+    // alignItems: 'center',
+    justifyContent: 'space-around'
+  }
+}
+
+const getLocalData = key => {
+  let data = {}
+  try {
+    data = JSON.parse(localStorage.getItem(key)) || {}
+  } catch (error) {
+    return {}
+  }
+  return data
+}
+
+function createImage (url) {
+  let im = new Image()
+  return new Promise((res, rej) => {
+    im.onload = () => res(im)
+    im.src = url
+  })
+}
+
+const parseSvg = async svgContent => {
+  // 创建一个临时的DOM元素来解析SVG
+  const tempContainer = document.createElement('div')
+  tempContainer.innerHTML = svgContent
+
+  // 提取SVG元素
+  const svgElement = tempContainer.querySelector('svg')
+  if (!svgElement) return
+  // 获取SVG中 rect元素
+  var rectElements = svgElement?.querySelectorAll('rect') || []
+
+  // 定义一个数组来存储处理后的数据
+  var data = []
+
+  Array.from(rectElements, (rectElement, i) => {
+    // 获取rect元素的属性值
+    var x = rectElement.getAttribute('x')
+    var y = rectElement.getAttribute('y')
+    var width = rectElement.getAttribute('width')
+    var height = rectElement.getAttribute('height')
+    if (x != undefined && y != undefined) {
+      // 创建一个新的canvas元素
+      var canvas = document.createElement('canvas')
+      canvas.width = width
+      canvas.height = height
+      var context = canvas.getContext('2d')
+
+      // 填充颜色到canvas
+      var fill = rectElement.getAttribute('fill')
+      context.fillStyle = fill
+      context.fillRect(0, 0, width, height)
+
+      // 将canvas转换为base64格式
+      var base64 = canvas.toDataURL()
+
+      // 将数据转化为指定的JSON格式
+
+      var rectData = {
+        x: parseInt(x),
+        y: parseInt(y),
+        width: parseInt(width),
+        height: parseInt(height),
+        z_index: i + 1,
+        scale_option: 'width',
+        image: base64,
+        mask: base64,
+        type: 'base64'
+      }
+
+      // 将处理后的数据添加到数组中
+      data.push(rectData)
+    }
+  })
+
+  var svgWidth = svgElement.getAttribute('width')
+  var svgHeight = svgElement.getAttribute('height')
+  // 创建一个新的canvas元素
+  var canvas = document.createElement('canvas')
+  canvas.width = svgWidth
+  canvas.height = svgHeight
+  var context = canvas.getContext('2d')
+  // 绘制SVG到canvas
+  var svgString = new XMLSerializer().serializeToString(svgElement)
+  var DOMURL = window.URL || window.webkitURL || window
+
+  var svgBlob = new Blob([svgString], { type: 'image/svg+xml;charset=utf-8' })
+  var url = DOMURL.createObjectURL(svgBlob)
+
+  let img = await createImage(url)
+  context.drawImage(img, 0, 0)
+
+  let base64 = canvas.toDataURL()
+
+  var rectData = {
+    x: 0,
+    y: 0,
+    width: parseInt(svgWidth),
+    height: parseInt(svgHeight),
+    z_index: 0,
+    scale_option: 'width',
+    image: base64,
+    mask: base64,
+    type: 'base64'
+  }
+  data.push(rectData)
+
+  // 打印处理后的数据
+  console.log({ data, image: base64, svgElement })
+  return { data, image: base64, svgElement }
+}
+
+app.registerExtension({
+  name: 'Mixlab.layer.ShowLayer',
+  async getCustomWidgets (app) {
+    return {
+      EDIT (node, inputName, inputData, app) {
+        //   console.log('EditLayer##node', node,inputName, inputData)
+        const widget = {
+          type: inputData[0], // the type, CHEESE
+          name: inputName, // the name, slice
+          size: [128, 44], // a default size
+          draw (ctx, node, widget_width, y, widget_height) {
+            // console.log('EditLayer', this)
+            if (this.input)
+              Object.assign(
+                this.input.style,
+                get_position_style(ctx, widget_width, 32, node.size[1])
+              )
+          },
+          computeSize (...args) {
+            return [128, 44] // a method to compute the current size of the widget
+          },
+          async serializeValue (nodeId, widgetIndex) {
+            let d = getLocalData('_mixlab_edit_layer')
+            // console.log('EditLayer',d[node.id])
+            return d[node.id]
+          }
+        }
+        //  widget.something = something;          // maybe adds stuff to it
+        node.addCustomWidget(widget) // adds it to the node
+        return widget // and returns it.
+      }
+    }
+  },
+
+  async beforeRegisterNodeDef (nodeType, nodeData, app) {
+    if (nodeType.comfyClass == 'ShowLayer') {
+      const orig_nodeCreated = nodeType.prototype.onNodeCreated
+      nodeType.prototype.onNodeCreated = async function () {
+        orig_nodeCreated?.apply(this, arguments)
+
+        const findNode = nodeId => {
+          let node = app.graph._nodes_by_id[nodeId]
+          if (node?.type == 'Reroute') {
+            
+            let linkId =node.inputs.filter(i=>i.type=='*')[0].link
+            nodeId = app.graph.links.filter(link => link.id == linkId)[0]
+              ?.origin_id
+            return findNode(nodeId)
+          } else {
+            return nodeId
+          }
+        }
+
+        // 获取layers数据
+        const getLayers = async () => {
+          let linkId = this.inputs.filter(ip => ip.name === 'layers')[0].link
+          let nodeId = app.graph.links.filter(link => link.id == linkId)[0]
+            ?.origin_id
+
+          nodeId = findNode(nodeId)
+
+          //   let node = app.graph._nodes_by_id[nodeId]
+          //   if (node?.type == 'Reroute') {
+          //     linkId = node.inputs[0].link
+          //     nodeId = app.graph.links.filter(link => link.id == linkId)[0]
+          //       ?.origin_id
+          //   }
+         
+          let d = getLocalData('_mixlab_svg_image')
+          console.log('test',d[nodeId])
+
+          if (d[nodeId]) {
+            let url = d[nodeId]
+            let dt = await fetch(url)
+            let svgStr = await dt.text()
+            const { data } = (await parseSvg(svgStr)) || {}
+            return data
+          } else {
+            return []
+          }
+        }
+
+        // 修改layers数据
+        const setLayer = async (editIndex, layers = null) => {
+          //   let editIndex = 0
+          let lys = layers || (await getLayers())
+          let layer = lys[editIndex]
+          //   console.log(layer)
+
+          const updateValue = name => {
+            const x = this.widgets.filter(w => w.name == name)[0]
+            x.value = layer[name]
+          }
+          if (layer) {
+            Array.from(['x', 'y', 'width', 'height', 'z_index'], n =>
+              updateValue(n)
+            )
+          }
+        }
+
+        let that = this
+        const save_edit_layer_index = i => {
+          let data = getLocalData('_mixlab_edit_layer')
+          data[that.id] = i
+          localStorage.setItem('_mixlab_edit_layer', JSON.stringify(data))
+        }
+
+        await setLayer(0)
+        save_edit_layer_index(0)
+
+        const edit = this.widgets.filter(w => w.name == 'edit')[0]
+
+        edit.input = $el('div', {})
+        edit.input.style = `
+        display: flex;
+        flex-direction:row;
+        align-items: center;
+        margin-top: 0;`
+
+        const ip = $el('input', {})
+        ip.className = 'comfy-multiline-input'
+        ip.type = 'number'
+        ip.min = 0
+        ip.step = 1
+        ip.max = Math.max(0, (await getLayers()).length - 1)
+        // ip.className = `${'comfy-multiline-input'} `
+
+        ip.value = 0
+
+        ip.style = `
+        background-color: var(--comfy-input-bg);
+        color: var(--input-text);
+        outline: none;
+          border: none;
+          padding: 4px;
+          width: 60%;
+          cursor: pointer;
+          height: 24px;`
+        const label = document.createElement('label')
+        label.style = 'font-size: 10px;min-width:32px'
+        label.innerText = 'Layer Index'
+        edit.input.appendChild(label)
+        edit.input.appendChild(ip)
+
+        document.body.appendChild(edit.input)
+
+        ip.addEventListener('click', async event => {
+          console.log(await getLayers())
+          ip.max = Math.max(0, (await getLayers()).length - 1)
+        })
+
+        ip.addEventListener('change', async event => {
+          let index = ~~ip.value
+          let lys = await getLayers()
+          await setLayer(index, lys)
+          app.graph.setDirtyCanvas(true, true)
+          save_edit_layer_index(index)
+        })
+
+        // console.log('EditLayer nodeData', edit)
+
+        const onRemoved = this.onRemoved
+        this.onRemoved = () => {
+          edit.input.remove()
+          return onRemoved?.()
+        }
+
+        if (this.onResize) {
+          this.onResize(this.size)
+        }
+
+        this.serialize_widgets = false //需要保存参数
+      }
+    }
+  },
+  async loadedGraphNode (node, app) {
+    // Fires every time a node is constructed
+    // You can modify widgets/add handlers/etc here
+    if (node.type === 'SvgImage') {
+      let widget = node.widgets.filter(w => w.div)[0]
+      let data = getLocalData('_mixlab_svg_image')
+      let id = node.id
+
+      // widget.div.querySelector('.Svg').value = data[id] || '#000000'
+    }
+  }
+})

web/javascript/main_mixlab.js

@@ -560,6 +560,26 @@ app.registerExtension({
         // console.log('###widget', widget)
         node.addCustomWidget(widget) // adds it to the node
         return widget // and returns it.
+      },
+      SEED (node, inputName, inputData, app) {
+        // We return an object containing a field CHEESE which has a function (taking node, name, data, app)
+        const widget = {
+          type: inputData[0], // the type, CHEESE
+          name: inputName, // the name, slice
+          size: [128, 12], // a default size
+          draw (ctx, node, width, y) {
+            // a method to draw the widget (ctx is a CanvasRenderingContext2D)
+          },
+          computeSize (...args) {
+            return [128, 12] // a method to compute the current size of the widget
+          },
+          async serializeValue (nodeId, widgetIndex) {
+            return window._mixlab_screen_seed_input || 0
+          }
+        }
+        // console.log('###widget', widget)
+        node.addCustomWidget(widget) // adds it to the node
+        return widget // and returns it.
       }
     }
   },
@@ -576,9 +596,15 @@ app.registerExtension({
           type: 'HTML', // whatever
           name: 'sreen_share', // whatever
           draw (ctx, node, widget_width, y, widget_height) {
+            console.log('ScreenSHare', y, widget_height)
             Object.assign(
               this.card.style,
-              get_position_style(ctx, widget_width, y, node.size[1])
+              get_position_style(
+                ctx,
+                widget_width,
+                widget_height * 5,
+                node.size[1]
+              )
             )
           }
         }
@@ -1305,13 +1331,38 @@ app.registerExtension({
 
           // inputDiv.style = ``
           let infoDiv = document.createElement('div')
-          infoDiv.style = `    width: 100%;
+          infoDiv.style = `width: 100%;
+          display: flex;
+          justify-content: space-between;
           height: 16px;
           color: white;
           margin-bottom: 4px;
           font-size: 12px;
-          text-shadow: 1px 1px gray;`
-          infoDiv.id = 'info'
+          text-shadow: gray 1px 1px;
+          align-items: center;`
+
+          let infoText = document.createElement('div')
+          infoText.id = 'info'
+
+          let hideBtn = document.createElement('button')
+          hideBtn.innerText = '🤖'
+          hideBtn.style = `
+          border: none;
+          background: none;
+          cursor: pointer; height: 24px; margin: 4px; color: red;`
+
+          hideBtn.addEventListener('click', () => {
+            if (fnDiv.style.display == 'none') {
+              fnDiv.style.display = 'flex'
+            } else {
+              fnDiv.style.display = 'none'
+            }
+            try {
+              pipWindow.document.querySelector('#info').innerText = ''
+            } catch (error) {
+              console.log(error)
+            }
+          })
 
           // Move the player to the Picture-in-Picture window.
           let input = document.createElement('textarea')
@@ -1356,21 +1407,25 @@ app.registerExtension({
           font-size: 16px;
           margin-right: 6px;user-select: none;`
 
-          let btn = document.createElement('butotn')
-          btn.innerText = '❤'
-          btn.style = `cursor: pointer;height: 24px;margin:4px;
+          let seedBtn = document.createElement('butotn')
+          seedBtn.innerText = '🎲'
+          seedBtn.style = `cursor: pointer;height: 24px;margin:4px;
           color: red;`
-          btn.addEventListener('click', () => {
-            if (inputDiv.style.display == 'none') {
-              inputDiv.style.display = 'block'
-            } else {
-              inputDiv.style.display = 'none'
-            }
+
+          seedBtn.addEventListener('click', () => {
+            window._mixlab_screen_seed_input = Math.round(
+              Math.floor(Math.random() * 0xffffffffffffffff)
+            )
+
             try {
-              pipWindow.document.querySelector('#info').innerText = ''
+              pipWindow.document.querySelector('#info').innerText =window._mixlab_screen_seed_input
             } catch (error) {
               console.log(error)
             }
+
+            // console.log(window._mixlab_screen_seed_input)
+            if (window._mixlab_screen_imagePath)
+              document.querySelector('#queue-button').click()
           })
 
           // TODO 需要判断是否有screenshare节点，没有的话，不需要添加
@@ -1428,7 +1483,9 @@ app.registerExtension({
             console.log('##更新Prompt')
             window._mixlab_screen_prompt =
               window._mixlab_screen_prompt_input || window._mixlab_screen_prompt
-            document.querySelector('#queue-button').click()
+
+            if (window._mixlab_screen_imagePath)
+              document.querySelector('#queue-button').click()
 
             try {
               pipWindow.document.querySelector('#info').innerText =
@@ -1490,7 +1547,8 @@ app.registerExtension({
             window._mixlab_screen_slide_input = ~~slideInp.value / 100
             try {
               pipWindow.document.querySelector('#info').innerText =
-                window._mixlab_screen_slide_input;
+                window._mixlab_screen_slide_input
+              if (window._mixlab_screen_imagePath)
                 document.querySelector('#queue-button').click()
             } catch (error) {
               console.log(error)
@@ -1505,9 +1563,12 @@ app.registerExtension({
           div.appendChild(infoDiv)
           div.appendChild(fnDiv)
 
-          fnDiv.appendChild(btnDiv)
+          infoDiv.appendChild(infoText)
+          infoDiv.appendChild(hideBtn)
 
-          btnDiv.appendChild(btn)
+          fnDiv.appendChild(btnDiv)
+          // 按钮区域
+          btnDiv.appendChild(seedBtn)
           btnDiv.appendChild(pauseBtn)
           btnDiv.appendChild(promptFinishBtn)
 
@@ -1538,7 +1599,9 @@ app.registerExtension({
                 window._mixlab_screen_prompt =
                   window._mixlab_screen_prompt_input ||
                   window._mixlab_screen_prompt
-                document.querySelector('#queue-button').click()
+
+                if (window._mixlab_screen_imagePath)
+                  document.querySelector('#queue-button').click()
 
                 try {
                   pipWindow.document.querySelector('#info').innerText =

web/javascript/ui_mixlab.js

@@ -1,19 +1,61 @@
 import { app } from '../../../scripts/app.js'
 
+function injectCSS(css) {
+  // 检查页面中是否已经存在具有相同内容的style标签
+  const existingStyle = document.querySelector('style');
+  if (existingStyle && existingStyle.textContent === css) {
+    return; // 如果已经存在相同的样式，则不进行注入
+  }
+
+  // 创建一个新的style标签，并将CSS内容注入其中
+  const style = document.createElement('style');
+  style.textContent = css;
+
+  // 将style标签插入到页面的head元素中
+  const head = document.querySelector('head');
+  head.appendChild(style);
+}
+
+injectCSS(`::-webkit-scrollbar {
+  width: 2px;
+}
+
+@keyframes loading_mixlab {
+  0% {
+    background-color: green;
+  }
+
+  50% {
+    background-color: lightgreen;
+  }
+
+  100% {
+    background-color: green;
+  }
+}
+
+.loading_mixlab {
+  background-color: green;
+  animation-name: loading_mixlab;
+  animation-duration: 2s;
+  animation-iteration-count: infinite;
+}`);
+
+
 async function getCustomnodeMappings (mode = 'url') {
   // mode = "local";
   let api_host = `${window.location.hostname}:${window.location.port}`
   let api_base = ''
   let url = `${window.location.protocol}//${api_host}${api_base}`
 
-  const response = await fetch(`${url}/customnode/getmappings?mode=${mode}`)
-  const data = await response.json()
-
   let nodes = {}
   try {
+    const response = await fetch(`${url}/customnode/getmappings?mode=${mode}`)
+    const data = await response.json()
     for (let url in data) {
       let n = data[url]
       for (let node of n[0]) {
+        // if(node=='CLIPSeg')console.log('#CLIPSeg',n)
         nodes[node] = { url, title: n[1].title_aux }
       }
     }
@@ -59,9 +101,10 @@ app.showMissingNodesError = async function (
   missingNodeTypes,
   hasAddedNodes = true
 ) {
+
   const nodesMap = await getCustomnodeMappings()
   console.log('#nodesMap', nodesMap)
-  //   console.log('###MIXLAB', missingNodeTypes, hasAddedNodes)
+    console.log('###MIXLAB', missingNodeTypes, hasAddedNodes)
   this.ui.dialog.show(
     `When loading the graph, the following node types were not found: <ul>${missingNodeGithub(
       missingNodeTypes,

web/javascript/utils_mixlab.js

@@ -0,0 +1,166 @@
+
+import { app } from '../../../scripts/app.js'
+import { api } from '../../../scripts/api.js'
+import { ComfyWidgets } from '../../../scripts/widgets.js'
+import { $el } from '../../../scripts/ui.js'
+
+
+const getLocalData = key => {
+  let data = {}
+  try {
+    data = JSON.parse(localStorage.getItem(key)) || {}
+  } catch (error) {
+    return {}
+  }
+  return data
+}
+function get_position_style (ctx, widget_width, y, node_height) {
+  const MARGIN = 4 // the margin around the html element
+
+  /* Create a transform that deals with all the scrolling and zooming */
+  const elRect = ctx.canvas.getBoundingClientRect()
+  const transform = new DOMMatrix()
+    .scaleSelf(
+      elRect.width / ctx.canvas.width,
+      elRect.height / ctx.canvas.height
+    )
+    .multiplySelf(ctx.getTransform())
+    .translateSelf(MARGIN, MARGIN + y)
+
+  return {
+    transformOrigin: '0 0',
+    transform: transform,
+    left: `0`,
+    top: `0`,
+    cursor: 'pointer',
+    position: 'absolute',
+    maxWidth: `${widget_width - MARGIN * 2}px`,
+    // maxHeight: `${node_height - MARGIN * 2}px`, // we're assuming we have the whole height of the node
+    width: `${widget_width - MARGIN * 2}px`,
+    // height: `${node_height * 0.3 - MARGIN * 2}px`,
+    // background: '#EEEEEE',
+    display: 'flex',
+    flexDirection: 'column',
+    // alignItems: 'center',
+    justifyContent: 'space-around'
+  }
+}
+
+app.registerExtension({
+    name: 'Mixlab.utils.Color',
+    async getCustomWidgets (app) {
+      return {
+        TCOLOR (node, inputName, inputData, app) {
+          // console.log('##node', node)
+          const widget = {
+            type: inputData[0], // the type, CHEESE
+            name: inputName, // the name, slice
+            size: [128, 32], // a default size
+            draw (ctx, node, width, y) {},
+            computeSize (...args) {
+              return [128, 32] // a method to compute the current size of the widget
+            },
+            async serializeValue (nodeId, widgetIndex) {
+              let data = getLocalData('_mixlab_utils_color')
+              return data[node.id] || '#000000'
+            }
+          }
+          //  widget.something = something;          // maybe adds stuff to it
+          node.addCustomWidget(widget) // adds it to the node
+          return widget // and returns it.
+        }
+      }
+    },
+  
+    async beforeRegisterNodeDef (nodeType, nodeData, app) {
+      if (nodeType.comfyClass == 'Color') {
+        const orig_nodeCreated = nodeType.prototype.onNodeCreated
+        nodeType.prototype.onNodeCreated = function () {
+          orig_nodeCreated?.apply(this, arguments)
+  
+          console.log('Color nodeData', this.widgets)
+   
+          const widget = {
+            type: 'div',
+            name: 'input_color',
+            draw (ctx, node, widget_width, y, widget_height) {
+              Object.assign(
+                this.div.style,
+                get_position_style(
+                  ctx,
+                  widget_width,
+                  44,
+                  node.size[1]
+                )
+              )
+            }
+          }
+  
+          widget.div = $el('div', {})
+  
+          document.body.appendChild(widget.div)
+  
+          const inputDiv = (key, placeholder, value) => {
+            let div = document.createElement('div')
+            const ip = document.createElement('input')
+            ip.type = 'color'
+            ip.className = `${'comfy-multiline-input'} ${placeholder}`
+            div.style = `display: flex;
+            align-items: center; 
+            margin: 6px 8px;
+            margin-top: 0;`
+            ip.placeholder = placeholder
+            ip.value = value
+  
+            ip.style = `outline: none;
+            border: none;
+            padding: 4px;
+            width: 100%;cursor: pointer;
+            height: 32px;`
+            const label = document.createElement('label')
+            label.style = 'font-size: 10px;min-width:32px'
+            label.innerText = placeholder
+            div.appendChild(label)
+            div.appendChild(ip)
+  
+            ip.addEventListener('change', () => {
+              let data = getLocalData(key)
+              data[this.id] = ip.value.trim()
+              localStorage.setItem(key, JSON.stringify(data))
+              // console.log(this.id, ip.value.trim())
+            })
+            return div
+          }
+  
+          let inputColor = inputDiv('_mixlab_utils_color', 'Color', '#000000')
+  
+          widget.div.appendChild(inputColor)
+  
+          this.addCustomWidget(widget)
+  
+          const onRemoved = this.onRemoved
+          this.onRemoved = () => {
+            inputColor.remove()
+            widget.div.remove()
+            return onRemoved?.()
+          }
+  
+          this.serialize_widgets = true //需要保存参数
+        }
+      }
+    },
+    async loadedGraphNode (node, app) {
+      // Fires every time a node is constructed
+      // You can modify widgets/add handlers/etc here
+  
+      if (node.type === 'Color') {
+        let widget = node.widgets.filter(w => w.div)[0]
+  
+        let data = getLocalData('_mixlab_utils_color')
+  
+        let id = node.id
+  
+        widget.div.querySelector('.Color').value = data[id] || '#000000'
+      }
+    }
+  })

web/main.css

@@ -1,3 +1,24 @@
 ::-webkit-scrollbar {
-    width: 2px;
-  }
+  width: 2px;
+}
+
+@keyframes loading_mixlab {
+  0% {
+    background-color: green;
+  }
+
+  50% {
+    background-color: lightgreen;
+  }
+
+  100% {
+    background-color: green;
+  }
+}
+
+.loading_mixlab {
+  background-color: green;
+  animation-name: loading_mixlab;
+  animation-duration: 2s;
+  animation-iteration-count: infinite;
+}

workflow/3-FloatVideo-workflow.json

@@ -1,6 +1,6 @@
 {
-  "last_node_id": 22,
-  "last_link_id": 48,
+  "last_node_id": 23,
+  "last_link_id": 51,
   "nodes": [
     {
       "id": 7,
@@ -105,7 +105,7 @@
         {
           "name": "text",
           "type": "STRING",
-          "link": 48,
+          "link": 51,
           "widget": {
             "name": "text"
           }
@@ -316,13 +316,13 @@
         "1": 246
       },
       "flags": {},
-      "order": 6,
+      "order": 7,
       "mode": 0,
       "inputs": [
         {
           "name": "images",
           "type": "IMAGE",
-          "link": 46
+          "link": 50
         }
       ],
       "properties": {
@@ -445,13 +445,13 @@
         "1": 58
       },
       "flags": {},
-      "order": 7,
+      "order": 6,
       "mode": 0,
       "inputs": [
         {
           "name": "image",
           "type": "IMAGE",
-          "link": 47
+          "link": 49
         }
       ],
       "outputs": [
@@ -472,45 +472,6 @@
         512
       ]
     },
-    {
-      "id": 22,
-      "type": "ScreenShare",
-      "pos": [
-        -63,
-        483
-      ],
-      "size": {
-        "0": 315,
-        "1": 98
-      },
-      "flags": {},
-      "order": 3,
-      "mode": 0,
-      "outputs": [
-        {
-          "name": "IMAGE",
-          "type": "IMAGE",
-          "links": [
-            46,
-            47
-          ],
-          "shape": 3,
-          "slot_index": 0
-        },
-        {
-          "name": "STRING",
-          "type": "STRING",
-          "links": [
-            48
-          ],
-          "shape": 3,
-          "slot_index": 1
-        }
-      ],
-      "properties": {
-        "Node name for S&R": "ScreenShare"
-      }
-    },
     {
       "id": 20,
       "type": "FloatingVideo",
@@ -518,10 +479,10 @@
         1928,
         295
       ],
-      "size": [
-        315,
-        58
-      ],
+      "size": {
+        "0": 315,
+        "1": 58
+      },
       "flags": {},
       "order": 12,
       "mode": 0,
@@ -534,7 +495,68 @@
       ],
       "properties": {
         "Node name for S&R": "FloatingVideo"
-      }
+      },
+      "widgets_values": [
+        null
+      ]
+    },
+    {
+      "id": 23,
+      "type": "ScreenShare",
+      "pos": [
+        -65,
+        446
+      ],
+      "size": {
+        "0": 315,
+        "1": 170
+      },
+      "flags": {},
+      "order": 3,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            49,
+            50
+          ],
+          "shape": 3,
+          "slot_index": 0
+        },
+        {
+          "name": "PROMPT",
+          "type": "STRING",
+          "links": [
+            51
+          ],
+          "shape": 3,
+          "slot_index": 1
+        },
+        {
+          "name": "FLOAT",
+          "type": "FLOAT",
+          "links": null,
+          "shape": 3
+        },
+        {
+          "name": "INT",
+          "type": "INT",
+          "links": null,
+          "shape": 3
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "ScreenShare"
+      },
+      "widgets_values": [
+        null,
+        null,
+        null,
+        null,
+        null
+      ]
     }
   ],
   "links": [
@@ -787,24 +809,24 @@
       "CLIP"
     ],
     [
-      46,
-      22,
-      0,
-      2,
-      0,
-      "IMAGE"
-    ],
-    [
-      47,
-      22,
+      49,
+      23,
       0,
       18,
       0,
       "IMAGE"
     ],
     [
-      48,
-      22,
+      50,
+      23,
+      0,
+      2,
+      0,
+      "IMAGE"
+    ],
+    [
+      51,
+      23,
       1,
       8,
       1,

workflow/7-camera-workflow.json

@@ -1,13 +1,13 @@
 {
-  "last_node_id": 23,
-  "last_link_id": 54,
+  "last_node_id": 24,
+  "last_link_id": 59,
   "nodes": [
     {
       "id": 7,
       "type": "CLIPTextEncode",
       "pos": [
-        495,
-        307
+        515,
+        130
       ],
       "size": {
         "0": 400,
@@ -45,8 +45,8 @@
       "id": 8,
       "type": "CLIPTextEncode",
       "pos": [
-        504,
-        33
+        515,
+        1268
       ],
       "size": {
         "0": 400,
@@ -64,7 +64,7 @@
         {
           "name": "text",
           "type": "STRING",
-          "link": 48,
+          "link": 59,
           "widget": {
             "name": "text"
           }
@@ -92,8 +92,8 @@
       "id": 6,
       "type": "LoraLoader",
       "pos": [
-        112,
-        5
+        515,
+        460
       ],
       "size": {
         "0": 315,
@@ -140,58 +140,17 @@
         1
       ]
     },
-    {
-      "id": 23,
-      "type": "VAEEncode",
-      "pos": [
-        563,
-        663
-      ],
-      "size": {
-        "0": 210,
-        "1": 46
-      },
-      "flags": {},
-      "order": 5,
-      "mode": 0,
-      "inputs": [
-        {
-          "name": "pixels",
-          "type": "IMAGE",
-          "link": 52
-        },
-        {
-          "name": "vae",
-          "type": "VAE",
-          "link": 53
-        }
-      ],
-      "outputs": [
-        {
-          "name": "LATENT",
-          "type": "LATENT",
-          "links": [
-            54
-          ],
-          "shape": 3,
-          "slot_index": 0
-        }
-      ],
-      "properties": {
-        "Node name for S&R": "VAEEncode"
-      }
-    },
     {
       "id": 5,
       "type": "KSampler",
       "pos": [
-        1085,
-        49
-      ],
-      "size": [
-        315,
-        262
+        1015,
+        130
       ],
+      "size": {
+        "0": 315,
+        "1": 262
+      },
       "flags": {},
       "order": 7,
       "mode": 0,
@@ -219,7 +178,7 @@
         {
           "name": "denoise",
           "type": "FLOAT",
-          "link": 49,
+          "link": 56,
           "widget": {
             "name": "denoise"
           }
@@ -253,8 +212,8 @@
       "id": 11,
       "type": "VAEDecode",
       "pos": [
-        1451,
-        59
+        1430,
+        130
       ],
       "size": {
         "0": 210,
@@ -294,13 +253,13 @@
       "id": 20,
       "type": "FloatingVideo",
       "pos": [
-        1464,
-        243
-      ],
-      "size": [
-        315,
-        58
+        1740,
+        130
       ],
+      "size": {
+        "0": 315,
+        "1": 58
+      },
       "flags": {},
       "order": 9,
       "mode": 0,
@@ -318,12 +277,78 @@
         null
       ]
     },
+    {
+      "id": 2,
+      "type": "PreviewImage",
+      "pos": [
+        515,
+        716
+      ],
+      "size": {
+        "0": 210,
+        "1": 246
+      },
+      "flags": {},
+      "order": 4,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 55
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "PreviewImage"
+      }
+    },
+    {
+      "id": 23,
+      "type": "VAEEncode",
+      "pos": [
+        515,
+        1092
+      ],
+      "size": {
+        "0": 210,
+        "1": 46
+      },
+      "flags": {},
+      "order": 5,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "pixels",
+          "type": "IMAGE",
+          "link": 57
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": 58
+        }
+      ],
+      "outputs": [
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": [
+            54
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VAEEncode"
+      }
+    },
     {
       "id": 10,
       "type": "CheckpointLoaderSimple",
       "pos": [
-        80,
-        238
+        100,
+        130
       ],
       "size": {
         "0": 315,
@@ -358,7 +383,7 @@
           "type": "VAE",
           "links": [
             34,
-            53
+            58
           ],
           "shape": 3,
           "slot_index": 2
@@ -372,15 +397,15 @@
       ]
     },
     {
-      "id": 22,
+      "id": 24,
       "type": "ScreenShare",
       "pos": [
-        103,
-        412
+        100,
+        358
       ],
       "size": {
         "0": 315,
-        "1": 146
+        "1": 170
       },
       "flags": {},
       "order": 1,
@@ -390,17 +415,17 @@
           "name": "IMAGE",
           "type": "IMAGE",
           "links": [
-            46,
-            52
+            55,
+            57
           ],
           "shape": 3,
           "slot_index": 0
         },
         {
-          "name": "STRING",
+          "name": "PROMPT",
           "type": "STRING",
           "links": [
-            48
+            59
           ],
           "shape": 3,
           "slot_index": 1
@@ -409,10 +434,16 @@
           "name": "FLOAT",
           "type": "FLOAT",
           "links": [
-            49
+            56
           ],
           "shape": 3,
           "slot_index": 2
+        },
+        {
+          "name": "INT",
+          "type": "INT",
+          "links": null,
+          "shape": 3
         }
       ],
       "properties": {
@@ -422,33 +453,9 @@
         null,
         null,
         null,
+        null,
         null
       ]
-    },
-    {
-      "id": 2,
-      "type": "PreviewImage",
-      "pos": [
-        -501,
-        918
-      ],
-      "size": {
-        "0": 210,
-        "1": 246
-      },
-      "flags": {},
-      "order": 4,
-      "mode": 0,
-      "inputs": [
-        {
-          "name": "images",
-          "type": "IMAGE",
-          "link": 46
-        }
-      ],
-      "properties": {
-        "Node name for S&R": "PreviewImage"
-      }
     }
   ],
   "links": [
@@ -660,30 +667,6 @@
       1,
       "CLIP"
     ],
-    [
-      46,
-      22,
-      0,
-      2,
-      0,
-      "IMAGE"
-    ],
-    [
-      48,
-      22,
-      1,
-      8,
-      1,
-      "STRING"
-    ],
-    [
-      49,
-      22,
-      2,
-      5,
-      4,
-      "FLOAT"
-    ],
     [
       51,
       8,
@@ -693,15 +676,39 @@
       "CONDITIONING"
     ],
     [
-      52,
-      22,
+      54,
+      23,
+      0,
+      5,
+      3,
+      "LATENT"
+    ],
+    [
+      55,
+      24,
+      0,
+      2,
+      0,
+      "IMAGE"
+    ],
+    [
+      56,
+      24,
+      2,
+      5,
+      4,
+      "FLOAT"
+    ],
+    [
+      57,
+      24,
       0,
       23,
       0,
       "IMAGE"
     ],
     [
-      53,
+      58,
       10,
       2,
       23,
@@ -709,12 +716,12 @@
       "VAE"
     ],
     [
-      54,
-      23,
-      0,
-      5,
-      3,
-      "LATENT"
+      59,
+      24,
+      1,
+      8,
+      1,
+      "STRING"
     ]
   ],
   "groups": [],