Upload 31 files

.gitattributes

@@ -65,3 +65,6 @@ ComfyUI/custom_nodes/ComfyUI-BrushNet/example/sleeping_cat_inpaint3.png filter=l
 ComfyUI/custom_nodes/ComfyUI-BrushNet/example/sleeping_cat_inpaint5.png filter=lfs diff=lfs merge=lfs -text
 ComfyUI/custom_nodes/ComfyUI-BrushNet/example/sleeping_cat_inpaint6.png filter=lfs diff=lfs merge=lfs -text
 ComfyUI/custom_nodes/ComfyUI-BrushNet/example/test_image3.png filter=lfs diff=lfs merge=lfs -text
+ComfyUI/custom_nodes/img2txt-comfyui-nodes/wiki/demo-pics/Selection_001.png filter=lfs diff=lfs merge=lfs -text
+ComfyUI/custom_nodes/img2txt-comfyui-nodes/wiki/demo-pics/Selection_002.png filter=lfs diff=lfs merge=lfs -text
+ComfyUI/custom_nodes/img2txt-comfyui-nodes/wiki/demo-pics/Selection_003.png filter=lfs diff=lfs merge=lfs -text

ComfyUI/custom_nodes/ComfyUI_yanc/__init__.py

@@ -0,0 +1,3 @@
+from .yanc import NODE_CLASS_MAPPINGS, NODE_DISPLAY_NAME_MAPPINGS
+
+__all__ = ['NODE_CLASS_MAPPINGS', 'NODE_DISPLAY_NAME_MAPPINGS']

ComfyUI/custom_nodes/ComfyUI_yanc/examples/yanc_save_with_filename.json

@@ -0,0 +1,194 @@
+{
+  "last_node_id": 5,
+  "last_link_id": 5,
+  "nodes": [
+    {
+      "id": 3,
+      "type": "PreviewImage",
+      "pos": [
+        442,
+        250
+      ],
+      "size": [
+        300,
+        246
+      ],
+      "flags": {},
+      "order": 2,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 2
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "PreviewImage"
+      }
+    },
+    {
+      "id": 4,
+      "type": "> Save Image",
+      "pos": [
+        820,
+        100
+      ],
+      "size": [
+        315,
+        338
+      ],
+      "flags": {},
+      "order": 3,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 3
+        },
+        {
+          "name": "filename_opt",
+          "type": "STRING",
+          "link": 4,
+          "widget": {
+            "name": "filename_opt"
+          }
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "> Save Image"
+      },
+      "widgets_values": [
+        "ComfyUI",
+        "myoutputs",
+        true,
+        ""
+      ]
+    },
+    {
+      "id": 1,
+      "type": "> Load Image From Folder",
+      "pos": [
+        440,
+        100
+      ],
+      "size": {
+        "0": 315,
+        "1": 102
+      },
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "index",
+          "type": "INT",
+          "link": 5,
+          "widget": {
+            "name": "index"
+          }
+        }
+      ],
+      "outputs": [
+        {
+          "name": "image",
+          "type": "IMAGE",
+          "links": [
+            2,
+            3
+          ],
+          "shape": 3,
+          "slot_index": 0
+        },
+        {
+          "name": "file_name",
+          "type": "STRING",
+          "links": [
+            4
+          ],
+          "shape": 3,
+          "slot_index": 1
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "> Load Image From Folder"
+      },
+      "widgets_values": [
+        "myinputs",
+        -1
+      ]
+    },
+    {
+      "id": 5,
+      "type": "> Int",
+      "pos": [
+        53,
+        103
+      ],
+      "size": {
+        "0": 315,
+        "1": 82
+      },
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "int",
+          "type": "INT",
+          "links": [
+            5
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "> Int"
+      },
+      "widgets_values": [
+        0,
+        "increment"
+      ]
+    }
+  ],
+  "links": [
+    [
+      2,
+      1,
+      0,
+      3,
+      0,
+      "IMAGE"
+    ],
+    [
+      3,
+      1,
+      0,
+      4,
+      0,
+      "IMAGE"
+    ],
+    [
+      4,
+      1,
+      1,
+      4,
+      1,
+      "STRING"
+    ],
+    [
+      5,
+      5,
+      0,
+      1,
+      0,
+      "INT"
+    ]
+  ],
+  "groups": [],
+  "config": {},
+  "extra": {},
+  "version": 0.4
+}

ComfyUI/custom_nodes/ComfyUI_yanc/examples/yanc_save_with_filename_and_counter.json

@@ -0,0 +1,485 @@
+{
+  "last_node_id": 10,
+  "last_link_id": 13,
+  "nodes": [
+    {
+      "id": 3,
+      "type": "PreviewImage",
+      "pos": [
+        442,
+        250
+      ],
+      "size": [
+        300,
+        246
+      ],
+      "flags": {},
+      "order": 4,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 2
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "PreviewImage"
+      }
+    },
+    {
+      "id": 4,
+      "type": "> Save Image",
+      "pos": [
+        1580,
+        100
+      ],
+      "size": [
+        315,
+        338
+      ],
+      "flags": {},
+      "order": 8,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 3
+        },
+        {
+          "name": "filename_opt",
+          "type": "STRING",
+          "link": 7,
+          "widget": {
+            "name": "filename_opt"
+          }
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "> Save Image"
+      },
+      "widgets_values": [
+        "ComfyUI",
+        "myoutputs",
+        true,
+        ""
+      ]
+    },
+    {
+      "id": 1,
+      "type": "> Load Image From Folder",
+      "pos": [
+        440,
+        100
+      ],
+      "size": {
+        "0": 315,
+        "1": 102
+      },
+      "flags": {},
+      "order": 2,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "index",
+          "type": "INT",
+          "link": 5,
+          "widget": {
+            "name": "index"
+          }
+        }
+      ],
+      "outputs": [
+        {
+          "name": "image",
+          "type": "IMAGE",
+          "links": [
+            2,
+            3
+          ],
+          "shape": 3,
+          "slot_index": 0
+        },
+        {
+          "name": "file_name",
+          "type": "STRING",
+          "links": [
+            6
+          ],
+          "shape": 3,
+          "slot_index": 1
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "> Load Image From Folder"
+      },
+      "widgets_values": [
+        "myinputs",
+        -1
+      ]
+    },
+    {
+      "id": 6,
+      "type": "> Text Combine",
+      "pos": [
+        1220,
+        160
+      ],
+      "size": [
+        315,
+        130
+      ],
+      "flags": {},
+      "order": 7,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "text",
+          "type": "STRING",
+          "link": 6,
+          "widget": {
+            "name": "text"
+          }
+        },
+        {
+          "name": "text_append",
+          "type": "STRING",
+          "link": 8,
+          "widget": {
+            "name": "text_append"
+          }
+        }
+      ],
+      "outputs": [
+        {
+          "name": "text",
+          "type": "STRING",
+          "links": [
+            7
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "> Text Combine"
+      },
+      "widgets_values": [
+        "",
+        "",
+        "_",
+        false
+      ]
+    },
+    {
+      "id": 7,
+      "type": "> Int to Text",
+      "pos": [
+        860,
+        240
+      ],
+      "size": [
+        315,
+        106
+      ],
+      "flags": {},
+      "order": 6,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "int",
+          "type": "INT",
+          "link": 13,
+          "widget": {
+            "name": "int"
+          }
+        }
+      ],
+      "outputs": [
+        {
+          "name": "text",
+          "type": "STRING",
+          "links": [
+            8
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "> Int to Text"
+      },
+      "widgets_values": [
+        0,
+        true,
+        5
+      ]
+    },
+    {
+      "id": 5,
+      "type": "> Int",
+      "pos": [
+        53,
+        103
+      ],
+      "size": {
+        "0": 315,
+        "1": 82
+      },
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "int",
+          "type": "INT",
+          "links": [
+            5,
+            10
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "> Int"
+      },
+      "widgets_values": [
+        124,
+        "increment"
+      ]
+    },
+    {
+      "id": 10,
+      "type": "> Float to Int",
+      "pos": [
+        780,
+        580
+      ],
+      "size": [
+        315,
+        82
+      ],
+      "flags": {},
+      "order": 5,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "float",
+          "type": "FLOAT",
+          "link": 12,
+          "widget": {
+            "name": "float"
+          }
+        }
+      ],
+      "outputs": [
+        {
+          "name": "int",
+          "type": "INT",
+          "links": [
+            13
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "> Float to Int"
+      },
+      "widgets_values": [
+        0,
+        "floor"
+      ]
+    },
+    {
+      "id": 8,
+      "type": "SimpleMath+",
+      "pos": [
+        420,
+        560
+      ],
+      "size": {
+        "0": 315,
+        "1": 78
+      },
+      "flags": {},
+      "order": 3,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "a",
+          "type": "INT,FLOAT",
+          "link": 10
+        },
+        {
+          "name": "b",
+          "type": "INT,FLOAT",
+          "link": 11
+        }
+      ],
+      "outputs": [
+        {
+          "name": "INT",
+          "type": "INT",
+          "links": null,
+          "shape": 3,
+          "slot_index": 0
+        },
+        {
+          "name": "FLOAT",
+          "type": "FLOAT",
+          "links": [
+            12
+          ],
+          "shape": 3,
+          "slot_index": 1
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "SimpleMath+"
+      },
+      "widgets_values": [
+        "a/b"
+      ]
+    },
+    {
+      "id": 9,
+      "type": "SimpleMath+",
+      "pos": [
+        60,
+        560
+      ],
+      "size": {
+        "0": 315,
+        "1": 78
+      },
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "a",
+          "type": "INT,FLOAT",
+          "link": null
+        },
+        {
+          "name": "b",
+          "type": "INT,FLOAT",
+          "link": null
+        }
+      ],
+      "outputs": [
+        {
+          "name": "INT",
+          "type": "INT",
+          "links": [
+            11
+          ],
+          "shape": 3,
+          "slot_index": 0
+        },
+        {
+          "name": "FLOAT",
+          "type": "FLOAT",
+          "links": null,
+          "shape": 3
+        }
+      ],
+      "title": "Amount of Images in Input Folder",
+      "properties": {
+        "Node name for S&R": "SimpleMath+"
+      },
+      "widgets_values": [
+        "62"
+      ]
+    }
+  ],
+  "links": [
+    [
+      2,
+      1,
+      0,
+      3,
+      0,
+      "IMAGE"
+    ],
+    [
+      3,
+      1,
+      0,
+      4,
+      0,
+      "IMAGE"
+    ],
+    [
+      5,
+      5,
+      0,
+      1,
+      0,
+      "INT"
+    ],
+    [
+      6,
+      1,
+      1,
+      6,
+      0,
+      "STRING"
+    ],
+    [
+      7,
+      6,
+      0,
+      4,
+      1,
+      "STRING"
+    ],
+    [
+      8,
+      7,
+      0,
+      6,
+      1,
+      "STRING"
+    ],
+    [
+      10,
+      5,
+      0,
+      8,
+      0,
+      "INT,FLOAT"
+    ],
+    [
+      11,
+      9,
+      0,
+      8,
+      1,
+      "INT,FLOAT"
+    ],
+    [
+      12,
+      8,
+      1,
+      10,
+      0,
+      "FLOAT"
+    ],
+    [
+      13,
+      10,
+      0,
+      7,
+      0,
+      "INT"
+    ]
+  ],
+  "groups": [],
+  "config": {},
+  "extra": {},
+  "version": 0.4
+}

ComfyUI/custom_nodes/ComfyUI_yanc/examples/yanc_save_with_filename_in_divided_folders.json

@@ -0,0 +1,536 @@
+{
+  "last_node_id": 11,
+  "last_link_id": 17,
+  "nodes": [
+    {
+      "id": 3,
+      "type": "PreviewImage",
+      "pos": [
+        442,
+        250
+      ],
+      "size": [
+        300,
+        246
+      ],
+      "flags": {},
+      "order": 5,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 2
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "PreviewImage"
+      }
+    },
+    {
+      "id": 10,
+      "type": "> Float to Int",
+      "pos": [
+        780,
+        580
+      ],
+      "size": [
+        315,
+        82
+      ],
+      "flags": {},
+      "order": 6,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "float",
+          "type": "FLOAT",
+          "link": 12,
+          "widget": {
+            "name": "float"
+          }
+        }
+      ],
+      "outputs": [
+        {
+          "name": "int",
+          "type": "INT",
+          "links": [
+            13
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "> Float to Int"
+      },
+      "widgets_values": [
+        0,
+        "floor"
+      ]
+    },
+    {
+      "id": 8,
+      "type": "SimpleMath+",
+      "pos": [
+        420,
+        560
+      ],
+      "size": {
+        "0": 315,
+        "1": 78
+      },
+      "flags": {},
+      "order": 4,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "a",
+          "type": "INT,FLOAT",
+          "link": 10
+        },
+        {
+          "name": "b",
+          "type": "INT,FLOAT",
+          "link": 11
+        }
+      ],
+      "outputs": [
+        {
+          "name": "INT",
+          "type": "INT",
+          "links": null,
+          "shape": 3,
+          "slot_index": 0
+        },
+        {
+          "name": "FLOAT",
+          "type": "FLOAT",
+          "links": [
+            12
+          ],
+          "shape": 3,
+          "slot_index": 1
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "SimpleMath+"
+      },
+      "widgets_values": [
+        "a/b"
+      ]
+    },
+    {
+      "id": 9,
+      "type": "SimpleMath+",
+      "pos": [
+        60,
+        560
+      ],
+      "size": {
+        "0": 315,
+        "1": 78
+      },
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "a",
+          "type": "INT,FLOAT",
+          "link": null
+        },
+        {
+          "name": "b",
+          "type": "INT,FLOAT",
+          "link": null
+        }
+      ],
+      "outputs": [
+        {
+          "name": "INT",
+          "type": "INT",
+          "links": [
+            11
+          ],
+          "shape": 3,
+          "slot_index": 0
+        },
+        {
+          "name": "FLOAT",
+          "type": "FLOAT",
+          "links": null,
+          "shape": 3
+        }
+      ],
+      "title": "Amount of Images in Input Folder",
+      "properties": {
+        "Node name for S&R": "SimpleMath+"
+      },
+      "widgets_values": [
+        "62"
+      ]
+    },
+    {
+      "id": 4,
+      "type": "> Save Image",
+      "pos": [
+        1580,
+        100
+      ],
+      "size": [
+        315,
+        338
+      ],
+      "flags": {},
+      "order": 9,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 3
+        },
+        {
+          "name": "filename_opt",
+          "type": "STRING",
+          "link": 14,
+          "widget": {
+            "name": "filename_opt"
+          }
+        },
+        {
+          "name": "folder",
+          "type": "STRING",
+          "link": 15,
+          "widget": {
+            "name": "folder"
+          }
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "> Save Image"
+      },
+      "widgets_values": [
+        "ComfyUI",
+        "myoutputs",
+        true,
+        ""
+      ]
+    },
+    {
+      "id": 1,
+      "type": "> Load Image From Folder",
+      "pos": [
+        440,
+        100
+      ],
+      "size": {
+        "0": 315,
+        "1": 102
+      },
+      "flags": {},
+      "order": 3,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "index",
+          "type": "INT",
+          "link": 5,
+          "widget": {
+            "name": "index"
+          }
+        }
+      ],
+      "outputs": [
+        {
+          "name": "image",
+          "type": "IMAGE",
+          "links": [
+            2,
+            3
+          ],
+          "shape": 3,
+          "slot_index": 0
+        },
+        {
+          "name": "file_name",
+          "type": "STRING",
+          "links": [
+            14
+          ],
+          "shape": 3,
+          "slot_index": 1
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "> Load Image From Folder"
+      },
+      "widgets_values": [
+        "myinputs",
+        -1
+      ]
+    },
+    {
+      "id": 7,
+      "type": "> Int to Text",
+      "pos": [
+        855,
+        325
+      ],
+      "size": [
+        315,
+        106
+      ],
+      "flags": {},
+      "order": 7,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "int",
+          "type": "INT",
+          "link": 13,
+          "widget": {
+            "name": "int"
+          }
+        }
+      ],
+      "outputs": [
+        {
+          "name": "text",
+          "type": "STRING",
+          "links": [
+            8
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "> Int to Text"
+      },
+      "widgets_values": [
+        0,
+        true,
+        5
+      ]
+    },
+    {
+      "id": 6,
+      "type": "> Text Combine",
+      "pos": [
+        1220,
+        220
+      ],
+      "size": [
+        315,
+        130
+      ],
+      "flags": {},
+      "order": 8,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "text",
+          "type": "STRING",
+          "link": 17,
+          "widget": {
+            "name": "text"
+          },
+          "slot_index": 0
+        },
+        {
+          "name": "text_append",
+          "type": "STRING",
+          "link": 8,
+          "widget": {
+            "name": "text_append"
+          }
+        }
+      ],
+      "outputs": [
+        {
+          "name": "text",
+          "type": "STRING",
+          "links": [
+            15
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "> Text Combine"
+      },
+      "widgets_values": [
+        "myoutputs",
+        "",
+        "_",
+        false
+      ]
+    },
+    {
+      "id": 11,
+      "type": "PrimitiveNode",
+      "pos": [
+        850,
+        215
+      ],
+      "size": [
+        320,
+        60
+      ],
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "STRING",
+          "type": "STRING",
+          "links": [
+            17
+          ],
+          "widget": {
+            "name": "text"
+          }
+        }
+      ],
+      "title": "text",
+      "properties": {
+        "Run widget replace on values": false
+      },
+      "widgets_values": [
+        "myoutputs"
+      ]
+    },
+    {
+      "id": 5,
+      "type": "> Int",
+      "pos": [
+        53,
+        103
+      ],
+      "size": {
+        "0": 315,
+        "1": 82
+      },
+      "flags": {},
+      "order": 2,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "int",
+          "type": "INT",
+          "links": [
+            5,
+            10
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "> Int"
+      },
+      "widgets_values": [
+        0,
+        "increment"
+      ]
+    }
+  ],
+  "links": [
+    [
+      2,
+      1,
+      0,
+      3,
+      0,
+      "IMAGE"
+    ],
+    [
+      3,
+      1,
+      0,
+      4,
+      0,
+      "IMAGE"
+    ],
+    [
+      5,
+      5,
+      0,
+      1,
+      0,
+      "INT"
+    ],
+    [
+      8,
+      7,
+      0,
+      6,
+      1,
+      "STRING"
+    ],
+    [
+      10,
+      5,
+      0,
+      8,
+      0,
+      "INT,FLOAT"
+    ],
+    [
+      11,
+      9,
+      0,
+      8,
+      1,
+      "INT,FLOAT"
+    ],
+    [
+      12,
+      8,
+      1,
+      10,
+      0,
+      "FLOAT"
+    ],
+    [
+      13,
+      10,
+      0,
+      7,
+      0,
+      "INT"
+    ],
+    [
+      14,
+      1,
+      1,
+      4,
+      1,
+      "STRING"
+    ],
+    [
+      15,
+      6,
+      0,
+      4,
+      2,
+      "STRING"
+    ],
+    [
+      17,
+      11,
+      0,
+      6,
+      0,
+      "STRING"
+    ]
+  ],
+  "groups": [],
+  "config": {},
+  "extra": {},
+  "version": 0.4
+}

ComfyUI/custom_nodes/ComfyUI_yanc/examples/yanc_text_nodes_example.json

@@ -0,0 +1,822 @@
+{
+  "last_node_id": 35,
+  "last_link_id": 64,
+  "nodes": [
+    {
+      "id": 8,
+      "type": "VAEDecode",
+      "pos": [
+        2040,
+        700
+      ],
+      "size": {
+        "0": 210,
+        "1": 46
+      },
+      "flags": {},
+      "order": 14,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "samples",
+          "type": "LATENT",
+          "link": 7
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": 8
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            34
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VAEDecode"
+      }
+    },
+    {
+      "id": 27,
+      "type": "> Save Image",
+      "pos": [
+        2300,
+        700
+      ],
+      "size": [
+        480,
+        620
+      ],
+      "flags": {},
+      "order": 15,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 34
+        },
+        {
+          "name": "filename_opt",
+          "type": "STRING",
+          "link": null,
+          "widget": {
+            "name": "filename_opt"
+          }
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "> Save Image"
+      },
+      "widgets_values": [
+        "ComfyUI",
+        "yanc_demo",
+        true,
+        ""
+      ]
+    },
+    {
+      "id": 29,
+      "type": "> Text Pick Random Line",
+      "pos": [
+        300,
+        560
+      ],
+      "size": [
+        315,
+        106
+      ],
+      "flags": {},
+      "order": 5,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "text",
+          "type": "STRING",
+          "link": 39,
+          "widget": {
+            "name": "text"
+          }
+        }
+      ],
+      "outputs": [
+        {
+          "name": "text",
+          "type": "STRING",
+          "links": [
+            42
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "> Text Pick Random Line"
+      },
+      "widgets_values": [
+        "",
+        529102614921446,
+        "randomize"
+      ]
+    },
+    {
+      "id": 24,
+      "type": "> Text Combine",
+      "pos": [
+        980,
+        540
+      ],
+      "size": [
+        210,
+        102
+      ],
+      "flags": {},
+      "order": 10,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "text",
+          "type": "STRING",
+          "link": 38,
+          "widget": {
+            "name": "text"
+          }
+        },
+        {
+          "name": "text_append",
+          "type": "STRING",
+          "link": 54,
+          "widget": {
+            "name": "text_append"
+          }
+        }
+      ],
+      "outputs": [
+        {
+          "name": "text",
+          "type": "STRING",
+          "links": [
+            52,
+            53
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "> Text Combine"
+      },
+      "widgets_values": [
+        "",
+        "",
+        "",
+        true
+      ]
+    },
+    {
+      "id": 23,
+      "type": "> Clear Text",
+      "pos": [
+        640,
+        800
+      ],
+      "size": [
+        320,
+        60
+      ],
+      "flags": {},
+      "order": 9,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "text",
+          "type": "STRING",
+          "link": 27,
+          "widget": {
+            "name": "text"
+          }
+        }
+      ],
+      "outputs": [
+        {
+          "name": "text",
+          "type": "STRING",
+          "links": [
+            54
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "> Clear Text"
+      },
+      "widgets_values": [
+        "",
+        0.25
+      ]
+    },
+    {
+      "id": 7,
+      "type": "CLIPTextEncode",
+      "pos": [
+        1240,
+        900
+      ],
+      "size": {
+        "0": 425.27801513671875,
+        "1": 180.6060791015625
+      },
+      "flags": {},
+      "order": 6,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "clip",
+          "type": "CLIP",
+          "link": 5
+        }
+      ],
+      "outputs": [
+        {
+          "name": "CONDITIONING",
+          "type": "CONDITIONING",
+          "links": [
+            6
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CLIPTextEncode"
+      },
+      "widgets_values": [
+        "text, watermark, author, signature, blurry, horror"
+      ]
+    },
+    {
+      "id": 6,
+      "type": "CLIPTextEncode",
+      "pos": [
+        1240,
+        700
+      ],
+      "size": [
+        220,
+        60
+      ],
+      "flags": {},
+      "order": 12,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "clip",
+          "type": "CLIP",
+          "link": 3
+        },
+        {
+          "name": "text",
+          "type": "STRING",
+          "link": 53,
+          "widget": {
+            "name": "text"
+          }
+        }
+      ],
+      "outputs": [
+        {
+          "name": "CONDITIONING",
+          "type": "CONDITIONING",
+          "links": [
+            4
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CLIPTextEncode"
+      },
+      "widgets_values": [
+        "beautiful scenery nature glass bottle landscape, , purple galaxy bottle,"
+      ]
+    },
+    {
+      "id": 25,
+      "type": "ConsoleDebug+",
+      "pos": [
+        1260,
+        540
+      ],
+      "size": {
+        "0": 315,
+        "1": 58
+      },
+      "flags": {},
+      "order": 11,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "value",
+          "type": "*",
+          "link": 52
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "ConsoleDebug+"
+      },
+      "widgets_values": [
+        "Generated Prompt: "
+      ]
+    },
+    {
+      "id": 5,
+      "type": "EmptyLatentImage",
+      "pos": [
+        1300,
+        1120
+      ],
+      "size": {
+        "0": 315,
+        "1": 106
+      },
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": [
+            2
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "EmptyLatentImage"
+      },
+      "widgets_values": [
+        512,
+        512,
+        1
+      ]
+    },
+    {
+      "id": 18,
+      "type": "> Text Replace",
+      "pos": [
+        640,
+        540
+      ],
+      "size": [
+        315,
+        106
+      ],
+      "flags": {},
+      "order": 8,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "text",
+          "type": "STRING",
+          "link": 64,
+          "widget": {
+            "name": "text"
+          }
+        },
+        {
+          "name": "replace",
+          "type": "STRING",
+          "link": 42,
+          "widget": {
+            "name": "replace"
+          }
+        }
+      ],
+      "outputs": [
+        {
+          "name": "text",
+          "type": "STRING",
+          "links": [
+            38
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "> Text Replace"
+      },
+      "widgets_values": [
+        "",
+        "_accessory_",
+        ""
+      ]
+    },
+    {
+      "id": 28,
+      "type": "> Text",
+      "pos": [
+        -120,
+        560
+      ],
+      "size": {
+        "0": 400,
+        "1": 200
+      },
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "text",
+          "type": "STRING",
+          "links": [
+            39
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "> Text"
+      },
+      "widgets_values": [
+        "a hat\na necklace\nglasses\na shirt"
+      ]
+    },
+    {
+      "id": 22,
+      "type": "> Text Random Weights",
+      "pos": [
+        300,
+        800
+      ],
+      "size": [
+        315,
+        154
+      ],
+      "flags": {},
+      "order": 7,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "text",
+          "type": "STRING",
+          "link": 58,
+          "widget": {
+            "name": "text"
+          }
+        }
+      ],
+      "outputs": [
+        {
+          "name": "text",
+          "type": "STRING",
+          "links": [
+            27
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "> Text Random Weights"
+      },
+      "widgets_values": [
+        "",
+        0,
+        1.2000000000000002,
+        784130165638034,
+        "randomize"
+      ]
+    },
+    {
+      "id": 4,
+      "type": "CheckpointLoaderSimple",
+      "pos": [
+        840,
+        980
+      ],
+      "size": {
+        "0": 315,
+        "1": 98
+      },
+      "flags": {},
+      "order": 2,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            1
+          ],
+          "slot_index": 0
+        },
+        {
+          "name": "CLIP",
+          "type": "CLIP",
+          "links": [
+            3,
+            5
+          ],
+          "slot_index": 1
+        },
+        {
+          "name": "VAE",
+          "type": "VAE",
+          "links": [
+            8
+          ],
+          "slot_index": 2
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CheckpointLoaderSimple"
+      },
+      "widgets_values": [
+        "15\\epicrealism_pureEvolutionV5.safetensors"
+      ]
+    },
+    {
+      "id": 31,
+      "type": "> Text",
+      "pos": [
+        -120,
+        800
+      ],
+      "size": {
+        "0": 400,
+        "1": 200
+      },
+      "flags": {},
+      "order": 3,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "text",
+          "type": "STRING",
+          "links": [
+            58
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "> Text"
+      },
+      "widgets_values": [
+        "oil painting\npencil sketch\ncoal sketch\ncomci strip\nmonochrome"
+      ]
+    },
+    {
+      "id": 3,
+      "type": "KSampler",
+      "pos": [
+        1680,
+        700
+      ],
+      "size": {
+        "0": 315,
+        "1": 262
+      },
+      "flags": {},
+      "order": 13,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 1
+        },
+        {
+          "name": "positive",
+          "type": "CONDITIONING",
+          "link": 4
+        },
+        {
+          "name": "negative",
+          "type": "CONDITIONING",
+          "link": 6
+        },
+        {
+          "name": "latent_image",
+          "type": "LATENT",
+          "link": 2
+        }
+      ],
+      "outputs": [
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": [
+            7
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "KSampler"
+      },
+      "widgets_values": [
+        0,
+        "fixed",
+        20,
+        6,
+        "dpmpp_2m",
+        "karras",
+        1
+      ]
+    },
+    {
+      "id": 33,
+      "type": "> Text",
+      "pos": [
+        -120,
+        320
+      ],
+      "size": {
+        "0": 400,
+        "1": 200
+      },
+      "flags": {},
+      "order": 4,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "text",
+          "type": "STRING",
+          "links": [
+            64
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "> Text"
+      },
+      "widgets_values": [
+        "painting of a cat wearing _accessory_\n\nhigh detail"
+      ]
+    }
+  ],
+  "links": [
+    [
+      1,
+      4,
+      0,
+      3,
+      0,
+      "MODEL"
+    ],
+    [
+      2,
+      5,
+      0,
+      3,
+      3,
+      "LATENT"
+    ],
+    [
+      3,
+      4,
+      1,
+      6,
+      0,
+      "CLIP"
+    ],
+    [
+      4,
+      6,
+      0,
+      3,
+      1,
+      "CONDITIONING"
+    ],
+    [
+      5,
+      4,
+      1,
+      7,
+      0,
+      "CLIP"
+    ],
+    [
+      6,
+      7,
+      0,
+      3,
+      2,
+      "CONDITIONING"
+    ],
+    [
+      7,
+      3,
+      0,
+      8,
+      0,
+      "LATENT"
+    ],
+    [
+      8,
+      4,
+      2,
+      8,
+      1,
+      "VAE"
+    ],
+    [
+      27,
+      22,
+      0,
+      23,
+      0,
+      "STRING"
+    ],
+    [
+      34,
+      8,
+      0,
+      27,
+      0,
+      "IMAGE"
+    ],
+    [
+      38,
+      18,
+      0,
+      24,
+      0,
+      "STRING"
+    ],
+    [
+      39,
+      28,
+      0,
+      29,
+      0,
+      "STRING"
+    ],
+    [
+      42,
+      29,
+      0,
+      18,
+      1,
+      "STRING"
+    ],
+    [
+      52,
+      24,
+      0,
+      25,
+      0,
+      "*"
+    ],
+    [
+      53,
+      24,
+      0,
+      6,
+      1,
+      "STRING"
+    ],
+    [
+      54,
+      23,
+      0,
+      24,
+      1,
+      "STRING"
+    ],
+    [
+      58,
+      31,
+      0,
+      22,
+      0,
+      "STRING"
+    ],
+    [
+      64,
+      33,
+      0,
+      18,
+      0,
+      "STRING"
+    ]
+  ],
+  "groups": [],
+  "config": {},
+  "extra": {},
+  "version": 0.4
+}

ComfyUI/custom_nodes/ComfyUI_yanc/yanc.py

@@ -0,0 +1,1594 @@
+import torch
+import torchvision.transforms as T
+import torchvision.transforms.functional as F
+import torch.nn.functional as NNF
+import torch.nn.functional as NNF
+from PIL import Image, ImageSequence, ImageOps
+from PIL.PngImagePlugin import PngInfo
+import random
+import folder_paths
+import hashlib
+import numpy as np
+import os
+from pathlib import Path
+from comfy.cli_args import args
+from comfy_extras import nodes_mask as masks
+import comfy.utils
+import nodes as nodes
+import json
+import math
+import datetime
+
+yanc_root_name = "YANC"
+yanc_sub_image = "/😼 Image"
+yanc_sub_text = "/😼 Text"
+yanc_sub_basics = "/😼 Basics"
+yanc_sub_nik = "/😼 Noise Injection Sampler"
+yanc_sub_masking = "/😼 Masking"
+yanc_sub_utils = "/😼 Utils"
+yanc_sub_experimental = "/😼 Experimental"
+
+# ------------------------------------------------------------------------------------------------------------------ #
+# Functions                                                                                                          #
+# ------------------------------------------------------------------------------------------------------------------ #
+
+
+def permute_to_image(image):
+    image = T.ToTensor()(image).unsqueeze(0)
+    return image.permute([0, 2, 3, 1])[:, :, :, :3]
+
+
+def to_binary_mask(image):
+    images_sum = image.sum(axis=3)
+    return torch.where(images_sum > 0, 1.0, 0.)
+
+
+def print_brown(text):
+    print("\033[33m" + text + "\033[0m")
+
+
+def print_cyan(text):
+    print("\033[96m" + text + "\033[0m")
+
+
+def print_green(text):
+    print("\033[92m" + text + "\033[0m")
+
+
+def get_common_aspect_ratios():
+    return [
+        (4, 3),
+        (3, 2),
+        (16, 9),
+        (1, 1),
+        (21, 9),
+        (9, 16),
+        (3, 4),
+        (2, 3),
+        (5, 8)
+    ]
+
+
+def get_sdxl_resolutions():
+    return [
+        ("1:1", (1024, 1024)),
+        ("3:4", (896, 1152)),
+        ("5:8", (832, 1216)),
+        ("9:16", (768, 1344)),
+        ("9:21", (640, 1536)),
+        ("4:3", (1152, 896)),
+        ("3:2", (1216, 832)),
+        ("16:9", (1344, 768)),
+        ("21:9", (1536, 640))
+    ]
+
+
+def get_15_resolutions():
+    return [
+        ("1:1", (512, 512)),
+        ("2:3", (512, 768)),
+        ("3:4", (512, 682)),
+        ("3:2", (768, 512)),
+        ("16:9", (910, 512)),
+        ("1.85:1", (952, 512)),
+        ("2:1", (1024, 512)),
+        ("2.39:1", (1224, 512))
+    ]
+
+
+def replace_dt_placeholders(string):
+    dt = datetime.datetime.now()
+
+    format_mapping = {
+        "%d",  # Day
+        "%m",  # Month
+        "%Y",  # Year long
+        "%y",  # Year short
+        "%H",  # Hour 00 - 23
+        "%I",  # Hour 00 - 12
+        "%p",  # AM/PM
+        "%M",  # Minute
+        "%S"  # Second
+    }
+
+    for placeholder in format_mapping:
+        if placeholder in string:
+            string = string.replace(placeholder, dt.strftime(placeholder))
+
+    return string
+
+
+def patch(model, multiplier):  # RescaleCFG functionality from the ComfyUI nodes
+    def rescale_cfg(args):
+        cond = args["cond"]
+        uncond = args["uncond"]
+        cond_scale = args["cond_scale"]
+        sigma = args["sigma"]
+        sigma = sigma.view(sigma.shape[:1] + (1,) * (cond.ndim - 1))
+        x_orig = args["input"]
+
+        # rescale cfg has to be done on v-pred model output
+        x = x_orig / (sigma * sigma + 1.0)
+        cond = ((x - (x_orig - cond)) * (sigma ** 2 + 1.0) ** 0.5) / (sigma)
+        uncond = ((x - (x_orig - uncond)) *
+                  (sigma ** 2 + 1.0) ** 0.5) / (sigma)
+
+        # rescalecfg
+        x_cfg = uncond + cond_scale * (cond - uncond)
+        ro_pos = torch.std(cond, dim=(1, 2, 3), keepdim=True)
+        ro_cfg = torch.std(x_cfg, dim=(1, 2, 3), keepdim=True)
+
+        x_rescaled = x_cfg * (ro_pos / ro_cfg)
+        x_final = multiplier * x_rescaled + (1.0 - multiplier) * x_cfg
+
+        return x_orig - (x - x_final * sigma / (sigma * sigma + 1.0) ** 0.5)
+
+    m = model.clone()
+    m.set_model_sampler_cfg_function(rescale_cfg)
+    return (m, )
+
+
+def blend_images(image1, image2, blend_mode, blend_rate):
+    if blend_mode == 'multiply':
+        return (1 - blend_rate) * image1 + blend_rate * (image1 * image2)
+    elif blend_mode == 'add':
+        return (1 - blend_rate) * image1 + blend_rate * (image1 + image2)
+    elif blend_mode == 'overlay':
+        blended_image = torch.where(
+            image1 < 0.5, 2 * image1 * image2, 1 - 2 * (1 - image1) * (1 - image2))
+        return (1 - blend_rate) * image1 + blend_rate * blended_image
+    elif blend_mode == 'soft light':
+        return (1 - blend_rate) * image1 + blend_rate * (soft_light_blend(image1, image2))
+    elif blend_mode == 'hard light':
+        return (1 - blend_rate) * image1 + blend_rate * (hard_light_blend(image1, image2))
+    elif blend_mode == 'lighten':
+        return (1 - blend_rate) * image1 + blend_rate * (lighten_blend(image1, image2))
+    elif blend_mode == 'darken':
+        return (1 - blend_rate) * image1 + blend_rate * (darken_blend(image1, image2))
+    else:
+        raise ValueError("Unsupported blend mode")
+
+
+def soft_light_blend(base, blend):
+    return 2 * base * blend + base**2 * (1 - 2 * blend)
+
+
+def hard_light_blend(base, blend):
+    return 2 * base * blend + (1 - 2 * base) * (1 - blend)
+
+
+def lighten_blend(base, blend):
+    return torch.max(base, blend)
+
+
+def darken_blend(base, blend):
+    return torch.min(base, blend)
+
+
+# ------------------------------------------------------------------------------------------------------------------ #
+# Comfy classes                                                                                                      #
+# ------------------------------------------------------------------------------------------------------------------ #
+class YANCRotateImage:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "rotation_angle": ("INT", {
+                    "default": 0,
+                    "min": -359,
+                    "max": 359,
+                    "step": 1,
+                    "display": "number"})
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE", "MASK")
+    RETURN_NAMES = ("image", "mask")
+
+    FUNCTION = "do_it"
+
+    CATEGORY = yanc_root_name + yanc_sub_image
+
+    def do_it(self, image, rotation_angle):
+        samples = image.movedim(-1, 1)
+        height, width = F.get_image_size(samples)
+
+        rotation_angle = rotation_angle * -1
+        rotated_image = F.rotate(samples, angle=rotation_angle, expand=True)
+
+        empty_mask = Image.new('RGBA', (height, width), color=(255, 255, 255))
+        rotated_mask = F.rotate(empty_mask, angle=rotation_angle, expand=True)
+
+        img_out = rotated_image.movedim(1, -1)
+        mask_out = to_binary_mask(permute_to_image(rotated_mask))
+
+        return (img_out, mask_out)
+
+# ------------------------------------------------------------------------------------------------------------------ #
+
+
+class YANCText:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "text": ("STRING", {
+                    "multiline": True,
+                    "default": "",
+                    "dynamicPrompts": True
+                }),
+            },
+        }
+
+    RETURN_TYPES = ("STRING",)
+    RETURN_NAMES = ("text",)
+
+    FUNCTION = "do_it"
+
+    CATEGORY = yanc_root_name + yanc_sub_text
+
+    def do_it(self, text):
+        return (text,)
+
+# ------------------------------------------------------------------------------------------------------------------ #
+
+
+class YANCTextCombine:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "text": ("STRING", {"forceInput": True}),
+                "text_append": ("STRING", {"forceInput": True}),
+                "delimiter": ("STRING", {"multiline": False, "default": ", "}),
+                "add_empty_line": ("BOOLEAN", {"default": False})
+            },
+        }
+
+    RETURN_TYPES = ("STRING",)
+    RETURN_NAMES = ("text",)
+
+    FUNCTION = "do_it"
+
+    CATEGORY = yanc_root_name + yanc_sub_text
+
+    def do_it(self, text, text_append, delimiter, add_empty_line):
+        if text_append.strip() == "":
+            delimiter = ""
+
+        str_list = [text, text_append]
+
+        if add_empty_line:
+            str_list = [text, "\n\n", text_append]
+
+        return (delimiter.join(str_list),)
+
+# ------------------------------------------------------------------------------------------------------------------ #
+
+
+class YANCTextPickRandomLine:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "text": ("STRING", {"forceInput": True}),
+                "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff})
+            },
+        }
+
+    RETURN_TYPES = ("STRING",)
+    RETURN_NAMES = ("text",)
+
+    FUNCTION = "do_it"
+
+    CATEGORY = yanc_root_name + yanc_sub_text
+
+    def do_it(self, text, seed):
+        lines = text.splitlines()
+        random.seed(seed)
+        line = random.choice(lines)
+
+        return (line,)
+
+# ------------------------------------------------------------------------------------------------------------------ #
+
+
+class YANCClearText:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "text": ("STRING", {"forceInput": True}),
+                "chance": ("FLOAT", {
+                    "default": 0.0,
+                    "min": 0.0,
+                    "max": 1.0,
+                    "step": 0.01,
+                    "round": 0.001,
+                    "display": "number"}),
+            },
+        }
+
+    RETURN_TYPES = ("STRING",)
+    RETURN_NAMES = ("text",)
+
+    FUNCTION = "do_it"
+
+    CATEGORY = yanc_root_name + yanc_sub_text
+
+    def do_it(self, text, chance):
+        dice = random.uniform(0, 1)
+
+        if chance > dice:
+            text = ""
+
+        return (text,)
+
+    @classmethod
+    def IS_CHANGED(s, text, chance):
+        return s.do_it(s, text, chance)
+
+# ------------------------------------------------------------------------------------------------------------------ #
+
+
+class YANCTextReplace:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "text": ("STRING", {"forceInput": True}),
+                "find": ("STRING", {
+                    "multiline": False,
+                    "Default": "find"
+                }),
+                "replace": ("STRING", {
+                    "multiline": False,
+                    "Default": "replace"
+                }),
+            },
+        }
+
+    RETURN_TYPES = ("STRING",)
+    RETURN_NAMES = ("text",)
+
+    FUNCTION = "do_it"
+
+    CATEGORY = yanc_root_name + yanc_sub_text
+
+    def do_it(self, text, find, replace):
+        text = text.replace(find, replace)
+
+        return (text,)
+
+# ------------------------------------------------------------------------------------------------------------------ #
+
+
+class YANCTextRandomWeights:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "text": ("STRING", {"forceInput": True}),
+                "min": ("FLOAT", {
+                    "default": 1.0,
+                    "min": 0.0,
+                    "max": 10.0,
+                    "step": 0.1,
+                    "round": 0.1,
+                    "display": "number"}),
+                "max": ("FLOAT", {
+                    "default": 1.0,
+                    "min": 0.0,
+                    "max": 10.0,
+                    "step": 0.1,
+                    "round": 0.1,
+                    "display": "number"}),
+                "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
+            },
+        }
+
+    RETURN_TYPES = ("STRING",)
+    RETURN_NAMES = ("text",)
+
+    FUNCTION = "do_it"
+
+    CATEGORY = yanc_root_name + yanc_sub_text
+
+    def do_it(self, text, min, max, seed):
+        lines = text.splitlines()
+        count = 0
+        out = ""
+
+        random.seed(seed)
+
+        for line in lines:
+            count += 1
+            out += "({}:{})".format(line, round(random.uniform(min, max), 1)
+                                    ) + (", " if count < len(lines) else "")
+
+        return (out,)
+
+# ------------------------------------------------------------------------------------------------------------------ #
+
+
+class YANCLoadImageAndFilename:
+    @classmethod
+    def INPUT_TYPES(s):
+        input_dir = folder_paths.get_input_directory()
+        # files = [f for f in os.listdir(input_dir) if os.path.isfile(
+        #     os.path.join(input_dir, f))]
+
+        files = []
+        for root, dirs, filenames in os.walk(input_dir):
+            for filename in filenames:
+                full_path = os.path.join(root, filename)
+                relative_path = os.path.relpath(full_path, input_dir)
+                relative_path = relative_path.replace("\\", "/")
+                files.append(relative_path)
+
+        return {"required":
+                {"image": (sorted(files), {"image_upload": True}),
+                 "strip_extension": ("BOOLEAN", {"default": True})}
+                }
+
+    CATEGORY = yanc_root_name + yanc_sub_image
+
+    RETURN_TYPES = ("IMAGE", "MASK", "STRING")
+    RETURN_NAMES = ("IMAGE", "MASK", "FILENAME")
+
+    FUNCTION = "do_it"
+
+    def do_it(self, image, strip_extension):
+        image_path = folder_paths.get_annotated_filepath(image)
+        img = Image.open(image_path)
+        output_images = []
+        output_masks = []
+        for i in ImageSequence.Iterator(img):
+            i = ImageOps.exif_transpose(i)
+            if i.mode == 'I':
+                i = i.point(lambda i: i * (1 / 255))
+            image = i.convert("RGB")
+            image = np.array(image).astype(np.float32) / 255.0
+            image = torch.from_numpy(image)[None,]
+            if 'A' in i.getbands():
+                mask = np.array(i.getchannel('A')).astype(np.float32) / 255.0
+                mask = 1. - torch.from_numpy(mask)
+            else:
+                mask = torch.zeros((64, 64), dtype=torch.float32, device="cpu")
+            output_images.append(image)
+            output_masks.append(mask.unsqueeze(0))
+
+        if len(output_images) > 1:
+            output_image = torch.cat(output_images, dim=0)
+            output_mask = torch.cat(output_masks, dim=0)
+        else:
+            output_image = output_images[0]
+            output_mask = output_masks[0]
+
+        if strip_extension:
+            filename = Path(image_path).stem
+        else:
+            filename = Path(image_path).name
+
+        return (output_image, output_mask, filename,)
+
+    @classmethod
+    def IS_CHANGED(s, image, strip_extension):
+        image_path = folder_paths.get_annotated_filepath(image)
+        m = hashlib.sha256()
+        with open(image_path, 'rb') as f:
+            m.update(f.read())
+        return m.digest().hex()
+
+    @classmethod
+    def VALIDATE_INPUTS(s, image, strip_extension):
+        if not folder_paths.exists_annotated_filepath(image):
+            return "Invalid image file: {}".format(image)
+
+        return True
+
+# ------------------------------------------------------------------------------------------------------------------ #
+
+
+class YANCSaveImage:
+    def __init__(self):
+        self.output_dir = folder_paths.get_output_directory()
+        self.type = "output"
+        self.prefix_append = ""
+        self.compress_level = 4
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required":
+                {"images": ("IMAGE", ),
+                 "filename_prefix": ("STRING", {"default": "ComfyUI"}),
+                 "folder": ("STRING", {"default": ""}),
+                 "overwrite_warning": ("BOOLEAN", {"default": False}),
+                 "include_metadata": ("BOOLEAN", {"default": True}),
+                 "extension": (["png", "jpg"],),
+                 "quality": ("INT", {"default": 95, "min": 0, "max": 100}),
+                 },
+                "optional":
+                    {"filename_opt": ("STRING", {"forceInput": True})},
+                "hidden": {"prompt": "PROMPT", "extra_pnginfo": "EXTRA_PNGINFO"},
+                }
+
+    RETURN_TYPES = ()
+    FUNCTION = "do_it"
+
+    OUTPUT_NODE = True
+
+    CATEGORY = yanc_root_name + yanc_sub_image
+
+    def do_it(self, images, overwrite_warning, include_metadata, extension, quality, filename_opt=None, folder=None, filename_prefix="ComfyUI", prompt=None, extra_pnginfo=None,):
+
+        if folder:
+            filename_prefix += self.prefix_append
+            filename_prefix = os.sep.join([folder, filename_prefix])
+        else:
+            filename_prefix += self.prefix_append
+
+        if "%" in filename_prefix:
+            filename_prefix = replace_dt_placeholders(filename_prefix)
+
+        full_output_folder, filename, counter, subfolder, filename_prefix = folder_paths.get_save_image_path(
+            filename_prefix, self.output_dir, images[0].shape[1], images[0].shape[0])
+
+        results = list()
+        for (batch_number, image) in enumerate(images):
+            i = 255. * image.cpu().numpy()
+            img = Image.fromarray(np.clip(i, 0, 255).astype(np.uint8))
+            metadata = None
+
+            if not filename_opt:
+
+                filename_with_batch_num = filename.replace(
+                    "%batch_num%", str(batch_number))
+
+                counter = 1
+
+                if os.path.exists(full_output_folder) and os.listdir(full_output_folder):
+                    filtered_filenames = list(filter(
+                        lambda filename: filename.startswith(
+                            filename_with_batch_num + "_")
+                        and filename[len(filename_with_batch_num) + 1:-4].isdigit(),
+                        os.listdir(full_output_folder)
+                    ))
+
+                    if filtered_filenames:
+                        max_counter = max(
+                            int(filename[len(filename_with_batch_num) + 1:-4])
+                            for filename in filtered_filenames
+                        )
+                        counter = max_counter + 1
+
+                file = f"{filename_with_batch_num}_{counter:05}.{extension}"
+            else:
+                if len(images) == 1:
+                    file = f"{filename_opt}.{extension}"
+                else:
+                    raise Exception(
+                        "Multiple images and filename detected: Images will overwrite themselves!")
+
+            save_path = os.path.join(full_output_folder, file)
+
+            if os.path.exists(save_path) and overwrite_warning:
+                raise Exception("Filename already exists.")
+            else:
+                if extension == "png":
+                    if not args.disable_metadata and include_metadata:
+                        metadata = PngInfo()
+                        if prompt is not None:
+                            metadata.add_text("prompt", json.dumps(prompt))
+                        if extra_pnginfo is not None:
+                            for x in extra_pnginfo:
+                                metadata.add_text(x, json.dumps(extra_pnginfo[x]))
+
+                    img.save(save_path, pnginfo=metadata,
+                            compress_level=self.compress_level)
+                elif extension == "jpg":
+                    if not args.disable_metadata and include_metadata:
+                        metadata = {}
+
+                        if prompt is not None:
+                            metadata["prompt"] = prompt
+                        if extra_pnginfo is not None:
+                            for key, value in extra_pnginfo.items():
+                                metadata[key] = value
+
+                        metadata_json = json.dumps(metadata)
+                        img.info["comment"] = metadata_json
+
+                    img.save(save_path, quality=quality)
+
+            results.append({
+                "filename": file,
+                "subfolder": subfolder,
+                "type": self.type
+            })
+
+        return {"ui": {"images": results}}
+
+# ------------------------------------------------------------------------------------------------------------------ #
+
+
+class YANCLoadImageFromFolder:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required":
+                {"image_folder": ("STRING", {"default": ""})
+                 },
+                "optional":
+                    {"index": ("INT",
+                               {"default": -1,
+                                "min": -1,
+                                "max": 0xffffffffffffffff,
+                                "forceInput": True})}
+                }
+
+    CATEGORY = yanc_root_name + yanc_sub_image
+
+    RETURN_TYPES = ("IMAGE", "STRING")
+    RETURN_NAMES = ("image", "file_name")
+    FUNCTION = "do_it"
+
+    def do_it(self, image_folder, index=-1):
+
+        image_path = os.path.join(
+            folder_paths.get_input_directory(), image_folder)
+
+        # Get all files in the directory
+        files = os.listdir(image_path)
+
+        # Filter out only image files
+        image_files = [file for file in files if file.endswith(
+            ('.jpg', '.jpeg', '.png', '.webp'))]
+
+        if index is not -1:
+            print_green("INFO: Index connected.")
+
+            if index > len(image_files) - 1:
+                index = index % len(image_files)
+                print_green(
+                    "INFO: Index too high, falling back to: " + str(index))
+
+            image_file = image_files[index]
+        else:
+            print_green("INFO: Picking a random image.")
+            image_file = random.choice(image_files)
+
+        filename = Path(image_file).stem
+
+        img_path = os.path.join(image_path, image_file)
+
+        img = Image.open(img_path)
+        img = ImageOps.exif_transpose(img)
+        if img.mode == 'I':
+            img = img.point(lambda i: i * (1 / 255))
+        output_image = img.convert("RGB")
+        output_image = np.array(output_image).astype(np.float32) / 255.0
+        output_image = torch.from_numpy(output_image)[None,]
+
+        return (output_image, filename)
+
+    @classmethod
+    def IS_CHANGED(s, image_folder, index):
+        image_path = folder_paths.get_input_directory()
+        m = hashlib.sha256()
+        with open(image_path, 'rb') as f:
+            m.update(f.read())
+        return m.digest().hex()
+
+# ------------------------------------------------------------------------------------------------------------------ #
+
+
+class YANCIntToText:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required":
+                {"int": ("INT",
+                         {"default": 0,
+                          "min": 0,
+                          "max": 0xffffffffffffffff,
+                          "forceInput": True}),
+                 "leading_zeros": ("BOOLEAN", {"default": False}),
+                 "length": ("INT",
+                            {"default": 5,
+                             "min": 0,
+                             "max": 5})
+                 }
+                }
+
+    CATEGORY = yanc_root_name + yanc_sub_basics
+
+    RETURN_TYPES = ("STRING",)
+    RETURN_NAMES = ("text",)
+    FUNCTION = "do_it"
+
+    def do_it(self, int, leading_zeros, length):
+
+        text = str(int)
+
+        if leading_zeros:
+            text = text.zfill(length)
+
+        return (text,)
+
+# ------------------------------------------------------------------------------------------------------------------ #
+
+
+class YANCInt:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required":
+                {"seed": ("INT", {"default": 0, "min": 0,
+                          "max": 0xffffffffffffffff}), }
+                }
+
+    CATEGORY = yanc_root_name + yanc_sub_basics
+
+    RETURN_TYPES = ("INT",)
+    RETURN_NAMES = ("int",)
+    FUNCTION = "do_it"
+
+    def do_it(self, seed):
+
+        return (seed,)
+
+# ------------------------------------------------------------------------------------------------------------------ #
+
+
+class YANCFloatToInt:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required":
+                {"float": ("FLOAT", {"forceInput": True}),
+                 "function": (["round", "floor", "ceil"],)
+                 }
+                }
+
+    CATEGORY = yanc_root_name + yanc_sub_basics
+
+    RETURN_TYPES = ("INT",)
+    RETURN_NAMES = ("int",)
+    FUNCTION = "do_it"
+
+    def do_it(self, float, function):
+
+        result = round(float)
+
+        if function == "floor":
+            result = math.floor(float)
+        elif function == "ceil":
+            result = math.ceil(float)
+
+        return (int(result),)
+
+# ------------------------------------------------------------------------------------------------------------------ #
+
+
+class YANCScaleImageToSide:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required":
+                {
+                    "image": ("IMAGE",),
+                    "scale_to": ("INT", {"default": 512}),
+                    "side": (["shortest", "longest", "width", "height"],),
+                    "interpolation": (["lanczos", "nearest", "bilinear", "bicubic", "area", "nearest-exact"],),
+                    "modulo": ("INT", {"default": 0})
+                },
+                "optional":
+                {
+                    "mask_opt": ("MASK",),
+                }
+                }
+
+    CATEGORY = yanc_root_name + yanc_sub_image
+
+    RETURN_TYPES = ("IMAGE", "MASK", "INT", "INT", "FLOAT",)
+    RETURN_NAMES = ("image", "mask", "width", "height", "scale_ratio",)
+    FUNCTION = "do_it"
+
+    def do_it(self, image, scale_to, side, interpolation, modulo, mask_opt=None):
+
+        image = image.movedim(-1, 1)
+
+        image_height, image_width = image.shape[-2:]
+
+        longer_side = "height" if image_height > image_width else "width"
+        shorter_side = "height" if image_height < image_width else "width"
+
+        new_height, new_width, scale_ratio = 0, 0, 0
+
+        if side == "shortest":
+            side = shorter_side
+        elif side == "longest":
+            side = longer_side
+
+        if side == "width":
+            scale_ratio = scale_to / image_width
+        elif side == "height":
+            scale_ratio = scale_to / image_height
+
+        new_height = image_height * scale_ratio
+        new_width = image_width * scale_ratio
+
+        if modulo != 0:
+            new_height = new_height - (new_height % modulo)
+            new_width = new_width - (new_width % modulo)
+
+        new_width = int(new_width)
+        new_height = int(new_height)
+
+        image = comfy.utils.common_upscale(image,
+                                           new_width, new_height, interpolation, "center")
+
+        if mask_opt is not None:
+            mask_opt = mask_opt.permute(0, 1, 2)
+
+            mask_opt = mask_opt.unsqueeze(0)
+            mask_opt = NNF.interpolate(mask_opt, size=(
+                new_height, new_width), mode='bilinear', align_corners=False)
+
+            mask_opt = mask_opt.squeeze(0)
+            mask_opt = mask_opt.squeeze(0)
+
+            mask_opt = mask_opt.permute(0, 1)
+
+        image = image.movedim(1, -1)
+
+        return (image, mask_opt, new_width, new_height, 1.0/scale_ratio)
+
+# ------------------------------------------------------------------------------------------------------------------ #
+
+
+class YANCResolutionByAspectRatio:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required":
+                {
+                    "stable_diffusion": (["1.5", "SDXL"],),
+                    "image": ("IMAGE",),
+                },
+                }
+
+    CATEGORY = yanc_root_name + yanc_sub_image
+
+    RETURN_TYPES = ("INT", "INT")
+    RETURN_NAMES = ("width", "height",)
+    FUNCTION = "do_it"
+
+    def do_it(self, stable_diffusion, image):
+
+        common_ratios = get_common_aspect_ratios()
+        resolutionsSDXL = get_sdxl_resolutions()
+        resolutions15 = get_15_resolutions()
+
+        resolution = resolutions15 if stable_diffusion == "1.5" else resolutionsSDXL
+
+        image_height, image_width = 0, 0
+
+        image = image.movedim(-1, 1)
+        image_height, image_width = image.shape[-2:]
+
+        gcd = math.gcd(image_width, image_height)
+        aspect_ratio = image_width // gcd, image_height // gcd
+
+        closest_ratio = min(common_ratios, key=lambda x: abs(
+            x[1] / x[0] - aspect_ratio[1] / aspect_ratio[0]))
+
+        closest_resolution = min(resolution, key=lambda res: abs(
+            res[1][0] * aspect_ratio[1] - res[1][1] * aspect_ratio[0]))
+
+        height, width = closest_resolution[1][1], closest_resolution[1][0]
+        sd_version = stable_diffusion if stable_diffusion == "SDXL" else "SD 1.5"
+
+        print_cyan(
+            f"Orig. Resolution: {image_width}x{image_height}, Aspect Ratio: {closest_ratio[0]}:{closest_ratio[1]}, Picked resolution: {width}x{height} for {sd_version}")
+
+        return (width, height,)
+
+# ------------------------------------------------------------------------------------------------------------------ #
+
+
+class YANCNIKSampler:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required":
+                {"model": ("MODEL",),
+                 "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
+                 "steps": ("INT", {"default": 30, "min": 1, "max": 10000}),
+                 "cfg": ("FLOAT", {"default": 8.0, "min": 0.0, "max": 100.0, "step": 0.1, "round": 0.01}),
+                 "cfg_noise": ("FLOAT", {"default": 8.0, "min": 0.0, "max": 100.0, "step": 0.1, "round": 0.01}),
+                 "sampler_name": (comfy.samplers.KSampler.SAMPLERS, ),
+                 "scheduler": (comfy.samplers.KSampler.SCHEDULERS, ),
+                 "positive": ("CONDITIONING", ),
+                 "negative": ("CONDITIONING", ),
+                 "latent_image": ("LATENT", ),
+                 "noise_strength": ("FLOAT", {"default": 0.5, "min": 0.1, "max": 1.0, "step": 0.1, "round": 0.01}),
+                 },
+                "optional":
+                {
+                    "latent_noise": ("LATENT", ),
+                    "mask": ("MASK",)
+                }
+                }
+
+    RETURN_TYPES = ("LATENT",)
+    RETURN_NAME = ("latent",)
+    FUNCTION = "do_it"
+
+    CATEGORY = yanc_root_name + yanc_sub_nik
+
+    def do_it(self, model, seed, steps, cfg, cfg_noise, sampler_name, scheduler, positive, negative, latent_image, noise_strength, latent_noise, inject_time=0.5, denoise=1.0, mask=None):
+
+        inject_at_step = round(steps * inject_time)
+        print("Inject at step: " + str(inject_at_step))
+
+        empty_latent = False if torch.all(
+            latent_image["samples"]) != 0 else True
+
+        print_cyan("Sampling first step image.")
+        samples_base_sampler = nodes.common_ksampler(model, seed, steps, cfg, sampler_name, scheduler, positive, negative, latent_image,
+                                                     denoise=denoise, disable_noise=False, start_step=0, last_step=inject_at_step, force_full_denoise=True)
+
+        if mask is not None and empty_latent:
+            print_cyan(
+                "Sampling full image for unmasked areas. You can avoid this step by providing a non empty latent.")
+            samples_base_sampler2 = nodes.common_ksampler(
+                model, seed, steps, cfg, sampler_name, scheduler, positive, negative, latent_image, denoise=1.0)
+
+        samples_base_sampler = samples_base_sampler[0]
+
+        if mask is not None and not empty_latent:
+            samples_base_sampler = latent_image.copy()
+            samples_base_sampler["samples"] = latent_image["samples"].clone()
+
+        samples_out = latent_image.copy()
+        samples_out["samples"] = latent_image["samples"].clone()
+
+        samples_noise = latent_noise.copy()
+        samples_noise = latent_noise["samples"].clone()
+
+        if samples_base_sampler["samples"].shape != samples_noise.shape:
+            samples_noise.permute(0, 3, 1, 2)
+            samples_noise = comfy.utils.common_upscale(
+                samples_noise, samples_base_sampler["samples"].shape[3], samples_base_sampler["samples"].shape[2], 'bicubic', crop='center')
+            samples_noise.permute(0, 2, 3, 1)
+
+        samples_o = samples_base_sampler["samples"] * (1 - noise_strength)
+        samples_n = samples_noise * noise_strength
+
+        samples_out["samples"] = samples_o + samples_n
+
+        patched_model = patch(model=model, multiplier=0.65)[
+            0] if round(cfg_noise, 1) > 8.0 else model
+
+        print_cyan("Applying noise.")
+        result = nodes.common_ksampler(patched_model, seed, steps, cfg_noise, sampler_name, scheduler, positive, negative, samples_out,
+                                       denoise=denoise, disable_noise=False, start_step=inject_at_step, last_step=steps, force_full_denoise=False)[0]
+
+        if mask is not None:
+            print_cyan("Composing...")
+            destination = latent_image["samples"].clone(
+            ) if not empty_latent else samples_base_sampler2[0]["samples"].clone()
+            source = result["samples"]
+            result["samples"] = masks.composite(
+                destination, source, 0, 0, mask, 8)
+
+        return (result,)
+
+# ------------------------------------------------------------------------------------------------------------------ #
+
+
+class YANCNoiseFromImage:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required":
+                {
+                    "image": ("IMAGE",),
+                    "magnitude": ("FLOAT", {"default": 210.0, "min": 0.0, "max": 250.0, "step": 0.5, "round": 0.1}),
+                    "smoothness": ("FLOAT", {"default": 3.0, "min": 0.0, "max": 10.0, "step": 0.5, "round": 0.1}),
+                    "noise_intensity": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.01, "round": 0.01}),
+                    "noise_resize_factor": ("INT", {"default": 2.0, "min": 0, "max": 5.0}),
+                    "noise_blend_rate": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 1.0, "step": 0.005, "round": 0.005}),
+                    "saturation_correction": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.5, "step": 0.1, "round": 0.1}),
+                    "blend_mode": (["off", "multiply", "add", "overlay", "soft light", "hard light", "lighten", "darken"],),
+                    "blend_rate": ("FLOAT", {"default": 0.25, "min": 0.0, "max": 1.0, "step": 0.01, "round": 0.01}),
+                },
+                "optional":
+                {
+                    "vae_opt": ("VAE", ),
+                }
+                }
+
+    CATEGORY = yanc_root_name + yanc_sub_nik
+
+    RETURN_TYPES = ("IMAGE", "LATENT")
+    RETURN_NAMES = ("image", "latent")
+    FUNCTION = "do_it"
+
+    def do_it(self, image, magnitude, smoothness, noise_intensity, noise_resize_factor, noise_blend_rate, saturation_correction, blend_mode, blend_rate, vae_opt=None):
+
+        # magnitude:                The alpha for the elastic transform. Magnitude of displacements.
+        # smoothness:               The sigma for the elastic transform. Smoothness of displacements.
+        # noise_intensity:          Multiplier for the torch noise.
+        # noise_resize_factor:      Multiplier to enlarge the generated noise.
+        # noise_blend_rate:         Blend rate between the elastic and the noise.
+        # saturation_correction:    Well, for saturation correction.
+        # blend_mode:               Different blending modes to blend over batched images.
+        # blend_rate:               The strength of the blending.
+
+        noise_blend_rate = noise_blend_rate / 2.25
+
+        if blend_mode != "off":
+            blended_image = image[0:1]
+
+            for i in range(1, image.size(0)):
+                blended_image = blend_images(
+                    blended_image, image[i:i+1], blend_mode=blend_mode, blend_rate=blend_rate)
+
+                max_value = torch.max(blended_image)
+                blended_image /= max_value
+
+            image = blended_image
+
+        noisy_image = torch.randn_like(image) * noise_intensity
+        noisy_image = noisy_image.movedim(-1, 1)
+
+        image = image.movedim(-1, 1)
+        image_height, image_width = image.shape[-2:]
+
+        r_mean = torch.mean(image[:, 0, :, :])
+        g_mean = torch.mean(image[:, 1, :, :])
+        b_mean = torch.mean(image[:, 2, :, :])
+
+        fill_value = (r_mean.item(), g_mean.item(), b_mean.item())
+
+        elastic_transformer = T.ElasticTransform(
+            alpha=float(magnitude), sigma=float(smoothness), fill=fill_value)
+        transformed_img = elastic_transformer(image)
+
+        if saturation_correction != 1.0:
+            transformed_img = F.adjust_saturation(
+                transformed_img, saturation_factor=saturation_correction)
+
+        if noise_resize_factor > 0:
+            resize_cropper = T.RandomResizedCrop(
+                size=(image_height // noise_resize_factor, image_width // noise_resize_factor))
+
+            resized_crop = resize_cropper(noisy_image)
+
+            resized_img = T.Resize(
+                size=(image_height, image_width))(resized_crop)
+            resized_img = resized_img.movedim(1, -1)
+        else:
+            resized_img = noisy_image.movedim(1, -1)
+
+        if image.size(0) == 1:
+            result = transformed_img.squeeze(0).permute(
+                1, 2, 0) + (resized_img * noise_blend_rate)
+        else:
+            result = transformed_img.squeeze(0).permute(
+                [0, 2, 3, 1])[:, :, :, :3] + (resized_img * noise_blend_rate)
+
+        latent = None
+
+        if vae_opt is not None:
+            latent = vae_opt.encode(result[:, :, :, :3])
+
+        return (result, {"samples": latent})
+
+# ------------------------------------------------------------------------------------------------------------------ #
+
+
+class YANCMaskCurves:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required":
+                {
+                    "mask": ("MASK",),
+                    "low_value_factor": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 3.0, "step": 0.05, "round": 0.05}),
+                    "mid_low_value_factor": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 3.0, "step": 0.05, "round": 0.05}),
+                    "mid_value_factor": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 3.0, "step": 0.05, "round": 0.05}),
+                    "high_value_factor": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 3.0, "step": 0.05, "round": 0.05}),
+                    "brightness": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 3.0, "step": 0.05, "round": 0.05}),
+                },
+                }
+
+    CATEGORY = yanc_root_name + yanc_sub_masking
+
+    RETURN_TYPES = ("MASK",)
+    RETURN_NAMES = ("mask",)
+    FUNCTION = "do_it"
+
+    def do_it(self, mask, low_value_factor, mid_low_value_factor, mid_value_factor, high_value_factor, brightness):
+
+        low_mask = (mask < 0.25).float()
+        mid_low_mask = ((mask >= 0.25) & (mask < 0.5)).float()
+        mid_mask = ((mask >= 0.5) & (mask < 0.75)).float()
+        high_mask = (mask >= 0.75).float()
+
+        low_mask = low_mask * (mask * low_value_factor)
+        mid_low_mask = mid_low_mask * (mask * mid_low_value_factor)
+        mid_mask = mid_mask * (mask * mid_value_factor)
+        high_mask = high_mask * (mask * high_value_factor)
+
+        final_mask = low_mask + mid_low_mask + mid_mask + high_mask
+        final_mask = final_mask * brightness
+        final_mask = torch.clamp(final_mask, 0, 1)
+
+        return (final_mask,)
+
+
+# ------------------------------------------------------------------------------------------------------------------ #
+
+
+class YANCLightSourceMask:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required":
+                {
+                    "image": ("IMAGE",),
+                    "threshold": ("FLOAT", {"default": 0.33, "min": 0.0, "max": 1.0, "step": 0.01, "round": 0.01}),
+                },
+                }
+
+    CATEGORY = yanc_root_name + yanc_sub_masking
+
+    RETURN_TYPES = ("MASK",)
+    RETURN_NAMES = ("mask",)
+    FUNCTION = "do_it"
+
+    def do_it(self, image, threshold):
+        batch_size, height, width, _ = image.shape
+
+        kernel_size = max(33, int(0.05 * min(height, width)))
+        kernel_size = kernel_size if kernel_size % 2 == 1 else kernel_size + 1
+        sigma = max(1.0, kernel_size / 5.0)
+
+        masks = []
+
+        for i in range(batch_size):
+            mask = image[i].permute(2, 0, 1)
+            mask = torch.mean(mask, dim=0)
+
+            mask = torch.where(mask > threshold, mask * 3.0,
+                               torch.tensor(0.0, device=mask.device))
+            mask.clamp_(min=0.0, max=1.0)
+
+            mask = mask.unsqueeze(0).unsqueeze(0)
+
+            blur = T.GaussianBlur(kernel_size=(
+                kernel_size, kernel_size), sigma=(sigma, sigma))
+            mask = blur(mask)
+
+            mask = mask.squeeze(0).squeeze(0)
+            masks.append(mask)
+
+        masks = torch.stack(masks)
+
+        return (masks,)
+
+
+# ------------------------------------------------------------------------------------------------------------------ #
+
+
+class YANCNormalMapLighting:
+
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "diffuse_map": ("IMAGE",),
+                "normal_map": ("IMAGE",),
+                "specular_map": ("IMAGE",),
+                "light_yaw": ("FLOAT", {"default": 45, "min": -180, "max": 180, "step": 1}),
+                "light_pitch": ("FLOAT", {"default": 30, "min": -90, "max": 90, "step": 1}),
+                "specular_power": ("FLOAT", {"default": 32, "min": 1, "max": 200, "step": 1}),
+                "ambient_light": ("FLOAT", {"default": 0.50, "min": 0, "max": 1, "step": 0.01}),
+                "NormalDiffuseStrength": ("FLOAT", {"default": 1.00, "min": 0, "max": 5.0, "step": 0.01}),
+                "SpecularHighlightsStrength": ("FLOAT", {"default": 1.00, "min": 0, "max": 5.0, "step": 0.01}),
+                "TotalGain": ("FLOAT", {"default": 1.00, "min": 0, "max": 2.0, "step": 0.01}),
+                "color": ("INT", {"default": 0xFFFFFF, "min": 0, "max": 0xFFFFFF, "step": 1, "display": "color"}),
+            },
+            "optional": {
+                "mask": ("MASK",),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+
+    FUNCTION = "do_it"
+
+    CATEGORY = yanc_root_name + yanc_sub_image
+
+    def resize_tensor(self, tensor, size):
+        return torch.nn.functional.interpolate(tensor, size=size, mode='bilinear', align_corners=False)
+
+    def do_it(self, diffuse_map, normal_map, specular_map, light_yaw, light_pitch, specular_power, ambient_light, NormalDiffuseStrength, SpecularHighlightsStrength, TotalGain, color, mask=None,):
+        if mask is None:
+            mask = torch.ones_like(diffuse_map[:, :, :, 0])
+
+        diffuse_tensor = diffuse_map.permute(
+            0, 3, 1, 2)
+        normal_tensor = normal_map.permute(
+            0, 3, 1, 2) * 2.0 - 1.0
+        specular_tensor = specular_map.permute(
+            0, 3, 1, 2)
+        mask_tensor = mask.unsqueeze(1)
+        mask_tensor = mask_tensor.expand(-1, 3, -1, -1)
+
+        target_size = (diffuse_tensor.shape[2], diffuse_tensor.shape[3])
+        normal_tensor = self.resize_tensor(normal_tensor, target_size)
+        specular_tensor = self.resize_tensor(specular_tensor, target_size)
+        mask_tensor = self.resize_tensor(mask_tensor, target_size)
+
+        normal_tensor = torch.nn.functional.normalize(normal_tensor, dim=1)
+
+        light_direction = self.euler_to_vector(light_yaw, light_pitch, 0)
+        light_direction = light_direction.view(1, 3, 1, 1)
+
+        camera_direction = self.euler_to_vector(0, 0, 0)
+        camera_direction = camera_direction.view(1, 3, 1, 1)
+
+        light_color = self.int_to_rgb(color)
+        light_color_tensor = torch.tensor(
+            light_color).view(1, 3, 1, 1)
+
+        diffuse = torch.sum(normal_tensor * light_direction,
+                            dim=1, keepdim=True)
+        diffuse = torch.clamp(diffuse, 0, 1)
+        diffuse = diffuse * light_color_tensor
+
+        half_vector = torch.nn.functional.normalize(
+            light_direction + camera_direction, dim=1)
+        specular = torch.sum(normal_tensor * half_vector, dim=1, keepdim=True)
+        specular = torch.pow(torch.clamp(specular, 0, 1), specular_power)
+
+        specular = specular * light_color_tensor
+
+        if diffuse.shape != target_size:
+            diffuse = self.resize_tensor(diffuse, target_size)
+        if specular.shape != target_size:
+            specular = self.resize_tensor(specular, target_size)
+
+        output_tensor = (diffuse_tensor * (ambient_light + diffuse * NormalDiffuseStrength) +
+                         specular_tensor * specular * SpecularHighlightsStrength) * TotalGain
+
+        output_tensor = output_tensor * mask_tensor + \
+            diffuse_tensor * (1 - mask_tensor)
+
+        output_tensor = output_tensor.permute(
+            0, 2, 3, 1)
+
+        return (output_tensor,)
+
+    def euler_to_vector(self, yaw, pitch, roll):
+        yaw_rad = np.radians(yaw)
+        pitch_rad = np.radians(pitch)
+        roll_rad = np.radians(roll)
+
+        cos_pitch = np.cos(pitch_rad)
+        sin_pitch = np.sin(pitch_rad)
+        cos_yaw = np.cos(yaw_rad)
+        sin_yaw = np.sin(yaw_rad)
+
+        direction = np.array([
+            sin_yaw * cos_pitch,
+            sin_pitch,
+            cos_pitch * cos_yaw
+        ])
+
+        return torch.from_numpy(direction).float()
+
+    def int_to_rgb(self, color_int):
+        r = (color_int >> 16) & 0xFF
+        g = (color_int >> 8) & 0xFF
+        b = color_int & 0xFF
+
+        return (r / 255.0, g / 255.0, b / 255.0)
+
+
+# ------------------------------------------------------------------------------------------------------------------ #
+
+
+class YANCRGBColor:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required":
+                {
+                    "red": ("INT", {"default": 0, "min": 0, "max": 255, "step": 1}),
+                    "green": ("INT", {"default": 0, "min": 0, "max": 255, "step": 1}),
+                    "blue": ("INT", {"default": 0, "min": 0, "max": 255, "step": 1}),
+                    "plus_minus": ("INT", {"default": 0, "min": -255, "max": 255, "step": 1}),
+                },
+                }
+
+    CATEGORY = yanc_root_name + yanc_sub_utils
+
+    RETURN_TYPES = ("INT", "INT", "INT", "INT", "STRING",)
+    RETURN_NAMES = ("int", "red", "green", "blue", "hex",)
+    FUNCTION = "do_it"
+
+    def do_it(self, red, green, blue, plus_minus):
+        total = red + green + blue
+
+        r_ratio = red / total if total != 0 else 0
+        g_ratio = green / total if total != 0 else 0
+        b_ratio = blue / total if total != 0 else 0
+
+        if plus_minus > 0:
+            max_plus_minus = min((255 - red) / r_ratio if r_ratio > 0 else float('inf'),
+                                (255 - green) / g_ratio if g_ratio > 0 else float('inf'),
+                                (255 - blue) / b_ratio if b_ratio > 0 else float('inf'))
+            effective_plus_minus = min(plus_minus, max_plus_minus)
+        else:
+            max_plus_minus = min(red / r_ratio if r_ratio > 0 else float('inf'),
+                                green / g_ratio if g_ratio > 0 else float('inf'),
+                                blue / b_ratio if b_ratio > 0 else float('inf'))
+            effective_plus_minus = max(plus_minus, -max_plus_minus)
+
+        new_r = red + effective_plus_minus * r_ratio
+        new_g = green + effective_plus_minus * g_ratio
+        new_b = blue + effective_plus_minus * b_ratio
+
+        new_r = max(0, min(255, round(new_r)))
+        new_g = max(0, min(255, round(new_g)))
+        new_b = max(0, min(255, round(new_b)))
+
+        color = (new_r << 16) | (new_g << 8) | new_b
+
+        hex_color = "#{:02x}{:02x}{:02x}".format(
+            int(new_r), int(new_g), int(new_b)).upper()
+
+        return (color, new_r, new_g, new_b, hex_color)
+
+
+# ------------------------------------------------------------------------------------------------------------------ #
+
+
+class YANCGetMeanColor:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required":
+                {
+                    "image": ("IMAGE",),
+                    "amplify": ("BOOLEAN", {"default": False})
+                },
+                "optional":
+                {
+                    "mask_opt": ("MASK",),
+                },
+                }
+
+    CATEGORY = yanc_root_name + yanc_sub_utils
+
+    RETURN_TYPES = ("INT", "INT", "INT", "INT", "STRING")
+    RETURN_NAMES = ("int", "red", "green", "blue", "hex")
+    FUNCTION = "do_it"
+
+    def do_it(self, image, amplify, mask_opt=None):
+        masked_image = image.clone()
+
+        if mask_opt is not None:
+            if mask_opt.shape[1:3] != image.shape[1:3]:
+                raise ValueError(
+                    "Mask and image spatial dimensions must match.")
+
+            mask_opt = mask_opt.unsqueeze(-1)
+            masked_image = masked_image * mask_opt
+
+            num_masked_pixels = torch.sum(mask_opt)
+            if num_masked_pixels == 0:
+                raise ValueError(
+                    "No masked pixels found in the image. Please set a mask.")
+
+            sum_r = torch.sum(masked_image[:, :, :, 0])
+            sum_g = torch.sum(masked_image[:, :, :, 1])
+            sum_b = torch.sum(masked_image[:, :, :, 2])
+
+            r_mean = sum_r / num_masked_pixels
+            g_mean = sum_g / num_masked_pixels
+            b_mean = sum_b / num_masked_pixels
+        else:
+            r_mean = torch.mean(masked_image[:, :, :, 0])
+            g_mean = torch.mean(masked_image[:, :, :, 1])
+            b_mean = torch.mean(masked_image[:, :, :, 2])
+
+        r_mean_255 = r_mean.item() * 255.0
+        g_mean_255 = g_mean.item() * 255.0
+        b_mean_255 = b_mean.item() * 255.0
+
+        if amplify:
+            highest_value = max(r_mean_255, g_mean_255, b_mean_255)
+            diff_to_max = 255.0 - highest_value
+
+            amp_factor = 1.0
+
+            r_mean_255 += diff_to_max * amp_factor * \
+                (r_mean_255 / highest_value)
+            g_mean_255 += diff_to_max * amp_factor * \
+                (g_mean_255 / highest_value)
+            b_mean_255 += diff_to_max * amp_factor * \
+                (b_mean_255 / highest_value)
+
+            r_mean_255 = min(max(r_mean_255, 0), 255)
+            g_mean_255 = min(max(g_mean_255, 0), 255)
+            b_mean_255 = min(max(b_mean_255, 0), 255)
+
+        fill_value = (int(r_mean_255) << 16) + \
+            (int(g_mean_255) << 8) + int(b_mean_255)
+
+        hex_color = "#{:02x}{:02x}{:02x}".format(
+            int(r_mean_255), int(g_mean_255), int(b_mean_255)).upper()
+
+        return (fill_value, int(r_mean_255), int(g_mean_255), int(b_mean_255), hex_color,)
+
+
+# ------------------------------------------------------------------------------------------------------------------ #
+
+
+class YANCLayerWeights:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required":
+                {
+                    "layer_0": ("FLOAT", {"default": 0, "min": 0, "max": 10.0, "step": 0.1}),
+                    "layer_1": ("FLOAT", {"default": 0, "min": 0, "max": 10.0, "step": 0.1}),
+                    "layer_2": ("FLOAT", {"default": 0, "min": 0, "max": 10.0, "step": 0.1}),
+                    "layer_3": ("FLOAT", {"default": 0, "min": 0, "max": 10.0, "step": 0.1}),
+                    "layer_4": ("FLOAT", {"default": 0, "min": 0, "max": 10.0, "step": 0.1}),
+                    "layer_5": ("FLOAT", {"default": 0, "min": 0, "max": 10.0, "step": 0.1}),
+                    "layer_6": ("FLOAT", {"default": 0, "min": 0, "max": 10.0, "step": 0.1}),
+                    "layer_7": ("FLOAT", {"default": 0, "min": 0, "max": 10.0, "step": 0.1}),
+                    "layer_8": ("FLOAT", {"default": 0, "min": 0, "max": 10.0, "step": 0.1}),
+                    "layer_9": ("FLOAT", {"default": 0, "min": 0, "max": 10.0, "step": 0.1}),
+                    "layer_10": ("FLOAT", {"default": 0, "min": 0, "max": 10.0, "step": 0.1}),
+                    "layer_11": ("FLOAT", {"default": 0, "min": 0, "max": 10.0, "step": 0.1}),
+                }
+                }
+
+    CATEGORY = yanc_root_name + yanc_sub_experimental
+
+    RETURN_TYPES = ("STRING", "STRING")
+    RETURN_NAMES = ("layer_weights", "help")
+    FUNCTION = "do_it"
+
+    def do_it(self, layer_0, layer_1, layer_2, layer_3, layer_4, layer_5, layer_6, layer_7, layer_8, layer_9, layer_10, layer_11,):
+        result = ""
+
+        result = f"0:{layer_0:g}, 1:{layer_1:g}, 2:{layer_2:g}, 3:{layer_3:g}, 4:{layer_4:g}, 5:{layer_5:g}, 6:{layer_6:g}, 7:{layer_7:g}, 8:{layer_8:g}, 9:{layer_9:g}, 10:{layer_10:g}, 11:{layer_11:g}"
+
+        help = """layer_3: Composition
+layer_6: Style
+"""
+
+        return (result, help)
+
+
+# ------------------------------------------------------------------------------------------------------------------ #
+NODE_CLASS_MAPPINGS = {
+    # Image
+    "> Rotate Image": YANCRotateImage,
+    "> Scale Image to Side": YANCScaleImageToSide,
+    "> Resolution by Aspect Ratio": YANCResolutionByAspectRatio,
+    "> Load Image": YANCLoadImageAndFilename,
+    "> Save Image": YANCSaveImage,
+    "> Load Image From Folder": YANCLoadImageFromFolder,
+    "> Normal Map Lighting": YANCNormalMapLighting,
+
+    # Text
+    "> Text": YANCText,
+    "> Text Combine": YANCTextCombine,
+    "> Text Pick Random Line": YANCTextPickRandomLine,
+    "> Clear Text": YANCClearText,
+    "> Text Replace": YANCTextReplace,
+    "> Text Random Weights": YANCTextRandomWeights,
+
+    # Basics
+    "> Int to Text": YANCIntToText,
+    "> Int": YANCInt,
+    "> Float to Int": YANCFloatToInt,
+
+    # Noise Injection Sampler
+    "> NIKSampler": YANCNIKSampler,
+    "> Noise From Image": YANCNoiseFromImage,
+
+    # Masking
+    "> Mask Curves": YANCMaskCurves,
+    "> Light Source Mask": YANCLightSourceMask,
+
+    # Utils
+    "> Get Mean Color": YANCGetMeanColor,
+    "> RGB Color": YANCRGBColor,
+
+    # Experimental
+    "> Layer Weights (for IPAMS)": YANCLayerWeights,
+}
+
+# A dictionary that contains the friendly/humanly readable titles for the nodes
+NODE_DISPLAY_NAME_MAPPINGS = {
+    # Image
+    "> Rotate Image": "😼> Rotate Image",
+    "> Scale Image to Side": "😼> Scale Image to Side",
+    "> Resolution by Aspect Ratio": "😼> Resolution by Aspect Ratio",
+    "> Load Image": "😼> Load Image",
+    "> Save Image": "😼> Save Image",
+    "> Load Image From Folder": "😼> Load Image From Folder",
+    "> Normal Map Lighting": "😼> Normal Map Lighting",
+
+    # Text
+    "> Text": "😼> Text",
+    "> Text Combine": "😼> Text Combine",
+    "> Text Pick Random Line": "😼> Text Pick Random Line",
+    "> Clear Text": "😼> Clear Text",
+    "> Text Replace": "😼> Text Replace",
+    "> Text Random Weights": "😼> Text Random Weights",
+
+    # Basics
+    "> Int to Text": "😼> Int to Text",
+    "> Int": "😼> Int",
+    "> Float to Int": "😼> Float to Int",
+
+    # Noise Injection Sampler
+    "> NIKSampler": "😼> NIKSampler",
+    "> Noise From Image": "😼> Noise From Image",
+
+    # Masking
+    "> Mask Curves": "😼> Mask Curves",
+    "> Light Source Mask": "😼> Light Source Mask",
+
+    # Utils
+    "> Get Mean Color": "😼> Get Mean Color",
+    "> RGB Color": "😼> RGB Color",
+
+    # Experimental
+    "> Layer Weights (for IPAMS)": "😼> Layer Weights (for IPAMS)",
+}

ComfyUI/custom_nodes/img2txt-comfyui-nodes/__init__.py

@@ -0,0 +1,9 @@
+from .src.img2txt_node import Img2TxtNode
+
+NODE_CLASS_MAPPINGS = {
+    "img2txt BLIP/Llava Multimodel Tagger": Img2TxtNode,
+}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "img2txt BLIP/Llava Multimodel Tagger": "Image to Text - Auto Caption"
+}
+WEB_DIRECTORY = "./web"

ComfyUI/custom_nodes/img2txt-comfyui-nodes/pyproject.toml

@@ -0,0 +1,15 @@
+[project]
+name = "img2txt-comfyui-nodes"
+description = "Get general description or specify questions to ask about images (medium, art style, background, etc.). Supports Chinese 🇨🇳 questions via MiniCPM model."
+version = "1.1.4"
+license = "LICENSE"
+dependencies = ["transformers>=4.36.0", "bitsandbytes>=0.43.0", "timm>=1.0.7", "sentencepiece==0.1.99", "accelerate>=0.3.0", "deepspeed"]
+
+[project.urls]
+Repository = "https://github.com/christian-byrne/img2txt-comfyui-nodes"
+#  Used by Comfy Registry https://comfyregistry.org
+
+[tool.comfy]
+PublisherId = "christian-byrne"
+DisplayName = "Img2txt - Auto Caption"
+Icon = "https://img.icons8.com/?size=100&id=49374&format=png&color=000000"

ComfyUI/custom_nodes/img2txt-comfyui-nodes/requirements.txt

@@ -0,0 +1,6 @@
+transformers>=4.36.0
+bitsandbytes>=0.43.0
+timm>=1.0.7
+sentencepiece
+accelerate>=0.3.0
+deepspeed

ComfyUI/custom_nodes/img2txt-comfyui-nodes/src/blip_img2txt.py

@@ -0,0 +1,81 @@
+from PIL import Image
+from transformers import (
+    BlipProcessor,
+    BlipForConditionalGeneration,
+    BlipConfig,
+    BlipTextConfig,
+    BlipVisionConfig,
+)
+
+import torch
+import model_management
+
+
+class BLIPImg2Txt:
+    def __init__(
+        self,
+        conditional_caption: str,
+        min_words: int,
+        max_words: int,
+        temperature: float,
+        repetition_penalty: float,
+        search_beams: int,
+        model_id: str = "Salesforce/blip-image-captioning-large",
+    ):
+        self.conditional_caption = conditional_caption
+        self.model_id = model_id
+
+        # Determine do_sample and num_beams
+        if temperature > 1.1 or temperature < 0.90:
+            do_sample = True
+            num_beams = 1  # Sampling does not use beam search
+        else:
+            do_sample = False
+            num_beams = (
+                search_beams if search_beams > 1 else 1
+            )  # Use beam search if num_beams > 1
+
+        # Initialize text config kwargs
+        self.text_config_kwargs = {
+            "do_sample": do_sample,
+            "max_length": max_words,
+            "min_length": min_words,
+            "repetition_penalty": repetition_penalty,
+            "padding": "max_length",
+        }
+        if not do_sample:
+            self.text_config_kwargs["temperature"] = temperature
+            self.text_config_kwargs["num_beams"] = num_beams
+
+    def generate_caption(self, image: Image.Image) -> str:
+        if image.mode != "RGB":
+            image = image.convert("RGB")
+
+        processor = BlipProcessor.from_pretrained(self.model_id)
+
+        # Update and apply configurations
+        config_text = BlipTextConfig.from_pretrained(self.model_id)
+        config_text.update(self.text_config_kwargs)
+        config_vision = BlipVisionConfig.from_pretrained(self.model_id)
+        config = BlipConfig.from_text_vision_configs(config_text, config_vision)
+
+        model = BlipForConditionalGeneration.from_pretrained(
+            self.model_id,
+            config=config,
+            torch_dtype=torch.float16,
+        ).to(model_management.get_torch_device())
+
+        inputs = processor(
+            image,
+            self.conditional_caption,
+            return_tensors="pt",
+        ).to(model_management.get_torch_device(), torch.float16)
+
+        with torch.no_grad():
+            out = model.generate(**inputs)
+            ret = processor.decode(out[0], skip_special_tokens=True)
+
+        del model
+        torch.cuda.empty_cache()
+
+        return ret

ComfyUI/custom_nodes/img2txt-comfyui-nodes/src/description_classifier.py

@@ -0,0 +1,8 @@
+#!pip install transformers[sentencepiece]
+# from transformers import pipeline
+# text = "Angela Merkel is a politician in Germany and leader of the CDU"
+# hypothesis_template = "This text is about {}"
+# classes_verbalized = ["politics", "economy", "entertainment", "environment"]
+# zeroshot_classifier = pipeline("zero-shot-classification", model="MoritzLaurer/deberta-v3-large-zeroshot-v2.0")  # change the model identifier here
+# output = zeroshot_classifier(text, classes_verbalized, hypothesis_template=hypothesis_template, multi_label=False)
+# print(output)

ComfyUI/custom_nodes/img2txt-comfyui-nodes/src/img2txt_node.py

@@ -0,0 +1,209 @@
+"""
+@author: christian-byrne
+@title: Img2Txt auto captioning. Choose from models: BLIP, Llava, MiniCPM, MS-GIT. Use model combos and merge results. Specify questions to ask about images (medium, art style, background). Supports Chinese 🇨🇳 questions via MiniCPM.
+@nickname: Image to Text - Auto Caption
+"""
+
+import torch
+from torchvision import transforms
+
+from .img_tensor_utils import TensorImgUtils
+from .llava_img2txt import LlavaImg2Txt
+from .blip_img2txt import BLIPImg2Txt
+from .mini_cpm_img2txt import MiniPCMImg2Txt
+
+from typing import Tuple
+
+
+class Img2TxtNode:
+    CATEGORY = "img2txt"
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "input_image": ("IMAGE",),
+            },
+            "optional": {
+                "use_blip_model": (
+                    "BOOLEAN",
+                    {
+                        "default": True,
+                        "label_on": "Use BLIP (Requires 2Gb Disk)",
+                        "label_off": "Don't use BLIP",
+                    },
+                ),
+                "use_llava_model": (
+                    "BOOLEAN",
+                    {
+                        "default": False,
+                        "label_on": "Use Llava (Requires 15Gb Disk)",
+                        "label_off": "Don't use Llava",
+                    },
+                ),
+                "use_mini_pcm_model": (
+                    "BOOLEAN",
+                    {
+                        "default": False,
+                        "label_on": "Use MiniCPM (Requires 6Gb Disk)",
+                        "label_off": "Don't use MiniCPM",
+                    },
+                ),
+                "use_all_models": (
+                    "BOOLEAN",
+                    {
+                        "default": False,
+                        "label_on": "Use all models and combine outputs (Total Size: 20+Gb)",
+                        "label_off": "Use selected models only",
+                    },
+                ),
+                "blip_caption_prefix": (
+                    "STRING",
+                    {
+                        "default": "a photograph of",
+                    },
+                ),
+                "prompt_questions": (
+                    "STRING",
+                    {
+                        "default": "What is the subject of this image?\nWhat are the mediums used to make this?\nWhat are the artistic styles this is reminiscent of?\nWhich famous artists is this reminiscent of?\nHow sharp or detailed is this image?\nWhat is the environment and background of this image?\nWhat are the objects in this image?\nWhat is the composition of this image?\nWhat is the color palette in this image?\nWhat is the lighting in this image?",
+                        "multiline": True,
+                    },
+                ),
+                "temperature": (
+                    "FLOAT",
+                    {
+                        "default": 0.8,
+                        "min": 0.1,
+                        "max": 2.0,
+                        "step": 0.01,
+                        "display": "slider",
+                    },
+                ),
+                "repetition_penalty": (
+                    "FLOAT",
+                    {
+                        "default": 1.2,
+                        "min": 0.1,
+                        "max": 2.0,
+                        "step": 0.01,
+                        "display": "slider",
+                    },
+                ),
+                "min_words": ("INT", {"default": 36}),
+                "max_words": ("INT", {"default": 128}),
+                "search_beams": ("INT", {"default": 5}),
+                "exclude_terms": (
+                    "STRING",
+                    {
+                        "default": "watermark, text, writing",
+                    },
+                ),
+            },
+            "hidden": {
+                "unique_id": "UNIQUE_ID",
+                "extra_pnginfo": "EXTRA_PNGINFO",
+                "output_text": (
+                    "STRING",
+                    {
+                        "default": "",
+                    },
+                ),
+            },
+        }
+
+    RETURN_TYPES = ("STRING",)
+    RETURN_NAMES = ("caption",)
+    FUNCTION = "main"
+    OUTPUT_NODE = True
+
+    def main(
+        self,
+        input_image: torch.Tensor,  # [Batch_n, H, W, 3-channel]
+        use_blip_model: bool,
+        use_llava_model: bool,
+        use_all_models: bool,
+        use_mini_pcm_model: bool,
+        blip_caption_prefix: str,
+        prompt_questions: str,
+        temperature: float,
+        repetition_penalty: float,
+        min_words: int,
+        max_words: int,
+        search_beams: int,
+        exclude_terms: str,
+        output_text: str = "",
+        unique_id=None,
+        extra_pnginfo=None,
+    ) -> Tuple[str, ...]:
+        raw_image = transforms.ToPILImage()(
+            TensorImgUtils.convert_to_type(input_image, "CHW")
+        ).convert("RGB")
+
+        if blip_caption_prefix == "":
+            blip_caption_prefix = "a photograph of"
+
+        captions = []
+        if use_all_models or use_blip_model:
+            blip = BLIPImg2Txt(
+                conditional_caption=blip_caption_prefix,
+                min_words=min_words,
+                max_words=max_words,
+                temperature=temperature,
+                repetition_penalty=repetition_penalty,
+                search_beams=search_beams,
+            )
+            captions.append(blip.generate_caption(raw_image))
+
+        if use_all_models or use_llava_model:
+            llava_questions = prompt_questions.split("\n")
+            llava_questions = [
+                q
+                for q in llava_questions
+                if q != "" and q != " " and q != "\n" and q != "\n\n"
+            ]
+            if len(llava_questions) > 0:
+                llava = LlavaImg2Txt(
+                    question_list=llava_questions,
+                    model_id="llava-hf/llava-1.5-7b-hf",
+                    use_4bit_quantization=True,
+                    use_low_cpu_mem=True,
+                    use_flash2_attention=False,
+                    max_tokens_per_chunk=300,
+                )
+                captions.append(llava.generate_caption(raw_image))
+
+        if use_all_models or use_mini_pcm_model:
+            mini_pcm = MiniPCMImg2Txt(
+                question_list=prompt_questions.split("\n"),
+                temperature=temperature,
+            )
+            captions.append(mini_pcm.generate_captions(raw_image))
+
+        out_string = self.exclude(exclude_terms, self.merge_captions(captions))
+
+        return {"ui": {"text": out_string}, "result": (out_string,)}
+
+    def merge_captions(self, captions: list) -> str:
+        """Merge captions from multiple models into one string.
+        Necessary because we can expect the generated captions will generally
+        be comma-separated fragments ordered by relevance - so combine
+        fragments in an alternating order."""
+        merged_caption = ""
+        captions = [c.split(",") for c in captions]
+        for i in range(max(len(c) for c in captions)):
+            for j in range(len(captions)):
+                if i < len(captions[j]) and captions[j][i].strip() != "":
+                    merged_caption += captions[j][i].strip() + ", "
+        return merged_caption
+
+    def exclude(self, exclude_terms: str, out_string: str) -> str:
+        # https://huggingface.co/Salesforce/blip-image-captioning-large/discussions/20
+        exclude_terms = "arafed," + exclude_terms
+        exclude_terms = [
+            term.strip().lower() for term in exclude_terms.split(",") if term != ""
+        ]
+        for term in exclude_terms:
+            out_string = out_string.replace(term, "")
+
+        return out_string

ComfyUI/custom_nodes/img2txt-comfyui-nodes/src/img_tensor_utils.py

@@ -0,0 +1,129 @@
+import torch
+from typing import Tuple
+
+
+class TensorImgUtils:
+    @staticmethod
+    def from_to(from_type: list[str], to_type: list[str]):
+        """Return a function that converts a tensor from one type to another. Args can be lists of strings or just strings (e.g., ["C", "H", "W"] or just "CHW")."""
+        if isinstance(from_type, list):
+            from_type = "".join(from_type)
+        if isinstance(to_type, list):
+            to_type = "".join(to_type)
+
+        permute_arg = [from_type.index(c) for c in to_type]
+
+        def convert(tensor: torch.Tensor) -> torch.Tensor:
+            return tensor.permute(permute_arg)
+
+        return convert
+
+    @staticmethod
+    def convert_to_type(tensor: torch.Tensor, to_type: str) -> torch.Tensor:
+        """Convert a tensor to a specific type."""
+        from_type = TensorImgUtils.identify_type(tensor)[0]
+        if from_type == list(to_type):
+            return tensor
+
+        if len(from_type) == 4 and len(to_type) == 3:
+            # If converting from a batched tensor to a non-batched tensor, squeeze the batch dimension
+            tensor = tensor.squeeze(0)
+            from_type = from_type[1:]
+        if len(from_type) == 3 and len(to_type) == 4:
+            # If converting from a non-batched tensor to a batched tensor, unsqueeze the batch dimension
+            tensor = tensor.unsqueeze(0)
+            from_type = ["B"] + from_type
+
+        return TensorImgUtils.from_to(from_type, list(to_type))(tensor)
+
+    @staticmethod
+    def identify_type(tensor: torch.Tensor) -> Tuple[list[str], str]:
+        """Identify the type of image tensor. Doesn't currently check for BHW. Returns one of the following:"""
+        dim_n = tensor.dim()
+        if dim_n == 2:
+            return (["H", "W"], "HW")
+        elif dim_n == 3:  # HWA, AHW, HWC, or CHW
+            if tensor.size(2) == 3:
+                return (["H", "W", "C"], "HWRGB")
+            elif tensor.size(2) == 4:
+                return (["H", "W", "C"], "HWRGBA")
+            elif tensor.size(0) == 3:
+                return (["C", "H", "W"], "RGBHW")
+            elif tensor.size(0) == 4:
+                return (["C", "H", "W"], "RGBAHW")
+            elif tensor.size(2) == 1:
+                return (["H", "W", "C"], "HWA")
+            elif tensor.size(0) == 1:
+                return (["C", "H", "W"], "AHW")
+        elif dim_n == 4:  # BHWC or BCHW
+            if tensor.size(3) >= 3:  # BHWRGB or BHWRGBA
+                if tensor.size(3) == 3:
+                    return (["B", "H", "W", "C"], "BHWRGB")
+                elif tensor.size(3) == 4:
+                    return (["B", "H", "W", "C"], "BHWRGBA")
+
+            elif tensor.size(1) >= 3:
+                if tensor.size(1) == 3:
+                    return (["B", "C", "H", "W"], "BRGBHW")
+                elif tensor.size(1) == 4:
+                    return (["B", "C", "H", "W"], "BRGBAHW")
+
+        else:
+            raise ValueError(
+                f"{dim_n} dimensions is not a valid number of dimensions for an image tensor."
+            )
+
+        raise ValueError(
+            f"Could not determine shape of Tensor with {dim_n} dimensions and {tensor.shape} shape."
+        )
+
+    @staticmethod
+    def test_squeeze_batch(tensor: torch.Tensor, strict=False) -> torch.Tensor:
+        # Check if the tensor has a batch dimension (size 4)
+        if tensor.dim() == 4:
+            if tensor.size(0) == 1 or not strict:
+                # If it has a batch dimension with size 1, remove it. It represents a single image.
+                return tensor.squeeze(0)
+            else:
+                raise ValueError(
+                    f"This is not a single image. It's a batch of {tensor.size(0)} images."
+                )
+        else:
+            # Otherwise, it doesn't have a batch dimension, so just return the tensor as is.
+            return tensor
+
+    @staticmethod
+    def test_unsqueeze_batch(tensor: torch.Tensor) -> torch.Tensor:
+        # Check if the tensor has a batch dimension (size 4)
+        if tensor.dim() == 3:
+            # If it doesn't have a batch dimension, add one. It represents a single image.
+            return tensor.unsqueeze(0)
+        else:
+            # Otherwise, it already has a batch dimension, so just return the tensor as is.
+            return tensor
+
+    @staticmethod
+    def most_pixels(img_tensors: list[torch.Tensor]) -> torch.Tensor:
+        sizes = [
+            TensorImgUtils.height_width(img)[0] * TensorImgUtils.height_width(img)[1]
+            for img in img_tensors
+        ]
+        return img_tensors[sizes.index(max(sizes))]
+
+    @staticmethod
+    def height_width(image: torch.Tensor) -> Tuple[int, int]:
+        """Like torchvision.transforms methods, this method assumes Tensor to
+        have [..., H, W] shape, where ... means an arbitrary number of leading
+        dimensions
+        """
+        return image.shape[-2:]
+
+    @staticmethod
+    def smaller_axis(image: torch.Tensor) -> int:
+        h, w = TensorImgUtils.height_width(image)
+        return 2 if h < w else 3
+
+    @staticmethod
+    def larger_axis(image: torch.Tensor) -> int:
+        h, w = TensorImgUtils.height_width(image)
+        return 2 if h > w else 3

ComfyUI/custom_nodes/img2txt-comfyui-nodes/src/keyword_extract.py

@@ -0,0 +1,114 @@
+import torch
+from transformers import AutoTokenizer, AutoModelForTokenClassification
+from nltk.tokenize import word_tokenize
+from nltk.corpus import stopwords
+from nltk import pos_tag
+from nltk.tokenize import word_tokenize
+import nltk
+
+
+def nltk_speach_tag(sentence):
+    nltk.download("punkt")
+    nltk.download("averaged_perceptron_tagger")
+    nltk.download("stopwords")
+
+    # Tokenize the sentence
+    tokens = word_tokenize(sentence)
+
+    # Filter out stopwords and punctuation
+    stop_words = set(stopwords.words("english"))
+    filtered_tokens = [
+        word for word in tokens if word.lower() not in stop_words and word.isalnum()
+    ]
+
+    # Perform Part-of-Speech tagging
+    tagged_tokens = pos_tag(filtered_tokens)
+
+    # Extract nouns and proper nouns
+    salient_tokens = [
+        token
+        for token, pos in tagged_tokens
+        if pos in ["NN", "NNP", "NNS", "NNPS", "ADJ", "JJ", "FW"]
+    ]
+    salient_tokens = list(set(salient_tokens))
+
+    # Re-add commas or periods relative to the original sentence
+
+    comma_period_indices = [i for i, char in enumerate(sentence) if char in [",", "."]]
+    salient_tokens_indices = [sentence.index(token) for token in salient_tokens]
+
+    # Add commas or periods between words if there was one in the original sentence
+    out = ""
+    for i, index in enumerate(salient_tokens_indices):
+        out += salient_tokens[i]
+        distance_between_next = (
+            salient_tokens_indices[i + 1] - index
+            if i + 1 < len(salient_tokens_indices)
+            else None
+        )
+
+        puncuated = False
+        if not distance_between_next:
+            puncuated = True
+        else:
+            for i in range(index, index + distance_between_next):
+                if i in comma_period_indices:
+                    puncuated = True
+                    break
+
+        if not puncuated:
+            # IF the previous word was an adjective, and current is a noun, add a space
+            if (
+                i > 0
+                and tagged_tokens[i - 1][1] in ["JJ", "ADJ"]
+                and tagged_tokens[i][1] in ["NN", "NNP", "NNS", "NNPS"]
+            ):
+                out += " "
+            else:
+                out += ", "
+        else:
+            out += ". "
+
+    # Add the last token
+    out += sentence[-1]
+
+    # Print the salient tokens
+    return out.strip().strip(",").strip(".").strip()
+
+
+def extract_keywords(text: str) -> str:
+    tokenizer = AutoTokenizer.from_pretrained("yanekyuk/bert-keyword-extractor")
+    model = AutoModelForTokenClassification.from_pretrained(
+        "yanekyuk/bert-keyword-extractor"
+    )
+    """Return keywords from text using a BERT model trained for keyword extraction as 
+    a comma-separated string."""
+    print(f"Extracting keywords from text: {text}")
+
+    for char in ["\n", "\t", "\r"]:
+        text = text.replace(char, " ")
+
+    sentences = text.split(".")
+    result = ""
+
+    for sentence in sentences:
+        print(f"Extracting keywords from sentence: {sentence}")
+        inputs = tokenizer(sentence, return_tensors="pt", padding=True, truncation=True)
+        with torch.no_grad():
+            logits = model(**inputs).logits
+
+        predicted_token_class_ids = logits.argmax(dim=-1)
+
+        predicted_keywords = []
+        for token_id, token in zip(
+            predicted_token_class_ids[0],
+            tokenizer.convert_ids_to_tokens(inputs["input_ids"][0]),
+        ):
+            if token_id == 1:
+                predicted_keywords.append(token)
+
+        print(f"Extracted keywords: {predicted_keywords}")
+        result += ", ".join(predicted_keywords) + ", "
+
+    print(f"All Keywords: {result}")
+    return result

ComfyUI/custom_nodes/img2txt-comfyui-nodes/src/llava_img2txt.py

@@ -0,0 +1,131 @@
+from PIL import Image
+import torch
+import model_management
+from transformers import AutoProcessor, LlavaForConditionalGeneration, BitsAndBytesConfig
+
+
+class LlavaImg2Txt:
+    """
+    A class to generate text captions for images using the Llava model.
+
+    Args:
+        question_list (list[str]): A list of questions to ask the model about the image.
+        model_id (str): The model's name in the Hugging Face model hub.
+        use_4bit_quantization (bool): Whether to use 4-bit quantization to reduce memory usage. 4-bit quantization reduces the precision of model parameters, potentially affecting the quality of generated outputs. Use if VRAM is limited. Default is True.
+        use_low_cpu_mem (bool): In low_cpu_mem_usage mode, the model is initialized with optimizations aimed at reducing CPU memory consumption. This can be beneficial when working with large models or limited computational resources. Default is True.
+        use_flash2_attention (bool): Whether to use Flash-Attention 2. Flash-Attention 2 focuses on optimizing attention mechanisms, which are crucial for the model's performance during generation. Use if computational resources are abundant. Default is False.
+        max_tokens_per_chunk (int): The maximum number of tokens to generate per prompt chunk. Default is 300.
+    """
+
+    def __init__(
+        self,
+        question_list,
+        model_id: str = "llava-hf/llava-1.5-7b-hf",
+        use_4bit_quantization: bool = True,
+        use_low_cpu_mem: bool = True,
+        use_flash2_attention: bool = False,
+        max_tokens_per_chunk: int = 300,
+    ):
+        self.question_list = question_list
+        self.model_id = model_id
+        self.use_4bit = use_4bit_quantization
+        self.use_flash2 = use_flash2_attention
+        self.use_low_cpu_mem = use_low_cpu_mem
+        self.max_tokens_per_chunk = max_tokens_per_chunk
+
+    def generate_caption(
+        self,
+        raw_image: Image.Image,
+    ) -> str:
+        """
+        Generate a caption for an image using the Llava model.
+
+        Args:
+            raw_image (Image): Image to generate caption for
+        """
+        # Convert Image to RGB first
+        if raw_image.mode != "RGB":
+            raw_image = raw_image.convert("RGB")
+
+        dtype = torch.float16
+        quant_config = BitsAndBytesConfig(
+            load_in_4bit=self.use_4bit,
+            bnb_4bit_compute_dtype=dtype,
+            bnb_4bit_quant_type="fp4"
+        )
+
+        model = LlavaForConditionalGeneration.from_pretrained(
+            self.model_id,
+            torch_dtype=dtype,
+            low_cpu_mem_usage=self.use_low_cpu_mem,
+            use_flash_attention_2=self.use_flash2,
+            quantization_config=quant_config,
+        )
+
+        # model.to() is not supported for 4-bit or 8-bit bitsandbytes models. With 4-bit quantization, use the model as it is, since the model will already be set to the correct devices and casted to the correct `dtype`.
+        if torch.cuda.is_available() and not self.use_4bit:
+            model = model.to(model_management.get_torch_device(), torch.float16)
+
+        processor = AutoProcessor.from_pretrained(self.model_id)
+        prompt_chunks = self.__get_prompt_chunks(chunk_size=4)
+
+        caption = ""
+        with torch.no_grad():
+            for prompt_list in prompt_chunks:
+                prompt = self.__get_single_answer_prompt(prompt_list)
+                inputs = processor(prompt, raw_image, return_tensors="pt").to(
+                    model_management.get_torch_device(), torch.float16
+                )
+                output = model.generate(
+                    **inputs, max_new_tokens=self.max_tokens_per_chunk, do_sample=False
+                )
+                decoded = processor.decode(output[0][2:])
+                cleaned = self.clean_output(decoded)
+                caption += cleaned
+
+        del model
+        torch.cuda.empty_cache()
+
+        return caption
+
+    def clean_output(self, decoded_output, delimiter=","):
+        output_only = decoded_output.split("ASSISTANT: ")[1]
+        lines = output_only.split("\n")
+        cleaned_output = ""
+        for line in lines:
+            cleaned_output += self.__replace_delimiter(line, ".", delimiter)
+
+        return cleaned_output
+
+    def __get_single_answer_prompt(self, questions):
+        """
+        For multiple turns conversation:
+        "USER: <image>\n<prompt1> ASSISTANT: <answer1></s>USER: <prompt2> ASSISTANT: <answer2></s>USER: <prompt3> ASSISTANT:"
+        From: https://huggingface.co/docs/transformers/en/model_doc/llava#usage-tips
+        Not sure how the formatting works for multi-turn but those are the docs.
+        """
+        prompt = "USER: <image>\n"
+        for index, question in enumerate(questions):
+            if index != 0:
+                prompt += "USER: "
+            prompt += f"{question} </s >"
+        prompt += "ASSISTANT: "
+
+        return prompt
+
+    def __replace_delimiter(self, text: str, old, new=","):
+        """Replace only the LAST instance of old with new"""
+        if old not in text:
+            return text.strip() + " "
+        last_old_index = text.rindex(old)
+        replaced = text[:last_old_index] + new + text[last_old_index + len(old) :]
+        return replaced.strip() + " "
+
+    def __get_prompt_chunks(self, chunk_size=4):
+        prompt_chunks = []
+        for index, feature in enumerate(self.question_list):
+            if index % chunk_size == 0:
+                prompt_chunks.append([feature])
+            else:
+                prompt_chunks[-1].append(feature)
+        return prompt_chunks

ComfyUI/custom_nodes/img2txt-comfyui-nodes/src/mini_cpm_img2txt.py

@@ -0,0 +1,53 @@
+import torch
+from PIL import Image
+from transformers import AutoModel, AutoTokenizer
+
+import model_management
+
+class MiniPCMImg2Txt:
+    def __init__(self, question_list: list[str], temperature: float = 0.7):
+        self.model_id = "openbmb/MiniCPM-V-2"
+        self.question_list = question_list
+        self.question_list = self.__create_question_list()
+        self.temperature = temperature
+
+    def __create_question_list(self) -> list:
+        ret = []
+        for q in self.question_list:
+            ret.append({"role": "user", "content": q})
+        return ret
+
+    def generate_captions(self, raw_image: Image.Image) -> str:
+        device = model_management.get_torch_device()
+
+        # For Nvidia GPUs support BF16 (like A100, H100, RTX3090)
+        # For Nvidia GPUs do NOT support BF16 (like V100, T4, RTX2080)
+        torch_dtype = torch.bfloat16 if torch.cuda.is_bf16_supported() else torch.float16
+
+        model = AutoModel.from_pretrained(
+            "openbmb/MiniCPM-V-2", trust_remote_code=True, torch_dtype=torch_dtype
+        )
+        model = model.to(device=device, dtype=torch_dtype)
+
+        tokenizer = AutoTokenizer.from_pretrained(
+            self.model_id, trust_remote_code=True
+        )
+        model.eval()
+
+        if raw_image.mode != "RGB":
+            raw_image = raw_image.convert("RGB")
+
+        with torch.no_grad():
+            res, _, _ = model.chat(
+                image=raw_image,
+                msgs=self.question_list,
+                context=None,
+                tokenizer=tokenizer,
+                sampling=True,
+                temperature=self.temperature,
+            )
+
+        del model
+        torch.cuda.empty_cache()
+
+        return res

ComfyUI/custom_nodes/img2txt-comfyui-nodes/web/show-output-text.js

@@ -0,0 +1,51 @@
+import { app } from "../../../scripts/app.js";
+import { ComfyWidgets } from "../../../scripts/widgets.js";
+
+// Displays output caption text
+app.registerExtension({
+  name: "Img2TxtNode",
+  async beforeRegisterNodeDef(nodeType, nodeData, app) {
+    if (nodeData.name === "img2txt BLIP/Llava Multimodel Tagger") {
+      function populate(message) {
+        console.log("message", message);
+        console.log("message.text", message.text);
+
+        const insertIndex = this.widgets.findIndex((w) => w.name === "output_text");
+        if (insertIndex !== -1) {
+          for (let i = insertIndex; i < this.widgets.length; i++) {
+            this.widgets[i].onRemove?.();
+          }
+          this.widgets.length = insertIndex;
+        }
+
+        const outputWidget = ComfyWidgets["STRING"](
+          this,
+          "output_text",
+          ["STRING", { multiline: true }],
+          app
+        ).widget;
+        outputWidget.inputEl.readOnly = true;
+        outputWidget.inputEl.style.opacity = 0.6;
+        outputWidget.value = message.text.join("");
+
+        requestAnimationFrame(() => {
+          const size_ = this.computeSize();
+          if (size_[0] < this.size[0]) {
+            size_[0] = this.size[0];
+          }
+          if (size_[1] < this.size[1]) {
+            size_[1] = this.size[1];
+          }
+          this.onResize?.(size_);
+          app.graph.setDirtyCanvas(true, false);
+        });
+      }
+
+      const onExecuted = nodeType.prototype.onExecuted;
+      nodeType.prototype.onExecuted = function (message) {
+        onExecuted?.apply(this, arguments);
+        populate.call(this, message);
+      };
+    }
+  },
+});

ComfyUI/custom_nodes/img2txt-comfyui-nodes/wiki/workflow-examples/img2img.json

@@ -0,0 +1,523 @@
+{
+  "last_node_id": 51,
+  "last_link_id": 60,
+  "nodes": [
+    {
+      "id": 41,
+      "type": "CLIPTextEncode",
+      "pos": [
+        1055,
+        571
+      ],
+      "size": {
+        "0": 348.9403381347656,
+        "1": 56.439388275146484
+      },
+      "flags": {},
+      "order": 5,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "clip",
+          "type": "CLIP",
+          "link": 50
+        },
+        {
+          "name": "text",
+          "type": "STRING",
+          "link": 60,
+          "widget": {
+            "name": "text"
+          }
+        }
+      ],
+      "outputs": [
+        {
+          "name": "CONDITIONING",
+          "type": "CONDITIONING",
+          "links": [
+            44
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CLIPTextEncode"
+      },
+      "widgets_values": [
+        ""
+      ]
+    },
+    {
+      "id": 39,
+      "type": "KSampler",
+      "pos": [
+        1587,
+        982
+      ],
+      "size": {
+        "0": 315,
+        "1": 262
+      },
+      "flags": {},
+      "order": 6,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 42
+        },
+        {
+          "name": "positive",
+          "type": "CONDITIONING",
+          "link": 44
+        },
+        {
+          "name": "negative",
+          "type": "CONDITIONING",
+          "link": 45
+        },
+        {
+          "name": "latent_image",
+          "type": "LATENT",
+          "link": 58
+        }
+      ],
+      "outputs": [
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": [
+            48
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "KSampler"
+      },
+      "widgets_values": [
+        290872458059323,
+        "randomize",
+        20,
+        8,
+        "euler",
+        "normal",
+        1
+      ]
+    },
+    {
+      "id": 45,
+      "type": "VAEDecode",
+      "pos": [
+        1998,
+        1018
+      ],
+      "size": {
+        "0": 210,
+        "1": 46
+      },
+      "flags": {},
+      "order": 7,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "samples",
+          "type": "LATENT",
+          "link": 48
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": 49
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            55
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VAEDecode"
+      }
+    },
+    {
+      "id": 48,
+      "type": "PreviewImage",
+      "pos": [
+        2039,
+        1262
+      ],
+      "size": {
+        "0": 210,
+        "1": 246
+      },
+      "flags": {},
+      "order": 8,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 55
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "PreviewImage"
+      }
+    },
+    {
+      "id": 42,
+      "type": "CLIPTextEncode",
+      "pos": [
+        1056,
+        683
+      ],
+      "size": {
+        "0": 352.9139404296875,
+        "1": 113.16606140136719
+      },
+      "flags": {},
+      "order": 3,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "clip",
+          "type": "CLIP",
+          "link": 51
+        }
+      ],
+      "outputs": [
+        {
+          "name": "CONDITIONING",
+          "type": "CONDITIONING",
+          "links": [
+            45
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CLIPTextEncode"
+      },
+      "widgets_values": [
+        "text, watermark"
+      ]
+    },
+    {
+      "id": 50,
+      "type": "VAEEncode",
+      "pos": [
+        1119,
+        1329
+      ],
+      "size": {
+        "0": 201.4841766357422,
+        "1": 55.59581756591797
+      },
+      "flags": {},
+      "order": 4,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "pixels",
+          "type": "IMAGE",
+          "link": 56
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": 57
+        }
+      ],
+      "outputs": [
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": [
+            58
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VAEEncode"
+      }
+    },
+    {
+      "id": 11,
+      "type": "LoadImage",
+      "pos": [
+        -135,
+        907
+      ],
+      "size": {
+        "0": 670,
+        "1": 460
+      },
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            56,
+            59
+          ],
+          "shape": 3,
+          "slot_index": 0
+        },
+        {
+          "name": "MASK",
+          "type": "MASK",
+          "links": [],
+          "shape": 3,
+          "slot_index": 1
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "LoadImage"
+      },
+      "widgets_values": [
+        "example.png",
+        "image"
+      ]
+    },
+    {
+      "id": 40,
+      "type": "CheckpointLoaderSimple",
+      "pos": [
+        1124,
+        1019
+      ],
+      "size": {
+        "0": 315,
+        "1": 98
+      },
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            42
+          ],
+          "shape": 3,
+          "slot_index": 0
+        },
+        {
+          "name": "CLIP",
+          "type": "CLIP",
+          "links": [
+            50,
+            51
+          ],
+          "shape": 3,
+          "slot_index": 1
+        },
+        {
+          "name": "VAE",
+          "type": "VAE",
+          "links": [
+            49,
+            57
+          ],
+          "shape": 3,
+          "slot_index": 2
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CheckpointLoaderSimple"
+      },
+      "widgets_values": [
+        "dreamshaper_8.safetensors"
+      ]
+    },
+    {
+      "id": 51,
+      "type": "img2txt BLIP/Llava Multimodel Tagger",
+      "pos": [
+        605,
+        881
+      ],
+      "size": {
+        "0": 427.2057800292969,
+        "1": 476.26934814453125
+      },
+      "flags": {},
+      "order": 2,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "input_image",
+          "type": "IMAGE",
+          "link": 59
+        }
+      ],
+      "outputs": [
+        {
+          "name": "caption",
+          "type": "STRING",
+          "links": [
+            60
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "img2txt BLIP/Llava Multimodel Tagger"
+      },
+      "widgets_values": [
+        true,
+        false,
+        false,
+        false,
+        "a photograph of",
+        "What is the subject and background of this image?",
+        0.7000000000000001,
+        1.26,
+        36,
+        128,
+        5,
+        "watermark, text, writing",
+        "a photograph of a girl dressed up, in pink dress and bright blue eyes poses in the grass with arms spread out in front of her face, holding an umbrella on a sky, "
+      ],
+      "color": "#322",
+      "bgcolor": "#533"
+    }
+  ],
+  "links": [
+    [
+      42,
+      40,
+      0,
+      39,
+      0,
+      "MODEL"
+    ],
+    [
+      44,
+      41,
+      0,
+      39,
+      1,
+      "CONDITIONING"
+    ],
+    [
+      45,
+      42,
+      0,
+      39,
+      2,
+      "CONDITIONING"
+    ],
+    [
+      48,
+      39,
+      0,
+      45,
+      0,
+      "LATENT"
+    ],
+    [
+      49,
+      40,
+      2,
+      45,
+      1,
+      "VAE"
+    ],
+    [
+      50,
+      40,
+      1,
+      41,
+      0,
+      "CLIP"
+    ],
+    [
+      51,
+      40,
+      1,
+      42,
+      0,
+      "CLIP"
+    ],
+    [
+      55,
+      45,
+      0,
+      48,
+      0,
+      "IMAGE"
+    ],
+    [
+      56,
+      11,
+      0,
+      50,
+      0,
+      "IMAGE"
+    ],
+    [
+      57,
+      40,
+      2,
+      50,
+      1,
+      "VAE"
+    ],
+    [
+      58,
+      50,
+      0,
+      39,
+      3,
+      "LATENT"
+    ],
+    [
+      59,
+      11,
+      0,
+      51,
+      0,
+      "IMAGE"
+    ],
+    [
+      60,
+      51,
+      0,
+      41,
+      1,
+      "STRING"
+    ]
+  ],
+  "groups": [],
+  "config": {},
+  "extra": {
+    "ds": {
+      "scale": 0.9090909090909091,
+      "offset": {
+        "0": 304.575645264068,
+        "1": -258.56908735931404
+      }
+    }
+  },
+  "version": 0.4
+}

ComfyUI/custom_nodes/img2txt-comfyui-nodes/wiki/workflow-examples/inpaint.json

@@ -0,0 +1,705 @@
+{
+  "last_node_id": 61,
+  "last_link_id": 80,
+  "nodes": [
+    {
+      "id": 45,
+      "type": "VAEDecode",
+      "pos": [
+        1998,
+        1018
+      ],
+      "size": {
+        "0": 210,
+        "1": 46
+      },
+      "flags": {},
+      "order": 10,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "samples",
+          "type": "LATENT",
+          "link": 71
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": 49
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            55
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VAEDecode"
+      }
+    },
+    {
+      "id": 42,
+      "type": "CLIPTextEncode",
+      "pos": [
+        1056,
+        683
+      ],
+      "size": {
+        "0": 352.9139404296875,
+        "1": 113.16606140136719
+      },
+      "flags": {},
+      "order": 2,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "clip",
+          "type": "CLIP",
+          "link": 51
+        }
+      ],
+      "outputs": [
+        {
+          "name": "CONDITIONING",
+          "type": "CONDITIONING",
+          "links": [
+            63
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CLIPTextEncode"
+      },
+      "widgets_values": [
+        "text, watermark"
+      ]
+    },
+    {
+      "id": 41,
+      "type": "CLIPTextEncode",
+      "pos": [
+        1055,
+        571
+      ],
+      "size": {
+        "0": 348.9403381347656,
+        "1": 56.439388275146484
+      },
+      "flags": {},
+      "order": 6,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "clip",
+          "type": "CLIP",
+          "link": 50
+        },
+        {
+          "name": "text",
+          "type": "STRING",
+          "link": 80,
+          "widget": {
+            "name": "text"
+          }
+        }
+      ],
+      "outputs": [
+        {
+          "name": "CONDITIONING",
+          "type": "CONDITIONING",
+          "links": [
+            64
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CLIPTextEncode"
+      },
+      "widgets_values": [
+        ""
+      ]
+    },
+    {
+      "id": 58,
+      "type": "PreviewImage",
+      "pos": [
+        616,
+        1631
+      ],
+      "size": {
+        "0": 401.17840576171875,
+        "1": 246
+      },
+      "flags": {},
+      "order": 7,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 73
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "PreviewImage"
+      }
+    },
+    {
+      "id": 57,
+      "type": "MaskToImage",
+      "pos": [
+        617,
+        1543
+      ],
+      "size": {
+        "0": 210,
+        "1": 26
+      },
+      "flags": {},
+      "order": 5,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "mask",
+          "type": "MASK",
+          "link": 78
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            73
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "MaskToImage"
+      }
+    },
+    {
+      "id": 40,
+      "type": "CheckpointLoaderSimple",
+      "pos": [
+        1044,
+        1032
+      ],
+      "size": {
+        "0": 315,
+        "1": 98
+      },
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            68
+          ],
+          "shape": 3,
+          "slot_index": 0
+        },
+        {
+          "name": "CLIP",
+          "type": "CLIP",
+          "links": [
+            50,
+            51
+          ],
+          "shape": 3,
+          "slot_index": 1
+        },
+        {
+          "name": "VAE",
+          "type": "VAE",
+          "links": [
+            49,
+            69
+          ],
+          "shape": 3,
+          "slot_index": 2
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CheckpointLoaderSimple"
+      },
+      "widgets_values": [
+        "experience_70-inpainting.safetensors"
+      ]
+    },
+    {
+      "id": 48,
+      "type": "PreviewImage",
+      "pos": [
+        2039,
+        1262
+      ],
+      "size": {
+        "0": 295.2332458496094,
+        "1": 293.2945251464844
+      },
+      "flags": {},
+      "order": 11,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 55
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "PreviewImage"
+      }
+    },
+    {
+      "id": 56,
+      "type": "KSampler",
+      "pos": [
+        1642,
+        820
+      ],
+      "size": {
+        "0": 315,
+        "1": 262
+      },
+      "flags": {},
+      "order": 9,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 68
+        },
+        {
+          "name": "positive",
+          "type": "CONDITIONING",
+          "link": 66
+        },
+        {
+          "name": "negative",
+          "type": "CONDITIONING",
+          "link": 67
+        },
+        {
+          "name": "latent_image",
+          "type": "LATENT",
+          "link": 65
+        }
+      ],
+      "outputs": [
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": [
+            71
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "KSampler"
+      },
+      "widgets_values": [
+        492464952856155,
+        "randomize",
+        30,
+        7,
+        "dpmpp_2m_sde_gpu",
+        "normal",
+        0.8
+      ]
+    },
+    {
+      "id": 55,
+      "type": "ImageColorToMask",
+      "pos": [
+        610,
+        1425
+      ],
+      "size": {
+        "0": 315,
+        "1": 58
+      },
+      "flags": {},
+      "order": 3,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "image",
+          "type": "IMAGE",
+          "link": 61
+        }
+      ],
+      "outputs": [
+        {
+          "name": "MASK",
+          "type": "MASK",
+          "links": [
+            77,
+            78
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "ImageColorToMask"
+      },
+      "widgets_values": [
+        6198527
+      ]
+    },
+    {
+      "id": 54,
+      "type": "InpaintModelConditioning",
+      "pos": [
+        1289,
+        1377
+      ],
+      "size": {
+        "0": 216.59999084472656,
+        "1": 106
+      },
+      "flags": {},
+      "order": 8,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "positive",
+          "type": "CONDITIONING",
+          "link": 64
+        },
+        {
+          "name": "negative",
+          "type": "CONDITIONING",
+          "link": 63
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": 69
+        },
+        {
+          "name": "pixels",
+          "type": "IMAGE",
+          "link": 70
+        },
+        {
+          "name": "mask",
+          "type": "MASK",
+          "link": 77
+        }
+      ],
+      "outputs": [
+        {
+          "name": "positive",
+          "type": "CONDITIONING",
+          "links": [
+            66
+          ],
+          "shape": 3,
+          "slot_index": 0
+        },
+        {
+          "name": "negative",
+          "type": "CONDITIONING",
+          "links": [
+            67
+          ],
+          "shape": 3,
+          "slot_index": 1
+        },
+        {
+          "name": "latent",
+          "type": "LATENT",
+          "links": [
+            65
+          ],
+          "shape": 3,
+          "slot_index": 2
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "InpaintModelConditioning"
+      }
+    },
+    {
+      "id": 11,
+      "type": "LoadImage",
+      "pos": [
+        -135,
+        907
+      ],
+      "size": {
+        "0": 670,
+        "1": 460
+      },
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            61,
+            70,
+            79
+          ],
+          "shape": 3,
+          "slot_index": 0
+        },
+        {
+          "name": "MASK",
+          "type": "MASK",
+          "links": [],
+          "shape": 3,
+          "slot_index": 1
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "LoadImage"
+      },
+      "widgets_values": [
+        "example.png",
+        "image"
+      ]
+    },
+    {
+      "id": 61,
+      "type": "img2txt BLIP/Llava Multimodel Tagger",
+      "pos": [
+        599,
+        886
+      ],
+      "size": [
+        414.8329491017887,
+        453.3791344354013
+      ],
+      "flags": {},
+      "order": 4,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "input_image",
+          "type": "IMAGE",
+          "link": 79
+        }
+      ],
+      "outputs": [
+        {
+          "name": "caption",
+          "type": "STRING",
+          "links": [
+            80
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "img2txt BLIP/Llava Multimodel Tagger"
+      },
+      "widgets_values": [
+        true,
+        false,
+        false,
+        false,
+        "a photograph of",
+        "What is the subject of this image?\n",
+        0.8,
+        1.2,
+        36,
+        128,
+        5,
+        "watermark, text, writing"
+      ],
+      "color": "#322",
+      "bgcolor": "#533"
+    }
+  ],
+  "links": [
+    [
+      49,
+      40,
+      2,
+      45,
+      1,
+      "VAE"
+    ],
+    [
+      50,
+      40,
+      1,
+      41,
+      0,
+      "CLIP"
+    ],
+    [
+      51,
+      40,
+      1,
+      42,
+      0,
+      "CLIP"
+    ],
+    [
+      55,
+      45,
+      0,
+      48,
+      0,
+      "IMAGE"
+    ],
+    [
+      61,
+      11,
+      0,
+      55,
+      0,
+      "IMAGE"
+    ],
+    [
+      63,
+      42,
+      0,
+      54,
+      1,
+      "CONDITIONING"
+    ],
+    [
+      64,
+      41,
+      0,
+      54,
+      0,
+      "CONDITIONING"
+    ],
+    [
+      65,
+      54,
+      2,
+      56,
+      3,
+      "LATENT"
+    ],
+    [
+      66,
+      54,
+      0,
+      56,
+      1,
+      "CONDITIONING"
+    ],
+    [
+      67,
+      54,
+      1,
+      56,
+      2,
+      "CONDITIONING"
+    ],
+    [
+      68,
+      40,
+      0,
+      56,
+      0,
+      "MODEL"
+    ],
+    [
+      69,
+      40,
+      2,
+      54,
+      2,
+      "VAE"
+    ],
+    [
+      70,
+      11,
+      0,
+      54,
+      3,
+      "IMAGE"
+    ],
+    [
+      71,
+      56,
+      0,
+      45,
+      0,
+      "LATENT"
+    ],
+    [
+      73,
+      57,
+      0,
+      58,
+      0,
+      "IMAGE"
+    ],
+    [
+      77,
+      55,
+      0,
+      54,
+      4,
+      "MASK"
+    ],
+    [
+      78,
+      55,
+      0,
+      57,
+      0,
+      "MASK"
+    ],
+    [
+      79,
+      11,
+      0,
+      61,
+      0,
+      "IMAGE"
+    ],
+    [
+      80,
+      61,
+      0,
+      41,
+      1,
+      "STRING"
+    ]
+  ],
+  "groups": [],
+  "config": {},
+  "extra": {
+    "ds": {
+      "scale": 0.8264462809917354,
+      "offset": {
+        "0": 478.9515963527572,
+        "1": -472.76124333876595
+      }
+    }
+  },
+  "version": 0.4
+}

ComfyUI/custom_nodes/img2txt-comfyui-nodes/wiki/workflow-examples/txt2img.json

@@ -0,0 +1,498 @@
+{
+  "last_node_id": 53,
+  "last_link_id": 61,
+  "nodes": [
+    {
+      "id": 41,
+      "type": "CLIPTextEncode",
+      "pos": [
+        1055,
+        571
+      ],
+      "size": {
+        "0": 348.9403381347656,
+        "1": 56.439388275146484
+      },
+      "flags": {},
+      "order": 5,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "clip",
+          "type": "CLIP",
+          "link": 50
+        },
+        {
+          "name": "text",
+          "type": "STRING",
+          "link": 61,
+          "widget": {
+            "name": "text"
+          }
+        }
+      ],
+      "outputs": [
+        {
+          "name": "CONDITIONING",
+          "type": "CONDITIONING",
+          "links": [
+            44
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CLIPTextEncode"
+      },
+      "widgets_values": [
+        ""
+      ]
+    },
+    {
+      "id": 39,
+      "type": "KSampler",
+      "pos": [
+        1587,
+        982
+      ],
+      "size": {
+        "0": 315,
+        "1": 262
+      },
+      "flags": {},
+      "order": 6,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 42
+        },
+        {
+          "name": "positive",
+          "type": "CONDITIONING",
+          "link": 44
+        },
+        {
+          "name": "negative",
+          "type": "CONDITIONING",
+          "link": 45
+        },
+        {
+          "name": "latent_image",
+          "type": "LATENT",
+          "link": 59
+        }
+      ],
+      "outputs": [
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": [
+            48
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "KSampler"
+      },
+      "widgets_values": [
+        438454791536393,
+        "randomize",
+        20,
+        8,
+        "euler",
+        "normal",
+        1
+      ]
+    },
+    {
+      "id": 45,
+      "type": "VAEDecode",
+      "pos": [
+        1998,
+        1018
+      ],
+      "size": {
+        "0": 210,
+        "1": 46
+      },
+      "flags": {},
+      "order": 7,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "samples",
+          "type": "LATENT",
+          "link": 48
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": 49
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            55
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VAEDecode"
+      }
+    },
+    {
+      "id": 48,
+      "type": "PreviewImage",
+      "pos": [
+        2039,
+        1262
+      ],
+      "size": {
+        "0": 210,
+        "1": 246
+      },
+      "flags": {},
+      "order": 8,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 55
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "PreviewImage"
+      }
+    },
+    {
+      "id": 42,
+      "type": "CLIPTextEncode",
+      "pos": [
+        1056,
+        683
+      ],
+      "size": {
+        "0": 352.9139404296875,
+        "1": 113.16606140136719
+      },
+      "flags": {},
+      "order": 4,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "clip",
+          "type": "CLIP",
+          "link": 51
+        }
+      ],
+      "outputs": [
+        {
+          "name": "CONDITIONING",
+          "type": "CONDITIONING",
+          "links": [
+            45
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CLIPTextEncode"
+      },
+      "widgets_values": [
+        "text, watermark"
+      ]
+    },
+    {
+      "id": 52,
+      "type": "EmptyLatentImage",
+      "pos": [
+        1126,
+        1189
+      ],
+      "size": {
+        "0": 315,
+        "1": 106
+      },
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": [
+            59
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "EmptyLatentImage"
+      },
+      "widgets_values": [
+        512,
+        512,
+        1
+      ]
+    },
+    {
+      "id": 11,
+      "type": "LoadImage",
+      "pos": [
+        -135,
+        907
+      ],
+      "size": {
+        "0": 670,
+        "1": 460
+      },
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            60
+          ],
+          "shape": 3,
+          "slot_index": 0
+        },
+        {
+          "name": "MASK",
+          "type": "MASK",
+          "links": [],
+          "shape": 3,
+          "slot_index": 1
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "LoadImage"
+      },
+      "widgets_values": [
+        "example.png",
+        "image"
+      ]
+    },
+    {
+      "id": 40,
+      "type": "CheckpointLoaderSimple",
+      "pos": [
+        1124,
+        1019
+      ],
+      "size": {
+        "0": 315,
+        "1": 98
+      },
+      "flags": {},
+      "order": 2,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            42
+          ],
+          "shape": 3,
+          "slot_index": 0
+        },
+        {
+          "name": "CLIP",
+          "type": "CLIP",
+          "links": [
+            50,
+            51
+          ],
+          "shape": 3,
+          "slot_index": 1
+        },
+        {
+          "name": "VAE",
+          "type": "VAE",
+          "links": [
+            49
+          ],
+          "shape": 3,
+          "slot_index": 2
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CheckpointLoaderSimple"
+      },
+      "widgets_values": [
+        "dreamshaper_8.safetensors"
+      ]
+    },
+    {
+      "id": 53,
+      "type": "img2txt BLIP/Llava Multimodel Tagger",
+      "pos": [
+        584,
+        865
+      ],
+      "size": [
+        462.2727684830322,
+        532.8236759410865
+      ],
+      "flags": {},
+      "order": 3,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "input_image",
+          "type": "IMAGE",
+          "link": 60
+        }
+      ],
+      "outputs": [
+        {
+          "name": "caption",
+          "type": "STRING",
+          "links": [
+            61
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "img2txt BLIP/Llava Multimodel Tagger"
+      },
+      "widgets_values": [
+        false,
+        false,
+        true,
+        false,
+        "a photograph of",
+        "What is a detailed description of this image?\nWhat is the background of this image?",
+        0.8,
+        1.2,
+        36,
+        128,
+        5,
+        "watermark, text, writing",
+        "The image features a cartoon character standing against an abstract background consisting of green, blue, and white elements. The main focus is on the woman with bright yellow wings wearing pink attire while smiling at something off-frame in front of her that seems to be representing \"clouds\" or possibly another object within view but not clearly visible due to its distance from us as viewers., "
+      ],
+      "color": "#322",
+      "bgcolor": "#533"
+    }
+  ],
+  "links": [
+    [
+      42,
+      40,
+      0,
+      39,
+      0,
+      "MODEL"
+    ],
+    [
+      44,
+      41,
+      0,
+      39,
+      1,
+      "CONDITIONING"
+    ],
+    [
+      45,
+      42,
+      0,
+      39,
+      2,
+      "CONDITIONING"
+    ],
+    [
+      48,
+      39,
+      0,
+      45,
+      0,
+      "LATENT"
+    ],
+    [
+      49,
+      40,
+      2,
+      45,
+      1,
+      "VAE"
+    ],
+    [
+      50,
+      40,
+      1,
+      41,
+      0,
+      "CLIP"
+    ],
+    [
+      51,
+      40,
+      1,
+      42,
+      0,
+      "CLIP"
+    ],
+    [
+      55,
+      45,
+      0,
+      48,
+      0,
+      "IMAGE"
+    ],
+    [
+      59,
+      52,
+      0,
+      39,
+      3,
+      "LATENT"
+    ],
+    [
+      60,
+      11,
+      0,
+      53,
+      0,
+      "IMAGE"
+    ],
+    [
+      61,
+      53,
+      0,
+      41,
+      1,
+      "STRING"
+    ]
+  ],
+  "groups": [],
+  "config": {},
+  "extra": {
+    "ds": {
+      "scale": 0.9090909090909091,
+      "offset": {
+        "0": 278.52736579431155,
+        "1": -323.6237095104226
+      }
+    }
+  },
+  "version": 0.4
+}