Add files using upload-large-folder tool

.gitattributes

@@ -35,3 +35,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
 ComfyUI-Florence-2/workflow_seg_crop.png filter=lfs diff=lfs merge=lfs -text
 ComfyUI-Florence-2/workflow_bbox.png filter=lfs diff=lfs merge=lfs -text
+comfyui-inpaint-cropandstitch/inpaint-cropandstitch_example_workflow.png filter=lfs diff=lfs merge=lfs -text
+comfyui-inpaint-cropandstitch/inpaint-cropandstitch_flux_example_workflow.png filter=lfs diff=lfs merge=lfs -text

ComfyUI_ExtraModels/.gitignore

@@ -0,0 +1,160 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

ComfyUI_ExtraModels/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

ComfyUI_ExtraModels/README.md

@@ -0,0 +1,287 @@
+# Extra Models for ComfyUI
+
+This repository aims to add support for various different image diffusion models to ComfyUI.
+
+## Installation
+
+Simply clone this repo to your custom_nodes folder using the following command:
+
+`git clone https://github.com/city96/ComfyUI_ExtraModels custom_nodes/ComfyUI_ExtraModels`
+
+You will also have to install the requirements from the provided file by running `pip install -r requirements.txt` inside your VENV/conda env. If you downloaded the standalone version of ComfyUI, then follow the steps below.
+
+### Standalone ComfyUI
+
+I haven't tested this completely, so if you know what you're doing, use the regular venv/`git clone` install option when installing ComfyUI.
+
+Go to the where you unpacked `ComfyUI_windows_portable` to (where your run_nvidia_gpu.bat file is) and open a command line window. Press `CTRL+SHIFT+Right click` in an empty space and click "Open PowerShell window here".
+
+Clone the repository to your custom nodes folder, assuming haven't installed in through the manager.
+
+`git clone https://github.com/city96/ComfyUI_ExtraModels .\ComfyUI\custom_nodes\ComfyUI_ExtraModels`
+
+To install the requirements on windows, run these commands in the same window:
+```
+.\python_embeded\python.exe -s -m pip install -r .\ComfyUI\custom_nodes\ComfyUI_ExtraModels\requirements.txt
+```
+
+To update, open the command line window like before and run the following commands:
+
+```
+cd .\ComfyUI\custom_nodes\ComfyUI_ExtraModels\
+git pull
+```
+
+Alternatively, use the manager, assuming it has an update function.
+
+
+## Sana
+
+[Original Repo](https://github.com/NVlabs/Sana)
+
+> [!CAUTION]
+> As many people have had issues with Sana, it's for now recommended to try the fork by the Sana devs, which auto downloads all models:
+> 
+> [Readme](https://github.com/NVlabs/Sana/blob/main/asset/docs/ComfyUI/comfyui.md) | [Fork repo](https://github.com/Efficient-Large-Model/ComfyUI_ExtraModels)
+
+A full rewrite to have better integration is in progress in [this PR](https://github.com/city96/ComfyUI_ExtraModels/pull/92) but isn't ready yet.
+
+https://github.com/NVlabs/Sana/blob/main/asset/docs/ComfyUI/comfyui.md
+https://github.com/Efficient-Large-Model/ComfyUI_ExtraModels
+
+### Model info / implementation
+- Uses Gemma2 2B as the text encoder
+- Multiple resolutions and models available
+- Compressed latent space (32 channels, /32 compression) - needs custom VAE
+
+### Usage
+1. Download the model weights from the [Sana HF repo](https://huggingface.co/Efficient-Large-Model/Sana_1600M_1024px/tree/main/checkpoints) - the HF account has alternative models available too.
+2. Place them in your checkpoints folder
+3. Load them with the correct PixArt checkpoint loader
+4. Use the "Gemma Loader" node - it should automatically download the requested model from Huggingface - Recommended to use the 4bit quantized model on CPU when low on memory.
+5. Download the VAE from [here](https://huggingface.co/Efficient-Large-Model/Sana_1600M_1024px_diffusers/blob/main/vae/diffusion_pytorch_model.safetensors) or [here](https://huggingface.co/mit-han-lab/dc-ae-f32c32-sana-1.0/blob/main/model.safetensors) and place it in your VAE folder after renaming it.
+6. Use either the "Empty Sana Latent Image" or "Empty DCAE Latent Image" node for the latent input when doing txt2img.
+
+[Sample workflow](https://github.com/user-attachments/files/18027854/SanaV1.json)
+
+![Sana](https://github.com/user-attachments/assets/e4334352-e894-416a-b200-dff096027481)
+
+
+## PixArt
+
+[Original Repo](https://github.com/PixArt-alpha/PixArt-alpha)
+
+### Model info / implementation
+- Uses T5 text encoder instead of clip
+- Available in 512 and 1024 versions, needs specific pre-defined resolutions to work correctly
+- Same latent space as SD1.5 (works with the SD1.5 VAE)
+- Attention needs optimization, images look worse without xformers.
+
+### Usage
+
+1. Download the model weights from the [PixArt alpha repo](https://huggingface.co/PixArt-alpha/PixArt-alpha/tree/main) - you most likely want the 1024px one - `PixArt-XL-2-1024-MS.pth`
+3. Place them in your checkpoints folder
+4. Load them with the correct PixArt checkpoint loader
+5. **Follow the T5v11 section of this readme** to set up the T5 text encoder
+
+> [!TIP]
+> You should be able to use the model with the default KSampler if you're on the latest version of the node.
+> In theory, this should allow you to use longer prompts as well as things like doing img2img.
+
+Limitations:
+- `PixArt DPM Sampler` requires the negative prompt to be shorter than the positive prompt.
+- `PixArt DPM Sampler` can only work with a batch size of 1.
+- `PixArt T5 Text Encode` is from the reference implementation, therefore it doesn't support weights. `T5 Text Encode` support weights, but I can't attest to the correctness of the implementation.
+
+> [!IMPORTANT]  
+> Installing `xformers` is optional but strongly recommended as torch SDP is only partially implemented, if that.
+
+[Sample workflow here](https://github.com/city96/ComfyUI_ExtraModels/files/13617463/PixArtV3.json)
+
+![PixArtT12](https://github.com/city96/ComfyUI_ExtraModels/assets/125218114/eb1a02f9-6114-47eb-a066-261c39c55615)
+
+### PixArt Sigma
+
+The Sigma models work just like the normal ones. Out of the released checkpoints, the 512, 1024 and 2K one are supported.
+
+You can find the [1024 checkpoint here](https://huggingface.co/PixArt-alpha/PixArt-Sigma/blob/main/PixArt-Sigma-XL-2-1024-MS.pth). Place it in your models folder and **select the appropriate type in the model loader / resolution selection node.**
+
+> [!IMPORTANT]
+> Make sure to select an SDXL VAE for PixArt Sigma!
+
+### PixArt LCM
+
+The LCM model also works if you're on the latest version. To use it:
+
+1. Download the [PixArt LCM model](https://huggingface.co/PixArt-alpha/PixArt-LCM-XL-2-1024-MS/blob/main/transformer/diffusion_pytorch_model.safetensors) and place it in your checkpoints folder.
+2. Add a `ModelSamplingDiscrete` node and set "sampling" to "lcm"
+3. Adjust the KSampler settings - Set the sampler to "lcm". Your CFG should be fairly low (1.1-1.5), your steps should be around 5.
+
+Everything else can be the same the same as in the example above.
+
+![PixArtLCM](https://github.com/city96/ComfyUI_ExtraModels/assets/125218114/558f8b30-449b-4973-ad7e-6aa69832adcb)
+
+
+
+## HunYuan DiT
+
+WIP implementation of [HunYuan DiT by Tencent](https://github.com/Tencent/HunyuanDiT)
+
+The initial work on this was done by [chaojie](https://github.com/chaojie) in [this PR](https://github.com/city96/ComfyUI_ExtraModels/pull/37).
+
+Instructions:
+- Download the [first text encoder from here](https://huggingface.co/Tencent-Hunyuan/HunyuanDiT/blob/main/t2i/clip_text_encoder/pytorch_model.bin) and place it in `ComfyUI/models/clip` - rename to "chinese-roberta-wwm-ext-large.bin"
+- Download the [second text encoder from here](https://huggingface.co/Tencent-Hunyuan/HunyuanDiT/blob/main/t2i/mt5/pytorch_model.bin) and place it in `ComfyUI/models/t5` - rename it to "mT5-xl.bin"
+- Download the [model file from here](https://huggingface.co/Tencent-Hunyuan/HunyuanDiT/blob/main/t2i/model/pytorch_model_module.pt) and place it in `ComfyUI/checkpoints` - rename it to "HunYuanDiT.pt"
+- Download/use any SDXL VAE, for example [this one](https://huggingface.co/madebyollin/sdxl-vae-fp16-fix)
+
+You may also try the following alternate model files for faster loading speed/smaller file size:
+- converted [second text encoder](https://huggingface.co/city96/mt5-xl-encoder-fp16/blob/main/model.safetensors) - rename to `mT5-xl-encoder-fp16.safetensors` and placed in `ComfyUI/models/t5`
+
+You can use the "simple" text encode node to only use one prompt, or you can use the regular one to pass different text to CLIP/T5.
+
+[Sample Workflow](https://github.com/city96/ComfyUI_ExtraModels/files/15444231/HyDiTV1.json)
+
+![image](https://github.com/city96/ComfyUI_ExtraModels/assets/125218114/7a9d6e34-d3f4-4f67-a17f-4f2d6795e54e)
+
+
+
+## DiT
+
+[Original Repo](https://github.com/facebookresearch/DiT)
+
+### Model info / implementation
+- Uses class labels instead of prompts
+- Limited to 256x256 or 512x512 images
+- Same latent space as SD1.5 (works with the SD1.5 VAE)
+- Works in FP16, but no other optimization
+
+### Usage
+
+1. Download the original model weights from the [DiT Repo](https://github.com/facebookresearch/DiT) or the converted [FP16 safetensor ones from Huggingface](https://huggingface.co/city96/DiT/tree/main).
+2. Place them in your checkpoints folder. (You may need to move them if you had them in `ComfyUI\models\dit` before)
+3. Load the model and select the class labels as shown in the image below
+4. **Make sure to use the Empty label conditioning for the Negative input of the KSampler!**
+
+ConditioningCombine nodes *should* work for combining multiple labels. The area ones don't since the model currently can't handle dynamic input dimensions.
+
+[Sample workflow here](https://github.com/city96/ComfyUI_ExtraModels/files/13619259/DiTV2.json)
+
+![DIT_WORKFLOW_IMG](https://github.com/city96/ComfyUI_ExtraModels/assets/125218114/cdd4ec94-b0eb-436a-bf23-a3bcef8d7b90)
+
+
+
+## T5
+
+### T5v11
+
+The model files can be downloaded from the [DeepFloyd/t5-v1_1-xxl](https://huggingface.co/DeepFloyd/t5-v1_1-xxl/tree/main) repository.
+
+You will need to download the following 4 files:
+ - `config.json`
+ - `pytorch_model-00001-of-00002.bin`
+ - `pytorch_model-00002-of-00002.bin`
+ - `pytorch_model.bin.index.json`
+
+Place them in your `ComfyUI/models/t5` folder. You can put them in a subfolder called "t5-v1.1-xxl" though it doesn't matter. There are int8 safetensor files in the other DeepFloyd repo, thought they didn't work for me.
+
+For faster loading/smaller file sizes, you may pick one of the following alternative downloads:
+- [FP16 converted version](https://huggingface.co/theunlikely/t5-v1_1-xxl-fp16/tree/main) - Same layout as the original, download both safetensor files as well as the `*.index.json` and `config.json` files.
+- [BF16 converter version](https://huggingface.co/city96/t5-v1_1-xxl-encoder-bf16/tree/main) - Merged into a single safetensor, only `model.safetensors` (+`config.json` for folder mode) are reqired.
+
+To move T5 to a different drive/folder, do the same as you would when moving checkpoints, but add `    t5: t5` to `extra_model_paths.yaml` and create a directory called "t5" in the alternate path specified in the `base_path` variable.
+
+### Usage
+
+Loaded onto the CPU, it'll use about 22GBs of system RAM. Depending on which weights you use, it might use slightly more during loading.
+
+If you have a second GPU, selecting "cuda:1" as the device will allow you to use it for T5, freeing at least some VRAM/System RAM. Using FP16 as the dtype is recommended.
+
+Loaded in bnb4bit mode, it only takes around 6GB VRAM, making it work with 12GB cards. The only drawback is that it'll constantly stay in VRAM since BitsAndBytes doesn't allow moving the weights to the system RAM temporarily. Switching to a different workflow *should* still release the VRAM as expected. Pascal cards (1080ti, P40) seem to struggle with 4bit. Select "cpu" if you encounter issues.
+
+On windows, you may need a newer version of bitsandbytes for 4bit. Try `python -m pip install bitsandbytes`
+
+> [!IMPORTANT]  
+> You may also need to upgrade transformers and install spiece for the tokenizer. `pip install -r requirements.txt`
+
+
+
+## MiaoBi
+
+### Original from: 
+
+- Author: Github [ShineChen1024](https://github.com/ShineChen1024) | Hugging Face [ShineChen1024](https://huggingface.co/ShineChen1024)
+- https://github.com/ShineChen1024/MiaoBi
+- https://huggingface.co/ShineChen1024/MiaoBi
+
+### Instructions
+- Download the [clip model](https://huggingface.co/ShineChen1024/MiaoBi/blob/main/miaobi_beta0.9/text_encoder/model.safetensors) and rename it to "MiaoBi_CLIP.safetensors" or any you like, then place it in `ComfyUI/models/clip`.
+- Download the [unet model](https://huggingface.co/ShineChen1024/MiaoBi/blob/main/miaobi_beta0.9/unet/diffusion_pytorch_model.safetensors) and rename it to "MiaoBi.safetensors", then place it in `ComfyUI/models/unet`.
+- Alternatively, clone/download the entire huggingface repo to `ComfyUI/models/diffusers` and use the MiaoBi diffusers loader.
+
+这是妙笔的测试版本。妙笔，一个中文文生图模型，与经典的stable-diffusion 1.5版本拥有一致的结构，兼容现有的lora，controlnet，T2I-Adapter等主流插件及其权重。
+
+This is the beta version of MiaoBi, a chinese text-to-image model, following the classical structure of sd-v1.5, compatible with existing mainstream plugins such as Lora, Controlnet, T2I Adapter, etc.
+
+Example Prompts:
+- 一只精致的陶瓷猫咪雕像，全身绘有精美的传统花纹，眼睛仿佛会发光。
+- 动漫风格的风景画，有山脉、湖泊，也有繁华的小镇子，色彩鲜艳，光影效果明显。
+- 极具真实感的复杂农村的老人肖像，黑白。
+- 红烧狮子头
+- 车水马龙的上海街道，春节，舞龙舞狮。
+- 枯藤老树昏鸦，小桥流水人家。水墨画。
+
+[Example Workflow](https://github.com/city96/ComfyUI_ExtraModels/files/15389380/MiaoBiV1.json)
+
+[Example Workflow (diffusers)](https://github.com/city96/ComfyUI_ExtraModels/files/15389381/MiaoBiV1D.json)
+
+![MiaoBi](https://github.com/city96/ComfyUI_ExtraModels/assets/125218114/d9e4ab7d-f61b-407f-b7dd-af5859627d0e)
+
+
+
+## VAE
+
+A few custom VAE models are supported. The option to select a different dtype when loading is also possible, which can be useful for testing/comparisons. You can load the models listed below using the "ExtraVAELoader" node.
+
+**Models like PixArt/DiT do NOT need a special VAE. Unless mentioned, use one of the following as you would with any other model:**
+- [VAE for SD1.X, DiT and PixArt alpha](https://huggingface.co/stabilityai/sd-vae-ft-mse-original/blob/main/vae-ft-mse-840000-ema-pruned.safetensors).
+- [VAE for SDXL and PixArt sigma](https://huggingface.co/madebyollin/sdxl-vae-fp16-fix/blob/main/diffusion_pytorch_model.safetensors)
+
+### Consistency Decoder
+
+[Original Repo](https://github.com/openai/consistencydecoder)
+
+This now works thanks to the work of @mrsteyk and @madebyollin - [Gist with more info](https://gist.github.com/madebyollin/865fa6a18d9099351ddbdfbe7299ccbf).
+
+- Download the converted safetensor VAE from [this HF repository](https://huggingface.co/mrsteyk/consistency-decoder-sd15/blob/main/stk_consistency_decoder_amalgamated.safetensors). If you downloaded the OpenAI model before, it won't work, as it is a TorchScript file. Feel free to delete it.
+- Put the file in your VAE folder
+- Load it with the ExtraVAELoader
+- Set it to fp16 or bf16 to not run out of VRAM
+- Use tiled VAE decode if required
+
+### Deflickering Decoder / VideoDecoder
+
+This is the VAE that comes baked into the [Stable Video Diffusion](https://stability.ai/news/stable-video-diffusion-open-ai-video-model) model.
+
+It doesn't seem particularly good as a normal VAE (color issues, pretty bad with finer details).
+
+Still for completeness sake the code to run it is mostly implemented. To obtain the weights just extract them from the sdv model:
+
+```py
+from safetensors.torch import load_file, save_file
+
+pf = "first_stage_model." # Key prefix
+sd = load_file("svd_xt.safetensors")
+vae = {k.replace(pf, ''):v for k,v in sd.items() if k.startswith(pf)}
+save_file(vae, "svd_xt_vae.safetensors")
+```
+
+### AutoencoderKL / VQModel
+
+`kl-f4/8/16/32` from the [compvis/latent diffusion repo](https://github.com/CompVis/latent-diffusion/tree/main#pretrained-autoencoding-models).
+
+`vq-f4/8/16` from the taming transformers repo, weights for both vq and kl models available [here](https://ommer-lab.com/files/latent-diffusion/)
+
+`vq-f8` can accepts latents from the SD unet but just like xl with v1 latents, output largely garbage. The rest are completely useless without a matching UNET that uses the correct channel count.
+
+![VAE_TEST](https://github.com/city96/ComfyUI_ExtraModels/assets/125218114/316c7029-ee78-4ff7-a46a-b56ef91477eb)

ComfyUI_ExtraModels/__init__.py

@@ -0,0 +1,51 @@
+# only import if running as a custom node
+try:
+	import comfy.utils
+except ImportError:
+	pass
+else:
+	NODE_CLASS_MAPPINGS = {}
+
+	# Deci Diffusion
+	# from .DeciDiffusion.nodes import NODE_CLASS_MAPPINGS as DeciDiffusion_Nodes
+	# NODE_CLASS_MAPPINGS.update(DeciDiffusion_Nodes)
+
+	# DiT
+	from .DiT.nodes import NODE_CLASS_MAPPINGS as DiT_Nodes
+	NODE_CLASS_MAPPINGS.update(DiT_Nodes)
+
+	# PixArt
+	from .PixArt.nodes import NODE_CLASS_MAPPINGS as PixArt_Nodes
+	NODE_CLASS_MAPPINGS.update(PixArt_Nodes)
+
+	# T5
+	from .T5.nodes import NODE_CLASS_MAPPINGS as T5_Nodes
+	NODE_CLASS_MAPPINGS.update(T5_Nodes)
+
+	# HYDiT
+	from .HunYuanDiT.nodes import NODE_CLASS_MAPPINGS as HunYuanDiT_Nodes
+	NODE_CLASS_MAPPINGS.update(HunYuanDiT_Nodes)
+
+	# VAE
+	from .VAE.nodes import NODE_CLASS_MAPPINGS as VAE_Nodes
+	NODE_CLASS_MAPPINGS.update(VAE_Nodes)
+ 
+ 	# MiaoBi
+	from .MiaoBi.nodes import NODE_CLASS_MAPPINGS as MiaoBi_Nodes
+	NODE_CLASS_MAPPINGS.update(MiaoBi_Nodes)
+
+	# Extra
+	from .utils.nodes import NODE_CLASS_MAPPINGS as Extra_Nodes
+	NODE_CLASS_MAPPINGS.update(Extra_Nodes)
+
+	# Sana
+	from .Sana.nodes import NODE_CLASS_MAPPINGS as Sana_Nodes
+	NODE_CLASS_MAPPINGS.update(Sana_Nodes)
+
+	# Gemma
+	from .Gemma.nodes import NODE_CLASS_MAPPINGS as Gemma_Nodes
+	NODE_CLASS_MAPPINGS.update(Gemma_Nodes)
+
+	NODE_DISPLAY_NAME_MAPPINGS = {k:v.TITLE for k,v in NODE_CLASS_MAPPINGS.items()}
+	__all__ = ['NODE_CLASS_MAPPINGS', 'NODE_DISPLAY_NAME_MAPPINGS']
+

ComfyUI_ExtraModels/requirements.txt

@@ -0,0 +1,7 @@
+timm>=0.6.13
+sentencepiece>=0.1.97
+transformers>=4.34.1
+accelerate>=0.23.0
+einops>=0.6.0
+protobuf>=3.20.3
+bitsandbytes>=0.41.0

ComfyUI_JPS-Nodes/README.md

@@ -0,0 +1,81 @@
+# JPS Custom Nodes for ComfyUI
+
+These nodes were originally made for use in JPS ComfyUI Workflows.
+
+The nodes can be used in any ComfyUI workflow.
+
+# Installation
+
+If you have a previous version of the "JPS Custom Nodes for ComfyUI", please delete this before installing these nodes.
+
+1. cd custom_nodes
+2. git clone https://github.com/JPS-GER/ComfyUI_JPS-Nodes.git
+3. Restart ComfyUI
+
+You can also install the nodes using the following methods:
+* install using [ComfyUI Manager](https://github.com/ltdrdata/ComfyUI-Manager)
+
+# List of Custom Nodes
+
+__IO__
+* Lora Loader - Lora Loader with On/Off Switch - output is 1 or 2, so it works with most "x to 1"-switches (while some other alternatives use boolean 0 or 1 and need corresponding switches or additional math nodes)
+
+__Settings__
+* SDXL Resolutions - small node that offers recommended SDXL resolutions and outputs height and width values
+* SDXL Basic Settings - menu node for basic SDXL settings, required for most SDXL workflows (connect to "SDXL Basic Settings Pipe" to access the values), includes FreeU options now
+* Generation TXT IMG Settings - menu node to switch between TXT2IMG and IMG2IMG
+* Generation Settings - menu node to switch between, TXT2IMG, IMG2IMG, Control Net Canny, Control Net Depth, Inpainting (conntect to "Generation Settings Pipe" to access the values) 
+* IP Adapter Settings - menu node to turn on/off five IP adapter input images and settings (conntect to "IP Adapter Settings Pipe" to access the values)
+* Revision Settings - menu node to turn on/off two revision input images and settings (conntect to "Revision Settings Pipe" to access the values)
+* Sampler Scheduler Settings - menu node for sampler + scheduler settings, can also be used as pipe
+
+__Switches__
+* Integer Switch - "5 to 1"-switch for integer values
+* Image Switch - "5 to 1"-switch for images
+* Latent Switch - "5 to 1"-switch for latent images
+* Conditioning Switch - "5 to 1"-switch for conditioning
+* Model Switch - "5 to 1"-switch for models
+* VAE Switch - "5 to 1"-switch for VAE
+* ControlNet Switch - "5 to 1"-switch for ControlNet
+* Disable Enable Switch - input for nodes that use "disable/enable" types of input (for example KSampler) - useful to switch those values in combinaton with other switches
+* Enable Disable Switch - input for nodes that use "enable/disable" types of input (for example KSampler) - useful to switch those values in combinaton with other switches
+
+__Pipes__
+* SDXL Basic Settings Pipe - used to access data from "SDXL Basic Settings" menu node - place outside of the menu structure of your workflow
+* Generation Settings Pipe - used to access data from "Generation Settings" menu node - place outside of the menu structure of your workflow 
+* IP Adapter Settings Pipe - used to access data from "IP Adapter Settings" menu node - place outside of the menu structure of your workflow
+* Revision Settings Pipe - used to access data from "Revision Settings" menu node - place outside of the menu structure of your workflow
+* SDXL Fundamentals MultiPipe - used to build a pipe for basic SDXL settings, has input/outputs for all supported types, so you can access/change values more easily than classic "from/to/edit"-pipes
+* Images Masks MultiPipe - used to build a pipe for various images and masks used in my workflow, has input/outputs for all images, so you can access/change images and masks more easily than classic "from/to/edit"-pipes 
+
+__Math__
+* SDXL Recommended Resolution Calc - gives you the closest recommended SDXL resolution for the width and height values, useful for IMG2IMG and ControlNet input images, to bring them in line with SDXL workflows
+* Resolution Multiply - multily height and width by some factor - useful to get 2x or 4x values for upscaling or SDXL target width and SDXL target height
+* Largest Int - input two integer values, output will be the larger value
+* Multiply Int Int - multiply two integer inputs, output is available as integer and float, so you can save an extra node converting to the required type
+* Multiply Int Float - multiply integer and float inputs, output is available as integer and float, so you can save an extra node converting to the required type
+* Multiply Float Float - multiply two flout inputs, output is available as integer and float, so you can save an extra node converting to the required type
+* Substract Int Int - subscract one integer input from another integer input, output is available as integer and float, so you can save an extra node converting to the required type
+
+__Text__
+* Text Concatenate - combine multiple input strings to one output string
+* Get Date Time String - get current date/time (has extra code to make sure it will not use cached data)
+* SDXL Prompt Handling - control how text_g and text_l input will be handled (many options)
+* SDXL Prompt Handling Plus - control how text_g and text_l input will be handled (many options), option to add an "universal negative" prompt
+
+![image](https://github.com/JPS-GER/ComfyUI_JPS-Nodes/assets/142158778/66da22f7-e4d6-4898-ae30-7b123a268615)
+![image](https://github.com/JPS-GER/ComfyUI_JPS-Nodes/assets/142158778/c5abb960-0c6c-448a-a2f2-72d857dddc70)
+  
+__Image__
+* Get Image Size - get width and height value from an input image, useful in combination with "Resolution Multiply" and "SDXL Recommended Resolution Calc" nodes
+* Crop Image Square - crop images to a square aspect ratio - choose between center, top, bottom, left and right part of the image and fine tune with offset option, optional: resize image to target size (useful for Clip Vision input images, like IP-Adapter or Revision)
+
+__Style__
+* SDXL Prompt Styler - add artists, movies and general styles to your text prompt, option to add an "universal negative" prompt - uses json files, so you can extend the available options
+
+![image](https://github.com/JPS-GER/ComfyUI_JPS-Nodes/assets/142158778/486e2e32-1a06-4a79-b85d-0d21e4013016)
+
+# Credits
+
+SDXL Prompt Styler is an extended version of SDXL Prompt Styler by twri - https://github.com/twri/sdxl_prompt_styler
+

ComfyUI_JPS-Nodes/__init__.py

@@ -0,0 +1,10 @@
+"""
+@author: JPS
+@title: JPS Custom Nodes for ComfyUI
+@nickname: JPS Custom Nodes
+@description: Various nodes to handle SDXL Resolutions, SDXL Basic Settings, IP Adapter Settings, Revision Settings, SDXL Prompt Styler, Crop Image to Square, Crop Image to Target Size, Get Date-Time String, Resolution Multiply, Largest Integer, 5-to-1 Switches for Integer, Images, Latents, Conditioning, Model, VAE, ControlNet
+"""
+
+from .jps_nodes import NODE_CLASS_MAPPINGS
+
+__all__ = ['NODE_CLASS_MAPPINGS']

ComfyUI_Qwen2-VL-Instruct/.gitignore

@@ -0,0 +1,162 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

ComfyUI_Qwen2-VL-Instruct/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2024 QwenLM
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

ComfyUI_Qwen2-VL-Instruct/README.md

@@ -0,0 +1,37 @@
+# ComfyUI_Qwen2-VL-Instruct
+
+This is an implementation of [Qwen2-VL-Instruct](https://github.com/QwenLM/Qwen2-VL) by [ComfyUI](https://github.com/comfyanonymous/ComfyUI), which includes, but is not limited to, support for text-based queries, video queries, single-image queries, and multi-image queries to generate captions or responses.
+
+---
+
+## Basic Workflow
+
+- **Text-based Query**: Users can submit textual queries to request information or generate descriptions. For instance, a user might input a description like "What is the meaning of life?"
+
+![Chat_with_text_workflow preview](examples/Chat_with_text_workflow.png)
+
+- **Video Query**: When a user uploads a video, the system can analyze the content and generate a detailed caption for each frame or a summary of the entire video. For example, "Generate a caption for the given video."
+
+![Chat_with_video_workflow preview](examples/Chat_with_video_workflow.png)
+
+- **Single-Image Query**: This workflow supports generating a caption for an individual image. A user could upload a photo and ask, "What does this image show?" resulting in a caption such as "A majestic lion pride relaxing on the savannah."
+
+![Chat_with_single_image_workflow preview](examples/Chat_with_single_image_workflow.png)
+
+- **Multi-Image Query**: For multiple images, the system can provide a collective description or a narrative that ties the images together. For example, "Create a story from the following series of images: one of a couple at a beach, another at a wedding ceremony, and the last one at a baby's christening."
+
+![Chat_with_multiple_images_workflow preview](examples/Chat_with_multiple_images_workflow.png)
+
+## Installation
+
+- Install from [ComfyUI Manager](https://github.com/ltdrdata/ComfyUI-Manager) (search for `Qwen2`)
+
+- Download or git clone this repository into the `ComfyUI\custom_nodes\` directory and run:
+
+```python
+pip install -r requirements.txt
+```
+
+## Download Models
+
+All the models will be downloaded automatically when running the workflow if they are not found in the `ComfyUI\models\prompt_generator\` directory.

ComfyUI_Qwen2-VL-Instruct/__init__.py

@@ -0,0 +1,18 @@
+from .nodes import Qwen2_VQA
+from .util_nodes import ImageLoader
+from .path_nodes import MultiplePathsInput
+WEB_DIRECTORY = "./web"
+# A dictionary that contains all nodes you want to export with their names
+# NOTE: names should be globally unique
+NODE_CLASS_MAPPINGS = {
+    "Qwen2_VQA": Qwen2_VQA,
+    "ImageLoader": ImageLoader,
+    "MultiplePathsInput": MultiplePathsInput,
+}
+
+# A dictionary that contains the friendly/humanly readable titles for the nodes
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "Qwen2_VQA": "Qwen2 VQA",
+    "ImageLoader": "Load Image Advanced",
+    "MultiplePathsInput": "Multiple Paths Input",
+}

ComfyUI_Qwen2-VL-Instruct/node_helpers.py

@@ -0,0 +1,37 @@
+import hashlib
+
+from comfy.cli_args import args
+
+from PIL import ImageFile, UnidentifiedImageError
+
+def conditioning_set_values(conditioning, values={}):
+    c = []
+    for t in conditioning:
+        n = [t[0], t[1].copy()]
+        for k in values:
+            n[1][k] = values[k]
+        c.append(n)
+
+    return c
+
+def pillow(fn, arg):
+    prev_value = None
+    try:
+        x = fn(arg)
+    except (OSError, UnidentifiedImageError, ValueError): #PIL issues #4472 and #2445, also fixes ComfyUI issue #3416
+        prev_value = ImageFile.LOAD_TRUNCATED_IMAGES
+        ImageFile.LOAD_TRUNCATED_IMAGES = True
+        x = fn(arg)
+    finally:
+        if prev_value is not None:
+            ImageFile.LOAD_TRUNCATED_IMAGES = prev_value
+    return x
+
+def hasher():
+    hashfuncs = {
+        "md5": hashlib.md5,
+        "sha1": hashlib.sha1,
+        "sha256": hashlib.sha256,
+        "sha512": hashlib.sha512
+    }
+    return hashfuncs[args.default_hashing_function]

ComfyUI_Qwen2-VL-Instruct/nodes.py

@@ -0,0 +1,195 @@
+import os
+import torch
+import folder_paths
+from transformers import (
+    Qwen2VLForConditionalGeneration,
+    AutoProcessor,
+    BitsAndBytesConfig,
+)
+from qwen_vl_utils import process_vision_info
+
+
+class Qwen2_VQA:
+    def __init__(self):
+        self.model_checkpoint = None
+        self.processor = None
+        self.model = None
+        self.device = (
+            torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
+        )
+        self.bf16_support = (
+            torch.cuda.is_available()
+            and torch.cuda.get_device_capability(self.device)[0] >= 8
+        )
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "text": ("STRING", {"default": "", "multiline": True}),
+                "model": (
+                    [
+                        "Qwen2-VL-2B-Instruct-GPTQ-Int4",
+                        "Qwen2-VL-2B-Instruct-GPTQ-Int8",
+                        "Qwen2-VL-2B-Instruct",
+                        "Qwen2-VL-7B-Instruct-GPTQ-Int4",
+                        "Qwen2-VL-7B-Instruct-GPTQ-Int8",
+                        "Qwen2-VL-7B-Instruct",
+                    ],
+                    {"default": "Qwen2-VL-2B-Instruct"},
+                ),
+                "quantization": (
+                    ["none", "4bit", "8bit"],
+                    {"default": "none"},
+                ),  # add quantization type selection
+                "keep_model_loaded": ("BOOLEAN", {"default": False}),
+                "temperature": (
+                    "FLOAT",
+                    {"default": 0.7, "min": 0, "max": 1, "step": 0.1},
+                ),
+                "max_new_tokens": (
+                    "INT",
+                    {"default": 2048, "min": 128, "max": 2048, "step": 1},
+                ),
+                "min_pixels": (
+                    "INT",
+                    {
+                        "default": 256 * 28 * 28,
+                        "min": 4 * 28 * 28,
+                        "max": 16384 * 28 * 28,
+                        "step": 28 * 28,
+                    },
+                ),
+                "max_pixels": (
+                    "INT",
+                    {
+                        "default": 1280 * 28 * 28,
+                        "min": 4 * 28 * 28,
+                        "max": 16384 * 28 * 28,
+                        "step": 28 * 28,
+                    },
+                ),
+                "seed": ("INT", {"default": -1}),  # add seed parameter, default is -1
+            },
+            "optional": {
+                "source_path": ("PATH",),
+            },
+        }
+
+    RETURN_TYPES = ("STRING",)
+    FUNCTION = "inference"
+    CATEGORY = "Comfyui_Qwen2-VL-Instruct"
+
+    def inference(
+        self,
+        text,
+        model,
+        keep_model_loaded,
+        temperature,
+        max_new_tokens,
+        min_pixels,
+        max_pixels,
+        seed,
+        quantization,
+        source_path=None,
+    ):
+        if seed != -1:
+            torch.manual_seed(seed)
+        model_id = f"qwen/{model}"
+        self.model_checkpoint = os.path.join(
+            folder_paths.models_dir, "prompt_generator", os.path.basename(model_id)
+        )
+
+        if not os.path.exists(self.model_checkpoint):
+            from huggingface_hub import snapshot_download
+
+            snapshot_download(
+                repo_id=model_id,
+                local_dir=self.model_checkpoint,
+                local_dir_use_symlinks=False,
+            )
+
+        if self.processor is None:
+            # The default range for the number of visual tokens per image in the model is 4-16384. You can set min_pixels and max_pixels according to your needs, such as a token count range of 256-1280, to balance speed and memory usage.
+            self.processor = AutoProcessor.from_pretrained(
+                self.model_checkpoint, min_pixels=min_pixels, max_pixels=max_pixels
+            )
+
+        if self.model is None:
+            # Load the model on the available device(s)
+            if quantization == "4bit":
+                quantization_config = BitsAndBytesConfig(
+                    load_in_4bit=True,
+                )
+            elif quantization == "8bit":
+                quantization_config = BitsAndBytesConfig(
+                    load_in_8bit=True,
+                )
+            else:
+                quantization_config = None
+
+            self.model = Qwen2VLForConditionalGeneration.from_pretrained(
+                self.model_checkpoint,
+                torch_dtype=torch.bfloat16 if self.bf16_support else torch.float16,
+                device_map="auto",
+                attn_implementation="sdpa",
+                quantization_config=quantization_config,
+            )
+
+        with torch.no_grad():
+            if source_path:
+                messages = [
+                    {
+                        "role": "user",
+                        "content": source_path
+                        + [
+                            {"type": "text", "text": text},
+                        ],
+                    }
+                ]
+            else:
+                messages = [
+                    {
+                        "role": "user",
+                        "content": [
+                            {"type": "text", "text": text},
+                        ],
+                    }
+                ]
+                # raise ValueError("Either image or video must be provided")
+
+            # Preparation for inference
+            text = self.processor.apply_chat_template(
+                messages, tokenize=False, add_generation_prompt=True
+            )
+            image_inputs, video_inputs = process_vision_info(messages)
+            inputs = self.processor(
+                text=[text],
+                images=image_inputs,
+                videos=video_inputs,
+                padding=True,
+                return_tensors="pt",
+            )
+            inputs = inputs.to("cuda")
+            # Inference: Generation of the output
+            generated_ids = self.model.generate(**inputs, max_new_tokens=max_new_tokens)
+            generated_ids_trimmed = [
+                out_ids[len(in_ids) :]
+                for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+            ]
+            result = self.processor.batch_decode(
+                generated_ids_trimmed,
+                skip_special_tokens=True,
+                clean_up_tokenization_spaces=False,
+                temperature=temperature,
+            )
+
+            if not keep_model_loaded:
+                del self.processor  # release processor memory
+                del self.model  # release model memory
+                self.processor = None  # set processor to None
+                self.model = None  # set model to None
+                torch.cuda.empty_cache()  # release GPU memory
+                torch.cuda.ipc_collect()
+
+            return (result,)

ComfyUI_Qwen2-VL-Instruct/path_nodes.py

@@ -0,0 +1,61 @@
+from decord import VideoReader, cpu  # pip install decord
+class MultiplePathsInput:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "inputcount": ("INT", {"default": 1, "min": 1, "max": 1000, "step": 1}),
+                "path_1": ("PATH",),
+            },
+        }
+
+    RETURN_TYPES = ("PATH",)
+    RETURN_NAMES = ("paths",)
+    FUNCTION = "combine"
+    CATEGORY = "Comfyui_Qwen2-VL-Instruct"
+    DESCRIPTION = """
+Creates a path batch from multiple paths.  
+You can set how many inputs the node has,  
+with the **inputcount** and clicking update.
+"""
+
+
+
+    @staticmethod
+    def convert_path_to_json(file_path):
+        ext = file_path.split('.')[-1].lower()
+        
+        if ext in ["jpg", "jpeg", "png", "bmp", "tiff", "webp"]:
+            return {"type": "image", "image": f"{file_path}"}
+        elif ext in ["mp4", "mkv", "mov", "avi", "flv", "wmv", "webm", "m4v"]:
+            print("source_video_path:", file_path)
+            vr = VideoReader(file_path, ctx=cpu(0))
+            total_frames = len(vr) + 1
+            print("Total frames:", total_frames)
+            avg_fps = vr.get_avg_fps()
+            print("Get average FPS(frame per second):", avg_fps)
+            duration = len(vr) / avg_fps
+            print("Total duration:", duration, "seconds")
+            width = vr[0].shape[1]
+            height = vr[0].shape[0]
+            print("Video resolution(width x height):", width, "x", height)
+            return {
+                "type": "video",
+                "video": f"{file_path}",
+                "fps": 1.0,
+            }
+        else:
+            return None
+
+
+
+    def combine(self, inputcount, **kwargs):
+        path_list = []
+        for c in range(inputcount):
+            path = kwargs[f"path_{c + 1}"]
+            path = self.convert_path_to_json(path)
+            print(path)
+            path_list.append(path)
+        print(path_list)
+        result = path_list
+        return (result,)

ComfyUI_Qwen2-VL-Instruct/pyproject.toml

@@ -0,0 +1,14 @@
+[project]
+name = "ComfyUI_Qwen2-VL-Instruct"
+description = "This is an implementation of [Qwen2-VL-Instruct](https://github.com/QwenLM/Qwen2-VL) by [ComfyUI](https://github.com/comfyanonymous/ComfyUI), which includes, but is not limited to, support for text-based queries, video queries, single-image queries, and multi-image queries to generate captions or responses."
+version = "1.0.0"
+license = "LICENSE"
+dependencies = ["torch", "torchvision", "numpy", "pillow", "huggingface_hub", "transformers", "decord", "bitsandbytes","accelerate","qwen-vl-utils","optimum","av"]
+
+[project.urls]
+Repository = "https://github.com/IuvenisSapiens/ComfyUI_Qwen2-VL-Instruct"
+
+[tool.comfy]
+PublisherId = "IuvenisSapiens"
+DisplayName = "ComfyUI_Qwen2-VL-Instruct"
+Icon = "favicon.ico"

ComfyUI_Qwen2-VL-Instruct/requirements.txt

@@ -0,0 +1,14 @@
+torch
+torchvision
+torchaudio
+numpy
+pillow
+huggingface_hub
+decord
+accelerate
+qwen-vl-utils[decord]
+optimum
+av
+decord
+auto-gptq 
+transformers>=4.45.0

ComfyUI_Qwen2-VL-Instruct/util_nodes.py

@@ -0,0 +1,80 @@
+import hashlib
+import os
+import folder_paths
+import numpy as np
+import torch
+import node_helpers
+from PIL import Image, ImageOps, ImageSequence
+
+
+class ImageLoader:
+    @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)) and f.split('.')[-1] in ['jpg', 'jpeg', 'png', 'bmp', 'tiff', 'webp']]
+        return {"required":
+                    {"image": (sorted(files), {"image_upload": True})},
+                }
+
+    CATEGORY = "Comfyui_Qwen2-VL-Instruct"
+
+    RETURN_TYPES = ("IMAGE", "MASK", "PATH")
+    FUNCTION = "load_image"
+    def load_image(self, image):
+        image_path = folder_paths.get_annotated_filepath(image)
+        
+        img = node_helpers.pillow(Image.open, image_path)
+        
+        output_images = []
+        output_masks = []
+        w, h = None, None
+
+        excluded_formats = ['MPO']
+        
+        for i in ImageSequence.Iterator(img):
+            i = node_helpers.pillow(ImageOps.exif_transpose, i)
+
+            if i.mode == 'I':
+                i = i.point(lambda i: i * (1 / 255))
+            image = i.convert("RGB")
+
+            if len(output_images) == 0:
+                w = image.size[0]
+                h = image.size[1]
+            
+            if image.size[0] != w or image.size[1] != h:
+                continue
+            
+            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 and img.format not in excluded_formats:
+            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]
+
+        return (output_image, output_mask, image_path)
+
+    @classmethod
+    def IS_CHANGED(s, image):
+        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):
+        if not folder_paths.exists_annotated_filepath(image):
+            return "Invalid image file: {}".format(image)
+
+        return True

ComfyUI_essentials/.gitignore

@@ -0,0 +1,6 @@
+/__pycache__/
+/luts/*.cube
+/luts/*.CUBE
+/fonts/*.ttf
+/fonts/*.otf
+!/fonts/ShareTechMono-Regular.ttf

ComfyUI_essentials/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Matteo Spinelli
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ComfyUI_essentials/README.md

@@ -0,0 +1,49 @@
+# :wrench: ComfyUI Essentials
+
+Essential nodes that are weirdly missing from ComfyUI core. With few exceptions they are new features and not commodities. I hope this will be just a temporary repository until the nodes get included into ComfyUI.
+
+# Sponsorship
+
+<div align="center">
+
+**[:heart: Github Sponsor](https://github.com/sponsors/cubiq) | [:coin: Paypal](https://paypal.me/matt3o)**
+
+</div>
+
+If you like my work and wish to see updates and new features please consider sponsoring my projects.
+
+- [ComfyUI IPAdapter Plus](https://github.com/cubiq/ComfyUI_IPAdapter_plus)
+- [ComfyUI InstantID (Native)](https://github.com/cubiq/ComfyUI_InstantID)
+- [ComfyUI Essentials](https://github.com/cubiq/ComfyUI_essentials)
+- [ComfyUI FaceAnalysis](https://github.com/cubiq/ComfyUI_FaceAnalysis)
+
+Not to mention the documentation and videos tutorials. Check my **ComfyUI Advanced Understanding** videos on YouTube for example, [part 1](https://www.youtube.com/watch?v=_C7kR2TFIX0) and [part 2](https://www.youtube.com/watch?v=ijqXnW_9gzc)
+
+The only way to keep the code open and free is by sponsoring its development. The more sponsorships the more time I can dedicate to my open source projects.
+
+Please consider a [Github Sponsorship](https://github.com/sponsors/cubiq) or [PayPal donation](https://paypal.me/matt3o) (Matteo "matt3o" Spinelli). For sponsorships of $50+, let me know if you'd like to be mentioned in this readme file, you can find me on [Discord](https://latent.vision/discord) or _matt3o :snail: gmail.com_.
+
+## Current sponsors
+
+It's only thanks to generous sponsors that **the whole community** can enjoy open and free software. Please join me in thanking the following companies and individuals!
+
+### :trophy: Gold sponsors
+
+[![Kaiber.ai](https://f.latent.vision/imgs/kaiber.png)](https://kaiber.ai/)&nbsp; &nbsp;[![InstaSD](https://f.latent.vision/imgs/instasd.png)](https://www.instasd.com/)
+
+### :tada: Silver sponsors
+
+[![OperArt.ai](https://f.latent.vision/imgs/openart.png?r=1)](https://openart.ai/workflows)&nbsp; &nbsp;[![Finetuners](https://f.latent.vision/imgs/finetuners.png)](https://www.finetuners.ai/)&nbsp; &nbsp;[![Comfy.ICU](https://f.latent.vision/imgs/comfyicu.png?r=1)](https://comfy.icu/)
+
+### Other companies supporting my projects
+
+- [RunComfy](https://www.runcomfy.com/) (ComfyUI Cloud)
+
+### Esteemed individuals
+
+- [Øystein Ø. Olsen](https://github.com/FireNeslo)
+- [Jack Gane](https://github.com/ganeJackS)
+- [Nathan Shipley](https://www.nathanshipley.com/)
+- [Dkdnzia](https://github.com/Dkdnzia)
+
+[And all my public and private sponsors!](https://github.com/sponsors/cubiq)

ComfyUI_essentials/__init__.py

@@ -0,0 +1,36 @@
+#from .essentials import NODE_CLASS_MAPPINGS, NODE_DISPLAY_NAME_MAPPINGS
+from .image import IMAGE_CLASS_MAPPINGS, IMAGE_NAME_MAPPINGS
+from .mask import MASK_CLASS_MAPPINGS, MASK_NAME_MAPPINGS
+from .sampling import SAMPLING_CLASS_MAPPINGS, SAMPLING_NAME_MAPPINGS
+from .segmentation import SEG_CLASS_MAPPINGS, SEG_NAME_MAPPINGS
+from .misc import MISC_CLASS_MAPPINGS, MISC_NAME_MAPPINGS
+from .conditioning import COND_CLASS_MAPPINGS, COND_NAME_MAPPINGS
+from .text import TEXT_CLASS_MAPPINGS, TEXT_NAME_MAPPINGS
+
+WEB_DIRECTORY = "./js"
+
+NODE_CLASS_MAPPINGS = {}
+NODE_DISPLAY_NAME_MAPPINGS = {}
+
+NODE_CLASS_MAPPINGS.update(COND_CLASS_MAPPINGS)
+NODE_DISPLAY_NAME_MAPPINGS.update(COND_NAME_MAPPINGS)
+
+NODE_CLASS_MAPPINGS.update(IMAGE_CLASS_MAPPINGS)
+NODE_DISPLAY_NAME_MAPPINGS.update(IMAGE_NAME_MAPPINGS)
+
+NODE_CLASS_MAPPINGS.update(MASK_CLASS_MAPPINGS)
+NODE_DISPLAY_NAME_MAPPINGS.update(MASK_NAME_MAPPINGS)
+
+NODE_CLASS_MAPPINGS.update(SAMPLING_CLASS_MAPPINGS)
+NODE_DISPLAY_NAME_MAPPINGS.update(SAMPLING_NAME_MAPPINGS)
+
+NODE_CLASS_MAPPINGS.update(SEG_CLASS_MAPPINGS)
+NODE_DISPLAY_NAME_MAPPINGS.update(SEG_NAME_MAPPINGS)
+
+NODE_CLASS_MAPPINGS.update(TEXT_CLASS_MAPPINGS)
+NODE_DISPLAY_NAME_MAPPINGS.update(TEXT_NAME_MAPPINGS)
+
+NODE_CLASS_MAPPINGS.update(MISC_CLASS_MAPPINGS)
+NODE_DISPLAY_NAME_MAPPINGS.update(MISC_NAME_MAPPINGS)
+
+__all__ = ['NODE_CLASS_MAPPINGS', 'NODE_DISPLAY_NAME_MAPPINGS', "WEB_DIRECTORY"]

ComfyUI_essentials/carve.py

@@ -0,0 +1,454 @@
+# MIT licensed code from https://github.com/li-plus/seam-carving/
+
+from enum import Enum
+from typing import Optional, Tuple
+
+import numba as nb
+import numpy as np
+from scipy.ndimage import sobel
+
+DROP_MASK_ENERGY = 1e5
+KEEP_MASK_ENERGY = 1e3
+
+
+class OrderMode(str, Enum):
+    WIDTH_FIRST = "width-first"
+    HEIGHT_FIRST = "height-first"
+
+
+class EnergyMode(str, Enum):
+    FORWARD = "forward"
+    BACKWARD = "backward"
+
+
+def _list_enum(enum_class) -> Tuple:
+    return tuple(x.value for x in enum_class)
+
+
+def _rgb2gray(rgb: np.ndarray) -> np.ndarray:
+    """Convert an RGB image to a grayscale image"""
+    coeffs = np.array([0.2125, 0.7154, 0.0721], dtype=np.float32)
+    return (rgb @ coeffs).astype(rgb.dtype)
+
+
+def _get_seam_mask(src: np.ndarray, seam: np.ndarray) -> np.ndarray:
+    """Convert a list of seam column indices to a mask"""
+    return np.eye(src.shape[1], dtype=bool)[seam]
+
+
+def _remove_seam_mask(src: np.ndarray, seam_mask: np.ndarray) -> np.ndarray:
+    """Remove a seam from the source image according to the given seam_mask"""
+    if src.ndim == 3:
+        h, w, c = src.shape
+        seam_mask = np.broadcast_to(seam_mask[:, :, None], src.shape)
+        dst = src[~seam_mask].reshape((h, w - 1, c))
+    else:
+        h, w = src.shape
+        dst = src[~seam_mask].reshape((h, w - 1))
+    return dst
+
+
+def _get_energy(gray: np.ndarray) -> np.ndarray:
+    """Get backward energy map from the source image"""
+    assert gray.ndim == 2
+
+    gray = gray.astype(np.float32)
+    grad_x = sobel(gray, axis=1)
+    grad_y = sobel(gray, axis=0)
+    energy = np.abs(grad_x) + np.abs(grad_y)
+    return energy
+
+
+@nb.njit(nb.int32[:](nb.float32[:, :]), cache=True)
+def _get_backward_seam(energy: np.ndarray) -> np.ndarray:
+    """Compute the minimum vertical seam from the backward energy map"""
+    h, w = energy.shape
+    inf = np.array([np.inf], dtype=np.float32)
+    cost = np.concatenate((inf, energy[0], inf))
+    parent = np.empty((h, w), dtype=np.int32)
+    base_idx = np.arange(-1, w - 1, dtype=np.int32)
+
+    for r in range(1, h):
+        choices = np.vstack((cost[:-2], cost[1:-1], cost[2:]))
+        min_idx = np.argmin(choices, axis=0) + base_idx
+        parent[r] = min_idx
+        cost[1:-1] = cost[1:-1][min_idx] + energy[r]
+
+    c = np.argmin(cost[1:-1])
+    seam = np.empty(h, dtype=np.int32)
+    for r in range(h - 1, -1, -1):
+        seam[r] = c
+        c = parent[r, c]
+
+    return seam
+
+
+def _get_backward_seams(
+    gray: np.ndarray, num_seams: int, aux_energy: Optional[np.ndarray]
+) -> np.ndarray:
+    """Compute the minimum N vertical seams using backward energy"""
+    h, w = gray.shape
+    seams = np.zeros((h, w), dtype=bool)
+    rows = np.arange(h, dtype=np.int32)
+    idx_map = np.broadcast_to(np.arange(w, dtype=np.int32), (h, w))
+    energy = _get_energy(gray)
+    if aux_energy is not None:
+        energy += aux_energy
+    for _ in range(num_seams):
+        seam = _get_backward_seam(energy)
+        seams[rows, idx_map[rows, seam]] = True
+
+        seam_mask = _get_seam_mask(gray, seam)
+        gray = _remove_seam_mask(gray, seam_mask)
+        idx_map = _remove_seam_mask(idx_map, seam_mask)
+        if aux_energy is not None:
+            aux_energy = _remove_seam_mask(aux_energy, seam_mask)
+
+        # Only need to re-compute the energy in the bounding box of the seam
+        _, cur_w = energy.shape
+        lo = max(0, np.min(seam) - 1)
+        hi = min(cur_w, np.max(seam) + 1)
+        pad_lo = 1 if lo > 0 else 0
+        pad_hi = 1 if hi < cur_w - 1 else 0
+        mid_block = gray[:, lo - pad_lo : hi + pad_hi]
+        _, mid_w = mid_block.shape
+        mid_energy = _get_energy(mid_block)[:, pad_lo : mid_w - pad_hi]
+        if aux_energy is not None:
+            mid_energy += aux_energy[:, lo:hi]
+        energy = np.hstack((energy[:, :lo], mid_energy, energy[:, hi + 1 :]))
+
+    return seams
+
+
+@nb.njit(
+    [
+        nb.int32[:](nb.float32[:, :], nb.none),
+        nb.int32[:](nb.float32[:, :], nb.float32[:, :]),
+    ],
+    cache=True,
+)
+def _get_forward_seam(gray: np.ndarray, aux_energy: Optional[np.ndarray]) -> np.ndarray:
+    """Compute the minimum vertical seam using forward energy"""
+    h, w = gray.shape
+
+    gray = np.hstack((gray[:, :1], gray, gray[:, -1:]))
+
+    inf = np.array([np.inf], dtype=np.float32)
+    dp = np.concatenate((inf, np.abs(gray[0, 2:] - gray[0, :-2]), inf))
+
+    parent = np.empty((h, w), dtype=np.int32)
+    base_idx = np.arange(-1, w - 1, dtype=np.int32)
+
+    inf = np.array([np.inf], dtype=np.float32)
+    for r in range(1, h):
+        curr_shl = gray[r, 2:]
+        curr_shr = gray[r, :-2]
+        cost_mid = np.abs(curr_shl - curr_shr)
+        if aux_energy is not None:
+            cost_mid += aux_energy[r]
+
+        prev_mid = gray[r - 1, 1:-1]
+        cost_left = cost_mid + np.abs(prev_mid - curr_shr)
+        cost_right = cost_mid + np.abs(prev_mid - curr_shl)
+
+        dp_mid = dp[1:-1]
+        dp_left = dp[:-2]
+        dp_right = dp[2:]
+
+        choices = np.vstack(
+            (cost_left + dp_left, cost_mid + dp_mid, cost_right + dp_right)
+        )
+        min_idx = np.argmin(choices, axis=0)
+        parent[r] = min_idx + base_idx
+        # numba does not support specifying axis in np.min, below loop is equivalent to:
+        # `dp_mid[:] = np.min(choices, axis=0)` or `dp_mid[:] = choices[min_idx, np.arange(w)]`
+        for j, i in enumerate(min_idx):
+            dp_mid[j] = choices[i, j]
+
+    c = np.argmin(dp[1:-1])
+    seam = np.empty(h, dtype=np.int32)
+    for r in range(h - 1, -1, -1):
+        seam[r] = c
+        c = parent[r, c]
+
+    return seam
+
+
+def _get_forward_seams(
+    gray: np.ndarray, num_seams: int, aux_energy: Optional[np.ndarray]
+) -> np.ndarray:
+    """Compute minimum N vertical seams using forward energy"""
+    h, w = gray.shape
+    seams = np.zeros((h, w), dtype=bool)
+    rows = np.arange(h, dtype=np.int32)
+    idx_map = np.broadcast_to(np.arange(w, dtype=np.int32), (h, w))
+    for _ in range(num_seams):
+        seam = _get_forward_seam(gray, aux_energy)
+        seams[rows, idx_map[rows, seam]] = True
+        seam_mask = _get_seam_mask(gray, seam)
+        gray = _remove_seam_mask(gray, seam_mask)
+        idx_map = _remove_seam_mask(idx_map, seam_mask)
+        if aux_energy is not None:
+            aux_energy = _remove_seam_mask(aux_energy, seam_mask)
+
+    return seams
+
+
+def _get_seams(
+    gray: np.ndarray, num_seams: int, energy_mode: str, aux_energy: Optional[np.ndarray]
+) -> np.ndarray:
+    """Get the minimum N seams from the grayscale image"""
+    gray = np.asarray(gray, dtype=np.float32)
+    if energy_mode == EnergyMode.BACKWARD:
+        return _get_backward_seams(gray, num_seams, aux_energy)
+    elif energy_mode == EnergyMode.FORWARD:
+        return _get_forward_seams(gray, num_seams, aux_energy)
+    else:
+        raise ValueError(
+            f"expect energy_mode to be one of {_list_enum(EnergyMode)}, got {energy_mode}"
+        )
+
+
+def _reduce_width(
+    src: np.ndarray,
+    delta_width: int,
+    energy_mode: str,
+    aux_energy: Optional[np.ndarray],
+) -> Tuple[np.ndarray, Optional[np.ndarray]]:
+    """Reduce the width of image by delta_width pixels"""
+    assert src.ndim in (2, 3) and delta_width >= 0
+    if src.ndim == 2:
+        gray = src
+        src_h, src_w = src.shape
+        dst_shape: Tuple[int, ...] = (src_h, src_w - delta_width)
+    else:
+        gray = _rgb2gray(src)
+        src_h, src_w, src_c = src.shape
+        dst_shape = (src_h, src_w - delta_width, src_c)
+
+    to_keep = ~_get_seams(gray, delta_width, energy_mode, aux_energy)
+    dst = src[to_keep].reshape(dst_shape)
+    if aux_energy is not None:
+        aux_energy = aux_energy[to_keep].reshape(dst_shape[:2])
+    return dst, aux_energy
+
+
+@nb.njit(
+    nb.float32[:, :, :](nb.float32[:, :, :], nb.boolean[:, :], nb.int32), cache=True
+)
+def _insert_seams_kernel(
+    src: np.ndarray, seams: np.ndarray, delta_width: int
+) -> np.ndarray:
+    """The numba kernel for inserting seams"""
+    src_h, src_w, src_c = src.shape
+    dst = np.empty((src_h, src_w + delta_width, src_c), dtype=src.dtype)
+    for row in range(src_h):
+        dst_col = 0
+        for src_col in range(src_w):
+            if seams[row, src_col]:
+                left = src[row, max(src_col - 1, 0)]
+                right = src[row, src_col]
+                dst[row, dst_col] = (left + right) / 2
+                dst_col += 1
+            dst[row, dst_col] = src[row, src_col]
+            dst_col += 1
+    return dst
+
+
+def _insert_seams(src: np.ndarray, seams: np.ndarray, delta_width: int) -> np.ndarray:
+    """Insert multiple seams into the source image"""
+    dst = src.astype(np.float32)
+    if dst.ndim == 2:
+        dst = dst[:, :, None]
+    dst = _insert_seams_kernel(dst, seams, delta_width).astype(src.dtype)
+    if src.ndim == 2:
+        dst = dst.squeeze(-1)
+    return dst
+
+
+def _expand_width(
+    src: np.ndarray,
+    delta_width: int,
+    energy_mode: str,
+    aux_energy: Optional[np.ndarray],
+    step_ratio: float,
+) -> Tuple[np.ndarray, Optional[np.ndarray]]:
+    """Expand the width of image by delta_width pixels"""
+    assert src.ndim in (2, 3) and delta_width >= 0
+    if not 0 < step_ratio <= 1:
+        raise ValueError(f"expect `step_ratio` to be between (0,1], got {step_ratio}")
+
+    dst = src
+    while delta_width > 0:
+        max_step_size = max(1, round(step_ratio * dst.shape[1]))
+        step_size = min(max_step_size, delta_width)
+        gray = dst if dst.ndim == 2 else _rgb2gray(dst)
+        seams = _get_seams(gray, step_size, energy_mode, aux_energy)
+        dst = _insert_seams(dst, seams, step_size)
+        if aux_energy is not None:
+            aux_energy = _insert_seams(aux_energy, seams, step_size)
+        delta_width -= step_size
+
+    return dst, aux_energy
+
+
+def _resize_width(
+    src: np.ndarray,
+    width: int,
+    energy_mode: str,
+    aux_energy: Optional[np.ndarray],
+    step_ratio: float,
+) -> Tuple[np.ndarray, Optional[np.ndarray]]:
+    """Resize the width of image by removing vertical seams"""
+    assert src.size > 0 and src.ndim in (2, 3)
+    assert width > 0
+
+    src_w = src.shape[1]
+    if src_w < width:
+        dst, aux_energy = _expand_width(
+            src, width - src_w, energy_mode, aux_energy, step_ratio
+        )
+    else:
+        dst, aux_energy = _reduce_width(src, src_w - width, energy_mode, aux_energy)
+    return dst, aux_energy
+
+
+def _transpose_image(src: np.ndarray) -> np.ndarray:
+    """Transpose a source image in rgb or grayscale format"""
+    if src.ndim == 3:
+        dst = src.transpose((1, 0, 2))
+    else:
+        dst = src.T
+    return dst
+
+
+def _resize_height(
+    src: np.ndarray,
+    height: int,
+    energy_mode: str,
+    aux_energy: Optional[np.ndarray],
+    step_ratio: float,
+) -> Tuple[np.ndarray, Optional[np.ndarray]]:
+    """Resize the height of image by removing horizontal seams"""
+    assert src.ndim in (2, 3) and height > 0
+    if aux_energy is not None:
+        aux_energy = aux_energy.T
+    src = _transpose_image(src)
+    src, aux_energy = _resize_width(src, height, energy_mode, aux_energy, step_ratio)
+    src = _transpose_image(src)
+    if aux_energy is not None:
+        aux_energy = aux_energy.T
+    return src, aux_energy
+
+
+def _check_mask(mask: np.ndarray, shape: Tuple[int, ...]) -> np.ndarray:
+    """Ensure the mask to be a 2D grayscale map of specific shape"""
+    mask = np.asarray(mask, dtype=bool)
+    if mask.ndim != 2:
+        raise ValueError(f"expect mask to be a 2d binary map, got shape {mask.shape}")
+    if mask.shape != shape:
+        raise ValueError(
+            f"expect the shape of mask to match the image, got {mask.shape} vs {shape}"
+        )
+    return mask
+
+
+def _check_src(src: np.ndarray) -> np.ndarray:
+    """Ensure the source to be RGB or grayscale"""
+    src = np.asarray(src)
+    if src.size == 0 or src.ndim not in (2, 3):
+        raise ValueError(
+            f"expect a 3d rgb image or a 2d grayscale image, got image in shape {src.shape}"
+        )
+    return src
+
+
+def seam_carving(
+    src: np.ndarray,
+    size: Optional[Tuple[int, int]] = None,
+    energy_mode: str = "backward",
+    order: str = "width-first",
+    keep_mask: Optional[np.ndarray] = None,
+    drop_mask: Optional[np.ndarray] = None,
+    step_ratio: float = 0.5,
+) -> np.ndarray:
+    """Resize the image using the content-aware seam-carving algorithm.
+
+    :param src: A source image in RGB or grayscale format.
+    :param size: The target size in pixels, as a 2-tuple (width, height).
+    :param energy_mode: Policy to compute energy for the source image. Could be
+        one of ``backward`` or ``forward``. If ``backward``, compute the energy
+        as the gradient at each pixel. If ``forward``, compute the energy as the
+        distances between adjacent pixels after each pixel is removed.
+    :param order: The order to remove horizontal and vertical seams. Could be
+        one of ``width-first`` or ``height-first``. In ``width-first`` mode, we
+        remove or insert all vertical seams first, then the horizontal ones,
+        while ``height-first`` is the opposite.
+    :param keep_mask: An optional mask where the foreground is protected from
+        seam removal. If not specified, no area will be protected.
+    :param drop_mask: An optional binary object mask to remove. If given, the
+        object will be removed before resizing the image to the target size.
+    :param step_ratio: The maximum size expansion ratio in one seam carving step.
+        The image will be expanded in multiple steps if target size is too large.
+    :return: A resized copy of the source image.
+    """
+    src = _check_src(src)
+
+    if order not in _list_enum(OrderMode):
+        raise ValueError(
+            f"expect order to be one of {_list_enum(OrderMode)}, got {order}"
+        )
+
+    aux_energy = None
+
+    if keep_mask is not None:
+        keep_mask = _check_mask(keep_mask, src.shape[:2])
+
+        aux_energy = np.zeros(src.shape[:2], dtype=np.float32)
+        aux_energy[keep_mask] += KEEP_MASK_ENERGY
+
+    # remove object if `drop_mask` is given
+    if drop_mask is not None:
+        drop_mask = _check_mask(drop_mask, src.shape[:2])
+
+        if aux_energy is None:
+            aux_energy = np.zeros(src.shape[:2], dtype=np.float32)
+        aux_energy[drop_mask] -= DROP_MASK_ENERGY
+
+        if order == OrderMode.HEIGHT_FIRST:
+            src = _transpose_image(src)
+            aux_energy = aux_energy.T
+
+        num_seams = (aux_energy < 0).sum(1).max()
+        while num_seams > 0:
+            src, aux_energy = _reduce_width(src, num_seams, energy_mode, aux_energy)
+            num_seams = (aux_energy < 0).sum(1).max()
+
+        if order == OrderMode.HEIGHT_FIRST:
+            src = _transpose_image(src)
+            aux_energy = aux_energy.T
+
+    # resize image if `size` is given
+    if size is not None:
+        width, height = size
+        width = round(width)
+        height = round(height)
+        if width <= 0 or height <= 0:
+            raise ValueError(f"expect target size to be positive, got {size}")
+
+        if order == OrderMode.WIDTH_FIRST:
+            src, aux_energy = _resize_width(
+                src, width, energy_mode, aux_energy, step_ratio
+            )
+            src, aux_energy = _resize_height(
+                src, height, energy_mode, aux_energy, step_ratio
+            )
+        else:
+            src, aux_energy = _resize_height(
+                src, height, energy_mode, aux_energy, step_ratio
+            )
+            src, aux_energy = _resize_width(
+                src, width, energy_mode, aux_energy, step_ratio
+            )
+
+    return src

ComfyUI_essentials/conditioning.py

@@ -0,0 +1,280 @@
+from nodes import MAX_RESOLUTION, ConditioningZeroOut, ConditioningSetTimestepRange, ConditioningCombine
+import re
+
+class CLIPTextEncodeSDXLSimplified:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+            "width": ("INT", {"default": 1024.0, "min": 0, "max": MAX_RESOLUTION}),
+            "height": ("INT", {"default": 1024.0, "min": 0, "max": MAX_RESOLUTION}),
+            "size_cond_factor": ("INT", {"default": 4, "min": 1, "max": 16 }),
+            "text": ("STRING", {"multiline": True, "dynamicPrompts": True, "default": ""}),
+            "clip": ("CLIP", ),
+            }}
+    RETURN_TYPES = ("CONDITIONING",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/conditioning"
+
+    def execute(self, clip, width, height, size_cond_factor, text):
+        crop_w = 0
+        crop_h = 0
+        width = width*size_cond_factor
+        height = height*size_cond_factor
+        target_width = width
+        target_height = height
+        text_g = text_l = text
+
+        tokens = clip.tokenize(text_g)
+        tokens["l"] = clip.tokenize(text_l)["l"]
+        if len(tokens["l"]) != len(tokens["g"]):
+            empty = clip.tokenize("")
+            while len(tokens["l"]) < len(tokens["g"]):
+                tokens["l"] += empty["l"]
+            while len(tokens["l"]) > len(tokens["g"]):
+                tokens["g"] += empty["g"]
+        cond, pooled = clip.encode_from_tokens(tokens, return_pooled=True)
+        return ([[cond, {"pooled_output": pooled, "width": width, "height": height, "crop_w": crop_w, "crop_h": crop_h, "target_width": target_width, "target_height": target_height}]], )
+
+class ConditioningCombineMultiple:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "conditioning_1": ("CONDITIONING",),
+                "conditioning_2": ("CONDITIONING",),
+            }, "optional": {
+                "conditioning_3": ("CONDITIONING",),
+                "conditioning_4": ("CONDITIONING",),
+                "conditioning_5": ("CONDITIONING",),
+            },
+        }
+    RETURN_TYPES = ("CONDITIONING",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/conditioning"
+
+    def execute(self, conditioning_1, conditioning_2, conditioning_3=None, conditioning_4=None, conditioning_5=None):
+        c = conditioning_1 + conditioning_2
+
+        if conditioning_3 is not None:
+            c += conditioning_3
+        if conditioning_4 is not None:
+            c += conditioning_4
+        if conditioning_5 is not None:
+            c += conditioning_5
+
+        return (c,)
+
+class SD3NegativeConditioning:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+            "conditioning": ("CONDITIONING",),
+            "end": ("FLOAT", {"default": 0.1, "min": 0.0, "max": 1.0, "step": 0.001 }),
+        }}
+    RETURN_TYPES = ("CONDITIONING",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/conditioning"
+
+    def execute(self, conditioning, end):
+        zero_c = ConditioningZeroOut().zero_out(conditioning)[0]
+
+        if end == 0:
+            return (zero_c, )
+
+        c = ConditioningSetTimestepRange().set_range(conditioning, 0, end)[0]
+        zero_c = ConditioningSetTimestepRange().set_range(zero_c, end, 1.0)[0]
+        c = ConditioningCombine().combine(zero_c, c)[0]
+
+        return (c, )
+
+class FluxAttentionSeeker:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+            "clip": ("CLIP",),
+            "apply_to_query": ("BOOLEAN", { "default": True }),
+            "apply_to_key": ("BOOLEAN", { "default": True }),
+            "apply_to_value": ("BOOLEAN", { "default": True }),
+            "apply_to_out": ("BOOLEAN", { "default": True }),
+            **{f"clip_l_{s}": ("FLOAT", { "display": "slider", "default": 1.0, "min": 0, "max": 5, "step": 0.05 }) for s in range(12)},
+            **{f"t5xxl_{s}": ("FLOAT", { "display": "slider", "default": 1.0, "min": 0, "max": 5, "step": 0.05 }) for s in range(24)},
+        }}
+
+    RETURN_TYPES = ("CLIP",)
+    FUNCTION = "execute"
+
+    CATEGORY = "essentials/conditioning"
+
+    def execute(self, clip, apply_to_query, apply_to_key, apply_to_value, apply_to_out, **values):
+        if not apply_to_key and not apply_to_query and not apply_to_value and not apply_to_out:
+            return (clip, )
+
+        m = clip.clone()
+        sd = m.patcher.model_state_dict()
+        
+        for k in sd:
+            if "self_attn" in k:
+                layer = re.search(r"\.layers\.(\d+)\.", k)
+                layer = int(layer.group(1)) if layer else None
+
+                if layer is not None and values[f"clip_l_{layer}"] != 1.0:
+                    if (apply_to_query and "q_proj" in k) or (apply_to_key and "k_proj" in k) or (apply_to_value and "v_proj" in k) or (apply_to_out and "out_proj" in k):
+                        m.add_patches({k: (None,)}, 0.0, values[f"clip_l_{layer}"])
+            elif "SelfAttention" in k:
+                block = re.search(r"\.block\.(\d+)\.", k)
+                block = int(block.group(1)) if block else None
+
+                if block is not None and values[f"t5xxl_{block}"] != 1.0:
+                    if (apply_to_query and ".q." in k) or (apply_to_key and ".k." in k) or (apply_to_value and ".v." in k) or (apply_to_out and ".o." in k):
+                        m.add_patches({k: (None,)}, 0.0, values[f"t5xxl_{block}"])
+
+        return (m, )
+
+class SD3AttentionSeekerLG:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+            "clip": ("CLIP",),
+            "apply_to_query": ("BOOLEAN", { "default": True }),
+            "apply_to_key": ("BOOLEAN", { "default": True }),
+            "apply_to_value": ("BOOLEAN", { "default": True }),
+            "apply_to_out": ("BOOLEAN", { "default": True }),
+            **{f"clip_l_{s}": ("FLOAT", { "display": "slider", "default": 1.0, "min": 0, "max": 5, "step": 0.05 }) for s in range(12)},
+            **{f"clip_g_{s}": ("FLOAT", { "display": "slider", "default": 1.0, "min": 0, "max": 5, "step": 0.05 }) for s in range(32)},
+        }}
+
+    RETURN_TYPES = ("CLIP",)
+    FUNCTION = "execute"
+
+    CATEGORY = "essentials/conditioning"
+
+    def execute(self, clip, apply_to_query, apply_to_key, apply_to_value, apply_to_out, **values):
+        if not apply_to_key and not apply_to_query and not apply_to_value and not apply_to_out:
+            return (clip, )
+
+        m = clip.clone()
+        sd = m.patcher.model_state_dict()
+        
+        for k in sd:
+            if "self_attn" in k:
+                layer = re.search(r"\.layers\.(\d+)\.", k)
+                layer = int(layer.group(1)) if layer else None
+
+                if layer is not None:
+                    if "clip_l" in k and values[f"clip_l_{layer}"] != 1.0:
+                        if (apply_to_query and "q_proj" in k) or (apply_to_key and "k_proj" in k) or (apply_to_value and "v_proj" in k) or (apply_to_out and "out_proj" in k):
+                            m.add_patches({k: (None,)}, 0.0, values[f"clip_l_{layer}"])
+                    elif "clip_g" in k and values[f"clip_g_{layer}"] != 1.0:
+                        if (apply_to_query and "q_proj" in k) or (apply_to_key and "k_proj" in k) or (apply_to_value and "v_proj" in k) or (apply_to_out and "out_proj" in k):
+                            m.add_patches({k: (None,)}, 0.0, values[f"clip_g_{layer}"])
+
+        return (m, )
+
+class SD3AttentionSeekerT5:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+            "clip": ("CLIP",),
+            "apply_to_query": ("BOOLEAN", { "default": True }),
+            "apply_to_key": ("BOOLEAN", { "default": True }),
+            "apply_to_value": ("BOOLEAN", { "default": True }),
+            "apply_to_out": ("BOOLEAN", { "default": True }),
+            **{f"t5xxl_{s}": ("FLOAT", { "display": "slider", "default": 1.0, "min": 0, "max": 5, "step": 0.05 }) for s in range(24)},
+        }}
+
+    RETURN_TYPES = ("CLIP",)
+    FUNCTION = "execute"
+
+    CATEGORY = "essentials/conditioning"
+
+    def execute(self, clip, apply_to_query, apply_to_key, apply_to_value, apply_to_out, **values):
+        if not apply_to_key and not apply_to_query and not apply_to_value and not apply_to_out:
+            return (clip, )
+
+        m = clip.clone()
+        sd = m.patcher.model_state_dict()
+        
+        for k in sd:
+            if "SelfAttention" in k:
+                block = re.search(r"\.block\.(\d+)\.", k)
+                block = int(block.group(1)) if block else None
+
+                if block is not None and values[f"t5xxl_{block}"] != 1.0:
+                    if (apply_to_query and ".q." in k) or (apply_to_key and ".k." in k) or (apply_to_value and ".v." in k) or (apply_to_out and ".o." in k):
+                        m.add_patches({k: (None,)}, 0.0, values[f"t5xxl_{block}"])
+
+        return (m, )
+
+class FluxBlocksBuster:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+            "model": ("MODEL",),
+            "blocks": ("STRING", {"default": "## 0 = 1.0\n## 1 = 1.0\n## 2 = 1.0\n## 3 = 1.0\n## 4 = 1.0\n## 5 = 1.0\n## 6 = 1.0\n## 7 = 1.0\n## 8 = 1.0\n## 9 = 1.0\n## 10 = 1.0\n## 11 = 1.0\n## 12 = 1.0\n## 13 = 1.0\n## 14 = 1.0\n## 15 = 1.0\n## 16 = 1.0\n## 17 = 1.0\n## 18 = 1.0\n# 0 = 1.0\n# 1 = 1.0\n# 2 = 1.0\n# 3 = 1.0\n# 4 = 1.0\n# 5 = 1.0\n# 6 = 1.0\n# 7 = 1.0\n# 8 = 1.0\n# 9 = 1.0\n# 10 = 1.0\n# 11 = 1.0\n# 12 = 1.0\n# 13 = 1.0\n# 14 = 1.0\n# 15 = 1.0\n# 16 = 1.0\n# 17 = 1.0\n# 18 = 1.0\n# 19 = 1.0\n# 20 = 1.0\n# 21 = 1.0\n# 22 = 1.0\n# 23 = 1.0\n# 24 = 1.0\n# 25 = 1.0\n# 26 = 1.0\n# 27 = 1.0\n# 28 = 1.0\n# 29 = 1.0\n# 30 = 1.0\n# 31 = 1.0\n# 32 = 1.0\n# 33 = 1.0\n# 34 = 1.0\n# 35 = 1.0\n# 36 = 1.0\n# 37 = 1.0", "multiline": True, "dynamicPrompts": True}),
+            #**{f"double_block_{s}": ("FLOAT", { "display": "slider", "default": 1.0, "min": 0, "max": 5, "step": 0.05 }) for s in range(19)},
+            #**{f"single_block_{s}": ("FLOAT", { "display": "slider", "default": 1.0, "min": 0, "max": 5, "step": 0.05 }) for s in range(38)},
+        }}
+    RETURN_TYPES = ("MODEL", "STRING")
+    RETURN_NAMES = ("MODEL", "patched_blocks")
+    FUNCTION = "patch"
+
+    CATEGORY = "essentials/conditioning"
+
+    def patch(self, model, blocks):
+        if blocks == "":
+            return (model, )
+
+        m = model.clone()
+        sd = model.model_state_dict()
+        patched_blocks = []
+
+        """
+        Also compatible with the following format:
+
+        double_blocks\.0\.(img|txt)_(mod|attn|mlp)\.(lin|qkv|proj|0|2)\.(weight|bias)=1.1
+        single_blocks\.0\.(linear[12]|modulation\.lin)\.(weight|bias)=1.1
+
+        The regex is used to match the block names
+        """
+
+        blocks = blocks.split("\n")
+        blocks = [b.strip() for b in blocks if b.strip()]
+
+        for k in sd:
+            for block in blocks:
+                block = block.split("=")
+                value = float(block[1].strip()) if len(block) > 1 else 1.0
+                block = block[0].strip()
+                if block.startswith("##"):
+                    block = r"double_blocks\." + block[2:].strip() + r"\.(img|txt)_(mod|attn|mlp)\.(lin|qkv|proj|0|2)\.(weight|bias)"
+                elif block.startswith("#"):
+                    block = r"single_blocks\." + block[1:].strip() + r"\.(linear[12]|modulation\.lin)\.(weight|bias)"
+
+                if value != 1.0 and re.search(block, k):
+                    m.add_patches({k: (None,)}, 0.0, value)
+                    patched_blocks.append(f"{k}: {value}")
+
+        patched_blocks = "\n".join(patched_blocks)
+
+        return (m, patched_blocks,)
+
+
+COND_CLASS_MAPPINGS = {
+    "CLIPTextEncodeSDXL+": CLIPTextEncodeSDXLSimplified,
+    "ConditioningCombineMultiple+": ConditioningCombineMultiple,
+    "SD3NegativeConditioning+": SD3NegativeConditioning,
+    "FluxAttentionSeeker+": FluxAttentionSeeker,
+    "SD3AttentionSeekerLG+": SD3AttentionSeekerLG,
+    "SD3AttentionSeekerT5+": SD3AttentionSeekerT5,
+    "FluxBlocksBuster+": FluxBlocksBuster,
+}
+
+COND_NAME_MAPPINGS = {
+    "CLIPTextEncodeSDXL+": "🔧 SDXL CLIPTextEncode",
+    "ConditioningCombineMultiple+": "🔧 Cond Combine Multiple",
+    "SD3NegativeConditioning+": "🔧 SD3 Negative Conditioning",
+    "FluxAttentionSeeker+": "🔧 Flux Attention Seeker",
+    "SD3AttentionSeekerLG+": "🔧 SD3 Attention Seeker L/G",
+    "SD3AttentionSeekerT5+": "🔧 SD3 Attention Seeker T5",
+    "FluxBlocksBuster+": "🔧 Flux Model Blocks Buster",
+}

ComfyUI_essentials/histogram_matching.py

@@ -0,0 +1,87 @@
+# from MIT licensed https://github.com/nemodleo/pytorch-histogram-matching
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+class Histogram_Matching(nn.Module):
+    def __init__(self, differentiable=False):
+        super(Histogram_Matching, self).__init__()
+        self.differentiable = differentiable
+
+    def forward(self, dst, ref):
+        # B C
+        B, C, H, W = dst.size()
+        # assertion
+        assert dst.device == ref.device
+        # [B*C 256]
+        hist_dst = self.cal_hist(dst)
+        hist_ref = self.cal_hist(ref)
+        # [B*C 256]
+        tables = self.cal_trans_batch(hist_dst, hist_ref)
+        # [B C H W]
+        rst = dst.clone()
+        for b in range(B):
+            for c in range(C):
+                rst[b,c] = tables[b*c, (dst[b,c] * 255).long()]
+        # [B C H W]
+        rst /= 255.
+        return rst
+
+    def cal_hist(self, img):
+        B, C, H, W = img.size()
+        # [B*C 256]
+        if self.differentiable: 
+            hists = self.soft_histc_batch(img * 255, bins=256, min=0, max=256, sigma=3*25)
+        else:
+            hists = torch.stack([torch.histc(img[b,c] * 255, bins=256, min=0, max=255) for b in range(B) for c in range(C)])
+        hists = hists.float()
+        hists = F.normalize(hists, p=1)
+        # BC 256
+        bc, n = hists.size()
+        # [B*C 256 256]
+        triu = torch.ones(bc, n, n, device=hists.device).triu()
+        # [B*C 256]
+        hists = torch.bmm(hists[:,None,:], triu)[:,0,:]
+        return hists
+
+    def soft_histc_batch(self, x, bins=256, min=0, max=256, sigma=3*25):
+        # B C H W
+        B, C, H, W = x.size()
+        # [B*C H*W]
+        x = x.view(B*C, -1)
+        # 1
+        delta = float(max - min) / float(bins)
+        # [256]
+        centers = float(min) + delta * (torch.arange(bins, device=x.device, dtype=torch.bfloat16) + 0.5)
+        # [B*C 1 H*W]
+        x = torch.unsqueeze(x, 1)
+        # [1 256 1]
+        centers = centers[None,:,None]
+        # [B*C 256 H*W]
+        x = x - centers
+        # [B*C 256 H*W]
+        x = x.type(torch.bfloat16)
+        # [B*C 256 H*W]
+        x = torch.sigmoid(sigma * (x + delta/2)) - torch.sigmoid(sigma * (x - delta/2))
+        # [B*C 256]
+        x = x.sum(dim=2)
+        # [B*C 256]
+        x = x.type(torch.float32)
+        # prevent oom
+        # torch.cuda.empty_cache()
+        return x
+
+    def cal_trans_batch(self, hist_dst, hist_ref):
+        # [B*C 256 256]
+        hist_dst = hist_dst[:,None,:].repeat(1,256,1)
+        # [B*C 256 256]
+        hist_ref = hist_ref[:,:,None].repeat(1,1,256)
+        # [B*C 256 256]
+        table = hist_dst - hist_ref
+        # [B*C 256 256]
+        table = torch.where(table>=0, 1., 0.)
+        # [B*C 256]
+        table = torch.sum(table, dim=1) - 1
+        # [B*C 256]
+        table = torch.clamp(table, min=0, max=255)
+        return table

ComfyUI_essentials/image.py

@@ -0,0 +1,1770 @@
+from .utils import max_, min_
+from nodes import MAX_RESOLUTION
+import comfy.utils
+from nodes import SaveImage
+from node_helpers import pillow
+from PIL import Image, ImageOps
+
+import kornia
+import torch
+import torch.nn.functional as F
+import torchvision.transforms.v2 as T
+
+#import warnings
+#warnings.filterwarnings('ignore', module="torchvision")
+import math
+import os
+import numpy as np
+import folder_paths
+from pathlib import Path
+import random
+
+"""
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    Image analysis
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+"""
+
+class ImageEnhanceDifference:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image1": ("IMAGE",),
+                "image2": ("IMAGE",),
+                "exponent": ("FLOAT", { "default": 0.75, "min": 0.00, "max": 1.00, "step": 0.05, }),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/image analysis"
+
+    def execute(self, image1, image2, exponent):
+        if image1.shape[1:] != image2.shape[1:]:
+            image2 = comfy.utils.common_upscale(image2.permute([0,3,1,2]), image1.shape[2], image1.shape[1], upscale_method='bicubic', crop='center').permute([0,2,3,1])
+
+        diff_image = image1 - image2
+        diff_image = torch.pow(diff_image, exponent)
+        diff_image = torch.clamp(diff_image, 0, 1)
+
+        return(diff_image,)
+
+"""
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    Batch tools
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+"""
+
+class ImageBatchMultiple:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image_1": ("IMAGE",),
+                "method": (["nearest-exact", "bilinear", "area", "bicubic", "lanczos"], { "default": "lanczos" }),
+            }, "optional": {
+                "image_2": ("IMAGE",),
+                "image_3": ("IMAGE",),
+                "image_4": ("IMAGE",),
+                "image_5": ("IMAGE",),
+            },
+        }
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/image batch"
+
+    def execute(self, image_1, method, image_2=None, image_3=None, image_4=None, image_5=None):
+        out = image_1
+
+        if image_2 is not None:
+            if image_1.shape[1:] != image_2.shape[1:]:
+                image_2 = comfy.utils.common_upscale(image_2.movedim(-1,1), image_1.shape[2], image_1.shape[1], method, "center").movedim(1,-1)
+            out = torch.cat((image_1, image_2), dim=0)
+        if image_3 is not None:
+            if image_1.shape[1:] != image_3.shape[1:]:
+                image_3 = comfy.utils.common_upscale(image_3.movedim(-1,1), image_1.shape[2], image_1.shape[1], method, "center").movedim(1,-1)
+            out = torch.cat((out, image_3), dim=0)
+        if image_4 is not None:
+            if image_1.shape[1:] != image_4.shape[1:]:
+                image_4 = comfy.utils.common_upscale(image_4.movedim(-1,1), image_1.shape[2], image_1.shape[1], method, "center").movedim(1,-1)
+            out = torch.cat((out, image_4), dim=0)
+        if image_5 is not None:
+            if image_1.shape[1:] != image_5.shape[1:]:
+                image_5 = comfy.utils.common_upscale(image_5.movedim(-1,1), image_1.shape[2], image_1.shape[1], method, "center").movedim(1,-1)
+            out = torch.cat((out, image_5), dim=0)
+
+        return (out,)
+
+
+class ImageExpandBatch:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "size": ("INT", { "default": 16, "min": 1, "step": 1, }),
+                "method": (["expand", "repeat all", "repeat first", "repeat last"],)
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/image batch"
+
+    def execute(self, image, size, method):
+        orig_size = image.shape[0]
+
+        if orig_size == size:
+            return (image,)
+
+        if size <= 1:
+            return (image[:size],)
+
+        if 'expand' in method:
+            out = torch.empty([size] + list(image.shape)[1:], dtype=image.dtype, device=image.device)
+            if size < orig_size:
+                scale = (orig_size - 1) / (size - 1)
+                for i in range(size):
+                    out[i] = image[min(round(i * scale), orig_size - 1)]
+            else:
+                scale = orig_size / size
+                for i in range(size):
+                    out[i] = image[min(math.floor((i + 0.5) * scale), orig_size - 1)]
+        elif 'all' in method:
+            out = image.repeat([math.ceil(size / image.shape[0])] + [1] * (len(image.shape) - 1))[:size]
+        elif 'first' in method:
+            if size < image.shape[0]:
+                out = image[:size]
+            else:
+                out = torch.cat([image[:1].repeat(size-image.shape[0], 1, 1, 1), image], dim=0)
+        elif 'last' in method:
+            if size < image.shape[0]:
+                out = image[:size]
+            else:
+                out = torch.cat((image, image[-1:].repeat((size-image.shape[0], 1, 1, 1))), dim=0)
+
+        return (out,)
+
+class ImageFromBatch:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE", ),
+                "start": ("INT", { "default": 0, "min": 0, "step": 1, }),
+                "length": ("INT", { "default": -1, "min": -1, "step": 1, }),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/image batch"
+
+    def execute(self, image, start, length):
+        if length<0:
+            length = image.shape[0]
+        start = min(start, image.shape[0]-1)
+        length = min(image.shape[0]-start, length)
+        return (image[start:start + length], )
+
+
+class ImageListToBatch:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+    INPUT_IS_LIST = True
+    CATEGORY = "essentials/image batch"
+
+    def execute(self, image):
+        shape = image[0].shape[1:3]
+        out = []
+
+        for i in range(len(image)):
+            img = image[i]
+            if image[i].shape[1:3] != shape:
+                img = comfy.utils.common_upscale(img.permute([0,3,1,2]), shape[1], shape[0], upscale_method='bicubic', crop='center').permute([0,2,3,1])
+            out.append(img)
+
+        out = torch.cat(out, dim=0)
+
+        return (out,)
+
+class ImageBatchToList:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    OUTPUT_IS_LIST = (True,)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/image batch"
+
+    def execute(self, image):
+        return ([image[i].unsqueeze(0) for i in range(image.shape[0])], )
+
+
+"""
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    Image manipulation
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+"""
+
+class ImageCompositeFromMaskBatch:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image_from": ("IMAGE", ),
+                "image_to": ("IMAGE", ),
+                "mask": ("MASK", )
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/image manipulation"
+
+    def execute(self, image_from, image_to, mask):
+        frames = mask.shape[0]
+
+        if image_from.shape[1] != image_to.shape[1] or image_from.shape[2] != image_to.shape[2]:
+            image_to = comfy.utils.common_upscale(image_to.permute([0,3,1,2]), image_from.shape[2], image_from.shape[1], upscale_method='bicubic', crop='center').permute([0,2,3,1])
+
+        if frames < image_from.shape[0]:
+            image_from = image_from[:frames]
+        elif frames > image_from.shape[0]:
+            image_from = torch.cat((image_from, image_from[-1].unsqueeze(0).repeat(frames-image_from.shape[0], 1, 1, 1)), dim=0)
+
+        mask = mask.unsqueeze(3).repeat(1, 1, 1, 3)
+
+        if image_from.shape[1] != mask.shape[1] or image_from.shape[2] != mask.shape[2]:
+            mask = comfy.utils.common_upscale(mask.permute([0,3,1,2]), image_from.shape[2], image_from.shape[1], upscale_method='bicubic', crop='center').permute([0,2,3,1])
+
+        out = mask * image_to + (1 - mask) * image_from
+
+        return (out, )
+
+class ImageComposite:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "destination": ("IMAGE",),
+                "source": ("IMAGE",),
+                "x": ("INT", { "default": 0, "min": -MAX_RESOLUTION, "max": MAX_RESOLUTION, "step": 1 }),
+                "y": ("INT", { "default": 0, "min": -MAX_RESOLUTION, "max": MAX_RESOLUTION, "step": 1 }),
+                "offset_x": ("INT", { "default": 0, "min": -MAX_RESOLUTION, "max": MAX_RESOLUTION, "step": 1 }),
+                "offset_y": ("INT", { "default": 0, "min": -MAX_RESOLUTION, "max": MAX_RESOLUTION, "step": 1 }),
+            },
+            "optional": {
+                "mask": ("MASK",),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/image manipulation"
+
+    def execute(self, destination, source, x, y, offset_x, offset_y, mask=None):
+        if mask is None:
+            mask = torch.ones_like(source)[:,:,:,0]
+        
+        mask = mask.unsqueeze(-1).repeat(1, 1, 1, 3)
+
+        if mask.shape[1:3] != source.shape[1:3]:
+            mask = F.interpolate(mask.permute([0, 3, 1, 2]), size=(source.shape[1], source.shape[2]), mode='bicubic')
+            mask = mask.permute([0, 2, 3, 1])
+        
+        if mask.shape[0] > source.shape[0]:
+            mask = mask[:source.shape[0]]
+        elif mask.shape[0] < source.shape[0]:
+            mask = torch.cat((mask, mask[-1:].repeat((source.shape[0]-mask.shape[0], 1, 1, 1))), dim=0)
+        
+        if destination.shape[0] > source.shape[0]:
+            destination = destination[:source.shape[0]]
+        elif destination.shape[0] < source.shape[0]:
+            destination = torch.cat((destination, destination[-1:].repeat((source.shape[0]-destination.shape[0], 1, 1, 1))), dim=0)
+        
+        if not isinstance(x, list):
+            x = [x]
+        if not isinstance(y, list):
+            y = [y]
+        
+        if len(x) < destination.shape[0]:
+            x = x + [x[-1]] * (destination.shape[0] - len(x))
+        if len(y) < destination.shape[0]:
+            y = y + [y[-1]] * (destination.shape[0] - len(y))
+        
+        x = [i + offset_x for i in x]
+        y = [i + offset_y for i in y]
+
+        output = []
+        for i in range(destination.shape[0]):
+            d = destination[i].clone()
+            s = source[i]
+            m = mask[i]
+
+            if x[i]+source.shape[2] > destination.shape[2]:
+                s = s[:, :, :destination.shape[2]-x[i], :]
+                m = m[:, :, :destination.shape[2]-x[i], :]
+            if y[i]+source.shape[1] > destination.shape[1]:
+                s = s[:, :destination.shape[1]-y[i], :, :]
+                m = m[:destination.shape[1]-y[i], :, :]
+            
+            #output.append(s * m + d[y[i]:y[i]+s.shape[0], x[i]:x[i]+s.shape[1], :] * (1 - m))
+            d[y[i]:y[i]+s.shape[0], x[i]:x[i]+s.shape[1], :] = s * m + d[y[i]:y[i]+s.shape[0], x[i]:x[i]+s.shape[1], :] * (1 - m)
+            output.append(d)
+        
+        output = torch.stack(output)
+
+        # apply the source to the destination at XY position using the mask
+        #for i in range(destination.shape[0]):
+        #    output[i, y[i]:y[i]+source.shape[1], x[i]:x[i]+source.shape[2], :] = source * mask + destination[i, y[i]:y[i]+source.shape[1], x[i]:x[i]+source.shape[2], :] * (1 - mask)
+
+        #for x_, y_ in zip(x, y):
+        #    output[:, y_:y_+source.shape[1], x_:x_+source.shape[2], :] = source * mask + destination[:, y_:y_+source.shape[1], x_:x_+source.shape[2], :] * (1 - mask)
+
+        #output[:, y:y+source.shape[1], x:x+source.shape[2], :] = source * mask + destination[:, y:y+source.shape[1], x:x+source.shape[2], :] * (1 - mask)
+        #output = destination * (1 - mask) + source * mask
+
+        return (output,)
+
+class ImageResize:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "width": ("INT", { "default": 512, "min": 0, "max": MAX_RESOLUTION, "step": 1, }),
+                "height": ("INT", { "default": 512, "min": 0, "max": MAX_RESOLUTION, "step": 1, }),
+                "interpolation": (["nearest", "bilinear", "bicubic", "area", "nearest-exact", "lanczos"],),
+                "method": (["stretch", "keep proportion", "fill / crop", "pad"],),
+                "condition": (["always", "downscale if bigger", "upscale if smaller", "if bigger area", "if smaller area"],),
+                "multiple_of": ("INT", { "default": 0, "min": 0, "max": 512, "step": 1, }),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE", "INT", "INT",)
+    RETURN_NAMES = ("IMAGE", "width", "height",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/image manipulation"
+
+    def execute(self, image, width, height, method="stretch", interpolation="nearest", condition="always", multiple_of=0, keep_proportion=False):
+        _, oh, ow, _ = image.shape
+        x = y = x2 = y2 = 0
+        pad_left = pad_right = pad_top = pad_bottom = 0
+
+        if keep_proportion:
+            method = "keep proportion"
+
+        if multiple_of > 1:
+            width = width - (width % multiple_of)
+            height = height - (height % multiple_of)
+
+        if method == 'keep proportion' or method == 'pad':
+            if width == 0 and oh < height:
+                width = MAX_RESOLUTION
+            elif width == 0 and oh >= height:
+                width = ow
+
+            if height == 0 and ow < width:
+                height = MAX_RESOLUTION
+            elif height == 0 and ow >= width:
+                height = oh
+
+            ratio = min(width / ow, height / oh)
+            new_width = round(ow*ratio)
+            new_height = round(oh*ratio)
+
+            if method == 'pad':
+                pad_left = (width - new_width) // 2
+                pad_right = width - new_width - pad_left
+                pad_top = (height - new_height) // 2
+                pad_bottom = height - new_height - pad_top
+
+            width = new_width
+            height = new_height
+        elif method.startswith('fill'):
+            width = width if width > 0 else ow
+            height = height if height > 0 else oh
+
+            ratio = max(width / ow, height / oh)
+            new_width = round(ow*ratio)
+            new_height = round(oh*ratio)
+            x = (new_width - width) // 2
+            y = (new_height - height) // 2
+            x2 = x + width
+            y2 = y + height
+            if x2 > new_width:
+                x -= (x2 - new_width)
+            if x < 0:
+                x = 0
+            if y2 > new_height:
+                y -= (y2 - new_height)
+            if y < 0:
+                y = 0
+            width = new_width
+            height = new_height
+        else:
+            width = width if width > 0 else ow
+            height = height if height > 0 else oh
+
+        if "always" in condition \
+            or ("downscale if bigger" == condition and (oh > height or ow > width)) or ("upscale if smaller" == condition and (oh < height or ow < width)) \
+            or ("bigger area" in condition and (oh * ow > height * width)) or ("smaller area" in condition and (oh * ow < height * width)):
+
+            outputs = image.permute(0,3,1,2)
+
+            if interpolation == "lanczos":
+                outputs = comfy.utils.lanczos(outputs, width, height)
+            else:
+                outputs = F.interpolate(outputs, size=(height, width), mode=interpolation)
+
+            if method == 'pad':
+                if pad_left > 0 or pad_right > 0 or pad_top > 0 or pad_bottom > 0:
+                    outputs = F.pad(outputs, (pad_left, pad_right, pad_top, pad_bottom), value=0)
+
+            outputs = outputs.permute(0,2,3,1)
+
+            if method.startswith('fill'):
+                if x > 0 or y > 0 or x2 > 0 or y2 > 0:
+                    outputs = outputs[:, y:y2, x:x2, :]
+        else:
+            outputs = image
+
+        if multiple_of > 1 and (outputs.shape[2] % multiple_of != 0 or outputs.shape[1] % multiple_of != 0):
+            width = outputs.shape[2]
+            height = outputs.shape[1]
+            x = (width % multiple_of) // 2
+            y = (height % multiple_of) // 2
+            x2 = width - ((width % multiple_of) - x)
+            y2 = height - ((height % multiple_of) - y)
+            outputs = outputs[:, y:y2, x:x2, :]
+        
+        outputs = torch.clamp(outputs, 0, 1)
+
+        return(outputs, outputs.shape[2], outputs.shape[1],)
+
+class ImageFlip:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "axis": (["x", "y", "xy"],),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/image manipulation"
+
+    def execute(self, image, axis):
+        dim = ()
+        if "y" in axis:
+            dim += (1,)
+        if "x" in axis:
+            dim += (2,)
+        image = torch.flip(image, dim)
+
+        return(image,)
+
+class ImageCrop:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "width": ("INT", { "default": 256, "min": 0, "max": MAX_RESOLUTION, "step": 8, }),
+                "height": ("INT", { "default": 256, "min": 0, "max": MAX_RESOLUTION, "step": 8, }),
+                "position": (["top-left", "top-center", "top-right", "right-center", "bottom-right", "bottom-center", "bottom-left", "left-center", "center"],),
+                "x_offset": ("INT", { "default": 0, "min": -99999, "step": 1, }),
+                "y_offset": ("INT", { "default": 0, "min": -99999, "step": 1, }),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE","INT","INT",)
+    RETURN_NAMES = ("IMAGE","x","y",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/image manipulation"
+
+    def execute(self, image, width, height, position, x_offset, y_offset):
+        _, oh, ow, _ = image.shape
+
+        width = min(ow, width)
+        height = min(oh, height)
+
+        if "center" in position:
+            x = round((ow-width) / 2)
+            y = round((oh-height) / 2)
+        if "top" in position:
+            y = 0
+        if "bottom" in position:
+            y = oh-height
+        if "left" in position:
+            x = 0
+        if "right" in position:
+            x = ow-width
+
+        x += x_offset
+        y += y_offset
+
+        x2 = x+width
+        y2 = y+height
+
+        if x2 > ow:
+            x2 = ow
+        if x < 0:
+            x = 0
+        if y2 > oh:
+            y2 = oh
+        if y < 0:
+            y = 0
+
+        image = image[:, y:y2, x:x2, :]
+
+        return(image, x, y, )
+
+class ImageTile:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "rows": ("INT", { "default": 2, "min": 1, "max": 256, "step": 1, }),
+                "cols": ("INT", { "default": 2, "min": 1, "max": 256, "step": 1, }),
+                "overlap": ("FLOAT", { "default": 0, "min": 0, "max": 0.5, "step": 0.01, }),
+                "overlap_x": ("INT", { "default": 0, "min": 0, "max": MAX_RESOLUTION//2, "step": 1, }),
+                "overlap_y": ("INT", { "default": 0, "min": 0, "max": MAX_RESOLUTION//2, "step": 1, }),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE", "INT", "INT", "INT", "INT")
+    RETURN_NAMES = ("IMAGE", "tile_width", "tile_height", "overlap_x", "overlap_y",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/image manipulation"
+
+    def execute(self, image, rows, cols, overlap, overlap_x, overlap_y):
+        h, w = image.shape[1:3]
+        tile_h = h // rows
+        tile_w = w // cols
+        h = tile_h * rows
+        w = tile_w * cols
+        overlap_h = int(tile_h * overlap) + overlap_y
+        overlap_w = int(tile_w * overlap) + overlap_x
+
+        # max overlap is half of the tile size
+        overlap_h = min(tile_h // 2, overlap_h)
+        overlap_w = min(tile_w // 2, overlap_w)
+
+        if rows == 1:
+            overlap_h = 0
+        if cols == 1:
+            overlap_w = 0
+        
+        tiles = []
+        for i in range(rows):
+            for j in range(cols):
+                y1 = i * tile_h
+                x1 = j * tile_w
+
+                if i > 0:
+                    y1 -= overlap_h
+                if j > 0:
+                    x1 -= overlap_w
+
+                y2 = y1 + tile_h + overlap_h
+                x2 = x1 + tile_w + overlap_w
+
+                if y2 > h:
+                    y2 = h
+                    y1 = y2 - tile_h - overlap_h
+                if x2 > w:
+                    x2 = w
+                    x1 = x2 - tile_w - overlap_w
+
+                tiles.append(image[:, y1:y2, x1:x2, :])
+        tiles = torch.cat(tiles, dim=0)
+
+        return(tiles, tile_w+overlap_w, tile_h+overlap_h, overlap_w, overlap_h,)
+
+class ImageUntile:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "tiles": ("IMAGE",),
+                "overlap_x": ("INT", { "default": 0, "min": 0, "max": MAX_RESOLUTION//2, "step": 1, }),
+                "overlap_y": ("INT", { "default": 0, "min": 0, "max": MAX_RESOLUTION//2, "step": 1, }),
+                "rows": ("INT", { "default": 2, "min": 1, "max": 256, "step": 1, }),
+                "cols": ("INT", { "default": 2, "min": 1, "max": 256, "step": 1, }),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/image manipulation"
+
+    def execute(self, tiles, overlap_x, overlap_y, rows, cols):
+        tile_h, tile_w = tiles.shape[1:3]
+        tile_h -= overlap_y
+        tile_w -= overlap_x
+        out_w = cols * tile_w
+        out_h = rows * tile_h
+
+        out = torch.zeros((1, out_h, out_w, tiles.shape[3]), device=tiles.device, dtype=tiles.dtype)
+
+        for i in range(rows):
+            for j in range(cols):
+                y1 = i * tile_h
+                x1 = j * tile_w
+
+                if i > 0:
+                    y1 -= overlap_y
+                if j > 0:
+                    x1 -= overlap_x
+
+                y2 = y1 + tile_h + overlap_y
+                x2 = x1 + tile_w + overlap_x
+
+                if y2 > out_h:
+                    y2 = out_h
+                    y1 = y2 - tile_h - overlap_y
+                if x2 > out_w:
+                    x2 = out_w
+                    x1 = x2 - tile_w - overlap_x
+                
+                mask = torch.ones((1, tile_h+overlap_y, tile_w+overlap_x), device=tiles.device, dtype=tiles.dtype)
+
+                # feather the overlap on top
+                if i > 0 and overlap_y > 0:
+                    mask[:, :overlap_y, :] *= torch.linspace(0, 1, overlap_y, device=tiles.device, dtype=tiles.dtype).unsqueeze(1)
+                # feather the overlap on bottom
+                #if i < rows - 1:
+                #    mask[:, -overlap_y:, :] *= torch.linspace(1, 0, overlap_y, device=tiles.device, dtype=tiles.dtype).unsqueeze(1)
+                # feather the overlap on left
+                if j > 0 and overlap_x > 0:
+                    mask[:, :, :overlap_x] *= torch.linspace(0, 1, overlap_x, device=tiles.device, dtype=tiles.dtype).unsqueeze(0)
+                # feather the overlap on right
+                #if j < cols - 1:
+                #    mask[:, :, -overlap_x:] *= torch.linspace(1, 0, overlap_x, device=tiles.device, dtype=tiles.dtype).unsqueeze(0)
+                
+                mask = mask.unsqueeze(-1).repeat(1, 1, 1, tiles.shape[3])
+                tile = tiles[i * cols + j] * mask
+                out[:, y1:y2, x1:x2, :] = out[:, y1:y2, x1:x2, :] * (1 - mask) + tile
+        return(out, )
+
+class ImageSeamCarving:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "width": ("INT", { "default": 512, "min": 1, "max": MAX_RESOLUTION, "step": 1, }),
+                "height": ("INT", { "default": 512, "min": 1, "max": MAX_RESOLUTION, "step": 1, }),
+                "energy": (["backward", "forward"],),
+                "order": (["width-first", "height-first"],),
+            },
+            "optional": {
+                "keep_mask": ("MASK",),
+                "drop_mask": ("MASK",),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    CATEGORY = "essentials/image manipulation"
+    FUNCTION = "execute"
+
+    def execute(self, image, width, height, energy, order, keep_mask=None, drop_mask=None):
+        from .carve import seam_carving
+
+        img = image.permute([0, 3, 1, 2])
+
+        if keep_mask is not None:
+            #keep_mask = keep_mask.reshape((-1, 1, keep_mask.shape[-2], keep_mask.shape[-1])).movedim(1, -1)
+            keep_mask = keep_mask.unsqueeze(1)
+
+            if keep_mask.shape[2] != img.shape[2] or keep_mask.shape[3] != img.shape[3]:
+                keep_mask = F.interpolate(keep_mask, size=(img.shape[2], img.shape[3]), mode="bilinear")
+        if drop_mask is not None:
+            drop_mask = drop_mask.unsqueeze(1)
+
+            if drop_mask.shape[2] != img.shape[2] or drop_mask.shape[3] != img.shape[3]:
+                drop_mask = F.interpolate(drop_mask, size=(img.shape[2], img.shape[3]), mode="bilinear")
+
+        out = []
+        for i in range(img.shape[0]):
+            resized = seam_carving(
+                T.ToPILImage()(img[i]),
+                size=(width, height),
+                energy_mode=energy,
+                order=order,
+                keep_mask=T.ToPILImage()(keep_mask[i]) if keep_mask is not None else None,
+                drop_mask=T.ToPILImage()(drop_mask[i]) if drop_mask is not None else None,
+            )
+            out.append(T.ToTensor()(resized))
+
+        out = torch.stack(out).permute([0, 2, 3, 1])
+
+        return(out, )
+
+class ImageRandomTransform:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
+                "repeat": ("INT", { "default": 1, "min": 1, "max": 256, "step": 1, }),
+                "variation": ("FLOAT", { "default": 0.1, "min": 0.0, "max": 1.0, "step": 0.05, }),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/image manipulation"
+
+    def execute(self, image, seed, repeat, variation):
+        h, w = image.shape[1:3]
+        image = image.repeat(repeat, 1, 1, 1).permute([0, 3, 1, 2])
+
+        distortion = 0.2 * variation
+        rotation = 5 * variation
+        brightness = 0.5 * variation
+        contrast = 0.5 * variation
+        saturation = 0.5 * variation
+        hue = 0.2 * variation
+        scale = 0.5 * variation
+
+        torch.manual_seed(seed)
+
+        out = []
+        for i in image:
+            tramsforms = T.Compose([
+                T.RandomPerspective(distortion_scale=distortion, p=0.5),
+                T.RandomRotation(degrees=rotation, interpolation=T.InterpolationMode.BILINEAR, expand=True),
+                T.ColorJitter(brightness=brightness, contrast=contrast, saturation=saturation, hue=(-hue, hue)),
+                T.RandomHorizontalFlip(p=0.5),
+                T.RandomResizedCrop((h, w), scale=(1-scale, 1+scale), ratio=(w/h, w/h), interpolation=T.InterpolationMode.BICUBIC),
+            ])
+            out.append(tramsforms(i.unsqueeze(0)))
+
+        out = torch.cat(out, dim=0).permute([0, 2, 3, 1]).clamp(0, 1)
+
+        return (out,)
+
+class RemBGSession:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "model": (["u2net: general purpose", "u2netp: lightweight general purpose", "u2net_human_seg: human segmentation", "u2net_cloth_seg: cloths Parsing", "silueta: very small u2net", "isnet-general-use: general purpose", "isnet-anime: anime illustrations", "sam: general purpose"],),
+                "providers": (['CPU', 'CUDA', 'ROCM', 'DirectML', 'OpenVINO', 'CoreML', 'Tensorrt', 'Azure'],),
+            },
+        }
+
+    RETURN_TYPES = ("REMBG_SESSION",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/image manipulation"
+
+    def execute(self, model, providers):
+        from rembg import new_session, remove
+
+        model = model.split(":")[0]
+
+        class Session:
+            def __init__(self, model, providers):
+                self.session = new_session(model, providers=[providers+"ExecutionProvider"])
+            def process(self, image):
+                return remove(image, session=self.session)
+            
+        return (Session(model, providers),)
+
+class TransparentBGSession:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "mode": (["base", "fast", "base-nightly"],),
+                "use_jit": ("BOOLEAN", { "default": True }),
+            },
+        }
+
+    RETURN_TYPES = ("REMBG_SESSION",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/image manipulation"
+
+    def execute(self, mode, use_jit):
+        from transparent_background import Remover
+
+        class Session:
+            def __init__(self, mode, use_jit):
+                self.session = Remover(mode=mode, jit=use_jit)
+            def process(self, image):
+                return self.session.process(image)
+
+        return (Session(mode, use_jit),)
+
+class ImageRemoveBackground:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "rembg_session": ("REMBG_SESSION",),
+                "image": ("IMAGE",),
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE", "MASK",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/image manipulation"
+
+    def execute(self, rembg_session, image):
+        image = image.permute([0, 3, 1, 2])
+        output = []
+        for img in image:
+            img = T.ToPILImage()(img)
+            img = rembg_session.process(img)
+            output.append(T.ToTensor()(img))
+
+        output = torch.stack(output, dim=0)
+        output = output.permute([0, 2, 3, 1])
+        mask = output[:, :, :, 3] if output.shape[3] == 4 else torch.ones_like(output[:, :, :, 0])
+        # output = output[:, :, :, :3]
+
+        return(output, mask,)
+
+"""
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    Image processing
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+"""
+
+class ImageDesaturate:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "factor": ("FLOAT", { "default": 1.00, "min": 0.00, "max": 1.00, "step": 0.05, }),
+                "method": (["luminance (Rec.709)", "luminance (Rec.601)", "average", "lightness"],),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/image processing"
+
+    def execute(self, image, factor, method):
+        if method == "luminance (Rec.709)":
+            grayscale = 0.2126 * image[..., 0] + 0.7152 * image[..., 1] + 0.0722 * image[..., 2]
+        elif method == "luminance (Rec.601)":
+            grayscale = 0.299 * image[..., 0] + 0.587 * image[..., 1] + 0.114 * image[..., 2]
+        elif method == "average":
+            grayscale = image.mean(dim=3)
+        elif method == "lightness":
+            grayscale = (torch.max(image, dim=3)[0] + torch.min(image, dim=3)[0]) / 2
+
+        grayscale = (1.0 - factor) * image + factor * grayscale.unsqueeze(-1).repeat(1, 1, 1, 3)
+        grayscale = torch.clamp(grayscale, 0, 1)
+
+        return(grayscale,)
+
+class PixelOEPixelize:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "downscale_mode": (["contrast", "bicubic", "nearest", "center", "k-centroid"],),
+                "target_size": ("INT", { "default": 128, "min": 0, "max": MAX_RESOLUTION, "step": 8 }),
+                "patch_size": ("INT", { "default": 16, "min": 4, "max": 32, "step": 2 }),
+                "thickness": ("INT", { "default": 2, "min": 1, "max": 16, "step": 1 }),
+                "color_matching": ("BOOLEAN", { "default": True }),
+                "upscale": ("BOOLEAN", { "default": True }),
+                #"contrast": ("FLOAT", { "default": 1.0, "min": 0.0, "max": 100.0, "step": 0.1 }),
+                #"saturation": ("FLOAT", { "default": 1.0, "min": 0.0, "max": 100.0, "step": 0.1 }),
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/image processing"
+
+    def execute(self, image, downscale_mode, target_size, patch_size, thickness, color_matching, upscale):
+        from pixeloe.pixelize import pixelize
+
+        image = image.clone().mul(255).clamp(0, 255).byte().cpu().numpy()
+        output = []
+        for img in image:
+            img = pixelize(img,
+                           mode=downscale_mode,
+                           target_size=target_size,
+                           patch_size=patch_size,
+                           thickness=thickness,
+                           contrast=1.0,
+                           saturation=1.0,
+                           color_matching=color_matching,
+                           no_upscale=not upscale)
+            output.append(T.ToTensor()(img))
+
+        output = torch.stack(output, dim=0).permute([0, 2, 3, 1])
+
+        return(output,)
+
+class ImagePosterize:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "threshold": ("FLOAT", { "default": 0.50, "min": 0.00, "max": 1.00, "step": 0.05, }),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/image processing"
+
+    def execute(self, image, threshold):
+        image = image.mean(dim=3, keepdim=True)
+        image = (image > threshold).float()
+        image = image.repeat(1, 1, 1, 3)
+
+        return(image,)
+
+# From https://github.com/yoonsikp/pycubelut/blob/master/pycubelut.py (MIT license)
+class ImageApplyLUT:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "lut_file": (folder_paths.get_filename_list("luts"),),
+                "gamma_correction": ("BOOLEAN", { "default": True }),
+                "clip_values": ("BOOLEAN", { "default": True }),
+                "strength": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.1 }),
+            }}
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/image processing"
+
+    # TODO: check if we can do without numpy
+    def execute(self, image, lut_file, gamma_correction, clip_values, strength):
+        lut_file_path = folder_paths.get_full_path("luts", lut_file)
+        if not lut_file_path or not Path(lut_file_path).exists():
+            print(f"Could not find LUT file: {lut_file_path}")
+            return (image,)
+            
+        from colour.io.luts.iridas_cube import read_LUT_IridasCube
+        
+        device = image.device
+        lut = read_LUT_IridasCube(lut_file_path)
+        lut.name = lut_file
+
+        if clip_values:
+            if lut.domain[0].max() == lut.domain[0].min() and lut.domain[1].max() == lut.domain[1].min():
+                lut.table = np.clip(lut.table, lut.domain[0, 0], lut.domain[1, 0])
+            else:
+                if len(lut.table.shape) == 2:  # 3x1D
+                    for dim in range(3):
+                        lut.table[:, dim] = np.clip(lut.table[:, dim], lut.domain[0, dim], lut.domain[1, dim])
+                else:  # 3D
+                    for dim in range(3):
+                        lut.table[:, :, :, dim] = np.clip(lut.table[:, :, :, dim], lut.domain[0, dim], lut.domain[1, dim])
+
+        out = []
+        for img in image: # TODO: is this more resource efficient? should we use a batch instead?
+            lut_img = img.cpu().numpy().copy()
+
+            is_non_default_domain = not np.array_equal(lut.domain, np.array([[0., 0., 0.], [1., 1., 1.]]))
+            dom_scale = None
+            if is_non_default_domain:
+                dom_scale = lut.domain[1] - lut.domain[0]
+                lut_img = lut_img * dom_scale + lut.domain[0]
+            if gamma_correction:
+                lut_img = lut_img ** (1/2.2)
+            lut_img = lut.apply(lut_img)
+            if gamma_correction:
+                lut_img = lut_img ** (2.2)
+            if is_non_default_domain:
+                lut_img = (lut_img - lut.domain[0]) / dom_scale
+
+            lut_img = torch.from_numpy(lut_img).to(device)
+            if strength < 1.0:
+                lut_img = strength * lut_img + (1 - strength) * img
+            out.append(lut_img)
+
+        out = torch.stack(out)
+
+        return (out, )
+
+# From https://github.com/Jamy-L/Pytorch-Contrast-Adaptive-Sharpening/
+class ImageCAS:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "amount": ("FLOAT", {"default": 0.8, "min": 0, "max": 1, "step": 0.05}),
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    CATEGORY = "essentials/image processing"
+    FUNCTION = "execute"
+
+    def execute(self, image, amount):
+        epsilon = 1e-5
+        img = F.pad(image.permute([0,3,1,2]), pad=(1, 1, 1, 1))
+
+        a = img[..., :-2, :-2]
+        b = img[..., :-2, 1:-1]
+        c = img[..., :-2, 2:]
+        d = img[..., 1:-1, :-2]
+        e = img[..., 1:-1, 1:-1]
+        f = img[..., 1:-1, 2:]
+        g = img[..., 2:, :-2]
+        h = img[..., 2:, 1:-1]
+        i = img[..., 2:, 2:]
+
+        # Computing contrast
+        cross = (b, d, e, f, h)
+        mn = min_(cross)
+        mx = max_(cross)
+
+        diag = (a, c, g, i)
+        mn2 = min_(diag)
+        mx2 = max_(diag)
+        mx = mx + mx2
+        mn = mn + mn2
+
+        # Computing local weight
+        inv_mx = torch.reciprocal(mx + epsilon)
+        amp = inv_mx * torch.minimum(mn, (2 - mx))
+
+        # scaling
+        amp = torch.sqrt(amp)
+        w = - amp * (amount * (1/5 - 1/8) + 1/8)
+        div = torch.reciprocal(1 + 4*w)
+
+        output = ((b + d + f + h)*w + e) * div
+        output = output.clamp(0, 1)
+        #output = torch.nan_to_num(output)
+
+        output = output.permute([0,2,3,1])
+
+        return (output,)
+
+class ImageSmartSharpen:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "noise_radius": ("INT", { "default": 7, "min": 1, "max": 25, "step": 1, }),
+                "preserve_edges": ("FLOAT", { "default": 0.75, "min": 0.0, "max": 1.0, "step": 0.05 }),
+                "sharpen": ("FLOAT", { "default": 5.0, "min": 0.0, "max": 25.0, "step": 0.5 }),
+                "ratio": ("FLOAT", { "default": 0.5, "min": 0.0, "max": 1.0, "step": 0.1 }),
+        }}
+
+    RETURN_TYPES = ("IMAGE",)
+    CATEGORY = "essentials/image processing"
+    FUNCTION = "execute"
+
+    def execute(self, image, noise_radius, preserve_edges, sharpen, ratio):
+        import cv2
+
+        output = []
+        #diagonal = np.sqrt(image.shape[1]**2 + image.shape[2]**2)
+        if preserve_edges > 0:
+            preserve_edges = max(1 - preserve_edges, 0.05)
+
+        for img in image:
+            if noise_radius > 1:
+                sigma = 0.3 * ((noise_radius - 1) * 0.5 - 1) + 0.8 # this is what pytorch uses for blur
+                #sigma_color = preserve_edges * (diagonal / 2048)
+                blurred = cv2.bilateralFilter(img.cpu().numpy(), noise_radius, preserve_edges, sigma)
+                blurred = torch.from_numpy(blurred)
+            else:
+                blurred = img
+
+            if sharpen > 0:
+                sharpened = kornia.enhance.sharpness(img.permute(2,0,1), sharpen).permute(1,2,0)
+            else:
+                sharpened = img
+
+            img = ratio * sharpened + (1 - ratio) * blurred
+            img = torch.clamp(img, 0, 1)
+            output.append(img)
+        
+        del blurred, sharpened
+        output = torch.stack(output)
+
+        return (output,)
+
+
+class ExtractKeyframes:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "threshold": ("FLOAT", { "default": 0.85, "min": 0.00, "max": 1.00, "step": 0.01, }),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE", "STRING")
+    RETURN_NAMES = ("KEYFRAMES", "indexes")
+
+    FUNCTION = "execute"
+    CATEGORY = "essentials"
+
+    def execute(self, image, threshold):
+        window_size = 2
+
+        variations = torch.sum(torch.abs(image[1:] - image[:-1]), dim=[1, 2, 3])
+        #variations = torch.sum((image[1:] - image[:-1]) ** 2, dim=[1, 2, 3])
+        threshold = torch.quantile(variations.float(), threshold).item()
+
+        keyframes = []
+        for i in range(image.shape[0] - window_size + 1):
+            window = image[i:i + window_size]
+            variation = torch.sum(torch.abs(window[-1] - window[0])).item()
+
+            if variation > threshold:
+                keyframes.append(i + window_size - 1)
+
+        return (image[keyframes], ','.join(map(str, keyframes)),)
+
+class ImageColorMatch:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "reference": ("IMAGE",),
+                "color_space": (["LAB", "YCbCr", "RGB", "LUV", "YUV", "XYZ"],),
+                "factor": ("FLOAT", { "default": 1.0, "min": 0.0, "max": 1.0, "step": 0.05, }),
+                "device": (["auto", "cpu", "gpu"],),
+                "batch_size": ("INT", { "default": 0, "min": 0, "max": 1024, "step": 1, }),
+            },
+            "optional": {
+                "reference_mask": ("MASK",),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/image processing"
+
+    def execute(self, image, reference, color_space, factor, device, batch_size, reference_mask=None):
+        if "gpu" == device:
+            device = comfy.model_management.get_torch_device()
+        elif "auto" == device:
+            device = comfy.model_management.intermediate_device()
+        else:
+            device = 'cpu'
+
+        image = image.permute([0, 3, 1, 2])
+        reference = reference.permute([0, 3, 1, 2]).to(device)
+         
+        # Ensure reference_mask is in the correct format and on the right device
+        if reference_mask is not None:
+            assert reference_mask.ndim == 3, f"Expected reference_mask to have 3 dimensions, but got {reference_mask.ndim}"
+            assert reference_mask.shape[0] == reference.shape[0], f"Frame count mismatch: reference_mask has {reference_mask.shape[0]} frames, but reference has {reference.shape[0]}"
+            
+            # Reshape mask to (batch, 1, height, width)
+            reference_mask = reference_mask.unsqueeze(1).to(device)
+             
+            # Ensure the mask is binary (0 or 1)
+            reference_mask = (reference_mask > 0.5).float()
+             
+            # Ensure spatial dimensions match
+            if reference_mask.shape[2:] != reference.shape[2:]:
+                reference_mask = comfy.utils.common_upscale(
+                    reference_mask,
+                    reference.shape[3], reference.shape[2],
+                    upscale_method='bicubic',
+                    crop='center'
+                )
+
+        if batch_size == 0 or batch_size > image.shape[0]:
+            batch_size = image.shape[0]
+
+        if "LAB" == color_space:
+            reference = kornia.color.rgb_to_lab(reference)
+        elif "YCbCr" == color_space:
+            reference = kornia.color.rgb_to_ycbcr(reference)
+        elif "LUV" == color_space:
+            reference = kornia.color.rgb_to_luv(reference)
+        elif "YUV" == color_space:
+            reference = kornia.color.rgb_to_yuv(reference)
+        elif "XYZ" == color_space:
+            reference = kornia.color.rgb_to_xyz(reference)
+
+        reference_mean, reference_std = self.compute_mean_std(reference, reference_mask)
+
+        image_batch = torch.split(image, batch_size, dim=0)
+        output = []
+
+        for image in image_batch:
+            image = image.to(device)
+
+            if color_space == "LAB":
+                image = kornia.color.rgb_to_lab(image)
+            elif color_space == "YCbCr":
+                image = kornia.color.rgb_to_ycbcr(image)
+            elif color_space == "LUV":
+                image = kornia.color.rgb_to_luv(image)
+            elif color_space == "YUV":
+                image = kornia.color.rgb_to_yuv(image)
+            elif color_space == "XYZ":
+                image = kornia.color.rgb_to_xyz(image)
+
+            image_mean, image_std = self.compute_mean_std(image)
+
+            matched = torch.nan_to_num((image - image_mean) / image_std) * torch.nan_to_num(reference_std) + reference_mean
+            matched = factor * matched + (1 - factor) * image
+
+            if color_space == "LAB":
+                matched = kornia.color.lab_to_rgb(matched)
+            elif color_space == "YCbCr":
+                matched = kornia.color.ycbcr_to_rgb(matched)
+            elif color_space == "LUV":
+                matched = kornia.color.luv_to_rgb(matched)
+            elif color_space == "YUV":
+                matched = kornia.color.yuv_to_rgb(matched)
+            elif color_space == "XYZ":
+                matched = kornia.color.xyz_to_rgb(matched)
+
+            out = matched.permute([0, 2, 3, 1]).clamp(0, 1).to(comfy.model_management.intermediate_device())
+            output.append(out)
+
+        out = None
+        output = torch.cat(output, dim=0)
+        return (output,)
+
+    def compute_mean_std(self, tensor, mask=None):
+        if mask is not None:
+            # Apply mask to the tensor
+            masked_tensor = tensor * mask
+
+            # Calculate the sum of the mask for each channel
+            mask_sum = mask.sum(dim=[2, 3], keepdim=True)
+
+            # Avoid division by zero
+            mask_sum = torch.clamp(mask_sum, min=1e-6)
+
+            # Calculate mean and std only for masked area
+            mean = torch.nan_to_num(masked_tensor.sum(dim=[2, 3], keepdim=True) / mask_sum)
+            std = torch.sqrt(torch.nan_to_num(((masked_tensor - mean) ** 2 * mask).sum(dim=[2, 3], keepdim=True) / mask_sum))
+        else:
+            mean = tensor.mean(dim=[2, 3], keepdim=True)
+            std = tensor.std(dim=[2, 3], keepdim=True)
+        return mean, std
+
+class ImageColorMatchAdobe(ImageColorMatch):
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "reference": ("IMAGE",),
+                "color_space": (["RGB", "LAB"],),
+                "luminance_factor": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 2.0, "step": 0.05}),
+                "color_intensity_factor": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 2.0, "step": 0.05}),
+                "fade_factor": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.05}),
+                "neutralization_factor": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 1.0, "step": 0.05}),
+                "device": (["auto", "cpu", "gpu"],),
+            },
+            "optional": {
+                "reference_mask": ("MASK",),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/image processing"
+
+    def analyze_color_statistics(self, image, mask=None):
+        # Assuming image is in RGB format
+        l, a, b = kornia.color.rgb_to_lab(image).chunk(3, dim=1)
+
+        if mask is not None:
+            # Ensure mask is binary and has the same spatial dimensions as the image
+            mask = F.interpolate(mask, size=image.shape[2:], mode='nearest')
+            mask = (mask > 0.5).float()
+            
+            # Apply mask to each channel
+            l = l * mask
+            a = a * mask
+            b = b * mask
+            
+            # Compute masked mean and std
+            num_pixels = mask.sum()
+            mean_l = (l * mask).sum() / num_pixels
+            mean_a = (a * mask).sum() / num_pixels
+            mean_b = (b * mask).sum() / num_pixels
+            std_l = torch.sqrt(((l - mean_l)**2 * mask).sum() / num_pixels)
+            var_ab = ((a - mean_a)**2 + (b - mean_b)**2) * mask
+            std_ab = torch.sqrt(var_ab.sum() / num_pixels)
+        else:
+            mean_l = l.mean()
+            std_l = l.std()
+            mean_a = a.mean()
+            mean_b = b.mean()
+            std_ab = torch.sqrt(a.var() + b.var())
+
+        return mean_l, std_l, mean_a, mean_b, std_ab
+
+    def apply_color_transformation(self, image, source_stats, dest_stats, L, C, N):
+        l, a, b = kornia.color.rgb_to_lab(image).chunk(3, dim=1)
+        
+        # Unpack statistics
+        src_mean_l, src_std_l, src_mean_a, src_mean_b, src_std_ab = source_stats
+        dest_mean_l, dest_std_l, dest_mean_a, dest_mean_b, dest_std_ab = dest_stats
+
+        # Adjust luminance
+        l_new = (l - dest_mean_l) * (src_std_l / dest_std_l) * L + src_mean_l
+
+        # Neutralize color cast
+        a = a - N * dest_mean_a
+        b = b - N * dest_mean_b
+
+        # Adjust color intensity
+        a_new = a * (src_std_ab / dest_std_ab) * C
+        b_new = b * (src_std_ab / dest_std_ab) * C
+
+        # Combine channels
+        lab_new = torch.cat([l_new, a_new, b_new], dim=1)
+
+        # Convert back to RGB
+        rgb_new = kornia.color.lab_to_rgb(lab_new)
+
+        return rgb_new
+
+    def execute(self, image, reference, color_space, luminance_factor, color_intensity_factor, fade_factor, neutralization_factor, device, reference_mask=None):
+        if "gpu" == device:
+            device = comfy.model_management.get_torch_device()
+        elif "auto" == device:
+            device = comfy.model_management.intermediate_device()
+        else:
+            device = 'cpu'
+
+        # Ensure image and reference are in the correct shape (B, C, H, W)
+        image = image.permute(0, 3, 1, 2).to(device)
+        reference = reference.permute(0, 3, 1, 2).to(device)
+
+        # Handle reference_mask (if provided)
+        if reference_mask is not None:
+            # Ensure reference_mask is 4D (B, 1, H, W)
+            if reference_mask.ndim == 2:
+                reference_mask = reference_mask.unsqueeze(0).unsqueeze(0)
+            elif reference_mask.ndim == 3:
+                reference_mask = reference_mask.unsqueeze(1)
+            reference_mask = reference_mask.to(device)
+
+         # Analyze color statistics
+        source_stats = self.analyze_color_statistics(reference, reference_mask)
+        dest_stats = self.analyze_color_statistics(image)
+
+        # Apply color transformation
+        transformed = self.apply_color_transformation(
+            image, source_stats, dest_stats, 
+            luminance_factor, color_intensity_factor, neutralization_factor
+        )
+
+        # Apply fade factor
+        result = fade_factor * transformed + (1 - fade_factor) * image
+
+        # Convert back to (B, H, W, C) format and ensure values are in [0, 1] range
+        result = result.permute(0, 2, 3, 1).clamp(0, 1).to(comfy.model_management.intermediate_device())
+
+        return (result,)
+
+
+class ImageHistogramMatch:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "reference": ("IMAGE",),
+                "method": (["pytorch", "skimage"],),
+                "factor": ("FLOAT", { "default": 1.0, "min": 0.0, "max": 1.0, "step": 0.05, }),
+                "device": (["auto", "cpu", "gpu"],),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/image processing"
+
+    def execute(self, image, reference, method, factor, device):
+        if "gpu" == device:
+            device = comfy.model_management.get_torch_device()
+        elif "auto" == device:
+            device = comfy.model_management.intermediate_device()
+        else:
+            device = 'cpu'
+
+        if "pytorch" in method:
+            from .histogram_matching import Histogram_Matching
+
+            image = image.permute([0, 3, 1, 2]).to(device)
+            reference = reference.permute([0, 3, 1, 2]).to(device)[0].unsqueeze(0)
+            image.requires_grad = True
+            reference.requires_grad = True
+
+            out = []
+
+            for i in image:
+                i = i.unsqueeze(0)
+                hm = Histogram_Matching(differentiable=True)
+                out.append(hm(i, reference))
+            out = torch.cat(out, dim=0)
+            out = factor * out + (1 - factor) * image
+            out = out.permute([0, 2, 3, 1]).clamp(0, 1)
+        else:
+            from skimage.exposure import match_histograms
+
+            out = torch.from_numpy(match_histograms(image.cpu().numpy(), reference.cpu().numpy(), channel_axis=3)).to(device)
+            out = factor * out + (1 - factor) * image.to(device)
+
+        return (out.to(comfy.model_management.intermediate_device()),)
+
+"""
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    Utilities
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+"""
+
+class ImageToDevice:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "device": (["auto", "cpu", "gpu"],),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/image utils"
+
+    def execute(self, image, device):
+        if "gpu" == device:
+            device = comfy.model_management.get_torch_device()
+        elif "auto" == device:
+            device = comfy.model_management.intermediate_device()
+        else:
+            device = 'cpu'
+
+        image = image.clone().to(device)
+        torch.cuda.empty_cache()
+
+        return (image,)
+
+class GetImageSize:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+            }
+        }
+
+    RETURN_TYPES = ("INT", "INT", "INT",)
+    RETURN_NAMES = ("width", "height", "count")
+    FUNCTION = "execute"
+    CATEGORY = "essentials/image utils"
+
+    def execute(self, image):
+        return (image.shape[2], image.shape[1], image.shape[0])
+
+class ImageRemoveAlpha:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/image utils"
+
+    def execute(self, image):
+        if image.shape[3] == 4:
+            image = image[..., :3]
+        return (image,)
+
+class ImagePreviewFromLatent(SaveImage):
+    def __init__(self):
+        self.output_dir = folder_paths.get_temp_directory()
+        self.type = "temp"
+        self.prefix_append = "_temp_" + ''.join(random.choice("abcdefghijklmnopqrstupvxyz") for x in range(5))
+        self.compress_level = 1
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "latent": ("LATENT",),
+                "vae": ("VAE", ),
+                "tile_size": ("INT", {"default": 0, "min": 0, "max": 4096, "step": 64})
+            }, "optional": {
+                "image": (["none"], {"image_upload": False}),
+            }, "hidden": {
+                "prompt": "PROMPT",
+                "extra_pnginfo": "EXTRA_PNGINFO",
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE", "MASK", "INT", "INT",)
+    RETURN_NAMES = ("IMAGE", "MASK", "width", "height",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/image utils"
+
+    def execute(self, latent, vae, tile_size, prompt=None, extra_pnginfo=None, image=None, filename_prefix="ComfyUI"):
+        mask = torch.zeros((64,64), dtype=torch.float32, device="cpu")
+        ui = None
+
+        if image.startswith("clipspace"):
+            image_path = folder_paths.get_annotated_filepath(image)
+            if not os.path.exists(image_path):
+                raise ValueError(f"Clipspace image does not exist anymore, select 'none' in the image field.")
+
+            img = pillow(Image.open, image_path)
+            img = pillow(ImageOps.exif_transpose, img)
+            if img.mode == "I":
+                img = img.point(lambda i: i * (1 / 255))
+            image = img.convert("RGB")
+            image = np.array(image).astype(np.float32) / 255.0
+            image = torch.from_numpy(image)[None,]
+            if "A" in img.getbands():
+                mask = np.array(img.getchannel('A')).astype(np.float32) / 255.0
+                mask = 1. - torch.from_numpy(mask)
+            ui = {
+                "filename": os.path.basename(image_path),
+                "subfolder": os.path.dirname(image_path),
+                "type": "temp",
+            }
+        else:
+            if tile_size > 0:
+                tile_size = max(tile_size, 320)
+                image = vae.decode_tiled(latent["samples"], tile_x=tile_size // 8, tile_y=tile_size // 8, )
+            else:
+                image = vae.decode(latent["samples"])
+            ui = self.save_images(image, filename_prefix, prompt, extra_pnginfo)
+
+        out = {**ui, "result": (image, mask, image.shape[2], image.shape[1],)}
+        return out
+
+class NoiseFromImage:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "noise_strenght": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.01 }),
+                "noise_size": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.01 }),
+                "color_noise": ("FLOAT", {"default": 0.2, "min": 0.0, "max": 1.0, "step": 0.01 }),
+                "mask_strength": ("FLOAT", {"default": 0.5, "min": 0.0, "max": 1.0, "step": 0.01 }),
+                "mask_scale_diff": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 1.0, "step": 0.01 }),
+                "mask_contrast": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 100.0, "step": 0.1 }),
+                "saturation": ("FLOAT", {"default": 2.0, "min": 0.0, "max": 100.0, "step": 0.1 }),
+                "contrast": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 100.0, "step": 0.1 }),
+                "blur": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 10.0, "step": 0.1 }),
+            },
+            "optional": {
+                "noise_mask": ("IMAGE",),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/image utils"
+
+    def execute(self, image, noise_size, color_noise, mask_strength, mask_scale_diff, mask_contrast, noise_strenght, saturation, contrast, blur, noise_mask=None):
+        torch.manual_seed(0)
+
+        elastic_alpha = max(image.shape[1], image.shape[2])# * noise_size
+        elastic_sigma = elastic_alpha / 400 * noise_size
+
+        blur_size = int(6 * blur+1)
+        if blur_size % 2 == 0:
+            blur_size+= 1
+
+        if noise_mask is None:
+            noise_mask = image
+        
+        # increase contrast of the mask
+        if mask_contrast != 1:
+            noise_mask = T.ColorJitter(contrast=(mask_contrast,mask_contrast))(noise_mask.permute([0, 3, 1, 2])).permute([0, 2, 3, 1])
+
+        # Ensure noise mask is the same size as the image
+        if noise_mask.shape[1:] != image.shape[1:]:
+            noise_mask = F.interpolate(noise_mask.permute([0, 3, 1, 2]), size=(image.shape[1], image.shape[2]), mode='bicubic', align_corners=False)
+            noise_mask = noise_mask.permute([0, 2, 3, 1])
+        # Ensure we have the same number of masks and images
+        if noise_mask.shape[0] > image.shape[0]:
+            noise_mask = noise_mask[:image.shape[0]]
+        else:
+            noise_mask = torch.cat((noise_mask, noise_mask[-1:].repeat((image.shape[0]-noise_mask.shape[0], 1, 1, 1))), dim=0)
+
+        # Convert mask to grayscale mask
+        noise_mask = noise_mask.mean(dim=3).unsqueeze(-1)
+
+        # add color noise
+        imgs = image.clone().permute([0, 3, 1, 2])
+        if color_noise > 0:
+            color_noise = torch.normal(torch.zeros_like(imgs), std=color_noise)
+            color_noise *= (imgs - imgs.min()) / (imgs.max() - imgs.min())
+
+            imgs = imgs + color_noise
+            imgs = imgs.clamp(0, 1)
+
+        # create fine and coarse noise
+        fine_noise = []
+        for n in imgs:
+            avg_color = n.mean(dim=[1,2])
+
+            tmp_noise = T.ElasticTransform(alpha=elastic_alpha, sigma=elastic_sigma, fill=avg_color.tolist())(n)
+            if blur > 0:
+                tmp_noise = T.GaussianBlur(blur_size, blur)(tmp_noise)
+            tmp_noise = T.ColorJitter(contrast=(contrast,contrast), saturation=(saturation,saturation))(tmp_noise)
+            fine_noise.append(tmp_noise)
+
+        imgs = None
+        del imgs
+
+        fine_noise = torch.stack(fine_noise, dim=0)
+        fine_noise = fine_noise.permute([0, 2, 3, 1])
+        #fine_noise = torch.stack(fine_noise, dim=0)
+        #fine_noise = pb(fine_noise)
+        mask_scale_diff = min(mask_scale_diff, 0.99)
+        if mask_scale_diff > 0:
+            coarse_noise = F.interpolate(fine_noise.permute([0, 3, 1, 2]), scale_factor=1-mask_scale_diff, mode='area')
+            coarse_noise = F.interpolate(coarse_noise, size=(fine_noise.shape[1], fine_noise.shape[2]), mode='bilinear', align_corners=False)
+            coarse_noise = coarse_noise.permute([0, 2, 3, 1])
+        else:
+            coarse_noise = fine_noise
+
+        output = (1 - noise_mask) * coarse_noise + noise_mask * fine_noise
+
+        if mask_strength < 1:
+            noise_mask = noise_mask.pow(mask_strength)
+            noise_mask = torch.nan_to_num(noise_mask).clamp(0, 1)
+        output = noise_mask * output + (1 - noise_mask) * image
+
+        # apply noise to image
+        output = output * noise_strenght + image * (1 - noise_strenght)
+        output = output.clamp(0, 1)
+
+        return (output, )
+
+IMAGE_CLASS_MAPPINGS = {
+    # Image analysis
+    "ImageEnhanceDifference+": ImageEnhanceDifference,
+
+    # Image batch
+    "ImageBatchMultiple+": ImageBatchMultiple,
+    "ImageExpandBatch+": ImageExpandBatch,
+    "ImageFromBatch+": ImageFromBatch,
+    "ImageListToBatch+": ImageListToBatch,
+    "ImageBatchToList+": ImageBatchToList,
+
+    # Image manipulation
+    "ImageCompositeFromMaskBatch+": ImageCompositeFromMaskBatch,
+    "ImageComposite+": ImageComposite,
+    "ImageCrop+": ImageCrop,
+    "ImageFlip+": ImageFlip,
+    "ImageRandomTransform+": ImageRandomTransform,
+    "ImageRemoveAlpha+": ImageRemoveAlpha,
+    "ImageRemoveBackground+": ImageRemoveBackground,
+    "ImageResize+": ImageResize,
+    "ImageSeamCarving+": ImageSeamCarving,
+    "ImageTile+": ImageTile,
+    "ImageUntile+": ImageUntile,
+    "RemBGSession+": RemBGSession,
+    "TransparentBGSession+": TransparentBGSession,
+
+    # Image processing
+    "ImageApplyLUT+": ImageApplyLUT,
+    "ImageCASharpening+": ImageCAS,
+    "ImageDesaturate+": ImageDesaturate,
+    "PixelOEPixelize+": PixelOEPixelize,
+    "ImagePosterize+": ImagePosterize,
+    "ImageColorMatch+": ImageColorMatch,
+    "ImageColorMatchAdobe+": ImageColorMatchAdobe,
+    "ImageHistogramMatch+": ImageHistogramMatch,
+    "ImageSmartSharpen+": ImageSmartSharpen,
+
+    # Utilities
+    "GetImageSize+": GetImageSize,
+    "ImageToDevice+": ImageToDevice,
+    "ImagePreviewFromLatent+": ImagePreviewFromLatent,
+    "NoiseFromImage+": NoiseFromImage,
+    #"ExtractKeyframes+": ExtractKeyframes,
+}
+
+IMAGE_NAME_MAPPINGS = {
+    # Image analysis
+    "ImageEnhanceDifference+": "🔧 Image Enhance Difference",
+
+    # Image batch
+    "ImageBatchMultiple+": "🔧 Images Batch Multiple",
+    "ImageExpandBatch+": "🔧 Image Expand Batch",
+    "ImageFromBatch+": "🔧 Image From Batch",
+    "ImageListToBatch+": "🔧 Image List To Batch",
+    "ImageBatchToList+": "🔧 Image Batch To List",
+
+    # Image manipulation
+    "ImageCompositeFromMaskBatch+": "🔧 Image Composite From Mask Batch",
+    "ImageComposite+": "🔧 Image Composite",
+    "ImageCrop+": "🔧 Image Crop",
+    "ImageFlip+": "🔧 Image Flip",
+    "ImageRandomTransform+": "🔧 Image Random Transform",
+    "ImageRemoveAlpha+": "🔧 Image Remove Alpha",
+    "ImageRemoveBackground+": "🔧 Image Remove Background",
+    "ImageResize+": "🔧 Image Resize",
+    "ImageSeamCarving+": "🔧 Image Seam Carving",
+    "ImageTile+": "🔧 Image Tile",
+    "ImageUntile+": "🔧 Image Untile",
+    "RemBGSession+": "🔧 RemBG Session",
+    "TransparentBGSession+": "🔧 InSPyReNet TransparentBG",
+
+    # Image processing
+    "ImageApplyLUT+": "🔧 Image Apply LUT",
+    "ImageCASharpening+": "🔧 Image Contrast Adaptive Sharpening",
+    "ImageDesaturate+": "🔧 Image Desaturate",
+    "PixelOEPixelize+": "🔧 Pixelize",
+    "ImagePosterize+": "🔧 Image Posterize",
+    "ImageColorMatch+": "🔧 Image Color Match",
+    "ImageColorMatchAdobe+": "🔧 Image Color Match Adobe",
+    "ImageHistogramMatch+": "🔧 Image Histogram Match",
+    "ImageSmartSharpen+": "🔧 Image Smart Sharpen",
+
+    # Utilities
+    "GetImageSize+": "🔧 Get Image Size",
+    "ImageToDevice+": "🔧 Image To Device",
+    "ImagePreviewFromLatent+": "🔧 Image Preview From Latent",
+    "NoiseFromImage+": "🔧 Noise From Image",
+}

ComfyUI_essentials/mask.py

@@ -0,0 +1,596 @@
+from nodes import SaveImage
+import torch
+import torchvision.transforms.v2 as T
+import random
+import folder_paths
+import comfy.utils
+from .image import ImageExpandBatch
+from .utils import AnyType
+import numpy as np
+import scipy
+from PIL import Image
+from nodes import MAX_RESOLUTION
+import math
+
+any = AnyType("*")
+
+class MaskBlur:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "mask": ("MASK",),
+                "amount": ("INT", { "default": 6, "min": 0, "max": 256, "step": 1, }),
+                "device": (["auto", "cpu", "gpu"],),
+            }
+        }
+
+    RETURN_TYPES = ("MASK",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/mask"
+
+    def execute(self, mask, amount, device):
+        if amount == 0:
+            return (mask,)
+
+        if "gpu" == device:
+            mask = mask.to(comfy.model_management.get_torch_device())
+        elif "cpu" == device:
+            mask = mask.to('cpu')
+
+        if amount % 2 == 0:
+            amount+= 1
+
+        if mask.dim() == 2:
+            mask = mask.unsqueeze(0)
+
+        mask = T.functional.gaussian_blur(mask.unsqueeze(1), amount).squeeze(1)
+
+        if "gpu" == device or "cpu" == device:
+            mask = mask.to(comfy.model_management.intermediate_device())
+
+        return(mask,)
+
+class MaskFlip:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "mask": ("MASK",),
+                "axis": (["x", "y", "xy"],),
+            }
+        }
+
+    RETURN_TYPES = ("MASK",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/mask"
+
+    def execute(self, mask, axis):
+        if mask.dim() == 2:
+            mask = mask.unsqueeze(0)
+
+        dim = ()
+        if "y" in axis:
+            dim += (1,)
+        if "x" in axis:
+            dim += (2,)
+        mask = torch.flip(mask, dims=dim)
+
+        return(mask,)
+
+class MaskPreview(SaveImage):
+    def __init__(self):
+        self.output_dir = folder_paths.get_temp_directory()
+        self.type = "temp"
+        self.prefix_append = "_temp_" + ''.join(random.choice("abcdefghijklmnopqrstupvxyz") for x in range(5))
+        self.compress_level = 4
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {"mask": ("MASK",), },
+            "hidden": {"prompt": "PROMPT", "extra_pnginfo": "EXTRA_PNGINFO"},
+        }
+
+    FUNCTION = "execute"
+    CATEGORY = "essentials/mask"
+
+    def execute(self, mask, filename_prefix="ComfyUI", prompt=None, extra_pnginfo=None):
+        preview = mask.reshape((-1, 1, mask.shape[-2], mask.shape[-1])).movedim(1, -1).expand(-1, -1, -1, 3)
+        return self.save_images(preview, filename_prefix, prompt, extra_pnginfo)
+
+class MaskBatch:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "mask1": ("MASK",),
+                "mask2": ("MASK",),
+            }
+        }
+
+    RETURN_TYPES = ("MASK",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/mask batch"
+
+    def execute(self, mask1, mask2):
+        if mask1.shape[1:] != mask2.shape[1:]:
+            mask2 = comfy.utils.common_upscale(mask2.unsqueeze(1).expand(-1,3,-1,-1), mask1.shape[2], mask1.shape[1], upscale_method='bicubic', crop='center')[:,0,:,:]
+
+        return (torch.cat((mask1, mask2), dim=0),)
+
+class MaskExpandBatch:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "mask": ("MASK",),
+                "size": ("INT", { "default": 16, "min": 1, "step": 1, }),
+                "method": (["expand", "repeat all", "repeat first", "repeat last"],)
+            }
+        }
+
+    RETURN_TYPES = ("MASK",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/mask batch"
+
+    def execute(self, mask, size, method):
+        return (ImageExpandBatch().execute(mask.unsqueeze(1).expand(-1,3,-1,-1), size, method)[0][:,0,:,:],)
+
+
+class MaskBoundingBox:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "mask": ("MASK",),
+                "padding": ("INT", { "default": 0, "min": 0, "max": 4096, "step": 1, }),
+                "blur": ("INT", { "default": 0, "min": 0, "max": 256, "step": 1, }),
+            },
+            "optional": {
+                "image_optional": ("IMAGE",),
+            }
+        }
+
+    RETURN_TYPES = ("MASK", "IMAGE", "INT", "INT", "INT", "INT")
+    RETURN_NAMES = ("MASK", "IMAGE", "x", "y", "width", "height")
+    FUNCTION = "execute"
+    CATEGORY = "essentials/mask"
+
+    def execute(self, mask, padding, blur, image_optional=None):
+        if mask.dim() == 2:
+            mask = mask.unsqueeze(0)
+
+        if image_optional is None:
+            image_optional = mask.unsqueeze(3).repeat(1, 1, 1, 3)
+
+        # resize the image if it's not the same size as the mask
+        if image_optional.shape[1:] != mask.shape[1:]:
+            image_optional = comfy.utils.common_upscale(image_optional.permute([0,3,1,2]), mask.shape[2], mask.shape[1], upscale_method='bicubic', crop='center').permute([0,2,3,1])
+
+        # match batch size
+        if image_optional.shape[0] < mask.shape[0]:
+            image_optional = torch.cat((image_optional, image_optional[-1].unsqueeze(0).repeat(mask.shape[0]-image_optional.shape[0], 1, 1, 1)), dim=0)
+        elif image_optional.shape[0] > mask.shape[0]:
+            image_optional = image_optional[:mask.shape[0]]
+
+        # blur the mask
+        if blur > 0:
+            if blur % 2 == 0:
+                blur += 1
+            mask = T.functional.gaussian_blur(mask.unsqueeze(1), blur).squeeze(1)
+
+        _, y, x = torch.where(mask)
+        x1 = max(0, x.min().item() - padding)
+        x2 = min(mask.shape[2], x.max().item() + 1 + padding)
+        y1 = max(0, y.min().item() - padding)
+        y2 = min(mask.shape[1], y.max().item() + 1 + padding)
+
+        # crop the mask
+        mask = mask[:, y1:y2, x1:x2]
+        image_optional = image_optional[:, y1:y2, x1:x2, :]
+
+        return (mask, image_optional, x1, y1, x2 - x1, y2 - y1)
+
+
+class MaskFromColor:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE", ),
+                "red": ("INT", { "default": 255, "min": 0, "max": 255, "step": 1, }),
+                "green": ("INT", { "default": 255, "min": 0, "max": 255, "step": 1, }),
+                "blue": ("INT", { "default": 255, "min": 0, "max": 255, "step": 1, }),
+                "threshold": ("INT", { "default": 0, "min": 0, "max": 127, "step": 1, }),
+            }
+        }
+
+    RETURN_TYPES = ("MASK",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/mask"
+
+    def execute(self, image, red, green, blue, threshold):
+        temp = (torch.clamp(image, 0, 1.0) * 255.0).round().to(torch.int)
+        color = torch.tensor([red, green, blue])
+        lower_bound = (color - threshold).clamp(min=0)
+        upper_bound = (color + threshold).clamp(max=255)
+        lower_bound = lower_bound.view(1, 1, 1, 3)
+        upper_bound = upper_bound.view(1, 1, 1, 3)
+        mask = (temp >= lower_bound) & (temp <= upper_bound)
+        mask = mask.all(dim=-1)
+        mask = mask.float()
+
+        return (mask, )
+
+
+class MaskFromSegmentation:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE", ),
+                "segments": ("INT", { "default": 6, "min": 1, "max": 16, "step": 1, }),
+                "remove_isolated_pixels": ("INT", { "default": 0, "min": 0, "max": 32, "step": 1, }),
+                "remove_small_masks": ("FLOAT", { "default": 0.0, "min": 0., "max": 1., "step": 0.01, }),
+                "fill_holes": ("BOOLEAN", { "default": False }),
+            }
+        }
+
+    RETURN_TYPES = ("MASK",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/mask"
+
+    def execute(self, image, segments, remove_isolated_pixels, fill_holes, remove_small_masks):
+        im = image[0] # we only work on the first image in the batch
+        im = Image.fromarray((im * 255).to(torch.uint8).cpu().numpy(), mode="RGB")
+        im = im.quantize(palette=im.quantize(colors=segments), dither=Image.Dither.NONE)
+        im = torch.tensor(np.array(im.convert("RGB"))).float() / 255.0
+
+        colors = im.reshape(-1, im.shape[-1])
+        colors = torch.unique(colors, dim=0)
+
+        masks = []
+        for color in colors:
+            mask = (im == color).all(dim=-1).float()
+            # remove isolated pixels
+            if remove_isolated_pixels > 0:
+                mask = torch.from_numpy(scipy.ndimage.binary_opening(mask.cpu().numpy(), structure=np.ones((remove_isolated_pixels, remove_isolated_pixels))))
+
+            # fill holes
+            if fill_holes:
+                mask = torch.from_numpy(scipy.ndimage.binary_fill_holes(mask.cpu().numpy()))
+
+            # if the mask is too small, it's probably noise
+            if mask.sum() / (mask.shape[0]*mask.shape[1]) > remove_small_masks:
+                masks.append(mask)
+
+        if masks == []:
+            masks.append(torch.zeros_like(im)[:,:,0]) # return an empty mask if no masks were found, prevents errors
+
+        mask = torch.stack(masks, dim=0).float()
+
+        return (mask, )
+
+
+class MaskFix:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "mask": ("MASK",),
+                "erode_dilate": ("INT", { "default": 0, "min": -256, "max": 256, "step": 1, }),
+                "fill_holes": ("INT", { "default": 0, "min": 0, "max": 128, "step": 1, }),
+                "remove_isolated_pixels": ("INT", { "default": 0, "min": 0, "max": 32, "step": 1, }),
+                "smooth": ("INT", { "default": 0, "min": 0, "max": 256, "step": 1, }),
+                "blur": ("INT", { "default": 0, "min": 0, "max": 256, "step": 1, }),
+            }
+        }
+
+    RETURN_TYPES = ("MASK",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/mask"
+
+    def execute(self, mask, erode_dilate, smooth, remove_isolated_pixels, blur, fill_holes):
+        masks = []
+        for m in mask:
+            # erode and dilate
+            if erode_dilate != 0:
+                if erode_dilate < 0:
+                    m = torch.from_numpy(scipy.ndimage.grey_erosion(m.cpu().numpy(), size=(-erode_dilate, -erode_dilate)))
+                else:
+                    m = torch.from_numpy(scipy.ndimage.grey_dilation(m.cpu().numpy(), size=(erode_dilate, erode_dilate)))
+
+            # fill holes
+            if fill_holes > 0:
+                #m = torch.from_numpy(scipy.ndimage.binary_fill_holes(m.cpu().numpy(), structure=np.ones((fill_holes,fill_holes)))).float()
+                m = torch.from_numpy(scipy.ndimage.grey_closing(m.cpu().numpy(), size=(fill_holes, fill_holes)))
+
+            # remove isolated pixels
+            if remove_isolated_pixels > 0:
+                m = torch.from_numpy(scipy.ndimage.grey_opening(m.cpu().numpy(), size=(remove_isolated_pixels, remove_isolated_pixels)))
+
+            # smooth the mask
+            if smooth > 0:
+                if smooth % 2 == 0:
+                    smooth += 1
+                m = T.functional.gaussian_blur((m > 0.5).unsqueeze(0), smooth).squeeze(0)
+
+            # blur the mask
+            if blur > 0:
+                if blur % 2 == 0:
+                    blur += 1
+                m = T.functional.gaussian_blur(m.float().unsqueeze(0), blur).squeeze(0)
+
+            masks.append(m.float())
+
+        masks = torch.stack(masks, dim=0).float()
+
+        return (masks, )
+
+class MaskSmooth:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "mask": ("MASK",),
+                "amount": ("INT", { "default": 0, "min": 0, "max": 127, "step": 1, }),
+            }
+        }
+
+    RETURN_TYPES = ("MASK",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/mask"
+
+    def execute(self, mask, amount):
+        if amount == 0:
+            return (mask,)
+        
+        if amount % 2 == 0:
+            amount += 1
+
+        mask = mask > 0.5
+        mask = T.functional.gaussian_blur(mask.unsqueeze(1), amount).squeeze(1).float()
+
+        return (mask,)
+
+class MaskFromBatch:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "mask": ("MASK", ),
+                "start": ("INT", { "default": 0, "min": 0, "step": 1, }),
+                "length": ("INT", { "default": 1, "min": 1, "step": 1, }),
+            }
+        }
+
+    RETURN_TYPES = ("MASK",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/mask batch"
+
+    def execute(self, mask, start, length):
+        if length > mask.shape[0]:
+            length = mask.shape[0]
+
+        start = min(start, mask.shape[0]-1)
+        length = min(mask.shape[0]-start, length)
+        return (mask[start:start + length], )
+
+class MaskFromList:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "width": ("INT", { "default": 32, "min": 0, "max": MAX_RESOLUTION, "step": 8, }),
+                "height": ("INT", { "default": 32, "min": 0, "max": MAX_RESOLUTION, "step": 8, }),
+            }, "optional": {
+                "values": (any, { "default": 0.0, "min": 0.0, "max": 1.0, }),
+                "str_values": ("STRING", { "default": "", "multiline": True, "placeholder": "0.0, 0.5, 1.0",}),
+            }
+        }
+
+    RETURN_TYPES = ("MASK",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/mask"
+
+    def execute(self, width, height, values=None, str_values=""):
+        out = []
+
+        if values is not None:
+            if not isinstance(values, list):
+                out = [values]
+            else:
+                out.extend([float(v) for v in values])
+
+        if str_values != "":
+            str_values = [float(v) for v in str_values.split(",")]
+            out.extend(str_values)
+
+        if out == []:
+            raise ValueError("No values provided")
+        
+        out = torch.tensor(out).float().clamp(0.0, 1.0)
+        out = out.view(-1, 1, 1).expand(-1, height, width)
+        
+        values = None
+        str_values = ""
+
+        return (out, )
+
+class MaskFromRGBCMYBW:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE", ),
+                "threshold_r": ("FLOAT", { "default": 0.15, "min": 0.0, "max": 1, "step": 0.01, }),
+                "threshold_g": ("FLOAT", { "default": 0.15, "min": 0.0, "max": 1, "step": 0.01, }),
+                "threshold_b": ("FLOAT", { "default": 0.15, "min": 0.0, "max": 1, "step": 0.01, }),
+            }
+        }
+
+    RETURN_TYPES = ("MASK","MASK","MASK","MASK","MASK","MASK","MASK","MASK",)
+    RETURN_NAMES = ("red","green","blue","cyan","magenta","yellow","black","white",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/mask"
+
+    def execute(self, image, threshold_r, threshold_g, threshold_b):
+        red = ((image[..., 0] >= 1-threshold_r) & (image[..., 1] < threshold_g) & (image[..., 2] < threshold_b)).float()
+        green = ((image[..., 0] < threshold_r) & (image[..., 1] >= 1-threshold_g) & (image[..., 2] < threshold_b)).float()
+        blue = ((image[..., 0] < threshold_r) & (image[..., 1] < threshold_g) & (image[..., 2] >= 1-threshold_b)).float()
+
+        cyan = ((image[..., 0] < threshold_r) & (image[..., 1] >= 1-threshold_g) & (image[..., 2] >= 1-threshold_b)).float()
+        magenta = ((image[..., 0] >= 1-threshold_r) & (image[..., 1] < threshold_g) & (image[..., 2] > 1-threshold_b)).float()
+        yellow = ((image[..., 0] >= 1-threshold_r) & (image[..., 1] >= 1-threshold_g) & (image[..., 2] < threshold_b)).float()
+
+        black = ((image[..., 0] <= threshold_r) & (image[..., 1] <= threshold_g) & (image[..., 2] <= threshold_b)).float()
+        white = ((image[..., 0] >= 1-threshold_r) & (image[..., 1] >= 1-threshold_g) & (image[..., 2] >= 1-threshold_b)).float()
+        
+        return (red, green, blue, cyan, magenta, yellow, black, white,)
+
+class TransitionMask:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "width": ("INT", { "default": 512, "min": 1, "max": MAX_RESOLUTION, "step": 1, }),
+                "height": ("INT", { "default": 512, "min": 1, "max": MAX_RESOLUTION, "step": 1, }),
+                "frames": ("INT", { "default": 16, "min": 1, "max": 9999, "step": 1, }),
+                "start_frame": ("INT", { "default": 0, "min": 0, "step": 1, }),
+                "end_frame": ("INT", { "default": 9999, "min": 0, "step": 1, }),
+                "transition_type": (["horizontal slide", "vertical slide", "horizontal bar", "vertical bar", "center box", "horizontal door", "vertical door", "circle", "fade"],),
+                "timing_function": (["linear", "in", "out", "in-out"],)
+            }
+        }
+
+    RETURN_TYPES = ("MASK",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/mask"
+
+    def linear(self, i, t):
+        return i/t
+    def ease_in(self, i, t):
+        return pow(i/t, 2)
+    def ease_out(self, i, t):
+        return 1 - pow(1 - i/t, 2)
+    def ease_in_out(self, i, t):
+        if i < t/2:
+            return pow(i/(t/2), 2) / 2
+        else:
+            return 1 - pow(1 - (i - t/2)/(t/2), 2) / 2
+
+    def execute(self, width, height, frames, start_frame, end_frame, transition_type, timing_function):
+        if timing_function == 'in':
+            timing_function = self.ease_in
+        elif timing_function == 'out':
+            timing_function = self.ease_out
+        elif timing_function == 'in-out':
+            timing_function = self.ease_in_out
+        else:
+            timing_function = self.linear
+
+        out = []
+
+        end_frame = min(frames, end_frame)
+        transition = end_frame - start_frame
+
+        if start_frame > 0:
+            out = out + [torch.full((height, width), 0.0, dtype=torch.float32, device="cpu")] * start_frame
+
+        for i in range(transition):
+            frame = torch.full((height, width), 0.0, dtype=torch.float32, device="cpu")
+            progress = timing_function(i, transition-1)
+
+            if "horizontal slide" in transition_type:
+                pos = round(width*progress)
+                frame[:, :pos] = 1.0
+            elif "vertical slide" in transition_type:
+                pos = round(height*progress)
+                frame[:pos, :] = 1.0
+            elif "box" in transition_type:
+                box_w = round(width*progress)
+                box_h = round(height*progress)
+                x1 = (width - box_w) // 2
+                y1 = (height - box_h) // 2
+                x2 = x1 + box_w
+                y2 = y1 + box_h
+                frame[y1:y2, x1:x2] = 1.0
+            elif "circle" in transition_type:
+                radius = math.ceil(math.sqrt(pow(width,2)+pow(height,2))*progress/2)
+                c_x = width // 2
+                c_y = height // 2
+                # is this real life? Am I hallucinating?
+                x = torch.arange(0, width, dtype=torch.float32, device="cpu")
+                y = torch.arange(0, height, dtype=torch.float32, device="cpu")
+                y, x = torch.meshgrid((y, x), indexing="ij")
+                circle = ((x - c_x) ** 2 + (y - c_y) ** 2) <= (radius ** 2)
+                frame[circle] = 1.0
+            elif "horizontal bar" in transition_type:
+                bar = round(height*progress)
+                y1 = (height - bar) // 2
+                y2 = y1 + bar
+                frame[y1:y2, :] = 1.0
+            elif "vertical bar" in transition_type:
+                bar = round(width*progress)
+                x1 = (width - bar) // 2
+                x2 = x1 + bar
+                frame[:, x1:x2] = 1.0
+            elif "horizontal door" in transition_type:
+                bar = math.ceil(height*progress/2)
+                if bar > 0:
+                    frame[:bar, :] = 1.0
+                    frame[-bar:, :] = 1.0
+            elif "vertical door" in transition_type:
+                bar = math.ceil(width*progress/2)
+                if bar > 0:
+                    frame[:, :bar] = 1.0
+                    frame[:, -bar:] = 1.0
+            elif "fade" in transition_type:
+                frame[:,:] = progress
+
+            out.append(frame)
+
+        if end_frame < frames:
+            out = out + [torch.full((height, width), 1.0, dtype=torch.float32, device="cpu")] * (frames - end_frame)
+
+        out = torch.stack(out, dim=0)
+
+        return (out, )
+
+MASK_CLASS_MAPPINGS = {
+    "MaskBlur+": MaskBlur,
+    "MaskBoundingBox+": MaskBoundingBox,
+    "MaskFix+": MaskFix,
+    "MaskFlip+": MaskFlip,
+    "MaskFromColor+": MaskFromColor,
+    "MaskFromList+": MaskFromList,
+    "MaskFromRGBCMYBW+": MaskFromRGBCMYBW,
+    "MaskFromSegmentation+": MaskFromSegmentation,
+    "MaskPreview+": MaskPreview,
+    "MaskSmooth+": MaskSmooth,
+    "TransitionMask+": TransitionMask,
+
+    # Batch
+    "MaskBatch+": MaskBatch,
+    "MaskExpandBatch+": MaskExpandBatch,
+    "MaskFromBatch+": MaskFromBatch,
+}
+
+MASK_NAME_MAPPINGS = {
+    "MaskBlur+": "🔧 Mask Blur",
+    "MaskFix+": "🔧 Mask Fix",
+    "MaskFlip+": "🔧 Mask Flip",
+    "MaskFromColor+": "🔧 Mask From Color",
+    "MaskFromList+": "🔧 Mask From List",
+    "MaskFromRGBCMYBW+": "🔧 Mask From RGB/CMY/BW",
+    "MaskFromSegmentation+": "🔧 Mask From Segmentation",
+    "MaskPreview+": "🔧 Mask Preview",
+    "MaskBoundingBox+": "🔧 Mask Bounding Box",
+    "MaskSmooth+": "🔧 Mask Smooth",
+    "TransitionMask+": "🔧 Transition Mask",
+
+    "MaskBatch+": "🔧 Mask Batch",
+    "MaskExpandBatch+": "🔧 Mask Expand Batch",
+    "MaskFromBatch+": "🔧 Mask From Batch",
+}

ComfyUI_essentials/misc.py

@@ -0,0 +1,574 @@
+import math
+import torch
+from .utils import AnyType
+import comfy.model_management
+from nodes import MAX_RESOLUTION
+import time
+
+any = AnyType("*")
+
+class SimpleMathFloat:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "value": ("FLOAT", { "default": 0.0, "min": -0xffffffffffffffff, "max": 0xffffffffffffffff, "step": 0.05 }),
+            },
+        }
+
+    RETURN_TYPES = ("FLOAT", )
+    FUNCTION = "execute"
+    CATEGORY = "essentials/utilities"
+
+    def execute(self, value):
+        return (float(value), )
+
+class SimpleMathPercent:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "value": ("FLOAT", { "default": 0.0, "min": 0, "max": 1, "step": 0.05 }),
+            },
+        }
+
+    RETURN_TYPES = ("FLOAT", )
+    FUNCTION = "execute"
+    CATEGORY = "essentials/utilities"
+
+    def execute(self, value):
+        return (float(value), )
+
+class SimpleMathInt:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "value": ("INT", { "default": 0, "min": -0xffffffffffffffff, "max": 0xffffffffffffffff, "step": 1 }),
+            },
+        }
+
+    RETURN_TYPES = ("INT",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/utilities"
+
+    def execute(self, value):
+        return (int(value), )
+
+class SimpleMathSlider:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "value": ("FLOAT", { "display": "slider", "default": 0.5, "min": 0.0, "max": 1.0, "step": 0.001 }),
+                "min": ("FLOAT", { "default": 0.0, "min": -0xffffffffffffffff, "max": 0xffffffffffffffff, "step": 0.001 }),
+                "max": ("FLOAT", { "default": 1.0, "min": -0xffffffffffffffff, "max": 0xffffffffffffffff, "step": 0.001 }),
+                "rounding": ("INT", { "default": 0, "min": 0, "max": 10, "step": 1 }),
+            },
+        }
+
+    RETURN_TYPES = ("FLOAT", "INT",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/utilities"
+
+    def execute(self, value, min, max, rounding):
+        value = min + value * (max - min)
+        
+        if rounding > 0:
+            value = round(value, rounding)
+
+        return (value, int(value), )
+
+class SimpleMathSliderLowRes:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "value": ("INT", { "display": "slider", "default": 5, "min": 0, "max": 10, "step": 1 }),
+                "min": ("FLOAT", { "default": 0.0, "min": -0xffffffffffffffff, "max": 0xffffffffffffffff, "step": 0.001 }),
+                "max": ("FLOAT", { "default": 1.0, "min": -0xffffffffffffffff, "max": 0xffffffffffffffff, "step": 0.001 }),
+                "rounding": ("INT", { "default": 0, "min": 0, "max": 10, "step": 1 }),
+            },
+        }
+
+    RETURN_TYPES = ("FLOAT", "INT",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/utilities"
+
+    def execute(self, value, min, max, rounding):
+        value = 0.1 * value
+        value = min + value * (max - min)
+        if rounding > 0:
+            value = round(value, rounding)
+
+        return (value, )
+
+class SimpleMathBoolean:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "value": ("BOOLEAN", { "default": False }),
+            },
+        }
+
+    RETURN_TYPES = ("BOOLEAN",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/utilities"
+
+    def execute(self, value):
+        return (value, int(value), )
+
+class SimpleMath:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "optional": {
+                "a": (any, { "default": 0.0 }),
+                "b": (any, { "default": 0.0 }),
+                "c": (any, { "default": 0.0 }),
+            },
+            "required": {
+                "value": ("STRING", { "multiline": False, "default": "" }),
+            },
+        }
+
+    RETURN_TYPES = ("INT", "FLOAT", )
+    FUNCTION = "execute"
+    CATEGORY = "essentials/utilities"
+
+    def execute(self, value, a = 0.0, b = 0.0, c = 0.0, d = 0.0):
+        import ast
+        import operator as op
+
+        h, w = 0.0, 0.0
+        if hasattr(a, 'shape'):
+            a = list(a.shape)
+        if hasattr(b, 'shape'):
+            b = list(b.shape)
+        if hasattr(c, 'shape'):
+            c = list(c.shape)
+        if hasattr(d, 'shape'):
+            d = list(d.shape)
+
+        if isinstance(a, str):
+            a = float(a)
+        if isinstance(b, str):
+            b = float(b)
+        if isinstance(c, str):
+            c = float(c)
+        if isinstance(d, str):
+            d = float(d)
+        
+        operators = {
+            ast.Add: op.add,
+            ast.Sub: op.sub,
+            ast.Mult: op.mul,
+            ast.Div: op.truediv,
+            ast.FloorDiv: op.floordiv,
+            ast.Pow: op.pow,
+            #ast.BitXor: op.xor,
+            #ast.BitOr: op.or_,
+            #ast.BitAnd: op.and_,
+            ast.USub: op.neg,
+            ast.Mod: op.mod,
+            ast.Eq: op.eq,
+            ast.NotEq: op.ne,
+            ast.Lt: op.lt,
+            ast.LtE: op.le,
+            ast.Gt: op.gt,
+            ast.GtE: op.ge,
+            ast.And: lambda x, y: x and y,
+            ast.Or: lambda x, y: x or y,
+            ast.Not: op.not_
+        }
+
+        op_functions = {
+            'min': min,
+            'max': max,
+            'round': round,
+            'sum': sum,
+            'len': len,
+        }
+
+        def eval_(node):
+            if isinstance(node, ast.Num): # number
+                return node.n
+            elif isinstance(node, ast.Name): # variable
+                if node.id == "a":
+                    return a
+                if node.id == "b":
+                    return b
+                if node.id == "c":
+                    return c
+                if node.id == "d":
+                    return d
+            elif isinstance(node, ast.BinOp): # <left> <operator> <right>
+                return operators[type(node.op)](eval_(node.left), eval_(node.right))
+            elif isinstance(node, ast.UnaryOp): # <operator> <operand> e.g., -1
+                return operators[type(node.op)](eval_(node.operand))
+            elif isinstance(node, ast.Compare):  # comparison operators
+                left = eval_(node.left)
+                for op, comparator in zip(node.ops, node.comparators):
+                    if not operators[type(op)](left, eval_(comparator)):
+                        return 0
+                return 1
+            elif isinstance(node, ast.BoolOp):  # boolean operators (And, Or)
+                values = [eval_(value) for value in node.values]
+                return operators[type(node.op)](*values)
+            elif isinstance(node, ast.Call): # custom function
+                if node.func.id in op_functions:
+                    args =[eval_(arg) for arg in node.args]
+                    return op_functions[node.func.id](*args)
+            elif isinstance(node, ast.Subscript): # indexing or slicing
+                value = eval_(node.value)
+                if isinstance(node.slice, ast.Constant):
+                    return value[node.slice.value]
+                else:
+                    return 0
+            else:
+                return 0
+
+        result = eval_(ast.parse(value, mode='eval').body)
+
+        if math.isnan(result):
+            result = 0.0
+        
+        return (round(result), result, )
+
+class SimpleMathDual:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "optional": {
+                "a": (any, { "default": 0.0 }),
+                "b": (any, { "default": 0.0 }),
+                "c": (any, { "default": 0.0 }),
+                "d": (any, { "default": 0.0 }),
+            },
+            "required": {
+                "value_1": ("STRING", { "multiline": False, "default": "" }),
+                "value_2": ("STRING", { "multiline": False, "default": "" }),
+            },
+        }
+    
+    RETURN_TYPES = ("INT", "FLOAT", "INT", "FLOAT", )
+    RETURN_NAMES = ("int_1", "float_1", "int_2", "float_2" )
+    FUNCTION = "execute"
+    CATEGORY = "essentials/utilities"
+
+    def execute(self, value_1, value_2, a = 0.0, b = 0.0, c = 0.0, d = 0.0):
+        return SimpleMath().execute(value_1, a, b, c, d) + SimpleMath().execute(value_2, a, b, c, d)
+
+class SimpleMathCondition:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "optional": {
+                "a": (any, { "default": 0.0 }),
+                "b": (any, { "default": 0.0 }),
+                "c": (any, { "default": 0.0 }),
+            },
+            "required": {
+                "evaluate": (any, {"default": 0}),
+                "on_true": ("STRING", { "multiline": False, "default": "" }),
+                "on_false": ("STRING", { "multiline": False, "default": "" }),
+            },
+        }
+    
+    RETURN_TYPES = ("INT", "FLOAT", )
+    FUNCTION = "execute"
+    CATEGORY = "essentials/utilities"
+
+    def execute(self, evaluate, on_true, on_false, a = 0.0, b = 0.0, c = 0.0):
+        return SimpleMath().execute(on_true if evaluate else on_false, a, b, c)
+
+class SimpleCondition:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "evaluate": (any, {"default": 0}),
+                "on_true": (any, {"default": 0}),
+            },
+            "optional": {
+                "on_false": (any, {"default": None}),
+            },
+        }
+
+    RETURN_TYPES = (any,)
+    RETURN_NAMES = ("result",)
+    FUNCTION = "execute"
+
+    CATEGORY = "essentials/utilities"
+
+    def execute(self, evaluate, on_true, on_false=None):
+        from comfy_execution.graph import ExecutionBlocker
+        if not evaluate:
+            return (on_false if on_false is not None else ExecutionBlocker(None),)
+
+        return (on_true,)
+
+class SimpleComparison:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "a": (any, {"default": 0}),
+                "b": (any, {"default": 0}),
+                "comparison": (["==", "!=", "<", "<=", ">", ">="],),
+            },
+        }
+
+    RETURN_TYPES = ("BOOLEAN",)
+    FUNCTION = "execute"
+
+    CATEGORY = "essentials/utilities"
+
+    def execute(self, a, b, comparison):
+        if comparison == "==":
+            return (a == b,)
+        elif comparison == "!=":
+            return (a != b,)
+        elif comparison == "<":
+            return (a < b,)
+        elif comparison == "<=":
+            return (a <= b,)
+        elif comparison == ">":
+            return (a > b,)
+        elif comparison == ">=":
+            return (a >= b,)
+
+class ConsoleDebug:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "value": (any, {}),
+            },
+            "optional": {
+                "prefix": ("STRING", { "multiline": False, "default": "Value:" })
+            }
+        }
+
+    RETURN_TYPES = ()
+    FUNCTION = "execute"
+    CATEGORY = "essentials/utilities"
+    OUTPUT_NODE = True
+
+    def execute(self, value, prefix):
+        print(f"\033[96m{prefix} {value}\033[0m")
+
+        return (None,)
+
+class DebugTensorShape:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "tensor": (any, {}),
+            },
+        }
+
+    RETURN_TYPES = ()
+    FUNCTION = "execute"
+    CATEGORY = "essentials/utilities"
+    OUTPUT_NODE = True
+
+    def execute(self, tensor):
+        shapes = []
+        def tensorShape(tensor):
+            if isinstance(tensor, dict):
+                for k in tensor:
+                    tensorShape(tensor[k])
+            elif isinstance(tensor, list):
+                for i in range(len(tensor)):
+                    tensorShape(tensor[i])
+            elif hasattr(tensor, 'shape'):
+                shapes.append(list(tensor.shape))
+
+        tensorShape(tensor)
+
+        print(f"\033[96mShapes found: {shapes}\033[0m")
+
+        return (None,)
+
+class BatchCount:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "batch": (any, {}),
+            },
+        }
+
+    RETURN_TYPES = ("INT",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/utilities"
+
+    def execute(self, batch):
+        count = 0
+        if hasattr(batch, 'shape'):
+            count = batch.shape[0]
+        elif isinstance(batch, dict) and 'samples' in batch:
+            count = batch['samples'].shape[0]
+        elif isinstance(batch, list) or isinstance(batch, dict):
+            count = len(batch)
+
+        return (count, )
+
+class ModelCompile():
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "model": ("MODEL",),
+                "fullgraph": ("BOOLEAN", { "default": False }),
+                "dynamic": ("BOOLEAN", { "default": False }),
+                "mode": (["default", "reduce-overhead", "max-autotune", "max-autotune-no-cudagraphs"],),
+            },
+        }
+
+    RETURN_TYPES = ("MODEL", )
+    FUNCTION = "execute"
+    CATEGORY = "essentials/utilities"
+
+    def execute(self, model, fullgraph, dynamic, mode):
+        work_model = model.clone()
+        torch._dynamo.config.suppress_errors = True
+        work_model.add_object_patch("diffusion_model", torch.compile(model=work_model.get_model_object("diffusion_model"), dynamic=dynamic, fullgraph=fullgraph, mode=mode))
+        return (work_model, )
+
+class RemoveLatentMask:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": { "samples": ("LATENT",),}}
+    RETURN_TYPES = ("LATENT",)
+    FUNCTION = "execute"
+
+    CATEGORY = "essentials/utilities"
+
+    def execute(self, samples):
+        s = samples.copy()
+        if "noise_mask" in s:
+            del s["noise_mask"]
+
+        return (s,)
+
+class SDXLEmptyLatentSizePicker:
+    def __init__(self):
+        self.device = comfy.model_management.intermediate_device()
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+            "resolution": (["704x1408 (0.5)","704x1344 (0.52)","768x1344 (0.57)","768x1280 (0.6)","832x1216 (0.68)","832x1152 (0.72)","896x1152 (0.78)","896x1088 (0.82)","960x1088 (0.88)","960x1024 (0.94)","1024x1024 (1.0)","1024x960 (1.07)","1088x960 (1.13)","1088x896 (1.21)","1152x896 (1.29)","1152x832 (1.38)","1216x832 (1.46)","1280x768 (1.67)","1344x768 (1.75)","1344x704 (1.91)","1408x704 (2.0)","1472x704 (2.09)","1536x640 (2.4)","1600x640 (2.5)","1664x576 (2.89)","1728x576 (3.0)",], {"default": "1024x1024 (1.0)"}),
+            "batch_size": ("INT", {"default": 1, "min": 1, "max": 4096}),
+            "width_override": ("INT", {"default": 0, "min": 0, "max": MAX_RESOLUTION, "step": 8}),
+            "height_override": ("INT", {"default": 0, "min": 0, "max": MAX_RESOLUTION, "step": 8}),
+            }}
+
+    RETURN_TYPES = ("LATENT","INT","INT",)
+    RETURN_NAMES = ("LATENT","width","height",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/utilities"
+
+    def execute(self, resolution, batch_size, width_override=0, height_override=0):
+        width, height = resolution.split(" ")[0].split("x")
+        width = width_override if width_override > 0 else int(width)
+        height = height_override if height_override > 0 else int(height)
+
+        latent = torch.zeros([batch_size, 4, height // 8, width // 8], device=self.device)
+
+        return ({"samples":latent}, width, height,)
+
+class DisplayAny:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "input": (("*",{})),
+                "mode": (["raw value", "tensor shape"],),
+            },
+        }
+
+    @classmethod
+    def VALIDATE_INPUTS(s, input_types):
+        return True
+
+    RETURN_TYPES = ("STRING",)
+    FUNCTION = "execute"
+    OUTPUT_NODE = True
+
+    CATEGORY = "essentials/utilities"
+
+    def execute(self, input, mode):
+        if mode == "tensor shape":
+            text = []
+            def tensorShape(tensor):
+                if isinstance(tensor, dict):
+                    for k in tensor:
+                        tensorShape(tensor[k])
+                elif isinstance(tensor, list):
+                    for i in range(len(tensor)):
+                        tensorShape(tensor[i])
+                elif hasattr(tensor, 'shape'):
+                    text.append(list(tensor.shape))
+
+            tensorShape(input)
+            input = text
+
+        text = str(input)
+
+        return {"ui": {"text": text}, "result": (text,)}
+
+MISC_CLASS_MAPPINGS = {
+    "BatchCount+": BatchCount,
+    "ConsoleDebug+": ConsoleDebug,
+    "DebugTensorShape+": DebugTensorShape,
+    "DisplayAny": DisplayAny,
+    "ModelCompile+": ModelCompile,
+    "RemoveLatentMask+": RemoveLatentMask,
+    "SDXLEmptyLatentSizePicker+": SDXLEmptyLatentSizePicker,
+    "SimpleComparison+": SimpleComparison,
+    "SimpleCondition+": SimpleCondition,
+    "SimpleMath+": SimpleMath,
+    "SimpleMathDual+": SimpleMathDual,
+    "SimpleMathCondition+": SimpleMathCondition,
+    "SimpleMathBoolean+": SimpleMathBoolean,
+    "SimpleMathFloat+": SimpleMathFloat,
+    "SimpleMathInt+": SimpleMathInt,
+    "SimpleMathPercent+": SimpleMathPercent,
+    "SimpleMathSlider+": SimpleMathSlider,
+    "SimpleMathSliderLowRes+": SimpleMathSliderLowRes,
+}
+
+MISC_NAME_MAPPINGS = {
+    "BatchCount+": "🔧 Batch Count",
+    "ConsoleDebug+": "🔧 Console Debug",
+    "DebugTensorShape+": "🔧 Debug Tensor Shape",
+    "DisplayAny": "🔧 Display Any",
+    "ModelCompile+": "🔧 Model Compile",
+    "RemoveLatentMask+": "🔧 Remove Latent Mask",
+    "SDXLEmptyLatentSizePicker+": "🔧 Empty Latent Size Picker",
+    "SimpleComparison+": "🔧 Simple Comparison",
+    "SimpleCondition+": "🔧 Simple Condition",
+    "SimpleMath+": "🔧 Simple Math",
+    "SimpleMathDual+": "🔧 Simple Math Dual",
+    "SimpleMathCondition+": "🔧 Simple Math Condition",
+    "SimpleMathBoolean+": "🔧 Simple Math Boolean",
+    "SimpleMathFloat+": "🔧 Simple Math Float",
+    "SimpleMathInt+": "🔧 Simple Math Int",
+    "SimpleMathPercent+": "🔧 Simple Math Percent",
+    "SimpleMathSlider+": "🔧 Simple Math Slider",
+    "SimpleMathSliderLowRes+": "🔧 Simple Math Slider low-res",
+}

ComfyUI_essentials/pyproject.toml

@@ -0,0 +1,15 @@
+[project]
+name = "comfyui_essentials"
+description = "Essential nodes that are weirdly missing from ComfyUI core. With few exceptions they are new features and not commodities."
+version = "1.1.0"
+license = { file = "LICENSE" }
+dependencies = ["numba", "colour-science", "rembg", "pixeloe"]
+
+[project.urls]
+Repository = "https://github.com/cubiq/ComfyUI_essentials"
+#  Used by Comfy Registry https://comfyregistry.org
+
+[tool.comfy]
+PublisherId = "matteo"
+DisplayName = "ComfyUI_essentials"
+Icon = ""

ComfyUI_essentials/requirements.txt

@@ -0,0 +1,5 @@
+numba
+colour-science
+rembg
+pixeloe
+transparent-background

ComfyUI_essentials/sampling.py

@@ -0,0 +1,811 @@
+import os
+import comfy.samplers
+import comfy.sample
+import torch
+from nodes import common_ksampler, CLIPTextEncode
+from comfy.utils import ProgressBar
+from .utils import expand_mask, FONTS_DIR, parse_string_to_list
+import torchvision.transforms.v2 as T
+import torch.nn.functional as F
+import logging
+import folder_paths
+
+# From https://github.com/BlenderNeko/ComfyUI_Noise/
+def slerp(val, low, high):
+    dims = low.shape
+
+    low = low.reshape(dims[0], -1)
+    high = high.reshape(dims[0], -1)
+
+    low_norm = low/torch.norm(low, dim=1, keepdim=True)
+    high_norm = high/torch.norm(high, dim=1, keepdim=True)
+
+    low_norm[low_norm != low_norm] = 0.0
+    high_norm[high_norm != high_norm] = 0.0
+
+    omega = torch.acos((low_norm*high_norm).sum(1))
+    so = torch.sin(omega)
+    res = (torch.sin((1.0-val)*omega)/so).unsqueeze(1)*low + (torch.sin(val*omega)/so).unsqueeze(1) * high
+
+    return res.reshape(dims)
+
+class KSamplerVariationsWithNoise:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                    "model": ("MODEL", ),
+                    "latent_image": ("LATENT", ),
+                    "main_seed": ("INT:seed", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
+                    "steps": ("INT", {"default": 20, "min": 1, "max": 10000}),
+                    "cfg": ("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", ),
+                    "variation_strength": ("FLOAT", {"default": 0.17, "min": 0.0, "max": 1.0, "step":0.01, "round": 0.01}),
+                    #"start_at_step": ("INT", {"default": 0, "min": 0, "max": 10000}),
+                    #"end_at_step": ("INT", {"default": 10000, "min": 0, "max": 10000}),
+                    #"return_with_leftover_noise": (["disable", "enable"], ),
+                    "variation_seed": ("INT:seed", {"default": 12345, "min": 0, "max": 0xffffffffffffffff}),
+                    "denoise": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step":0.01, "round": 0.01}),
+                }}
+
+    RETURN_TYPES = ("LATENT",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/sampling"
+
+    def prepare_mask(self, mask, shape):
+        mask = torch.nn.functional.interpolate(mask.reshape((-1, 1, mask.shape[-2], mask.shape[-1])), size=(shape[2], shape[3]), mode="bilinear")
+        mask = mask.expand((-1,shape[1],-1,-1))
+        if mask.shape[0] < shape[0]:
+            mask = mask.repeat((shape[0] -1) // mask.shape[0] + 1, 1, 1, 1)[:shape[0]]
+        return mask
+
+    def execute(self, model, latent_image, main_seed, steps, cfg, sampler_name, scheduler, positive, negative, variation_strength, variation_seed, denoise):
+        if main_seed == variation_seed:
+            variation_seed += 1
+
+        end_at_step = steps #min(steps, end_at_step)
+        start_at_step = round(end_at_step - end_at_step * denoise)
+
+        force_full_denoise = True
+        disable_noise = True
+
+        device = comfy.model_management.get_torch_device()
+
+        # Generate base noise
+        batch_size, _, height, width = latent_image["samples"].shape
+        generator = torch.manual_seed(main_seed)
+        base_noise = torch.randn((1, 4, height, width), dtype=torch.float32, device="cpu", generator=generator).repeat(batch_size, 1, 1, 1).cpu()
+
+        # Generate variation noise
+        generator = torch.manual_seed(variation_seed)
+        variation_noise = torch.randn((batch_size, 4, height, width), dtype=torch.float32, device="cpu", generator=generator).cpu()
+
+        slerp_noise = slerp(variation_strength, base_noise, variation_noise)
+
+        # Calculate sigma
+        comfy.model_management.load_model_gpu(model)
+        sampler = comfy.samplers.KSampler(model, steps=steps, device=device, sampler=sampler_name, scheduler=scheduler, denoise=1.0, model_options=model.model_options)
+        sigmas = sampler.sigmas
+        sigma = sigmas[start_at_step] - sigmas[end_at_step]
+        sigma /= model.model.latent_format.scale_factor
+        sigma = sigma.detach().cpu().item()
+
+        work_latent = latent_image.copy()
+        work_latent["samples"] = latent_image["samples"].clone() + slerp_noise * sigma
+
+        # if there's a mask we need to expand it to avoid artifacts, 5 pixels should be enough
+        if "noise_mask" in latent_image:
+            noise_mask = self.prepare_mask(latent_image["noise_mask"], latent_image['samples'].shape)
+            work_latent["samples"] = noise_mask * work_latent["samples"] + (1-noise_mask) * latent_image["samples"]
+            work_latent['noise_mask'] = expand_mask(latent_image["noise_mask"].clone(), 5, True)
+
+        return common_ksampler(model, main_seed, steps, cfg, sampler_name, scheduler, positive, negative, work_latent, denoise=1.0, disable_noise=disable_noise, start_step=start_at_step, last_step=end_at_step, force_full_denoise=force_full_denoise)
+
+
+class KSamplerVariationsStochastic:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required":{
+                    "model": ("MODEL",),
+                    "latent_image": ("LATENT", ),
+                    "noise_seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
+                    "steps": ("INT", {"default": 25, "min": 1, "max": 10000}),
+                    "cfg": ("FLOAT", {"default": 7.0, "min": 0.0, "max": 100.0, "step":0.1, "round": 0.01}),
+                    "sampler": (comfy.samplers.KSampler.SAMPLERS, ),
+                    "scheduler": (comfy.samplers.KSampler.SCHEDULERS, ),
+                    "positive": ("CONDITIONING", ),
+                    "negative": ("CONDITIONING", ),
+                    "variation_seed": ("INT:seed", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
+                    "variation_strength": ("FLOAT", {"default": 0.2, "min": 0.0, "max": 1.0, "step":0.05, "round": 0.01}),
+                    #"variation_sampler": (comfy.samplers.KSampler.SAMPLERS, ),
+                    "cfg_scale": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step":0.05, "round": 0.01}),
+                }}
+
+    RETURN_TYPES = ("LATENT", )
+    FUNCTION = "execute"
+    CATEGORY = "essentials/sampling"
+
+    def execute(self, model, latent_image, noise_seed, steps, cfg, sampler, scheduler, positive, negative, variation_seed, variation_strength, cfg_scale, variation_sampler="dpmpp_2m_sde"):
+        # Stage 1: composition sampler
+        force_full_denoise = False # return with leftover noise = "enable"
+        disable_noise = False # add noise = "enable"
+
+        end_at_step = max(int(steps * (1-variation_strength)), 1)
+        start_at_step = 0
+
+        work_latent = latent_image.copy()
+        batch_size = work_latent["samples"].shape[0]
+        work_latent["samples"] = work_latent["samples"][0].unsqueeze(0)
+
+        stage1 = common_ksampler(model, noise_seed, steps, cfg, sampler, scheduler, positive, negative, work_latent, denoise=1.0, disable_noise=disable_noise, start_step=start_at_step, last_step=end_at_step, force_full_denoise=force_full_denoise)[0]
+
+        if batch_size > 1:
+            stage1["samples"] = stage1["samples"].clone().repeat(batch_size, 1, 1, 1)
+
+        # Stage 2: variation sampler
+        force_full_denoise = True
+        disable_noise = True
+        cfg = max(cfg * cfg_scale, 1.0)
+        start_at_step = end_at_step
+        end_at_step = steps
+
+        return common_ksampler(model, variation_seed, steps, cfg, variation_sampler, scheduler, positive, negative, stage1, denoise=1.0, disable_noise=disable_noise, start_step=start_at_step, last_step=end_at_step, force_full_denoise=force_full_denoise)
+
+class InjectLatentNoise:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                    "latent": ("LATENT", ),
+                    "noise_seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
+                    "noise_strength": ("FLOAT", {"default": 1.0, "min": -20.0, "max": 20.0, "step":0.01, "round": 0.01}),
+                    "normalize": (["false", "true"], {"default": "false"}),
+                },
+                "optional": {
+                    "mask": ("MASK", ),
+                }}
+
+    RETURN_TYPES = ("LATENT",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/sampling"
+
+    def execute(self, latent, noise_seed, noise_strength, normalize="false", mask=None):
+        torch.manual_seed(noise_seed)
+        noise_latent = latent.copy()
+        original_samples = noise_latent["samples"].clone()
+        random_noise = torch.randn_like(original_samples)
+
+        if normalize == "true":
+            mean = original_samples.mean()
+            std = original_samples.std()
+            random_noise = random_noise * std + mean
+
+        random_noise = original_samples + random_noise * noise_strength
+
+        if mask is not None:
+            mask = F.interpolate(mask.reshape((-1, 1, mask.shape[-2], mask.shape[-1])), size=(random_noise.shape[2], random_noise.shape[3]), mode="bilinear")
+            mask = mask.expand((-1,random_noise.shape[1],-1,-1)).clamp(0.0, 1.0)
+            if mask.shape[0] < random_noise.shape[0]:
+                mask = mask.repeat((random_noise.shape[0] -1) // mask.shape[0] + 1, 1, 1, 1)[:random_noise.shape[0]]
+            elif mask.shape[0] > random_noise.shape[0]:
+                mask = mask[:random_noise.shape[0]]
+            random_noise = mask * random_noise + (1-mask) * original_samples
+
+        noise_latent["samples"] = random_noise
+
+        return (noise_latent, )
+
+class TextEncodeForSamplerParams:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "text": ("STRING", {"multiline": True, "dynamicPrompts": True, "default": "Separate prompts with at least three dashes\n---\nLike so"}),
+                "clip": ("CLIP", )
+            }}
+
+    RETURN_TYPES = ("CONDITIONING", )
+    FUNCTION = "execute"
+    CATEGORY = "essentials/sampling"
+
+    def execute(self, text, clip):
+        import re
+        output_text = []
+        output_encoded = []
+        text = re.sub(r'[-*=~]{4,}\n', '---\n', text)
+        text = text.split("---\n")
+
+        for t in text:
+            t = t.strip()
+            if t:
+                output_text.append(t)
+                output_encoded.append(CLIPTextEncode().encode(clip, t)[0])
+
+        #if len(output_encoded) == 1:
+        #    output = output_encoded[0]
+        #else:
+        output = {"text": output_text, "encoded": output_encoded}
+
+        return (output, )
+
+class SamplerSelectHelper:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+            **{s: ("BOOLEAN", { "default": False }) for s in comfy.samplers.KSampler.SAMPLERS},
+        }}
+
+    RETURN_TYPES = ("STRING", )
+    FUNCTION = "execute"
+    CATEGORY = "essentials/sampling"
+
+    def execute(self, **values):
+        values = [v for v in values if values[v]]
+        values = ", ".join(values)
+
+        return (values, )
+
+class SchedulerSelectHelper:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+            **{s: ("BOOLEAN", { "default": False }) for s in comfy.samplers.KSampler.SCHEDULERS},
+        }}
+
+    RETURN_TYPES = ("STRING", )
+    FUNCTION = "execute"
+    CATEGORY = "essentials/sampling"
+
+    def execute(self, **values):
+        values = [v for v in values if values[v]]
+        values = ", ".join(values)
+
+        return (values, )
+
+class LorasForFluxParams:
+    @classmethod
+    def INPUT_TYPES(s):
+        optional_loras = ['none'] + folder_paths.get_filename_list("loras")
+        return {
+            "required": {
+                "lora_1": (folder_paths.get_filename_list("loras"), {"tooltip": "The name of the LoRA."}),
+                "strength_model_1": ("STRING", { "multiline": False, "dynamicPrompts": False, "default": "1.0" }),
+            },
+            #"optional": {
+            #    "lora_2": (optional_loras, ),
+            #    "strength_lora_2": ("STRING", { "multiline": False, "dynamicPrompts": False }),
+            #    "lora_3": (optional_loras, ),
+            #    "strength_lora_3": ("STRING", { "multiline": False, "dynamicPrompts": False }),
+            #    "lora_4": (optional_loras, ),
+            #    "strength_lora_4": ("STRING", { "multiline": False, "dynamicPrompts": False }),
+            #}
+        }
+
+    RETURN_TYPES = ("LORA_PARAMS", )
+    FUNCTION = "execute"
+    CATEGORY = "essentials/sampling"
+
+    def execute(self, lora_1, strength_model_1, lora_2="none", strength_lora_2="", lora_3="none", strength_lora_3="", lora_4="none", strength_lora_4=""):
+        output = { "loras": [], "strengths": [] }
+        output["loras"].append(lora_1)
+        output["strengths"].append(parse_string_to_list(strength_model_1))
+
+        if lora_2 != "none":
+            output["loras"].append(lora_2)
+            if strength_lora_2 == "":
+                strength_lora_2 = "1.0"
+            output["strengths"].append(parse_string_to_list(strength_lora_2))
+        if lora_3 != "none":
+            output["loras"].append(lora_3)
+            if strength_lora_3 == "":
+                strength_lora_3 = "1.0"
+            output["strengths"].append(parse_string_to_list(strength_lora_3))
+        if lora_4 != "none":
+            output["loras"].append(lora_4)
+            if strength_lora_4 == "":
+                strength_lora_4 = "1.0"
+            output["strengths"].append(parse_string_to_list(strength_lora_4))
+
+        return (output,)
+
+
+class FluxSamplerParams:
+    def __init__(self):
+        self.loraloader = None
+        self.lora = (None, None)
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                    "model": ("MODEL", ),
+                    "conditioning": ("CONDITIONING", ),
+                    "latent_image": ("LATENT", ),
+
+                    "seed": ("STRING", { "multiline": False, "dynamicPrompts": False, "default": "?" }),
+                    "sampler": ("STRING", { "multiline": False, "dynamicPrompts": False, "default": "euler" }),
+                    "scheduler": ("STRING", { "multiline": False, "dynamicPrompts": False, "default": "simple" }),
+                    "steps": ("STRING", { "multiline": False, "dynamicPrompts": False, "default": "20" }),
+                    "guidance": ("STRING", { "multiline": False, "dynamicPrompts": False, "default": "3.5" }),
+                    "max_shift": ("STRING", { "multiline": False, "dynamicPrompts": False, "default": "" }),
+                    "base_shift": ("STRING", { "multiline": False, "dynamicPrompts": False, "default": "" }),
+                    "denoise": ("STRING", { "multiline": False, "dynamicPrompts": False, "default": "1.0" }),
+                },
+                "optional": {
+                    "loras": ("LORA_PARAMS",),
+                }}
+
+    RETURN_TYPES = ("LATENT","SAMPLER_PARAMS")
+    RETURN_NAMES = ("latent", "params")
+    FUNCTION = "execute"
+    CATEGORY = "essentials/sampling"
+
+    def execute(self, model, conditioning, latent_image, seed, sampler, scheduler, steps, guidance, max_shift, base_shift, denoise, loras=None):
+        import random
+        import time
+        from comfy_extras.nodes_custom_sampler import Noise_RandomNoise, BasicScheduler, BasicGuider, SamplerCustomAdvanced
+        from comfy_extras.nodes_latent import LatentBatch
+        from comfy_extras.nodes_model_advanced import ModelSamplingFlux, ModelSamplingAuraFlow
+        from node_helpers import conditioning_set_values
+        from nodes import LoraLoader
+
+        is_schnell = model.model.model_type == comfy.model_base.ModelType.FLOW
+
+        noise = seed.replace("\n", ",").split(",")
+        noise = [random.randint(0, 999999) if "?" in n else int(n) for n in noise]
+        if not noise:
+            noise = [random.randint(0, 999999)]
+
+        if sampler == '*':
+            sampler = comfy.samplers.KSampler.SAMPLERS
+        elif sampler.startswith("!"):
+            sampler = sampler.replace("\n", ",").split(",")
+            sampler = [s.strip("! ") for s in sampler]
+            sampler = [s for s in comfy.samplers.KSampler.SAMPLERS if s not in sampler]
+        else:
+            sampler = sampler.replace("\n", ",").split(",")
+            sampler = [s.strip() for s in sampler if s.strip() in comfy.samplers.KSampler.SAMPLERS]
+        if not sampler:
+            sampler = ['ipndm']
+
+        if scheduler == '*':
+            scheduler = comfy.samplers.KSampler.SCHEDULERS
+        elif scheduler.startswith("!"):
+            scheduler = scheduler.replace("\n", ",").split(",")
+            scheduler = [s.strip("! ") for s in scheduler]
+            scheduler = [s for s in comfy.samplers.KSampler.SCHEDULERS if s not in scheduler]
+        else:
+            scheduler = scheduler.replace("\n", ",").split(",")
+            scheduler = [s.strip() for s in scheduler]
+            scheduler = [s for s in scheduler if s in comfy.samplers.KSampler.SCHEDULERS]
+        if not scheduler:
+            scheduler = ['simple']
+
+        if steps == "":
+            if is_schnell:
+                steps = "4"
+            else:
+                steps = "20"
+        steps = parse_string_to_list(steps)
+
+        denoise = "1.0" if denoise == "" else denoise
+        denoise = parse_string_to_list(denoise)
+
+        guidance = "3.5" if guidance == "" else guidance
+        guidance = parse_string_to_list(guidance)
+
+        if not is_schnell:
+            max_shift = "1.15" if max_shift == "" else max_shift
+            base_shift = "0.5" if base_shift == "" else base_shift
+        else:
+            max_shift = "0"
+            base_shift = "1.0" if base_shift == "" else base_shift
+
+        max_shift = parse_string_to_list(max_shift)
+        base_shift = parse_string_to_list(base_shift)
+
+        cond_text = None
+        if isinstance(conditioning, dict) and "encoded" in conditioning:
+            cond_text = conditioning["text"]
+            cond_encoded = conditioning["encoded"]
+        else:
+            cond_encoded = [conditioning]
+
+        out_latent = None
+        out_params = []
+
+        basicschedueler = BasicScheduler()
+        basicguider = BasicGuider()
+        samplercustomadvanced = SamplerCustomAdvanced()
+        latentbatch = LatentBatch()
+        modelsamplingflux = ModelSamplingFlux() if not is_schnell else ModelSamplingAuraFlow()
+        width = latent_image["samples"].shape[3]*8
+        height = latent_image["samples"].shape[2]*8
+
+        lora_strength_len = 1
+        if loras:
+            lora_model = loras["loras"]
+            lora_strength = loras["strengths"]
+            lora_strength_len = sum(len(i) for i in lora_strength)
+
+            if self.loraloader is None:
+                self.loraloader = LoraLoader()
+
+        # count total number of samples
+        total_samples = len(cond_encoded) * len(noise) * len(max_shift) * len(base_shift) * len(guidance) * len(sampler) * len(scheduler) * len(steps) * len(denoise) * lora_strength_len
+        current_sample = 0
+        if total_samples > 1:
+            pbar = ProgressBar(total_samples)
+
+        lora_strength_len = 1
+        if loras:
+            lora_strength_len = len(lora_strength[0])
+
+        for los in range(lora_strength_len):
+            if loras:
+                patched_model = self.loraloader.load_lora(model, None, lora_model[0], lora_strength[0][los], 0)[0]
+            else:
+                patched_model = model
+
+            for i in range(len(cond_encoded)):
+                conditioning = cond_encoded[i]
+                ct = cond_text[i] if cond_text else None
+                for n in noise:
+                    randnoise = Noise_RandomNoise(n)
+                    for ms in max_shift:
+                        for bs in base_shift:
+                            if is_schnell:
+                                work_model = modelsamplingflux.patch_aura(patched_model, bs)[0]
+                            else:
+                                work_model = modelsamplingflux.patch(patched_model, ms, bs, width, height)[0]
+                            for g in guidance:
+                                cond = conditioning_set_values(conditioning, {"guidance": g})
+                                guider = basicguider.get_guider(work_model, cond)[0]
+                                for s in sampler:
+                                    samplerobj = comfy.samplers.sampler_object(s)
+                                    for sc in scheduler:
+                                        for st in steps:
+                                            for d in denoise:
+                                                sigmas = basicschedueler.get_sigmas(work_model, sc, st, d)[0]
+                                                current_sample += 1
+                                                log = f"Sampling {current_sample}/{total_samples} with seed {n}, sampler {s}, scheduler {sc}, steps {st}, guidance {g}, max_shift {ms}, base_shift {bs}, denoise {d}"
+                                                lora_name = None
+                                                lora_str = 0
+                                                if loras:
+                                                    lora_name = lora_model[0]
+                                                    lora_str = lora_strength[0][los]
+                                                    log += f", lora {lora_name}, lora_strength {lora_str}"
+                                                logging.info(log)
+                                                start_time = time.time()
+                                                latent = samplercustomadvanced.sample(randnoise, guider, samplerobj, sigmas, latent_image)[1]
+                                                elapsed_time = time.time() - start_time
+                                                out_params.append({"time": elapsed_time,
+                                                                "seed": n,
+                                                                "width": width,
+                                                                "height": height,
+                                                                "sampler": s,
+                                                                "scheduler": sc,
+                                                                "steps": st,
+                                                                "guidance": g,
+                                                                "max_shift": ms,
+                                                                "base_shift": bs,
+                                                                "denoise": d,
+                                                                "prompt": ct,
+                                                                "lora": lora_name,
+                                                                "lora_strength": lora_str})
+
+                                                if out_latent is None:
+                                                    out_latent = latent
+                                                else:
+                                                    out_latent = latentbatch.batch(out_latent, latent)[0]
+                                                if total_samples > 1:
+                                                    pbar.update(1)
+
+        return (out_latent, out_params)
+
+class PlotParameters:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                    "images": ("IMAGE", ),
+                    "params": ("SAMPLER_PARAMS", ),
+                    "order_by": (["none", "time", "seed", "steps", "denoise", "sampler", "scheduler", "guidance", "max_shift", "base_shift", "lora_strength"], ),
+                    "cols_value": (["none", "time", "seed", "steps", "denoise", "sampler", "scheduler", "guidance", "max_shift", "base_shift", "lora_strength"], ),
+                    "cols_num": ("INT", {"default": -1, "min": -1, "max": 1024 }),
+                    "add_prompt": (["false", "true", "excerpt"], ),
+                    "add_params": (["false", "true", "changes only"], {"default": "true"}),
+                }}
+
+    RETURN_TYPES = ("IMAGE", )
+    FUNCTION = "execute"
+    CATEGORY = "essentials/sampling"
+
+    def execute(self, images, params, order_by, cols_value, cols_num, add_prompt, add_params):
+        from PIL import Image, ImageDraw, ImageFont
+        import math
+        import textwrap
+
+        if images.shape[0] != len(params):
+            raise ValueError("Number of images and number of parameters do not match.")
+
+        _params = params.copy()
+
+        if order_by != "none":
+            sorted_params = sorted(_params, key=lambda x: x[order_by])
+            indices = [_params.index(item) for item in sorted_params]
+            images = images[torch.tensor(indices)]
+            _params = sorted_params
+
+        if cols_value != "none" and cols_num > -1:
+            groups = {}
+            for p in _params:
+                value = p[cols_value]
+                if value not in groups:
+                    groups[value] = []
+                groups[value].append(p)
+            cols_num = len(groups)
+
+            sorted_params = []
+            groups = list(groups.values())
+            for g in zip(*groups):
+                sorted_params.extend(g)
+
+            indices = [_params.index(item) for item in sorted_params]
+            images = images[torch.tensor(indices)]
+            _params = sorted_params
+        elif cols_num == 0:
+            cols_num = int(math.sqrt(images.shape[0]))
+            cols_num = max(1, min(cols_num, 1024))
+
+        width = images.shape[2]
+        out_image = []
+
+        font = ImageFont.truetype(os.path.join(FONTS_DIR, 'ShareTechMono-Regular.ttf'), min(48, int(32*(width/1024))))
+        text_padding = 3
+        line_height = font.getmask('Q').getbbox()[3] + font.getmetrics()[1] + text_padding*2
+        char_width = font.getbbox('M')[2]+1 # using monospace font
+
+        if add_params == "changes only":
+            value_tracker = {}
+            for p in _params:
+                for key, value in p.items():
+                    if key != "time":
+                        if key not in value_tracker:
+                            value_tracker[key] = set()
+                        value_tracker[key].add(value)
+            changing_keys = {key for key, values in value_tracker.items() if len(values) > 1 or key == "prompt"}
+
+            result = []
+            for p in _params:
+                changing_params = {key: value for key, value in p.items() if key in changing_keys}
+                result.append(changing_params)
+
+            _params = result
+
+        for (image, param) in zip(images, _params):
+            image = image.permute(2, 0, 1)
+
+            if add_params != "false":
+                if add_params == "changes only":
+                    text = "\n".join([f"{key}: {value}" for key, value in param.items() if key != "prompt"])
+                else:
+                    text = f"time: {param['time']:.2f}s, seed: {param['seed']}, steps: {param['steps']}, size: {param['width']}×{param['height']}\ndenoise: {param['denoise']}, sampler: {param['sampler']}, sched: {param['scheduler']}\nguidance: {param['guidance']}, max/base shift: {param['max_shift']}/{param['base_shift']}"
+                    if 'lora' in param and param['lora']:
+                        text += f"\nLoRA: {param['lora'][:32]}, str: {param['lora_strength']}"
+
+                lines = text.split("\n")
+                text_height = line_height * len(lines)
+                text_image = Image.new('RGB', (width, text_height), color=(0, 0, 0))
+
+                for i, line in enumerate(lines):
+                    draw = ImageDraw.Draw(text_image)
+                    draw.text((text_padding, i * line_height + text_padding), line, font=font, fill=(255, 255, 255))
+
+                text_image = T.ToTensor()(text_image).to(image.device)
+                image = torch.cat([image, text_image], 1)
+
+            if 'prompt' in param and param['prompt'] and add_prompt != "false":
+                prompt = param['prompt']
+                if add_prompt == "excerpt":
+                    prompt = " ".join(param['prompt'].split()[:64])
+                    prompt += "..."
+
+                cols = math.ceil(width / char_width)
+                prompt_lines = textwrap.wrap(prompt, width=cols)
+                prompt_height = line_height * len(prompt_lines)
+                prompt_image = Image.new('RGB', (width, prompt_height), color=(0, 0, 0))
+
+                for i, line in enumerate(prompt_lines):
+                    draw = ImageDraw.Draw(prompt_image)
+                    draw.text((text_padding, i * line_height + text_padding), line, font=font, fill=(255, 255, 255))
+
+                prompt_image = T.ToTensor()(prompt_image).to(image.device)
+                image = torch.cat([image, prompt_image], 1)
+
+            # a little cleanup
+            image = torch.nan_to_num(image, nan=0.0).clamp(0.0, 1.0)
+            out_image.append(image)
+
+        # ensure all images have the same height
+        if add_prompt != "false" or add_params == "changes only":
+            max_height = max([image.shape[1] for image in out_image])
+            out_image = [F.pad(image, (0, 0, 0, max_height - image.shape[1])) for image in out_image]
+
+        out_image = torch.stack(out_image, 0).permute(0, 2, 3, 1)
+
+        # merge images
+        if cols_num > -1:
+            cols = min(cols_num, out_image.shape[0])
+            b, h, w, c = out_image.shape
+            rows = math.ceil(b / cols)
+
+            # Pad the tensor if necessary
+            if b % cols != 0:
+                padding = cols - (b % cols)
+                out_image = F.pad(out_image, (0, 0, 0, 0, 0, 0, 0, padding))
+                b = out_image.shape[0]
+
+            # Reshape and transpose
+            out_image = out_image.reshape(rows, cols, h, w, c)
+            out_image = out_image.permute(0, 2, 1, 3, 4)
+            out_image = out_image.reshape(rows * h, cols * w, c).unsqueeze(0)
+
+            """
+            width = out_image.shape[2]
+            # add the title and notes on top
+            if title and export_labels:
+                title_font = ImageFont.truetype(os.path.join(FONTS_DIR, 'ShareTechMono-Regular.ttf'), 48)
+                title_width = title_font.getbbox(title)[2]
+                title_padding = 6
+                title_line_height = title_font.getmask(title).getbbox()[3] + title_font.getmetrics()[1] + title_padding*2
+                title_text_height = title_line_height
+                title_text_image = Image.new('RGB', (width, title_text_height), color=(0, 0, 0, 0))
+
+                draw = ImageDraw.Draw(title_text_image)
+                draw.text((width//2 - title_width//2, title_padding), title, font=title_font, fill=(255, 255, 255))
+
+                title_text_image = T.ToTensor()(title_text_image).unsqueeze(0).permute([0,2,3,1]).to(out_image.device)
+                out_image = torch.cat([title_text_image, out_image], 1)
+            """
+
+        return (out_image, )
+
+class GuidanceTimestepping:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "model": ("MODEL",),
+                "value": ("FLOAT", {"default": 2.0, "min": 0.0, "max": 100.0, "step": 0.05}),
+                "start_at": ("FLOAT", {"default": 0.2, "min": 0.0, "max": 1.0, "step": 0.01}),
+                "end_at": ("FLOAT", {"default": 0.8, "min": 0.0, "max": 1.0, "step": 0.01}),
+            }
+        }
+
+    RETURN_TYPES = ("MODEL",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/sampling"
+
+    def execute(self, model, value, start_at, end_at):
+        sigma_start = model.get_model_object("model_sampling").percent_to_sigma(start_at)
+        sigma_end = model.get_model_object("model_sampling").percent_to_sigma(end_at)
+
+        def apply_apg(args):
+            cond = args["cond"]
+            uncond = args["uncond"]
+            cond_scale = args["cond_scale"]
+            sigma = args["sigma"]
+
+            sigma = sigma.detach().cpu()[0].item()
+
+            if sigma <= sigma_start and sigma > sigma_end:
+                cond_scale = value
+
+            return uncond + (cond - uncond) * cond_scale
+        
+        m = model.clone()
+        m.set_model_sampler_cfg_function(apply_apg)
+        return (m,)
+
+class ModelSamplingDiscreteFlowCustom(torch.nn.Module):
+    def __init__(self, model_config=None):
+        super().__init__()
+        if model_config is not None:
+            sampling_settings = model_config.sampling_settings
+        else:
+            sampling_settings = {}
+
+        self.set_parameters(shift=sampling_settings.get("shift", 1.0), multiplier=sampling_settings.get("multiplier", 1000))
+
+    def set_parameters(self, shift=1.0, timesteps=1000, multiplier=1000, cut_off=1.0, shift_multiplier=0):
+        self.shift = shift
+        self.multiplier = multiplier
+        self.cut_off = cut_off
+        self.shift_multiplier = shift_multiplier
+        ts = self.sigma((torch.arange(1, timesteps + 1, 1) / timesteps) * multiplier)
+        self.register_buffer('sigmas', ts)
+
+    @property
+    def sigma_min(self):
+        return self.sigmas[0]
+
+    @property
+    def sigma_max(self):
+        return self.sigmas[-1]
+
+    def timestep(self, sigma):
+        return sigma * self.multiplier
+
+    def sigma(self, timestep):
+        shift = self.shift
+        if timestep.dim() == 0:
+            t = timestep.cpu().item() / self.multiplier
+            if t <= self.cut_off:
+                shift = shift * self.shift_multiplier
+            
+        return comfy.model_sampling.time_snr_shift(shift, timestep / self.multiplier)
+
+    def percent_to_sigma(self, percent):
+        if percent <= 0.0:
+            return 1.0
+        if percent >= 1.0:
+            return 0.0
+        return 1.0 - percent
+
+class ModelSamplingSD3Advanced:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": { "model": ("MODEL",),
+                              "shift": ("FLOAT", {"default": 3.0, "min": 0.0, "max": 100.0, "step":0.01}),
+                              "cut_off": ("FLOAT", {"default": 0.5, "min": 0.0, "max": 1.0, "step":0.05}),
+                              "shift_multiplier": ("FLOAT", {"default": 2, "min": 0, "max": 10, "step":0.05}),
+                              }}
+
+    RETURN_TYPES = ("MODEL",)
+    FUNCTION = "execute"
+
+    CATEGORY = "essentials/sampling"
+
+    def execute(self, model, shift, multiplier=1000, cut_off=1.0, shift_multiplier=0):
+        m = model.clone()
+        
+
+        sampling_base = ModelSamplingDiscreteFlowCustom
+        sampling_type = comfy.model_sampling.CONST
+
+        class ModelSamplingAdvanced(sampling_base, sampling_type):
+            pass
+
+        model_sampling = ModelSamplingAdvanced(model.model.model_config)
+        model_sampling.set_parameters(shift=shift, multiplier=multiplier, cut_off=cut_off, shift_multiplier=shift_multiplier)
+        m.add_object_patch("model_sampling", model_sampling)
+
+        return (m, )
+
+SAMPLING_CLASS_MAPPINGS = {
+    "KSamplerVariationsStochastic+": KSamplerVariationsStochastic,
+    "KSamplerVariationsWithNoise+": KSamplerVariationsWithNoise,
+    "InjectLatentNoise+": InjectLatentNoise,
+    "FluxSamplerParams+": FluxSamplerParams,
+    "GuidanceTimestepping+": GuidanceTimestepping,
+    "PlotParameters+": PlotParameters,
+    "TextEncodeForSamplerParams+": TextEncodeForSamplerParams,
+    "SamplerSelectHelper+": SamplerSelectHelper,
+    "SchedulerSelectHelper+": SchedulerSelectHelper,
+    "LorasForFluxParams+": LorasForFluxParams,
+    "ModelSamplingSD3Advanced+": ModelSamplingSD3Advanced,
+}
+
+SAMPLING_NAME_MAPPINGS = {
+    "KSamplerVariationsStochastic+": "🔧 KSampler Stochastic Variations",
+    "KSamplerVariationsWithNoise+": "🔧 KSampler Variations with Noise Injection",
+    "InjectLatentNoise+": "🔧 Inject Latent Noise",
+    "FluxSamplerParams+": "🔧 Flux Sampler Parameters",
+    "GuidanceTimestepping+": "🔧 Guidance Timestep (experimental)",
+    "PlotParameters+": "🔧 Plot Sampler Parameters",
+    "TextEncodeForSamplerParams+": "🔧Text Encode for Sampler Params",
+    "SamplerSelectHelper+": "🔧 Sampler Select Helper",
+    "SchedulerSelectHelper+": "🔧 Scheduler Select Helper",
+    "LorasForFluxParams+": "🔧 LoRA for Flux Parameters",
+    "ModelSamplingSD3Advanced+": "🔧 Model Sampling SD3 Advanced",
+}

ComfyUI_essentials/segmentation.py

@@ -0,0 +1,89 @@
+import torch
+import torchvision.transforms.v2 as T
+import torch.nn.functional as F
+from .utils import expand_mask
+
+class LoadCLIPSegModels:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {},
+        }
+
+    RETURN_TYPES = ("CLIP_SEG",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/segmentation"
+
+    def execute(self):
+        from transformers import CLIPSegProcessor, CLIPSegForImageSegmentation
+        processor = CLIPSegProcessor.from_pretrained("CIDAS/clipseg-rd64-refined")
+        model = CLIPSegForImageSegmentation.from_pretrained("CIDAS/clipseg-rd64-refined")
+
+        return ((processor, model),)
+
+class ApplyCLIPSeg:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "clip_seg": ("CLIP_SEG",),
+                "image": ("IMAGE",),
+                "prompt": ("STRING", { "multiline": False, "default": "" }),
+                "threshold": ("FLOAT", { "default": 0.4, "min": 0.0, "max": 1.0, "step": 0.05 }),
+                "smooth": ("INT", { "default": 9, "min": 0, "max": 32, "step": 1 }),
+                "dilate": ("INT", { "default": 0, "min": -32, "max": 32, "step": 1 }),
+                "blur": ("INT", { "default": 0, "min": 0, "max": 64, "step": 1 }),
+            },
+        }
+
+    RETURN_TYPES = ("MASK",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/segmentation"
+
+    def execute(self, image, clip_seg, prompt, threshold, smooth, dilate, blur):
+        processor, model = clip_seg
+
+        imagenp = image.mul(255).clamp(0, 255).byte().cpu().numpy()
+
+        outputs = []
+        for i in imagenp:
+            inputs = processor(text=prompt, images=[i], return_tensors="pt")
+            out = model(**inputs)
+            out = out.logits.unsqueeze(1)
+            out = torch.sigmoid(out[0][0])
+            out = (out > threshold)
+            outputs.append(out)
+
+        del imagenp
+
+        outputs = torch.stack(outputs, dim=0)
+
+        if smooth > 0:
+            if smooth % 2 == 0:
+                smooth += 1
+            outputs = T.functional.gaussian_blur(outputs, smooth)
+
+        outputs = outputs.float()
+
+        if dilate != 0:
+            outputs = expand_mask(outputs, dilate, True)
+
+        if blur > 0:
+            if blur % 2 == 0:
+                blur += 1
+            outputs = T.functional.gaussian_blur(outputs, blur)
+        
+        # resize to original size
+        outputs = F.interpolate(outputs.unsqueeze(1), size=(image.shape[1], image.shape[2]), mode='bicubic').squeeze(1)
+
+        return (outputs,)
+
+SEG_CLASS_MAPPINGS = {
+    "ApplyCLIPSeg+": ApplyCLIPSeg,
+    "LoadCLIPSegModels+": LoadCLIPSegModels,
+}
+
+SEG_NAME_MAPPINGS = {
+    "ApplyCLIPSeg+": "🔧 Apply CLIPSeg",
+    "LoadCLIPSegModels+": "🔧 Load CLIPSeg Models",
+}

ComfyUI_essentials/text.py

@@ -0,0 +1,113 @@
+import os
+import torch
+from nodes import MAX_RESOLUTION
+import torchvision.transforms.v2 as T
+from .utils import FONTS_DIR
+
+class DrawText:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "text": ("STRING", { "multiline": True, "dynamicPrompts": True, "default": "Hello, World!" }),
+                "font": (sorted([f for f in os.listdir(FONTS_DIR) if f.endswith('.ttf') or f.endswith('.otf')]), ),
+                "size": ("INT", { "default": 56, "min": 1, "max": 9999, "step": 1 }),
+                "color": ("STRING", { "multiline": False, "default": "#FFFFFF" }),
+                "background_color": ("STRING", { "multiline": False, "default": "#00000000" }),
+                "shadow_distance": ("INT", { "default": 0, "min": 0, "max": 100, "step": 1 }),
+                "shadow_blur": ("INT", { "default": 0, "min": 0, "max": 100, "step": 1 }),
+                "shadow_color": ("STRING", { "multiline": False, "default": "#000000" }),
+                "horizontal_align": (["left", "center", "right"],),
+                "vertical_align": (["top", "center", "bottom"],),
+                "offset_x": ("INT", { "default": 0, "min": -MAX_RESOLUTION, "max": MAX_RESOLUTION, "step": 1 }),
+                "offset_y": ("INT", { "default": 0, "min": -MAX_RESOLUTION, "max": MAX_RESOLUTION, "step": 1 }),
+                "direction": (["ltr", "rtl"],),
+            },
+            "optional": {
+                "img_composite": ("IMAGE",),
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE", "MASK",)
+    FUNCTION = "execute"
+    CATEGORY = "essentials/text"
+
+    def execute(self, text, font, size, color, background_color, shadow_distance, shadow_blur, shadow_color, horizontal_align, vertical_align, offset_x, offset_y, direction, img_composite=None):
+        from PIL import Image, ImageDraw, ImageFont, ImageColor, ImageFilter
+
+        font = ImageFont.truetype(os.path.join(FONTS_DIR, font), size)
+
+        lines = text.split("\n")
+        if direction == "rtl":
+            lines = [line[::-1] for line in lines]
+
+        # Calculate the width and height of the text
+        text_width = max(font.getbbox(line)[2] for line in lines)
+        line_height = font.getmask(text).getbbox()[3] + font.getmetrics()[1]  # add descent to height
+        text_height = line_height * len(lines)
+
+        if img_composite is not None:
+            img_composite = T.ToPILImage()(img_composite.permute([0,3,1,2])[0]).convert('RGBA')
+            width = img_composite.width
+            height = img_composite.height
+            image = Image.new('RGBA', (width, height), color=background_color)
+        else:
+            width = text_width
+            height = text_height
+            background_color = ImageColor.getrgb(background_color)
+            image = Image.new('RGBA', (width + shadow_distance, height + shadow_distance), color=background_color)
+
+        image_shadow = None
+        if shadow_distance > 0:
+            image_shadow = image.copy()
+            #image_shadow = Image.new('RGBA', (width + shadow_distance, height + shadow_distance), color=background_color)
+
+        for i, line in enumerate(lines):
+            line_width = font.getbbox(line)[2]
+            #text_height =font.getbbox(line)[3]
+            if horizontal_align == "left":
+                x = 0
+            elif horizontal_align == "center":
+                x = (width - line_width) / 2
+            elif horizontal_align == "right":
+                x = width - line_width
+            
+            if vertical_align == "top":
+                y = 0
+            elif vertical_align == "center":
+                y = (height - text_height) / 2
+            elif vertical_align == "bottom":
+                y = height - text_height
+
+            x += offset_x
+            y += i * line_height + offset_y
+
+            draw = ImageDraw.Draw(image)
+            draw.text((x, y), line, font=font, fill=color)
+
+            if image_shadow is not None:
+                draw = ImageDraw.Draw(image_shadow)
+                draw.text((x + shadow_distance, y + shadow_distance), line, font=font, fill=shadow_color)
+
+        if image_shadow is not None:
+            image_shadow = image_shadow.filter(ImageFilter.GaussianBlur(shadow_blur))
+            image = Image.alpha_composite(image_shadow, image)
+
+        #image = T.ToTensor()(image).unsqueeze(0).permute([0,2,3,1])
+        mask = T.ToTensor()(image).unsqueeze(0).permute([0,2,3,1])
+        mask = mask[:, :, :, 3] if mask.shape[3] == 4 else torch.ones_like(mask[:, :, :, 0])
+
+        if img_composite is not None:
+            image = Image.alpha_composite(img_composite, image)
+        
+        image = T.ToTensor()(image).unsqueeze(0).permute([0,2,3,1])
+
+        return (image[:, :, :, :3], mask,)
+
+TEXT_CLASS_MAPPINGS = {
+    "DrawText+": DrawText,
+}
+
+TEXT_NAME_MAPPINGS = {
+    "DrawText+": "🔧 Draw Text",
+}

ComfyUI_essentials/utils.py

@@ -0,0 +1,89 @@
+import torch
+import numpy as np
+import scipy
+import os
+#import re
+from pathlib import Path
+import folder_paths
+
+FONTS_DIR = os.path.join(os.path.dirname(os.path.realpath(__file__)), "fonts")
+
+SCRIPT_DIR = Path(__file__).parent
+folder_paths.add_model_folder_path("luts", (SCRIPT_DIR / "luts").as_posix())
+folder_paths.add_model_folder_path(
+    "luts", (Path(folder_paths.models_dir) / "luts").as_posix()
+)
+
+# from https://github.com/pythongosssss/ComfyUI-Custom-Scripts
+class AnyType(str):
+    def __ne__(self, __value: object) -> bool:
+        return False
+
+def min_(tensor_list):
+    # return the element-wise min of the tensor list.
+    x = torch.stack(tensor_list)
+    mn = x.min(axis=0)[0]
+    return torch.clamp(mn, min=0)
+
+def max_(tensor_list):
+    # return the element-wise max of the tensor list.
+    x = torch.stack(tensor_list)
+    mx = x.max(axis=0)[0]
+    return torch.clamp(mx, max=1)
+
+def expand_mask(mask, expand, tapered_corners):
+    c = 0 if tapered_corners else 1
+    kernel = np.array([[c, 1, c],
+                       [1, 1, 1],
+                       [c, 1, c]])
+    mask = mask.reshape((-1, mask.shape[-2], mask.shape[-1]))
+    out = []
+    for m in mask:
+        output = m.numpy()
+        for _ in range(abs(expand)):
+            if expand < 0:
+                output = scipy.ndimage.grey_erosion(output, footprint=kernel)
+            else:
+                output = scipy.ndimage.grey_dilation(output, footprint=kernel)
+        output = torch.from_numpy(output)
+        out.append(output)
+
+    return torch.stack(out, dim=0)
+
+def parse_string_to_list(s):
+    elements = s.split(',')
+    result = []
+
+    def parse_number(s):
+        try:
+            if '.' in s:
+                return float(s)
+            else:
+                return int(s)
+        except ValueError:
+            return 0
+
+    def decimal_places(s):
+        if '.' in s:
+            return len(s.split('.')[1])
+        return 0
+
+    for element in elements:
+        element = element.strip()
+        if '...' in element:
+            start, rest = element.split('...')
+            end, step = rest.split('+')
+            decimals = decimal_places(step)
+            start = parse_number(start)
+            end = parse_number(end)
+            step = parse_number(step)
+            current = start
+            if (start > end and step > 0) or (start < end and step < 0):
+                step = -step
+            while current <= end:
+                result.append(round(current, decimals))
+                current += step
+        else:
+            result.append(round(parse_number(element), decimal_places(element)))
+
+    return result

ComfyUI_essentials/workflow_all_nodes.json

@@ -0,0 +1,994 @@
+{
+  "last_node_id": 42,
+  "last_link_id": 61,
+  "nodes": [
+    {
+      "id": 9,
+      "type": "ConsoleDebug+",
+      "pos": [
+        720,
+        140
+      ],
+      "size": {
+        "0": 210,
+        "1": 60
+      },
+      "flags": {},
+      "order": 12,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "value",
+          "type": "*",
+          "link": 3
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "ConsoleDebug+"
+      },
+      "widgets_values": [
+        "Height:"
+      ]
+    },
+    {
+      "id": 28,
+      "type": "PreviewImage",
+      "pos": [
+        860,
+        1180
+      ],
+      "size": {
+        "0": 210,
+        "1": 246
+      },
+      "flags": {},
+      "order": 17,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 23
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "PreviewImage"
+      }
+    },
+    {
+      "id": 12,
+      "type": "PreviewImage",
+      "pos": [
+        860,
+        580
+      ],
+      "size": {
+        "0": 210,
+        "1": 246
+      },
+      "flags": {},
+      "order": 15,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 11
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "PreviewImage"
+      }
+    },
+    {
+      "id": 14,
+      "type": "PreviewImage",
+      "pos": [
+        860,
+        880
+      ],
+      "size": {
+        "0": 210,
+        "1": 246
+      },
+      "flags": {},
+      "order": 16,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 13
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "PreviewImage"
+      }
+    },
+    {
+      "id": 18,
+      "type": "MaskPreview+",
+      "pos": [
+        2100,
+        90
+      ],
+      "size": {
+        "0": 210,
+        "1": 246
+      },
+      "flags": {},
+      "order": 20,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "mask",
+          "type": "MASK",
+          "link": 19
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "MaskPreview+"
+      }
+    },
+    {
+      "id": 1,
+      "type": "GetImageSize+",
+      "pos": [
+        450,
+        80
+      ],
+      "size": {
+        "0": 210,
+        "1": 46
+      },
+      "flags": {},
+      "order": 2,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "image",
+          "type": "IMAGE",
+          "link": 1
+        }
+      ],
+      "outputs": [
+        {
+          "name": "width",
+          "type": "INT",
+          "links": [
+            2
+          ],
+          "shape": 3,
+          "slot_index": 0
+        },
+        {
+          "name": "height",
+          "type": "INT",
+          "links": [
+            3
+          ],
+          "shape": 3,
+          "slot_index": 1
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "GetImageSize+"
+      }
+    },
+    {
+      "id": 8,
+      "type": "ConsoleDebug+",
+      "pos": [
+        720,
+        40
+      ],
+      "size": {
+        "0": 210,
+        "1": 60
+      },
+      "flags": {},
+      "order": 11,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "value",
+          "type": "*",
+          "link": 2
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "ConsoleDebug+"
+      },
+      "widgets_values": [
+        "Width:"
+      ]
+    },
+    {
+      "id": 10,
+      "type": "PreviewImage",
+      "pos": [
+        860,
+        280
+      ],
+      "size": {
+        "0": 210,
+        "1": 246
+      },
+      "flags": {},
+      "order": 13,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 9
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "PreviewImage"
+      }
+    },
+    {
+      "id": 36,
+      "type": "SimpleMath+",
+      "pos": [
+        1650,
+        780
+      ],
+      "size": {
+        "0": 210,
+        "1": 80
+      },
+      "flags": {},
+      "order": 14,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "a",
+          "type": "INT,FLOAT",
+          "link": 44
+        },
+        {
+          "name": "b",
+          "type": "INT,FLOAT",
+          "link": 45
+        }
+      ],
+      "outputs": [
+        {
+          "name": "INT",
+          "type": "INT",
+          "links": [
+            46
+          ],
+          "shape": 3,
+          "slot_index": 0
+        },
+        {
+          "name": "FLOAT",
+          "type": "FLOAT",
+          "links": null,
+          "shape": 3
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "SimpleMath+"
+      },
+      "widgets_values": [
+        "a*b"
+      ]
+    },
+    {
+      "id": 23,
+      "type": "ConsoleDebug+",
+      "pos": [
+        1920,
+        780
+      ],
+      "size": {
+        "0": 210,
+        "1": 60
+      },
+      "flags": {},
+      "order": 22,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "value",
+          "type": "*",
+          "link": 46
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "ConsoleDebug+"
+      },
+      "widgets_values": [
+        "Value:"
+      ]
+    },
+    {
+      "id": 2,
+      "type": "ImageResize+",
+      "pos": [
+        430,
+        340
+      ],
+      "size": {
+        "0": 310,
+        "1": 170
+      },
+      "flags": {},
+      "order": 3,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "image",
+          "type": "IMAGE",
+          "link": 4
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            9
+          ],
+          "shape": 3,
+          "slot_index": 0
+        },
+        {
+          "name": "width",
+          "type": "INT",
+          "links": [
+            44
+          ],
+          "shape": 3,
+          "slot_index": 1
+        },
+        {
+          "name": "height",
+          "type": "INT",
+          "links": [
+            45
+          ],
+          "shape": 3,
+          "slot_index": 2
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "ImageResize+"
+      },
+      "widgets_values": [
+        256,
+        64,
+        "lanczos",
+        true
+      ]
+    },
+    {
+      "id": 4,
+      "type": "ImageFlip+",
+      "pos": [
+        430,
+        800
+      ],
+      "size": {
+        "0": 310,
+        "1": 60
+      },
+      "flags": {},
+      "order": 4,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "image",
+          "type": "IMAGE",
+          "link": 6
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            11
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "ImageFlip+"
+      },
+      "widgets_values": [
+        "xy"
+      ]
+    },
+    {
+      "id": 6,
+      "type": "ImagePosterize+",
+      "pos": [
+        430,
+        1000
+      ],
+      "size": {
+        "0": 310,
+        "1": 60
+      },
+      "flags": {},
+      "order": 5,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "image",
+          "type": "IMAGE",
+          "link": 8
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            13
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "ImagePosterize+"
+      },
+      "widgets_values": [
+        0.5
+      ]
+    },
+    {
+      "id": 27,
+      "type": "ImageCASharpening+",
+      "pos": [
+        430,
+        1110
+      ],
+      "size": {
+        "0": 310.79998779296875,
+        "1": 60
+      },
+      "flags": {},
+      "order": 6,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "image",
+          "type": "IMAGE",
+          "link": 22
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            23
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "ImageCASharpening+"
+      },
+      "widgets_values": [
+        0.8
+      ]
+    },
+    {
+      "id": 15,
+      "type": "MaskBlur+",
+      "pos": [
+        1690,
+        130
+      ],
+      "size": {
+        "0": 310,
+        "1": 82
+      },
+      "flags": {},
+      "order": 9,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "mask",
+          "type": "MASK",
+          "link": 14
+        }
+      ],
+      "outputs": [
+        {
+          "name": "MASK",
+          "type": "MASK",
+          "links": [
+            19
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "MaskBlur+"
+      },
+      "widgets_values": [
+        45,
+        28.5
+      ]
+    },
+    {
+      "id": 16,
+      "type": "MaskFlip+",
+      "pos": [
+        1690,
+        270
+      ],
+      "size": {
+        "0": 310,
+        "1": 60
+      },
+      "flags": {},
+      "order": 10,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "mask",
+          "type": "MASK",
+          "link": 15
+        }
+      ],
+      "outputs": [
+        {
+          "name": "MASK",
+          "type": "MASK",
+          "links": [
+            18
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "MaskFlip+"
+      },
+      "widgets_values": [
+        "xy"
+      ]
+    },
+    {
+      "id": 13,
+      "type": "PreviewImage",
+      "pos": [
+        1100,
+        760
+      ],
+      "size": {
+        "0": 210,
+        "1": 246
+      },
+      "flags": {},
+      "order": 18,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 49
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "PreviewImage"
+      }
+    },
+    {
+      "id": 37,
+      "type": "ImageDesaturate+",
+      "pos": [
+        500,
+        920
+      ],
+      "size": {
+        "0": 190,
+        "1": 30
+      },
+      "flags": {},
+      "order": 7,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "image",
+          "type": "IMAGE",
+          "link": 48
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            49
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "ImageDesaturate+"
+      }
+    },
+    {
+      "id": 7,
+      "type": "LoadImage",
+      "pos": [
+        -90,
+        650
+      ],
+      "size": {
+        "0": 315,
+        "1": 314
+      },
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            1,
+            4,
+            6,
+            8,
+            22,
+            48,
+            57
+          ],
+          "shape": 3,
+          "slot_index": 0
+        },
+        {
+          "name": "MASK",
+          "type": "MASK",
+          "links": null,
+          "shape": 3
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "LoadImage"
+      },
+      "widgets_values": [
+        "venere.jpg",
+        "image"
+      ]
+    },
+    {
+      "id": 11,
+      "type": "PreviewImage",
+      "pos": [
+        1100,
+        450
+      ],
+      "size": {
+        "0": 210,
+        "1": 246
+      },
+      "flags": {},
+      "order": 19,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 58
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "PreviewImage"
+      }
+    },
+    {
+      "id": 40,
+      "type": "ImageCrop+",
+      "pos": [
+        430,
+        560
+      ],
+      "size": {
+        "0": 310,
+        "1": 194
+      },
+      "flags": {},
+      "order": 8,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "image",
+          "type": "IMAGE",
+          "link": 57
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            58
+          ],
+          "shape": 3,
+          "slot_index": 0
+        },
+        {
+          "name": "x",
+          "type": "INT",
+          "links": null,
+          "shape": 3
+        },
+        {
+          "name": "y",
+          "type": "INT",
+          "links": null,
+          "shape": 3
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "ImageCrop+"
+      },
+      "widgets_values": [
+        256,
+        256,
+        "center",
+        0,
+        0
+      ]
+    },
+    {
+      "id": 20,
+      "type": "LoadImageMask",
+      "pos": [
+        1400,
+        260
+      ],
+      "size": {
+        "0": 220.70516967773438,
+        "1": 318
+      },
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "MASK",
+          "type": "MASK",
+          "links": [
+            14,
+            15
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "LoadImageMask"
+      },
+      "widgets_values": [
+        "cwf_inpaint_example_mask.png",
+        "alpha",
+        "image"
+      ]
+    },
+    {
+      "id": 21,
+      "type": "MaskPreview+",
+      "pos": [
+        2100,
+        380
+      ],
+      "size": {
+        "0": 210,
+        "1": 246
+      },
+      "flags": {},
+      "order": 21,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "mask",
+          "type": "MASK",
+          "link": 18
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "MaskPreview+"
+      }
+    }
+  ],
+  "links": [
+    [
+      1,
+      7,
+      0,
+      1,
+      0,
+      "IMAGE"
+    ],
+    [
+      2,
+      1,
+      0,
+      8,
+      0,
+      "*"
+    ],
+    [
+      3,
+      1,
+      1,
+      9,
+      0,
+      "*"
+    ],
+    [
+      4,
+      7,
+      0,
+      2,
+      0,
+      "IMAGE"
+    ],
+    [
+      6,
+      7,
+      0,
+      4,
+      0,
+      "IMAGE"
+    ],
+    [
+      8,
+      7,
+      0,
+      6,
+      0,
+      "IMAGE"
+    ],
+    [
+      9,
+      2,
+      0,
+      10,
+      0,
+      "IMAGE"
+    ],
+    [
+      11,
+      4,
+      0,
+      12,
+      0,
+      "IMAGE"
+    ],
+    [
+      13,
+      6,
+      0,
+      14,
+      0,
+      "IMAGE"
+    ],
+    [
+      14,
+      20,
+      0,
+      15,
+      0,
+      "MASK"
+    ],
+    [
+      15,
+      20,
+      0,
+      16,
+      0,
+      "MASK"
+    ],
+    [
+      18,
+      16,
+      0,
+      21,
+      0,
+      "MASK"
+    ],
+    [
+      19,
+      15,
+      0,
+      18,
+      0,
+      "MASK"
+    ],
+    [
+      22,
+      7,
+      0,
+      27,
+      0,
+      "IMAGE"
+    ],
+    [
+      23,
+      27,
+      0,
+      28,
+      0,
+      "IMAGE"
+    ],
+    [
+      44,
+      2,
+      1,
+      36,
+      0,
+      "INT,FLOAT"
+    ],
+    [
+      45,
+      2,
+      2,
+      36,
+      1,
+      "INT,FLOAT"
+    ],
+    [
+      46,
+      36,
+      0,
+      23,
+      0,
+      "*"
+    ],
+    [
+      48,
+      7,
+      0,
+      37,
+      0,
+      "IMAGE"
+    ],
+    [
+      49,
+      37,
+      0,
+      13,
+      0,
+      "IMAGE"
+    ],
+    [
+      57,
+      7,
+      0,
+      40,
+      0,
+      "IMAGE"
+    ],
+    [
+      58,
+      40,
+      0,
+      11,
+      0,
+      "IMAGE"
+    ]
+  ],
+  "groups": [],
+  "config": {},
+  "extra": {},
+  "version": 0.4
+}

comfyui_controlnet_aux/README.md

@@ -0,0 +1,252 @@
+# ComfyUI's ControlNet Auxiliary Preprocessors
+Plug-and-play [ComfyUI](https://github.com/comfyanonymous/ComfyUI) node sets for making [ControlNet](https://github.com/lllyasviel/ControlNet/) hint images
+
+"anime style, a protest in the street, cyberpunk city, a woman with pink hair and golden eyes (looking at the viewer) is holding a sign with the text "ComfyUI ControlNet Aux" in bold, neon pink" on Flux.1 Dev
+
+![](./examples/CNAuxBanner.jpg)
+
+The code is copy-pasted from the respective folders in https://github.com/lllyasviel/ControlNet/tree/main/annotator and connected to [the 🤗 Hub](https://huggingface.co/lllyasviel/Annotators).
+
+All credit & copyright goes to https://github.com/lllyasviel.
+
+# Updates
+Go to [Update page](./UPDATES.md) to follow updates
+
+# Installation:
+## Using ComfyUI Manager (recommended):
+Install [ComfyUI Manager](https://github.com/ltdrdata/ComfyUI-Manager) and do steps introduced there to install this repo.
+
+## Alternative:
+If you're running on Linux, or non-admin account on windows you'll want to ensure `/ComfyUI/custom_nodes` and `comfyui_controlnet_aux` has write permissions.
+
+There is now a **install.bat** you can run to install to portable if detected. Otherwise it will default to system and assume you followed ConfyUI's manual installation steps. 
+
+If you can't run **install.bat** (e.g. you are a Linux user). Open the CMD/Shell and do the following:
+  - Navigate to your `/ComfyUI/custom_nodes/` folder
+  - Run `git clone https://github.com/Fannovel16/comfyui_controlnet_aux/`
+  - Navigate to your `comfyui_controlnet_aux` folder
+    - Portable/venv:
+       - Run `path/to/ComfUI/python_embeded/python.exe -s -m pip install -r requirements.txt`
+	- With system python
+	   - Run `pip install -r requirements.txt`
+  - Start ComfyUI
+
+# Nodes
+Please note that this repo only supports preprocessors making hint images (e.g. stickman, canny edge, etc).
+All preprocessors except Inpaint are intergrated into `AIO Aux Preprocessor` node. 
+This node allow you to quickly get the preprocessor but a preprocessor's own threshold parameters won't be able to set.
+You need to use its node directly to set thresholds.
+
+# Nodes (sections are categories in Comfy menu)
+## Line Extractors
+| Preprocessor Node           | sd-webui-controlnet/other |          ControlNet/T2I-Adapter           |
+|-----------------------------|---------------------------|-------------------------------------------|
+| Binary Lines                | binary                    | control_scribble                          |
+| Canny Edge                  | canny                     | control_v11p_sd15_canny <br> control_canny <br> t2iadapter_canny |
+| HED Soft-Edge Lines         | hed                       | control_v11p_sd15_softedge <br> control_hed |
+| Standard Lineart            | standard_lineart          | control_v11p_sd15_lineart                 |
+| Realistic Lineart           | lineart (or `lineart_coarse` if `coarse` is enabled) | control_v11p_sd15_lineart |
+| Anime Lineart               | lineart_anime             | control_v11p_sd15s2_lineart_anime         |
+| Manga Lineart               | lineart_anime_denoise     | control_v11p_sd15s2_lineart_anime         |
+| M-LSD Lines                 | mlsd                      | control_v11p_sd15_mlsd <br> control_mlsd  |
+| PiDiNet Soft-Edge Lines     | pidinet                   | control_v11p_sd15_softedge <br> control_scribble |
+| Scribble Lines              | scribble                  | control_v11p_sd15_scribble <br> control_scribble |
+| Scribble XDoG Lines         | scribble_xdog             | control_v11p_sd15_scribble <br> control_scribble |
+| Fake Scribble Lines         | scribble_hed              | control_v11p_sd15_scribble <br> control_scribble |
+| TEED Soft-Edge Lines        | teed                      | [controlnet-sd-xl-1.0-softedge-dexined](https://huggingface.co/SargeZT/controlnet-sd-xl-1.0-softedge-dexined/blob/main/controlnet-sd-xl-1.0-softedge-dexined.safetensors) <br> control_v11p_sd15_softedge (Theoretically)
+| Scribble PiDiNet Lines      | scribble_pidinet          | control_v11p_sd15_scribble <br> control_scribble |
+| AnyLine Lineart             |                           | mistoLine_fp16.safetensors <br> mistoLine_rank256 <br> control_v11p_sd15s2_lineart_anime <br> control_v11p_sd15_lineart |
+
+## Normal and Depth Estimators
+| Preprocessor Node           | sd-webui-controlnet/other |          ControlNet/T2I-Adapter           |
+|-----------------------------|---------------------------|-------------------------------------------|
+| MiDaS Depth Map           | (normal) depth            | control_v11f1p_sd15_depth <br> control_depth <br> t2iadapter_depth |
+| LeReS Depth Map           | depth_leres               | control_v11f1p_sd15_depth <br> control_depth <br> t2iadapter_depth |
+| Zoe Depth Map             | depth_zoe                 | control_v11f1p_sd15_depth <br> control_depth <br> t2iadapter_depth |
+| MiDaS Normal Map          | normal_map                | control_normal                            |
+| BAE Normal Map            | normal_bae                | control_v11p_sd15_normalbae               |
+| MeshGraphormer Hand Refiner ([HandRefinder](https://github.com/wenquanlu/HandRefiner))  | depth_hand_refiner | [control_sd15_inpaint_depth_hand_fp16](https://huggingface.co/hr16/ControlNet-HandRefiner-pruned/blob/main/control_sd15_inpaint_depth_hand_fp16.safetensors) |
+| Depth Anything            |  depth_anything           | [Depth-Anything](https://huggingface.co/spaces/LiheYoung/Depth-Anything/blob/main/checkpoints_controlnet/diffusion_pytorch_model.safetensors) |
+| Zoe Depth Anything <br> (Basically Zoe but the encoder is replaced with DepthAnything)       | depth_anything | [Depth-Anything](https://huggingface.co/spaces/LiheYoung/Depth-Anything/blob/main/checkpoints_controlnet/diffusion_pytorch_model.safetensors) |
+| Normal DSINE              |                           | control_normal/control_v11p_sd15_normalbae |
+| Metric3D Depth            |                           | control_v11f1p_sd15_depth <br> control_depth <br> t2iadapter_depth |
+| Metric3D Normal           |                           | control_v11p_sd15_normalbae |
+| Depth Anything V2         |                           | [Depth-Anything](https://huggingface.co/spaces/LiheYoung/Depth-Anything/blob/main/checkpoints_controlnet/diffusion_pytorch_model.safetensors) |
+
+## Faces and Poses Estimators
+| Preprocessor Node           | sd-webui-controlnet/other |          ControlNet/T2I-Adapter           |
+|-----------------------------|---------------------------|-------------------------------------------|
+| DWPose Estimator                 | dw_openpose_full          | control_v11p_sd15_openpose <br> control_openpose <br> t2iadapter_openpose |
+| OpenPose Estimator               | openpose (detect_body) <br> openpose_hand (detect_body + detect_hand) <br> openpose_faceonly (detect_face) <br> openpose_full (detect_hand + detect_body + detect_face)    | control_v11p_sd15_openpose <br> control_openpose <br> t2iadapter_openpose |
+| MediaPipe Face Mesh         | mediapipe_face            | controlnet_sd21_laion_face_v2             | 
+| Animal Estimator                 | animal_openpose           | [control_sd15_animal_openpose_fp16](https://huggingface.co/huchenlei/animal_openpose/blob/main/control_sd15_animal_openpose_fp16.pth) |
+
+## Optical Flow Estimators
+| Preprocessor Node           | sd-webui-controlnet/other |          ControlNet/T2I-Adapter           |
+|-----------------------------|---------------------------|-------------------------------------------|
+| Unimatch Optical Flow       |                           | [DragNUWA](https://github.com/ProjectNUWA/DragNUWA) |
+
+### How to get OpenPose-format JSON?
+#### User-side
+This workflow will save images to ComfyUI's output folder (the same location as output images). If you haven't found `Save Pose Keypoints` node, update this extension
+![](./examples/example_save_kps.png)
+
+#### Dev-side
+An array of [OpenPose-format JSON](https://github.com/CMU-Perceptual-Computing-Lab/openpose/blob/master/doc/02_output.md#json-output-format) corresponsding to each frame in an IMAGE batch can be gotten from DWPose and OpenPose using `app.nodeOutputs` on the UI or `/history` API endpoint. JSON output from AnimalPose uses a kinda similar format to OpenPose JSON:
+```
+[
+    {
+        "version": "ap10k",
+        "animals": [
+            [[x1, y1, 1], [x2, y2, 1],..., [x17, y17, 1]],
+            [[x1, y1, 1], [x2, y2, 1],..., [x17, y17, 1]],
+            ...
+        ],
+        "canvas_height": 512,
+        "canvas_width": 768
+    },
+    ...
+]
+```
+
+For extension developers (e.g. Openpose editor):
+```js
+const poseNodes = app.graph._nodes.filter(node => ["OpenposePreprocessor", "DWPreprocessor", "AnimalPosePreprocessor"].includes(node.type))
+for (const poseNode of poseNodes) {
+    const openposeResults = JSON.parse(app.nodeOutputs[poseNode.id].openpose_json[0])
+    console.log(openposeResults) //An array containing Openpose JSON for each frame
+}
+```
+
+For API users:
+Javascript
+```js
+import fetch from "node-fetch" //Remember to add "type": "module" to "package.json"
+async function main() {
+    const promptId = '792c1905-ecfe-41f4-8114-83e6a4a09a9f' //Too lazy to POST /queue
+    let history = await fetch(`http://127.0.0.1:8188/history/${promptId}`).then(re => re.json())
+    history = history[promptId]
+    const nodeOutputs = Object.values(history.outputs).filter(output => output.openpose_json)
+    for (const nodeOutput of nodeOutputs) {
+        const openposeResults = JSON.parse(nodeOutput.openpose_json[0])
+        console.log(openposeResults) //An array containing Openpose JSON for each frame
+    }
+}
+main()
+```
+
+Python
+```py
+import json, urllib.request
+
+server_address = "127.0.0.1:8188"
+prompt_id = '' #Too lazy to POST /queue
+
+def get_history(prompt_id):
+    with urllib.request.urlopen("http://{}/history/{}".format(server_address, prompt_id)) as response:
+        return json.loads(response.read())
+
+history = get_history(prompt_id)[prompt_id]
+for o in history['outputs']:
+    for node_id in history['outputs']:
+        node_output = history['outputs'][node_id]
+        if 'openpose_json' in node_output:
+            print(json.loads(node_output['openpose_json'][0])) #An list containing Openpose JSON for each frame
+```
+## Semantic Segmentation
+| Preprocessor Node           | sd-webui-controlnet/other |          ControlNet/T2I-Adapter           |
+|-----------------------------|---------------------------|-------------------------------------------|
+| OneFormer ADE20K Segmentor  | oneformer_ade20k          | control_v11p_sd15_seg                     |
+| OneFormer COCO Segmentor    | oneformer_coco            | control_v11p_sd15_seg                     |
+| UniFormer Segmentor         | segmentation              |control_sd15_seg <br> control_v11p_sd15_seg|
+
+## T2IAdapter-only
+| Preprocessor Node           | sd-webui-controlnet/other |          ControlNet/T2I-Adapter           |
+|-----------------------------|---------------------------|-------------------------------------------|
+| Color Pallete               | color                     | t2iadapter_color                          |
+| Content Shuffle             | shuffle                   | t2iadapter_style                          |
+
+## Recolor
+| Preprocessor Node           | sd-webui-controlnet/other |          ControlNet/T2I-Adapter           |
+|-----------------------------|---------------------------|-------------------------------------------|
+| Image Luminance             | recolor_luminance         | [ioclab_sd15_recolor](https://huggingface.co/lllyasviel/sd_control_collection/resolve/main/ioclab_sd15_recolor.safetensors) <br> [sai_xl_recolor_256lora](https://huggingface.co/lllyasviel/sd_control_collection/resolve/main/sai_xl_recolor_256lora.safetensors) <br> [bdsqlsz_controlllite_xl_recolor_luminance](https://huggingface.co/bdsqlsz/qinglong_controlnet-lllite/resolve/main/bdsqlsz_controlllite_xl_recolor_luminance.safetensors) |
+| Image Intensity             | recolor_intensity         | Idk. Maybe same as above? |
+
+# Examples
+> A picture is worth a thousand words
+
+![](./examples/ExecuteAll1.jpg)
+![](./examples/ExecuteAll2.jpg)
+
+# Testing workflow
+https://github.com/Fannovel16/comfyui_controlnet_aux/blob/main/examples/ExecuteAll.png
+Input image: https://github.com/Fannovel16/comfyui_controlnet_aux/blob/main/examples/comfyui-controlnet-aux-logo.png
+
+# Q&A:
+## Why some nodes doesn't appear after I installed this repo?
+
+This repo has a new mechanism which will skip any custom node can't be imported. If you meet this case, please create a issue on [Issues tab](https://github.com/Fannovel16/comfyui_controlnet_aux/issues) with the log from the command line.
+
+## DWPose/AnimalPose only uses CPU so it's so slow. How can I make it use GPU?
+There are two ways to speed-up DWPose: using TorchScript checkpoints (.torchscript.pt) checkpoints or ONNXRuntime (.onnx). TorchScript way is little bit slower than ONNXRuntime but doesn't require any additional library and still way way faster than CPU. 
+
+A torchscript bbox detector is compatiable with an onnx pose estimator and vice versa.
+### TorchScript
+Set `bbox_detector` and `pose_estimator` according to this picture. You can try other bbox detector endings with `.torchscript.pt` to reduce bbox detection time if input images are ideal.
+![](./examples/example_torchscript.png)
+### ONNXRuntime
+If onnxruntime is installed successfully and the checkpoint used endings with `.onnx`, it will replace default cv2 backend to take advantage of GPU. Note that if you are using NVidia card, this method currently can only works on CUDA 11.8 (ComfyUI_windows_portable_nvidia_cu118_or_cpu.7z) unless you compile onnxruntime yourself.
+
+1. Know your onnxruntime build:
+* * NVidia CUDA 11.x or bellow/AMD GPU: `onnxruntime-gpu`
+* * NVidia CUDA 12.x: `onnxruntime-gpu --extra-index-url https://aiinfra.pkgs.visualstudio.com/PublicPackages/_packaging/onnxruntime-cuda-12/pypi/simple/`
+* * DirectML: `onnxruntime-directml`
+* * OpenVINO: `onnxruntime-openvino`
+
+Note that if this is your first time using ComfyUI, please test if it can run on your device before doing next steps.
+
+2. Add it into `requirements.txt`
+
+3. Run `install.bat` or pip command mentioned in Installation
+
+![](./examples/example_onnx.png)
+
+# Assets files of preprocessors
+* anime_face_segment:  [bdsqlsz/qinglong_controlnet-lllite/Annotators/UNet.pth](https://huggingface.co/bdsqlsz/qinglong_controlnet-lllite/blob/main/Annotators/UNet.pth), [anime-seg/isnetis.ckpt](https://huggingface.co/skytnt/anime-seg/blob/main/isnetis.ckpt)
+* densepose:  [LayerNorm/DensePose-TorchScript-with-hint-image/densepose_r50_fpn_dl.torchscript](https://huggingface.co/LayerNorm/DensePose-TorchScript-with-hint-image/blob/main/densepose_r50_fpn_dl.torchscript)
+* dwpose:  
+* * bbox_detector: Either [yzd-v/DWPose/yolox_l.onnx](https://huggingface.co/yzd-v/DWPose/blob/main/yolox_l.onnx), [hr16/yolox-onnx/yolox_l.torchscript.pt](https://huggingface.co/hr16/yolox-onnx/blob/main/yolox_l.torchscript.pt), [hr16/yolo-nas-fp16/yolo_nas_l_fp16.onnx](https://huggingface.co/hr16/yolo-nas-fp16/blob/main/yolo_nas_l_fp16.onnx), [hr16/yolo-nas-fp16/yolo_nas_m_fp16.onnx](https://huggingface.co/hr16/yolo-nas-fp16/blob/main/yolo_nas_m_fp16.onnx), [hr16/yolo-nas-fp16/yolo_nas_s_fp16.onnx](https://huggingface.co/hr16/yolo-nas-fp16/blob/main/yolo_nas_s_fp16.onnx)
+* * pose_estimator: Either [hr16/DWPose-TorchScript-BatchSize5/dw-ll_ucoco_384_bs5.torchscript.pt](https://huggingface.co/hr16/DWPose-TorchScript-BatchSize5/blob/main/dw-ll_ucoco_384_bs5.torchscript.pt), [yzd-v/DWPose/dw-ll_ucoco_384.onnx](https://huggingface.co/yzd-v/DWPose/blob/main/dw-ll_ucoco_384.onnx)
+* animal_pose (ap10k):
+* * bbox_detector: Either [yzd-v/DWPose/yolox_l.onnx](https://huggingface.co/yzd-v/DWPose/blob/main/yolox_l.onnx), [hr16/yolox-onnx/yolox_l.torchscript.pt](https://huggingface.co/hr16/yolox-onnx/blob/main/yolox_l.torchscript.pt), [hr16/yolo-nas-fp16/yolo_nas_l_fp16.onnx](https://huggingface.co/hr16/yolo-nas-fp16/blob/main/yolo_nas_l_fp16.onnx), [hr16/yolo-nas-fp16/yolo_nas_m_fp16.onnx](https://huggingface.co/hr16/yolo-nas-fp16/blob/main/yolo_nas_m_fp16.onnx), [hr16/yolo-nas-fp16/yolo_nas_s_fp16.onnx](https://huggingface.co/hr16/yolo-nas-fp16/blob/main/yolo_nas_s_fp16.onnx)
+* * pose_estimator: Either [hr16/DWPose-TorchScript-BatchSize5/rtmpose-m_ap10k_256_bs5.torchscript.pt](https://huggingface.co/hr16/DWPose-TorchScript-BatchSize5/blob/main/rtmpose-m_ap10k_256_bs5.torchscript.pt), [hr16/UnJIT-DWPose/rtmpose-m_ap10k_256.onnx](https://huggingface.co/hr16/UnJIT-DWPose/blob/main/rtmpose-m_ap10k_256.onnx)
+* hed:  [lllyasviel/Annotators/ControlNetHED.pth](https://huggingface.co/lllyasviel/Annotators/blob/main/ControlNetHED.pth)
+* leres:  [lllyasviel/Annotators/res101.pth](https://huggingface.co/lllyasviel/Annotators/blob/main/res101.pth), [lllyasviel/Annotators/latest_net_G.pth](https://huggingface.co/lllyasviel/Annotators/blob/main/latest_net_G.pth)
+* lineart:  [lllyasviel/Annotators/sk_model.pth](https://huggingface.co/lllyasviel/Annotators/blob/main/sk_model.pth), [lllyasviel/Annotators/sk_model2.pth](https://huggingface.co/lllyasviel/Annotators/blob/main/sk_model2.pth)
+* lineart_anime:  [lllyasviel/Annotators/netG.pth](https://huggingface.co/lllyasviel/Annotators/blob/main/netG.pth)
+* manga_line:  [lllyasviel/Annotators/erika.pth](https://huggingface.co/lllyasviel/Annotators/blob/main/erika.pth)
+* mesh_graphormer:  [hr16/ControlNet-HandRefiner-pruned/graphormer_hand_state_dict.bin](https://huggingface.co/hr16/ControlNet-HandRefiner-pruned/blob/main/graphormer_hand_state_dict.bin), [hr16/ControlNet-HandRefiner-pruned/hrnetv2_w64_imagenet_pretrained.pth](https://huggingface.co/hr16/ControlNet-HandRefiner-pruned/blob/main/hrnetv2_w64_imagenet_pretrained.pth)
+* midas:  [lllyasviel/Annotators/dpt_hybrid-midas-501f0c75.pt](https://huggingface.co/lllyasviel/Annotators/blob/main/dpt_hybrid-midas-501f0c75.pt)
+* mlsd:  [lllyasviel/Annotators/mlsd_large_512_fp32.pth](https://huggingface.co/lllyasviel/Annotators/blob/main/mlsd_large_512_fp32.pth)
+* normalbae:  [lllyasviel/Annotators/scannet.pt](https://huggingface.co/lllyasviel/Annotators/blob/main/scannet.pt)
+* oneformer:  [lllyasviel/Annotators/250_16_swin_l_oneformer_ade20k_160k.pth](https://huggingface.co/lllyasviel/Annotators/blob/main/250_16_swin_l_oneformer_ade20k_160k.pth)
+* open_pose:  [lllyasviel/Annotators/body_pose_model.pth](https://huggingface.co/lllyasviel/Annotators/blob/main/body_pose_model.pth), [lllyasviel/Annotators/hand_pose_model.pth](https://huggingface.co/lllyasviel/Annotators/blob/main/hand_pose_model.pth), [lllyasviel/Annotators/facenet.pth](https://huggingface.co/lllyasviel/Annotators/blob/main/facenet.pth)
+* pidi:  [lllyasviel/Annotators/table5_pidinet.pth](https://huggingface.co/lllyasviel/Annotators/blob/main/table5_pidinet.pth)
+* sam:  [dhkim2810/MobileSAM/mobile_sam.pt](https://huggingface.co/dhkim2810/MobileSAM/blob/main/mobile_sam.pt)
+* uniformer:  [lllyasviel/Annotators/upernet_global_small.pth](https://huggingface.co/lllyasviel/Annotators/blob/main/upernet_global_small.pth)
+* zoe:  [lllyasviel/Annotators/ZoeD_M12_N.pt](https://huggingface.co/lllyasviel/Annotators/blob/main/ZoeD_M12_N.pt)
+* teed:  [bdsqlsz/qinglong_controlnet-lllite/7_model.pth](https://huggingface.co/bdsqlsz/qinglong_controlnet-lllite/blob/main/Annotators/7_model.pth)
+* depth_anything: Either [LiheYoung/Depth-Anything/checkpoints/depth_anything_vitl14.pth](https://huggingface.co/spaces/LiheYoung/Depth-Anything/blob/main/checkpoints/depth_anything_vitl14.pth), [LiheYoung/Depth-Anything/checkpoints/depth_anything_vitb14.pth](https://huggingface.co/spaces/LiheYoung/Depth-Anything/blob/main/checkpoints/depth_anything_vitb14.pth) or [LiheYoung/Depth-Anything/checkpoints/depth_anything_vits14.pth](https://huggingface.co/spaces/LiheYoung/Depth-Anything/blob/main/checkpoints/depth_anything_vits14.pth)
+* diffusion_edge: Either [hr16/Diffusion-Edge/diffusion_edge_indoor.pt](https://huggingface.co/hr16/Diffusion-Edge/blob/main/diffusion_edge_indoor.pt), [hr16/Diffusion-Edge/diffusion_edge_urban.pt](https://huggingface.co/hr16/Diffusion-Edge/blob/main/diffusion_edge_urban.pt) or [hr16/Diffusion-Edge/diffusion_edge_natrual.pt](https://huggingface.co/hr16/Diffusion-Edge/blob/main/diffusion_edge_natrual.pt)
+* unimatch: Either [hr16/Unimatch/gmflow-scale2-regrefine6-mixdata.pth](https://huggingface.co/hr16/Unimatch/blob/main/gmflow-scale2-regrefine6-mixdata.pth), [hr16/Unimatch/gmflow-scale2-mixdata.pth](https://huggingface.co/hr16/Unimatch/blob/main/gmflow-scale2-mixdata.pth) or [hr16/Unimatch/gmflow-scale1-mixdata.pth](https://huggingface.co/hr16/Unimatch/blob/main/gmflow-scale1-mixdata.pth)
+* zoe_depth_anything: Either [LiheYoung/Depth-Anything/checkpoints_metric_depth/depth_anything_metric_depth_indoor.pt](https://huggingface.co/spaces/LiheYoung/Depth-Anything/blob/main/checkpoints_metric_depth/depth_anything_metric_depth_indoor.pt) or [LiheYoung/Depth-Anything/checkpoints_metric_depth/depth_anything_metric_depth_outdoor.pt](https://huggingface.co/spaces/LiheYoung/Depth-Anything/blob/main/checkpoints_metric_depth/depth_anything_metric_depth_outdoor.pt)
+# 2000 Stars 😄
+<a href="https://star-history.com/#Fannovel16/comfyui_controlnet_aux&Date">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=Fannovel16/comfyui_controlnet_aux&type=Date&theme=dark" />
+    <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=Fannovel16/comfyui_controlnet_aux&type=Date" />
+    <img alt="Star History Chart" src="https://api.star-history.com/svg?repos=Fannovel16/comfyui_controlnet_aux&type=Date" />
+  </picture>
+</a>
+
+Thanks for yalls supports. I never thought the graph for stars would be linear lol.

comfyui_controlnet_aux/UPDATES.md

@@ -0,0 +1,44 @@
+* `AIO Aux Preprocessor` intergrating all loadable aux preprocessors as dropdown options. Easy to copy, paste and get the preprocessor faster.
+* Added OpenPose-format JSON output from OpenPose Preprocessor and DWPose Preprocessor. Checks [here](#faces-and-poses).
+* Fixed wrong model path when downloading DWPose.
+* Make hint images less blurry.
+* Added `resolution` option, `PixelPerfectResolution` and `HintImageEnchance` nodes (TODO: Documentation).
+* Added `RAFT Optical Flow Embedder` for TemporalNet2 (TODO: Workflow example).
+* Fixed opencv's conflicts between this extension, [ReActor](https://github.com/Gourieff/comfyui-reactor-node) and Roop. Thanks `Gourieff` for [the solution](https://github.com/Fannovel16/comfyui_controlnet_aux/issues/7#issuecomment-1734319075)!
+* RAFT is removed as the code behind it doesn't match what what the original code does
+* Changed `lineart`'s display name from `Normal Lineart` to `Realistic Lineart`. This change won't affect old workflows
+* Added support for `onnxruntime` to speed-up DWPose (see the Q&A)
+* Fixed TypeError: expected size to be one of int or Tuple[int] or Tuple[int, int] or Tuple[int, int, int], but got size with types [<class 'numpy.int64'>, <class 'numpy.int64'>]: [Issue](https://github.com/Fannovel16/comfyui_controlnet_aux/issues/2), [PR](https://github.com/Fannovel16/comfyui_controlnet_aux/pull/71))
+* Fixed ImageGenResolutionFromImage mishape (https://github.com/Fannovel16/comfyui_controlnet_aux/pull/74)
+* Fixed LeRes and MiDaS's incomatipility with MPS device
+* Fixed checking DWPose onnxruntime session multiple times: https://github.com/Fannovel16/comfyui_controlnet_aux/issues/89)
+* Added `Anime Face Segmentor` (in `ControlNet Preprocessors/Semantic Segmentation`) for [ControlNet AnimeFaceSegmentV2](https://huggingface.co/bdsqlsz/qinglong_controlnet-lllite#animefacesegmentv2). Checks [here](#anime-face-segmentor)
+* Change download functions and fix [download error](https://github.com/Fannovel16/comfyui_controlnet_aux/issues/39): [PR](https://github.com/Fannovel16/comfyui_controlnet_aux/pull/96)
+* Caching DWPose Onnxruntime during the first use of DWPose node instead of ComfyUI startup
+* Added alternative YOLOX models for faster speed when using DWPose
+* Added alternative DWPose models
+* Implemented the preprocessor for [AnimalPose ControlNet](https://github.com/abehonest/ControlNet_AnimalPose/tree/main). Check [Animal Pose AP-10K](#animal-pose-ap-10k) 
+* Added YOLO-NAS models which are drop-in replacements of YOLOX
+* Fixed Openpose Face/Hands no longer detecting: https://github.com/Fannovel16/comfyui_controlnet_aux/issues/54
+* Added TorchScript implementation of DWPose and AnimalPose
+* Added TorchScript implementation of DensePose from [Colab notebook](https://colab.research.google.com/drive/16hcaaKs210ivpxjoyGNuvEXZD4eqOOSQ) which doesn't require detectron2. [Example](#densepose). Thanks [@LayerNome](https://github.com/Layer-norm) for fixing bugs related.
+* Added Standard Lineart Preprocessor
+* Fixed OpenPose misplacements in some cases 
+* Added Mesh Graphormer - Hand Depth Map & Mask
+* Misaligned hands bug from MeshGraphormer was fixed
+* Added more mask options for MeshGraphormer
+* Added Save Pose Keypoint node for editing
+* Added Unimatch Optical Flow
+* Added Depth Anything & Zoe Depth Anything
+* Removed resolution field from Unimatch Optical Flow as that interpolating optical flow seems unstable
+* Added TEED Soft-Edge Preprocessor
+* Added DiffusionEdge
+* Added Image Luminance and Image Intensity
+* Added Normal DSINE
+* Added TTPlanet Tile (09/05/2024, DD/MM/YYYY)
+* Added AnyLine, Metric3D (18/05/2024)
+* Added Depth Anything V2 (16/06/2024)
+* Added Union model of ControlNet and preprocessors
+![345832280-edf41dab-7619-494c-9f60-60ec1f8789cb](https://github.com/user-attachments/assets/aa55f57c-cad7-48e6-84d3-8f506d847989)
+* Refactor INPUT_TYPES and add Execute All node during the process of learning [Execution Model Inversion](https://github.com/comfyanonymous/ComfyUI/pull/2666)
+* Added scale_stick_for_xinsr_cn (https://github.com/Fannovel16/comfyui_controlnet_aux/issues/447) (09/04/2024)

comfyui_controlnet_aux/__init__.py

@@ -0,0 +1,214 @@
+import sys, os
+from .utils import here, define_preprocessor_inputs, INPUT
+from pathlib import Path
+import traceback
+import importlib
+from .log import log, blue_text, cyan_text, get_summary, get_label
+from .hint_image_enchance import NODE_CLASS_MAPPINGS as HIE_NODE_CLASS_MAPPINGS
+from .hint_image_enchance import NODE_DISPLAY_NAME_MAPPINGS as HIE_NODE_DISPLAY_NAME_MAPPINGS
+#Ref: https://github.com/comfyanonymous/ComfyUI/blob/76d53c4622fc06372975ed2a43ad345935b8a551/nodes.py#L17
+sys.path.insert(0, str(Path(here, "src").resolve()))
+for pkg_name in ["custom_controlnet_aux", "custom_mmpkg"]:
+    sys.path.append(str(Path(here, "src", pkg_name).resolve()))
+
+#Enable CPU fallback for ops not being supported by MPS like upsample_bicubic2d.out
+#https://github.com/pytorch/pytorch/issues/77764
+#https://github.com/Fannovel16/comfyui_controlnet_aux/issues/2#issuecomment-1763579485
+os.environ["PYTORCH_ENABLE_MPS_FALLBACK"] = os.getenv("PYTORCH_ENABLE_MPS_FALLBACK", '1')
+
+
+def load_nodes():
+    shorted_errors = []
+    full_error_messages = []
+    node_class_mappings = {}
+    node_display_name_mappings = {}
+
+    for filename in (here / "node_wrappers").iterdir():
+        module_name = filename.stem
+        if module_name.startswith('.'): continue #Skip hidden files created by the OS (e.g. [.DS_Store](https://en.wikipedia.org/wiki/.DS_Store))
+        try:
+            module = importlib.import_module(
+                f".node_wrappers.{module_name}", package=__package__
+            )
+            node_class_mappings.update(getattr(module, "NODE_CLASS_MAPPINGS"))
+            if hasattr(module, "NODE_DISPLAY_NAME_MAPPINGS"):
+                node_display_name_mappings.update(getattr(module, "NODE_DISPLAY_NAME_MAPPINGS"))
+
+            log.debug(f"Imported {module_name} nodes")
+
+        except AttributeError:
+            pass  # wip nodes
+        except Exception:
+            error_message = traceback.format_exc()
+            full_error_messages.append(error_message)
+            error_message = error_message.splitlines()[-1]
+            shorted_errors.append(
+                f"Failed to import module {module_name} because {error_message}"
+            )
+    
+    if len(shorted_errors) > 0:
+        full_err_log = '\n\n'.join(full_error_messages)
+        print(f"\n\nFull error log from comfyui_controlnet_aux: \n{full_err_log}\n\n")
+        log.info(
+            f"Some nodes failed to load:\n\t"
+            + "\n\t".join(shorted_errors)
+            + "\n\n"
+            + "Check that you properly installed the dependencies.\n"
+            + "If you think this is a bug, please report it on the github page (https://github.com/Fannovel16/comfyui_controlnet_aux/issues)"
+        )
+    return node_class_mappings, node_display_name_mappings
+
+AUX_NODE_MAPPINGS, AUX_DISPLAY_NAME_MAPPINGS = load_nodes()
+
+#For nodes not mapping image to image or has special requirements
+AIO_NOT_SUPPORTED = ["InpaintPreprocessor", "MeshGraphormer+ImpactDetector-DepthMapPreprocessor", "DiffusionEdge_Preprocessor"]
+AIO_NOT_SUPPORTED += ["SavePoseKpsAsJsonFile", "FacialPartColoringFromPoseKps", "UpperBodyTrackingFromPoseKps", "RenderPeopleKps", "RenderAnimalKps"]
+AIO_NOT_SUPPORTED += ["Unimatch_OptFlowPreprocessor", "MaskOptFlow"]
+
+def preprocessor_options():
+    auxs = list(AUX_NODE_MAPPINGS.keys())
+    auxs.insert(0, "none")
+    for name in AIO_NOT_SUPPORTED:
+        if name in auxs:
+            auxs.remove(name)
+    return auxs
+
+
+PREPROCESSOR_OPTIONS = preprocessor_options()
+
+class AIO_Preprocessor:
+    @classmethod
+    def INPUT_TYPES(s):
+        return define_preprocessor_inputs(
+            preprocessor=INPUT.COMBO(PREPROCESSOR_OPTIONS, default="none"),
+            resolution=INPUT.RESOLUTION()
+        )
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+
+    CATEGORY = "ControlNet Preprocessors"
+
+    def execute(self, preprocessor, image, resolution=512):
+        if preprocessor == "none":
+            return (image, )
+        else:
+            aux_class = AUX_NODE_MAPPINGS[preprocessor]
+            input_types = aux_class.INPUT_TYPES()
+            input_types = {
+                **input_types["required"],
+                **(input_types["optional"] if "optional" in input_types else {})
+            }
+            params = {}
+            for name, input_type in input_types.items():
+                if name == "image":
+                    params[name] = image
+                    continue
+
+                if name == "resolution":
+                    params[name] = resolution
+                    continue
+
+                if len(input_type) == 2 and ("default" in input_type[1]):
+                    params[name] = input_type[1]["default"]
+                    continue
+
+                default_values = { "INT": 0, "FLOAT": 0.0 }
+                if input_type[0] in default_values:
+                    params[name] = default_values[input_type[0]]
+
+            return getattr(aux_class(), aux_class.FUNCTION)(**params)
+
+class ControlNetAuxSimpleAddText:
+    @classmethod
+    def INPUT_TYPES(s):
+        return dict(
+            required=dict(image=INPUT.IMAGE(), text=INPUT.STRING())
+        )
+    
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+    CATEGORY = "ControlNet Preprocessors"
+    def execute(self, image, text):
+        from PIL import Image, ImageDraw, ImageFont
+        import numpy as np
+        import torch
+
+        font = ImageFont.truetype(str((here / "NotoSans-Regular.ttf").resolve()), 40)
+        img = Image.fromarray(image[0].cpu().numpy().__mul__(255.).astype(np.uint8))
+        ImageDraw.Draw(img).text((0,0), text, fill=(0,255,0), font=font)
+        return (torch.from_numpy(np.array(img)).unsqueeze(0) / 255.,)
+
+class ExecuteAllControlNetPreprocessors:
+    @classmethod
+    def INPUT_TYPES(s):
+        return define_preprocessor_inputs(resolution=INPUT.RESOLUTION())
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+
+    CATEGORY = "ControlNet Preprocessors"
+
+    def execute(self, image, resolution=512):
+        try:
+            from comfy_execution.graph_utils import GraphBuilder
+        except:
+            raise RuntimeError("ExecuteAllControlNetPreprocessor requries [Execution Model Inversion](https://github.com/comfyanonymous/ComfyUI/commit/5cfe38). Update ComfyUI/SwarmUI to get this feature")
+        
+        graph = GraphBuilder()
+        curr_outputs = []
+        for preprocc in PREPROCESSOR_OPTIONS:
+            preprocc_node = graph.node("AIO_Preprocessor", preprocessor=preprocc, image=image, resolution=resolution)
+            hint_img = preprocc_node.out(0)
+            add_text_node = graph.node("ControlNetAuxSimpleAddText", image=hint_img, text=preprocc)
+            curr_outputs.append(add_text_node.out(0))
+        
+        while len(curr_outputs) > 1:
+            _outputs = []
+            for i in range(0, len(curr_outputs), 2):
+                if i+1 < len(curr_outputs):
+                    image_batch = graph.node("ImageBatch", image1=curr_outputs[i], image2=curr_outputs[i+1])
+                    _outputs.append(image_batch.out(0))
+                else:
+                    _outputs.append(curr_outputs[i])
+            curr_outputs = _outputs
+
+        return {
+            "result": (curr_outputs[0],),
+            "expand": graph.finalize(),
+        }
+
+class ControlNetPreprocessorSelector:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "preprocessor": (PREPROCESSOR_OPTIONS,),
+            }
+        }
+
+    RETURN_TYPES = (PREPROCESSOR_OPTIONS,)
+    RETURN_NAMES = ("preprocessor",)
+    FUNCTION = "get_preprocessor"
+
+    CATEGORY = "ControlNet Preprocessors"
+
+    def get_preprocessor(self, preprocessor: str):
+        return (preprocessor,)
+
+
+NODE_CLASS_MAPPINGS = {
+    **AUX_NODE_MAPPINGS,
+    "AIO_Preprocessor": AIO_Preprocessor,
+    "ControlNetPreprocessorSelector": ControlNetPreprocessorSelector,
+    **HIE_NODE_CLASS_MAPPINGS,
+    "ExecuteAllControlNetPreprocessors": ExecuteAllControlNetPreprocessors,
+    "ControlNetAuxSimpleAddText": ControlNetAuxSimpleAddText
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    **AUX_DISPLAY_NAME_MAPPINGS,
+    "AIO_Preprocessor": "AIO Aux Preprocessor",
+    "ControlNetPreprocessorSelector": "Preprocessor Selector",
+    **HIE_NODE_DISPLAY_NAME_MAPPINGS,
+    "ExecuteAllControlNetPreprocessors": "Execute All ControlNet Preprocessors"
+}

comfyui_controlnet_aux/log.py

@@ -0,0 +1,80 @@
+#Cre: https://github.com/melMass/comfy_mtb/blob/main/log.py
+import logging
+import re
+import os
+
+base_log_level = logging.INFO
+
+
+# Custom object that discards the output
+class NullWriter:
+    def write(self, text):
+        pass
+
+
+class Formatter(logging.Formatter):
+    grey = "\x1b[38;20m"
+    cyan = "\x1b[36;20m"
+    purple = "\x1b[35;20m"
+    yellow = "\x1b[33;20m"
+    red = "\x1b[31;20m"
+    bold_red = "\x1b[31;1m"
+    reset = "\x1b[0m"
+    # format = "%(asctime)s - [%(name)s] - %(levelname)s - %(message)s (%(filename)s:%(lineno)d)"
+    format = "[%(name)s] | %(levelname)s -> %(message)s"
+
+    FORMATS = {
+        logging.DEBUG: purple + format + reset,
+        logging.INFO: cyan + format + reset,
+        logging.WARNING: yellow + format + reset,
+        logging.ERROR: red + format + reset,
+        logging.CRITICAL: bold_red + format + reset,
+    }
+
+    def format(self, record):
+        log_fmt = self.FORMATS.get(record.levelno)
+        formatter = logging.Formatter(log_fmt)
+        return formatter.format(record)
+
+
+def mklog(name, level=base_log_level):
+    logger = logging.getLogger(name)
+    logger.setLevel(level)
+
+    for handler in logger.handlers:
+        logger.removeHandler(handler)
+
+    ch = logging.StreamHandler()
+    ch.setLevel(level)
+    ch.setFormatter(Formatter())
+    logger.addHandler(ch)
+
+    # Disable log propagation
+    logger.propagate = False
+
+    return logger
+
+
+# - The main app logger
+log = mklog(__package__, base_log_level)
+
+
+def log_user(arg):
+    print("\033[34mComfyUI ControlNet AUX:\033[0m {arg}")
+
+
+def get_summary(docstring):
+    return docstring.strip().split("\n\n", 1)[0]
+
+
+def blue_text(text):
+    return f"\033[94m{text}\033[0m"
+
+
+def cyan_text(text):
+    return f"\033[96m{text}\033[0m"
+
+
+def get_label(label):
+    words = re.findall(r"(?:^|[A-Z])[a-z]*", label)
+    return " ".join(words).strip()

comfyui_controlnet_aux/requirements.txt

@@ -0,0 +1,25 @@
+torch
+importlib_metadata
+huggingface_hub
+scipy
+opencv-python>=4.7.0.72
+filelock
+numpy
+Pillow
+einops
+torchvision
+pyyaml
+scikit-image
+python-dateutil
+mediapipe
+svglib
+fvcore
+yapf
+omegaconf
+ftfy
+addict
+yacs
+trimesh[easy]
+albumentations
+scikit-learn
+matplotlib

comfyui_controlnet_aux/search_hf_assets.py

@@ -0,0 +1,56 @@
+from pathlib import Path
+import os
+import re
+#Thanks ChatGPT
+pattern = r'\bfrom_pretrained\(.*?pretrained_model_or_path\s*=\s*(.*?)(?:,|\))|filename\s*=\s*(.*?)(?:,|\))|(\w+_filename)\s*=\s*(.*?)(?:,|\))'
+aux_dir = Path(__file__).parent / 'src' / 'custom_controlnet_aux'
+VAR_DICT = dict(
+    HF_MODEL_NAME = "lllyasviel/Annotators",
+    DWPOSE_MODEL_NAME = "yzd-v/DWPose",
+    BDS_MODEL_NAME = "bdsqlsz/qinglong_controlnet-lllite",
+    DENSEPOSE_MODEL_NAME = "LayerNorm/DensePose-TorchScript-with-hint-image",
+    MESH_GRAPHORMER_MODEL_NAME = "hr16/ControlNet-HandRefiner-pruned",
+    SAM_MODEL_NAME = "dhkim2810/MobileSAM",
+    UNIMATCH_MODEL_NAME = "hr16/Unimatch",
+    DEPTH_ANYTHING_MODEL_NAME = "LiheYoung/Depth-Anything", #HF Space
+    DIFFUSION_EDGE_MODEL_NAME = "hr16/Diffusion-Edge"
+)
+re_result_dict = {}
+for preprocc in os.listdir(aux_dir):
+    if preprocc in ["__pycache__", 'tests']: continue
+    if '.py' in preprocc: continue
+    f = open(aux_dir / preprocc / '__init__.py', 'r')
+    code = f.read()
+    matches = re.findall(pattern, code)
+    result = [match[0] or match[1] or match[3] for match in matches]
+    if not len(result):
+        print(preprocc)
+        continue
+    result = [el.replace("'", '').replace('"', '') for el in result]
+    result = [VAR_DICT.get(el, el) for el in result]
+    re_result_dict[preprocc] = result
+    f.close()
+
+for preprocc, re_result in re_result_dict.items():
+    model_name, filenames = re_result[0], re_result[1:]
+    print(f"* {preprocc}: ", end=' ')
+    assests_md = ', '.join([f"[{model_name}/{filename}](https://huggingface.co/{model_name}/blob/main/{filename})" for filename in filenames])
+    print(assests_md)
+
+preprocc = "dwpose"
+model_name, filenames = VAR_DICT['DWPOSE_MODEL_NAME'], ["yolox_l.onnx", "dw-ll_ucoco_384.onnx"]
+print(f"* {preprocc}: ", end=' ')
+assests_md = ', '.join([f"[{model_name}/{filename}](https://huggingface.co/{model_name}/blob/main/{filename})" for filename in filenames])
+print(assests_md)
+
+preprocc = "yolo-nas"
+model_name, filenames = "hr16/yolo-nas-fp16", ["yolo_nas_l_fp16.onnx", "yolo_nas_m_fp16.onnx", "yolo_nas_s_fp16.onnx"]
+print(f"* {preprocc}: ", end=' ')
+assests_md = ', '.join([f"[{model_name}/{filename}](https://huggingface.co/{model_name}/blob/main/{filename})" for filename in filenames])
+print(assests_md)
+
+preprocc = "dwpose-torchscript"
+model_name, filenames = "hr16/DWPose-TorchScript-BatchSize5", ["dw-ll_ucoco_384_bs5.torchscript.pt", "rtmpose-m_ap10k_256_bs5.torchscript.pt"]
+print(f"* {preprocc}: ", end=' ')
+assests_md = ', '.join([f"[{model_name}/{filename}](https://huggingface.co/{model_name}/blob/main/{filename})" for filename in filenames])
+print(assests_md)

comfyui_controlnet_aux/utils.py

@@ -0,0 +1,250 @@
+import torch
+import numpy as np
+import os
+import cv2
+import yaml
+from pathlib import Path
+from enum import Enum
+from .log import log
+import subprocess
+import threading
+import comfy
+import tempfile
+
+here = Path(__file__).parent.resolve()
+
+config_path = Path(here, "config.yaml")
+
+if os.path.exists(config_path):
+    config = yaml.load(open(config_path, "r"), Loader=yaml.FullLoader)
+
+    annotator_ckpts_path = str(Path(here, config["annotator_ckpts_path"]))
+    TEMP_DIR = config["custom_temp_path"]
+    USE_SYMLINKS = config["USE_SYMLINKS"]
+    ORT_PROVIDERS = config["EP_list"]
+
+    if USE_SYMLINKS is None or type(USE_SYMLINKS) != bool:
+        log.error("USE_SYMLINKS must be a boolean. Using False by default.")
+        USE_SYMLINKS = False
+
+    if TEMP_DIR is None:
+        TEMP_DIR = tempfile.gettempdir()
+    elif not os.path.isdir(TEMP_DIR):
+        try:
+            os.makedirs(TEMP_DIR)
+        except:
+            log.error("Failed to create custom temp directory. Using default.")
+            TEMP_DIR = tempfile.gettempdir()
+
+    if not os.path.isdir(annotator_ckpts_path):
+        try:
+            os.makedirs(annotator_ckpts_path)
+        except:
+            log.error("Failed to create config ckpts directory. Using default.")
+            annotator_ckpts_path = str(Path(here, "./ckpts"))
+else:
+    annotator_ckpts_path = str(Path(here, "./ckpts"))
+    TEMP_DIR = tempfile.gettempdir()
+    USE_SYMLINKS = False
+    ORT_PROVIDERS = ["CUDAExecutionProvider", "DirectMLExecutionProvider", "OpenVINOExecutionProvider", "ROCMExecutionProvider", "CPUExecutionProvider", "CoreMLExecutionProvider"]
+
+os.environ['AUX_ANNOTATOR_CKPTS_PATH'] = os.getenv('AUX_ANNOTATOR_CKPTS_PATH', annotator_ckpts_path)
+os.environ['AUX_TEMP_DIR'] = os.getenv('AUX_TEMP_DIR', str(TEMP_DIR))
+os.environ['AUX_USE_SYMLINKS'] = os.getenv('AUX_USE_SYMLINKS', str(USE_SYMLINKS))
+os.environ['AUX_ORT_PROVIDERS'] = os.getenv('AUX_ORT_PROVIDERS', str(",".join(ORT_PROVIDERS)))
+
+log.info(f"Using ckpts path: {annotator_ckpts_path}")
+log.info(f"Using symlinks: {USE_SYMLINKS}")
+log.info(f"Using ort providers: {ORT_PROVIDERS}")
+
+# Sync with theoritical limit from Comfy base
+# https://github.com/comfyanonymous/ComfyUI/blob/eecd69b53a896343775bcb02a4f8349e7442ffd1/nodes.py#L45
+MAX_RESOLUTION=16384
+
+def common_annotator_call(model, tensor_image, input_batch=False, show_pbar=True, **kwargs):
+    if "detect_resolution" in kwargs:
+        del kwargs["detect_resolution"] #Prevent weird case?
+
+    if "resolution" in kwargs:
+        detect_resolution = kwargs["resolution"] if type(kwargs["resolution"]) == int and kwargs["resolution"] >= 64 else 512
+        del kwargs["resolution"]
+    else:
+        detect_resolution = 512
+
+    if input_batch:
+        np_images = np.asarray(tensor_image * 255., dtype=np.uint8)
+        np_results = model(np_images, output_type="np", detect_resolution=detect_resolution, **kwargs)
+        return torch.from_numpy(np_results.astype(np.float32) / 255.0)
+
+    batch_size = tensor_image.shape[0]
+    if show_pbar:
+        pbar = comfy.utils.ProgressBar(batch_size)
+    out_tensor = None
+    for i, image in enumerate(tensor_image):
+        np_image = np.asarray(image.cpu() * 255., dtype=np.uint8)
+        np_result = model(np_image, output_type="np", detect_resolution=detect_resolution, **kwargs)
+        out = torch.from_numpy(np_result.astype(np.float32) / 255.0)
+        if out_tensor is None:
+            out_tensor = torch.zeros(batch_size, *out.shape, dtype=torch.float32)
+        out_tensor[i] = out
+        if show_pbar:
+            pbar.update(1)
+    return out_tensor
+
+def define_preprocessor_inputs(**arguments):
+    return dict(
+        required=dict(image=INPUT.IMAGE()),
+        optional=arguments
+    )
+
+class INPUT(Enum):
+    def IMAGE():
+        return ("IMAGE",)
+    def LATENT():
+        return ("LATENT",)
+    def MASK():
+        return ("MASK",)
+    def SEED(default=0):
+        return ("INT", dict(default=default, min=0, max=0xffffffffffffffff))
+    def RESOLUTION(default=512, min=64, max=MAX_RESOLUTION, step=64): 
+        return ("INT", dict(default=default, min=min, max=max, step=step))
+    def INT(default=0, min=0, max=MAX_RESOLUTION, step=1): 
+        return ("INT", dict(default=default, min=min, max=max, step=step))
+    def FLOAT(default=0, min=0, max=1, step=0.01):
+        return ("FLOAT", dict(default=default, min=min, max=max, step=step))
+    def STRING(default='', multiline=False): 
+        return ("STRING", dict(default=default, multiline=multiline))
+    def COMBO(values, default=None):
+        return (values, dict(default=values[0] if default is None else default))
+    def BOOLEAN(default=True):
+        return ("BOOLEAN", dict(default=default))
+
+
+
+class ResizeMode(Enum):
+    """
+    Resize modes for ControlNet input images.
+    """
+
+    RESIZE = "Just Resize"
+    INNER_FIT = "Crop and Resize"
+    OUTER_FIT = "Resize and Fill"
+
+    def int_value(self):
+        if self == ResizeMode.RESIZE:
+            return 0
+        elif self == ResizeMode.INNER_FIT:
+            return 1
+        elif self == ResizeMode.OUTER_FIT:
+            return 2
+        assert False, "NOTREACHED"
+
+#https://github.com/Mikubill/sd-webui-controlnet/blob/e67e017731aad05796b9615dc6eadce911298ea1/internal_controlnet/external_code.py#L89
+#Replaced logger with internal log
+def pixel_perfect_resolution(
+        image: np.ndarray,
+        target_H: int,
+        target_W: int,
+        resize_mode: ResizeMode,
+) -> int:
+    """
+    Calculate the estimated resolution for resizing an image while preserving aspect ratio.
+
+    The function first calculates scaling factors for height and width of the image based on the target
+    height and width. Then, based on the chosen resize mode, it either takes the smaller or the larger
+    scaling factor to estimate the new resolution.
+
+    If the resize mode is OUTER_FIT, the function uses the smaller scaling factor, ensuring the whole image
+    fits within the target dimensions, potentially leaving some empty space.
+
+    If the resize mode is not OUTER_FIT, the function uses the larger scaling factor, ensuring the target
+    dimensions are fully filled, potentially cropping the image.
+
+    After calculating the estimated resolution, the function prints some debugging information.
+
+    Args:
+        image (np.ndarray): A 3D numpy array representing an image. The dimensions represent [height, width, channels].
+        target_H (int): The target height for the image.
+        target_W (int): The target width for the image.
+        resize_mode (ResizeMode): The mode for resizing.
+
+    Returns:
+        int: The estimated resolution after resizing.
+    """
+    raw_H, raw_W, _ = image.shape
+
+    k0 = float(target_H) / float(raw_H)
+    k1 = float(target_W) / float(raw_W)
+
+    if resize_mode == ResizeMode.OUTER_FIT:
+        estimation = min(k0, k1) * float(min(raw_H, raw_W))
+    else:
+        estimation = max(k0, k1) * float(min(raw_H, raw_W))
+
+    log.debug(f"Pixel Perfect Computation:")
+    log.debug(f"resize_mode = {resize_mode}")
+    log.debug(f"raw_H = {raw_H}")
+    log.debug(f"raw_W = {raw_W}")
+    log.debug(f"target_H = {target_H}")
+    log.debug(f"target_W = {target_W}")
+    log.debug(f"estimation = {estimation}")
+
+    return int(np.round(estimation))
+
+#https://github.com/Mikubill/sd-webui-controlnet/blob/e67e017731aad05796b9615dc6eadce911298ea1/scripts/controlnet.py#L404
+def safe_numpy(x):
+    # A very safe method to make sure that Apple/Mac works
+    y = x
+
+    # below is very boring but do not change these. If you change these Apple or Mac may fail.
+    y = y.copy()
+    y = np.ascontiguousarray(y)
+    y = y.copy()
+    return y
+
+#https://github.com/Mikubill/sd-webui-controlnet/blob/e67e017731aad05796b9615dc6eadce911298ea1/scripts/utils.py#L140
+def get_unique_axis0(data):
+    arr = np.asanyarray(data)
+    idxs = np.lexsort(arr.T)
+    arr = arr[idxs]
+    unique_idxs = np.empty(len(arr), dtype=np.bool_)
+    unique_idxs[:1] = True
+    unique_idxs[1:] = np.any(arr[:-1, :] != arr[1:, :], axis=-1)
+    return arr[unique_idxs]
+
+#Ref: https://github.com/ltdrdata/ComfyUI-Manager/blob/284e90dc8296a2e1e4f14b4b2d10fba2f52f0e53/__init__.py#L14
+def handle_stream(stream, prefix):
+    for line in stream:
+        print(prefix, line, end="")
+
+
+def run_script(cmd, cwd='.'):
+    process = subprocess.Popen(cmd, cwd=cwd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, bufsize=1)
+
+    stdout_thread = threading.Thread(target=handle_stream, args=(process.stdout, ""))
+    stderr_thread = threading.Thread(target=handle_stream, args=(process.stderr, "[!]"))
+
+    stdout_thread.start()
+    stderr_thread.start()
+
+    stdout_thread.join()
+    stderr_thread.join()
+
+    return process.wait()
+
+def nms(x, t, s):
+    x = cv2.GaussianBlur(x.astype(np.float32), (0, 0), s)
+
+    f1 = np.array([[0, 0, 0], [1, 1, 1], [0, 0, 0]], dtype=np.uint8)
+    f2 = np.array([[0, 1, 0], [0, 1, 0], [0, 1, 0]], dtype=np.uint8)
+    f3 = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]], dtype=np.uint8)
+    f4 = np.array([[0, 0, 1], [0, 1, 0], [1, 0, 0]], dtype=np.uint8)
+
+    y = np.zeros_like(x)
+
+    for f in [f1, f2, f3, f4]:
+        np.putmask(y, cv2.dilate(x, kernel=f) == x, x)
+
+    z = np.zeros_like(y, dtype=np.uint8)
+    z[y > t] = 255
+    return z

comfyui_layerstyle/.gitignore

@@ -0,0 +1,6 @@
+_test_*.*
+__pycache__
+.venv
+.idea
+*.pth
+*.ini

comfyui_layerstyle/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 chflame163
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

comfyui_layerstyle/__init__.py

@@ -0,0 +1,48 @@
+import importlib.util
+import os
+import sys
+import json
+
+NODE_CLASS_MAPPINGS = {}
+NODE_DISPLAY_NAME_MAPPINGS = {}
+
+python = sys.executable
+
+def get_ext_dir(subpath=None, mkdir=False):
+    dir = os.path.dirname(__file__)
+    if subpath is not None:
+        dir = os.path.join(dir, subpath)
+
+    dir = os.path.abspath(dir)
+
+    if mkdir and not os.path.exists(dir):
+        os.makedirs(dir)
+    return dir
+
+def serialize(obj):
+    if isinstance(obj, (str, int, float, bool, list, dict, type(None))):
+        return obj
+    return str(obj)  # 转为字符串
+
+
+py = get_ext_dir("py")
+files = os.listdir(py)
+all_nodes = {}
+for file in files:
+    if not file.endswith(".py"):
+        continue
+    name = os.path.splitext(file)[0]
+    imported_module = importlib.import_module(".py.{}".format(name), __name__)
+    try:
+        NODE_CLASS_MAPPINGS = {**NODE_CLASS_MAPPINGS, **imported_module.NODE_CLASS_MAPPINGS}
+        NODE_DISPLAY_NAME_MAPPINGS = {**NODE_DISPLAY_NAME_MAPPINGS, **imported_module.NODE_DISPLAY_NAME_MAPPINGS}
+        serialized_CLASS_MAPPINGS = {k: serialize(v) for k, v in imported_module.NODE_CLASS_MAPPINGS.items()}
+        serialized_DISPLAY_NAME_MAPPINGS = {k: serialize(v) for k, v in imported_module.NODE_DISPLAY_NAME_MAPPINGS.items()}
+        all_nodes[file]={"NODE_CLASS_MAPPINGS": serialized_CLASS_MAPPINGS, "NODE_DISPLAY_NAME_MAPPINGS": serialized_DISPLAY_NAME_MAPPINGS}
+    except:
+        pass
+
+
+WEB_DIRECTORY = "./js"
+
+__all__ = ["NODE_CLASS_MAPPINGS", "NODE_DISPLAY_NAME_MAPPINGS", "WEB_DIRECTORY"]

comfyui_layerstyle/custom_size.ini.example

@@ -0,0 +1,10 @@
+# LayerStyle Custom_size
+1024 x 1024
+768 x 512
+512 x 768
+1280 x 720
+720 x 1280
+1344 x 768
+768 x 1344
+1536 x 640
+640 x 1536