Upload 48 files

.gitattributes

@@ -34,3 +34,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
 comfyui_screenshot.png filter=lfs diff=lfs merge=lfs -text
+NotoSans-Regular.ttf filter=lfs diff=lfs merge=lfs -text

LICENSE.txt

@@ -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.

NotoSans-Regular.ttf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6b04c8dd65af6b73eb4279472ed1580b29102d6496a377340e80a40cdb3b22c9
+size 455188

README.md

@@ -1,12 +1,252 @@
----
-title: FooocusEnhanced
-emoji: 😻
-colorFrom: red
-colorTo: indigo
-sdk: gradio
-sdk_version: 5.37.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 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_embedded/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)
+# 1500 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.

__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"
+}

dev_interface.py

@@ -0,0 +1,6 @@
+from pathlib import Path
+from utils import here
+import sys
+sys.path.append(str(Path(here, "src")))
+
+from custom_controlnet_aux import *

hint_image_enchance.py

@@ -0,0 +1,233 @@
+from .log import log
+from .utils import ResizeMode, safe_numpy
+import numpy as np
+import torch
+import cv2
+from .utils import get_unique_axis0
+from .lvminthin import nake_nms, lvmin_thin
+
+MAX_IMAGEGEN_RESOLUTION = 8192 #https://github.com/comfyanonymous/ComfyUI/blob/c910b4a01ca58b04e5d4ab4c747680b996ada02b/nodes.py#L42
+RESIZE_MODES = [ResizeMode.RESIZE.value, ResizeMode.INNER_FIT.value, ResizeMode.OUTER_FIT.value]
+
+#Port from https://github.com/Mikubill/sd-webui-controlnet/blob/e67e017731aad05796b9615dc6eadce911298ea1/internal_controlnet/external_code.py#L89
+class PixelPerfectResolution:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "original_image": ("IMAGE", ),
+                "image_gen_width": ("INT", {"default": 512, "min": 64, "max": MAX_IMAGEGEN_RESOLUTION, "step": 8}),
+                "image_gen_height": ("INT", {"default": 512, "min": 64, "max": MAX_IMAGEGEN_RESOLUTION, "step": 8}),
+                #https://github.com/comfyanonymous/ComfyUI/blob/c910b4a01ca58b04e5d4ab4c747680b996ada02b/nodes.py#L854
+                "resize_mode": (RESIZE_MODES, {"default": ResizeMode.RESIZE.value})
+            }
+        }
+    
+    RETURN_TYPES = ("INT",)
+    RETURN_NAMES = ("RESOLUTION (INT)", )
+    FUNCTION = "execute"
+
+    CATEGORY = "ControlNet Preprocessors"
+
+    def execute(self, original_image, image_gen_width, image_gen_height, resize_mode):
+        _, raw_H, raw_W, _ = original_image.shape
+
+        k0 = float(image_gen_height) / float(raw_H)
+        k1 = float(image_gen_width) / float(raw_W)
+
+        if resize_mode == ResizeMode.OUTER_FIT.value:
+            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 = {image_gen_height}")
+        log.debug(f"target_W = {image_gen_width}")
+        log.debug(f"estimation = {estimation}")
+
+        return (int(np.round(estimation)), )
+
+class HintImageEnchance:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "hint_image": ("IMAGE", ),
+                "image_gen_width": ("INT", {"default": 512, "min": 64, "max": MAX_IMAGEGEN_RESOLUTION, "step": 8}),
+                "image_gen_height": ("INT", {"default": 512, "min": 64, "max": MAX_IMAGEGEN_RESOLUTION, "step": 8}),
+                #https://github.com/comfyanonymous/ComfyUI/blob/c910b4a01ca58b04e5d4ab4c747680b996ada02b/nodes.py#L854
+                "resize_mode": (RESIZE_MODES, {"default": ResizeMode.RESIZE.value})
+            }
+        }
+    
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+
+    CATEGORY = "ControlNet Preprocessors"
+    def execute(self, hint_image, image_gen_width, image_gen_height, resize_mode):
+        outs = []
+        for single_hint_image in hint_image:
+            np_hint_image = np.asarray(single_hint_image * 255., dtype=np.uint8)
+
+            if resize_mode == ResizeMode.RESIZE.value:
+                np_hint_image = self.execute_resize(np_hint_image, image_gen_width, image_gen_height)
+            elif resize_mode == ResizeMode.OUTER_FIT.value:
+                np_hint_image = self.execute_outer_fit(np_hint_image, image_gen_width, image_gen_height)
+            else:
+                np_hint_image = self.execute_inner_fit(np_hint_image, image_gen_width, image_gen_height)
+            
+            outs.append(torch.from_numpy(np_hint_image.astype(np.float32) / 255.0))
+        
+        return (torch.stack(outs, dim=0),)
+    
+    def execute_resize(self, detected_map, w, h):
+        detected_map = self.high_quality_resize(detected_map, (w, h))
+        detected_map = safe_numpy(detected_map)
+        return detected_map
+    
+    def execute_outer_fit(self, detected_map, w, h):
+        old_h, old_w, _ = detected_map.shape
+        old_w = float(old_w)
+        old_h = float(old_h)
+        k0 = float(h) / old_h
+        k1 = float(w) / old_w
+        safeint = lambda x: int(np.round(x))
+        k = min(k0, k1)
+        
+        borders = np.concatenate([detected_map[0, :, :], detected_map[-1, :, :], detected_map[:, 0, :], detected_map[:, -1, :]], axis=0)
+        high_quality_border_color = np.median(borders, axis=0).astype(detected_map.dtype)
+        if len(high_quality_border_color) == 4:
+            # Inpaint hijack
+            high_quality_border_color[3] = 255
+        high_quality_background = np.tile(high_quality_border_color[None, None], [h, w, 1])
+        detected_map = self.high_quality_resize(detected_map, (safeint(old_w * k), safeint(old_h * k)))
+        new_h, new_w, _ = detected_map.shape
+        pad_h = max(0, (h - new_h) // 2)
+        pad_w = max(0, (w - new_w) // 2)
+        high_quality_background[pad_h:pad_h + new_h, pad_w:pad_w + new_w] = detected_map
+        detected_map = high_quality_background
+        detected_map = safe_numpy(detected_map)
+        return detected_map
+    
+    def execute_inner_fit(self, detected_map, w, h):
+        old_h, old_w, _ = detected_map.shape
+        old_w = float(old_w)
+        old_h = float(old_h)
+        k0 = float(h) / old_h
+        k1 = float(w) / old_w
+        safeint = lambda x: int(np.round(x))
+        k = max(k0, k1)
+
+        detected_map = self.high_quality_resize(detected_map, (safeint(old_w * k), safeint(old_h * k)))
+        new_h, new_w, _ = detected_map.shape
+        pad_h = max(0, (new_h - h) // 2)
+        pad_w = max(0, (new_w - w) // 2)
+        detected_map = detected_map[pad_h:pad_h+h, pad_w:pad_w+w]
+        detected_map = safe_numpy(detected_map)
+        return detected_map
+
+    def high_quality_resize(self, x, size):
+        # Written by lvmin
+        # Super high-quality control map up-scaling, considering binary, seg, and one-pixel edges
+
+        inpaint_mask = None
+        if x.ndim == 3 and x.shape[2] == 4:
+            inpaint_mask = x[:, :, 3]
+            x = x[:, :, 0:3]
+
+        if x.shape[0] != size[1] or x.shape[1] != size[0]:
+            new_size_is_smaller = (size[0] * size[1]) < (x.shape[0] * x.shape[1])
+            new_size_is_bigger = (size[0] * size[1]) > (x.shape[0] * x.shape[1])
+            unique_color_count = len(get_unique_axis0(x.reshape(-1, x.shape[2])))
+            is_one_pixel_edge = False
+            is_binary = False
+            if unique_color_count == 2:
+                is_binary = np.min(x) < 16 and np.max(x) > 240
+                if is_binary:
+                    xc = x
+                    xc = cv2.erode(xc, np.ones(shape=(3, 3), dtype=np.uint8), iterations=1)
+                    xc = cv2.dilate(xc, np.ones(shape=(3, 3), dtype=np.uint8), iterations=1)
+                    one_pixel_edge_count = np.where(xc < x)[0].shape[0]
+                    all_edge_count = np.where(x > 127)[0].shape[0]
+                    is_one_pixel_edge = one_pixel_edge_count * 2 > all_edge_count
+
+            if 2 < unique_color_count < 200:
+                interpolation = cv2.INTER_NEAREST
+            elif new_size_is_smaller:
+                interpolation = cv2.INTER_AREA
+            else:
+                interpolation = cv2.INTER_CUBIC  # Must be CUBIC because we now use nms. NEVER CHANGE THIS
+
+            y = cv2.resize(x, size, interpolation=interpolation)
+            if inpaint_mask is not None:
+                inpaint_mask = cv2.resize(inpaint_mask, size, interpolation=interpolation)
+
+            if is_binary:
+                y = np.mean(y.astype(np.float32), axis=2).clip(0, 255).astype(np.uint8)
+                if is_one_pixel_edge:
+                    y = nake_nms(y)
+                    _, y = cv2.threshold(y, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
+                    y = lvmin_thin(y, prunings=new_size_is_bigger)
+                else:
+                    _, y = cv2.threshold(y, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
+                y = np.stack([y] * 3, axis=2)
+        else:
+            y = x
+
+        if inpaint_mask is not None:
+            inpaint_mask = (inpaint_mask > 127).astype(np.float32) * 255.0
+            inpaint_mask = inpaint_mask[:, :, None].clip(0, 255).astype(np.uint8)
+            y = np.concatenate([y, inpaint_mask], axis=2)
+
+        return y
+
+
+class ImageGenResolutionFromLatent:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": { "latent": ("LATENT", ) }
+        }
+    
+    RETURN_TYPES = ("INT", "INT")
+    RETURN_NAMES = ("IMAGE_GEN_WIDTH (INT)", "IMAGE_GEN_HEIGHT (INT)")
+    FUNCTION = "execute"
+
+    CATEGORY = "ControlNet Preprocessors"
+
+    def execute(self, latent):
+        _, _, H, W = latent["samples"].shape
+        return (W * 8, H * 8)
+
+class ImageGenResolutionFromImage:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": { "image": ("IMAGE", ) }
+        }
+    
+    RETURN_TYPES = ("INT", "INT")
+    RETURN_NAMES = ("IMAGE_GEN_WIDTH (INT)", "IMAGE_GEN_HEIGHT (INT)")
+    FUNCTION = "execute"
+
+    CATEGORY = "ControlNet Preprocessors"
+
+    def execute(self, image):
+        _, H, W, _ = image.shape
+        return (W, H)
+    
+NODE_CLASS_MAPPINGS = {
+    "PixelPerfectResolution": PixelPerfectResolution,
+    "ImageGenResolutionFromImage": ImageGenResolutionFromImage,
+    "ImageGenResolutionFromLatent": ImageGenResolutionFromLatent,
+    "HintImageEnchance": HintImageEnchance
+}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "PixelPerfectResolution": "Pixel Perfect Resolution",
+    "ImageGenResolutionFromImage": "Generation Resolution From Image",
+    "ImageGenResolutionFromLatent": "Generation Resolution From Latent",
+    "HintImageEnchance": "Enchance And Resize Hint Images"
+}

install.bat

@@ -0,0 +1,20 @@
+@echo off
+
+set "requirements_txt=%~dp0\requirements.txt"
+set "python_exec=..\..\..\python_embedded\python.exe"
+
+echo Installing ComfyUI's ControlNet Auxiliary Preprocessors..
+
+if exist "%python_exec%" (
+    echo Installing with ComfyUI Portable
+    for /f "delims=" %%i in (%requirements_txt%) do (
+        %python_exec% -s -m pip install "%%i"
+    )
+) else (
+    echo Installing with system Python
+    for /f "delims=" %%i in (%requirements_txt%) do (
+        pip install "%%i"
+    )
+)
+
+pause

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()

lvminthin.py

@@ -0,0 +1,87 @@
+# High Quality Edge Thinning using Pure Python
+# Written by Lvmin Zhang
+# 2023 April
+# Stanford University
+# If you use this, please Cite "High Quality Edge Thinning using Pure Python", Lvmin Zhang, In Mikubill/sd-webui-controlnet.
+
+
+import cv2
+import numpy as np
+
+
+lvmin_kernels_raw = [
+    np.array([
+        [-1, -1, -1],
+        [0, 1, 0],
+        [1, 1, 1]
+    ], dtype=np.int32),
+    np.array([
+        [0, -1, -1],
+        [1, 1, -1],
+        [0, 1, 0]
+    ], dtype=np.int32)
+]
+
+lvmin_kernels = []
+lvmin_kernels += [np.rot90(x, k=0, axes=(0, 1)) for x in lvmin_kernels_raw]
+lvmin_kernels += [np.rot90(x, k=1, axes=(0, 1)) for x in lvmin_kernels_raw]
+lvmin_kernels += [np.rot90(x, k=2, axes=(0, 1)) for x in lvmin_kernels_raw]
+lvmin_kernels += [np.rot90(x, k=3, axes=(0, 1)) for x in lvmin_kernels_raw]
+
+lvmin_prunings_raw = [
+    np.array([
+        [-1, -1, -1],
+        [-1, 1, -1],
+        [0, 0, -1]
+    ], dtype=np.int32),
+    np.array([
+        [-1, -1, -1],
+        [-1, 1, -1],
+        [-1, 0, 0]
+    ], dtype=np.int32)
+]
+
+lvmin_prunings = []
+lvmin_prunings += [np.rot90(x, k=0, axes=(0, 1)) for x in lvmin_prunings_raw]
+lvmin_prunings += [np.rot90(x, k=1, axes=(0, 1)) for x in lvmin_prunings_raw]
+lvmin_prunings += [np.rot90(x, k=2, axes=(0, 1)) for x in lvmin_prunings_raw]
+lvmin_prunings += [np.rot90(x, k=3, axes=(0, 1)) for x in lvmin_prunings_raw]
+
+
+def remove_pattern(x, kernel):
+    objects = cv2.morphologyEx(x, cv2.MORPH_HITMISS, kernel)
+    objects = np.where(objects > 127)
+    x[objects] = 0
+    return x, objects[0].shape[0] > 0
+
+
+def thin_one_time(x, kernels):
+    y = x
+    is_done = True
+    for k in kernels:
+        y, has_update = remove_pattern(y, k)
+        if has_update:
+            is_done = False
+    return y, is_done
+
+
+def lvmin_thin(x, prunings=True):
+    y = x
+    for i in range(32):
+        y, is_done = thin_one_time(y, lvmin_kernels)
+        if is_done:
+            break
+    if prunings:
+        y, _ = thin_one_time(y, lvmin_prunings)
+    return y
+
+
+def nake_nms(x):
+    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)
+    return y

node_wrappers/anime_face_segment.py

@@ -0,0 +1,43 @@
+from ..utils import common_annotator_call, define_preprocessor_inputs, INPUT
+import comfy.model_management as model_management
+import torch
+from einops import rearrange
+
+class AnimeFace_SemSegPreprocessor:
+    @classmethod
+    def INPUT_TYPES(s):
+        #This preprocessor is only trained on 512x resolution
+        #https://github.com/siyeong0/Anime-Face-Segmentation/blob/main/predict.py#L25
+        return define_preprocessor_inputs(
+            remove_background_using_abg=INPUT.BOOLEAN(True),
+            resolution=INPUT.RESOLUTION(default=512, min=512, max=512)
+        )
+
+    RETURN_TYPES = ("IMAGE", "MASK")
+    RETURN_NAMES = ("IMAGE", "ABG_CHARACTER_MASK (MASK)")
+    FUNCTION = "execute"
+
+    CATEGORY = "ControlNet Preprocessors/Semantic Segmentation"
+
+    def execute(self, image, remove_background_using_abg=True, resolution=512, **kwargs):
+        from custom_controlnet_aux.anime_face_segment import AnimeFaceSegmentor
+
+        model = AnimeFaceSegmentor.from_pretrained().to(model_management.get_torch_device())
+        if remove_background_using_abg:
+            out_image_with_mask = common_annotator_call(model, image, resolution=resolution, remove_background=True)
+            out_image = out_image_with_mask[..., :3]
+            mask = out_image_with_mask[..., 3:]
+            mask = rearrange(mask, "n h w c -> n c h w")
+        else:
+            out_image = common_annotator_call(model, image, resolution=resolution, remove_background=False)
+            N, H, W, C = out_image.shape
+            mask = torch.ones(N, C, H, W)
+        del model
+        return (out_image, mask)
+
+NODE_CLASS_MAPPINGS = {
+    "AnimeFace_SemSegPreprocessor": AnimeFace_SemSegPreprocessor
+}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "AnimeFace_SemSegPreprocessor": "Anime Face Segmentor"
+}

node_wrappers/anyline.py

@@ -0,0 +1,87 @@
+import torch
+import numpy as np
+import comfy.model_management as model_management
+import comfy.utils
+
+# Requires comfyui_controlnet_aux funcsions and classes
+from ..utils import common_annotator_call, INPUT, define_preprocessor_inputs
+
+def get_intensity_mask(image_array, lower_bound, upper_bound):
+    mask = image_array[:, :, 0]
+    mask = np.where((mask >= lower_bound) & (mask <= upper_bound), mask, 0)
+    mask = np.expand_dims(mask, 2).repeat(3, axis=2)
+    return mask
+
+def combine_layers(base_layer, top_layer):
+    mask = top_layer.astype(bool)
+    temp = 1 - (1 - top_layer) * (1 - base_layer)
+    result = base_layer * (~mask) + temp * mask
+    return result
+
+class AnyLinePreprocessor:
+    @classmethod
+    def INPUT_TYPES(s):
+        return define_preprocessor_inputs(
+            merge_with_lineart=INPUT.COMBO(["lineart_standard", "lineart_realisitic", "lineart_anime", "manga_line"], default="lineart_standard"),
+            resolution=INPUT.RESOLUTION(default=1280, step=8),
+            lineart_lower_bound=INPUT.FLOAT(default=0),
+            lineart_upper_bound=INPUT.FLOAT(default=1),
+            object_min_size=INPUT.INT(default=36, min=1),
+            object_connectivity=INPUT.INT(default=1, min=1)
+        )
+
+    RETURN_TYPES = ("IMAGE",)
+    RETURN_NAMES = ("image",)
+
+    FUNCTION = "get_anyline"
+    CATEGORY = "ControlNet Preprocessors/Line Extractors"
+
+    def __init__(self):
+        self.device = model_management.get_torch_device()
+
+    def get_anyline(self, image, merge_with_lineart="lineart_standard", resolution=512, lineart_lower_bound=0, lineart_upper_bound=1, object_min_size=36, object_connectivity=1):
+        from custom_controlnet_aux.teed import TEDDetector
+        from skimage import morphology
+        pbar = comfy.utils.ProgressBar(3)
+
+        # Process the image with MTEED model
+        mteed_model = TEDDetector.from_pretrained("TheMistoAI/MistoLine", "MTEED.pth", subfolder="Anyline").to(self.device)
+        mteed_result = common_annotator_call(mteed_model, image, resolution=resolution, show_pbar=False)
+        mteed_result = mteed_result.numpy()
+        del mteed_model
+        pbar.update(1)
+
+        # Process the image with the lineart standard preprocessor
+        if merge_with_lineart == "lineart_standard":
+            from custom_controlnet_aux.lineart_standard import LineartStandardDetector
+            lineart_standard_detector = LineartStandardDetector()
+            lineart_result = common_annotator_call(lineart_standard_detector, image, guassian_sigma=2, intensity_threshold=3, resolution=resolution, show_pbar=False).numpy()
+            del lineart_standard_detector
+        else:
+            from custom_controlnet_aux.lineart import LineartDetector
+            from custom_controlnet_aux.lineart_anime import LineartAnimeDetector
+            from custom_controlnet_aux.manga_line import LineartMangaDetector
+            lineart_detector = dict(lineart_realisitic=LineartDetector, lineart_anime=LineartAnimeDetector, manga_line=LineartMangaDetector)[merge_with_lineart]
+            lineart_detector = lineart_detector.from_pretrained().to(self.device)
+            lineart_result = common_annotator_call(lineart_detector, image, resolution=resolution, show_pbar=False).numpy()
+            del lineart_detector
+        pbar.update(1)
+        
+        final_result = []
+        for i in range(len(image)):
+            _lineart_result  = get_intensity_mask(lineart_result[i], lower_bound=lineart_lower_bound, upper_bound=lineart_upper_bound)
+            _cleaned = morphology.remove_small_objects(_lineart_result.astype(bool), min_size=object_min_size, connectivity=object_connectivity)
+            _lineart_result = _lineart_result * _cleaned
+            _mteed_result = mteed_result[i]
+
+            # Combine the results
+            final_result.append(torch.from_numpy(combine_layers(_mteed_result, _lineart_result)))
+        pbar.update(1)
+        return (torch.stack(final_result),)
+
+NODE_CLASS_MAPPINGS = {
+    "AnyLineArtPreprocessor_aux": AnyLinePreprocessor
+}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "AnyLineArtPreprocessor_aux": "AnyLine Lineart"
+}

node_wrappers/binary.py

@@ -0,0 +1,29 @@
+from ..utils import common_annotator_call, INPUT, define_preprocessor_inputs
+import comfy.model_management as model_management
+
+class Binary_Preprocessor:
+    @classmethod
+    def INPUT_TYPES(s):
+        return define_preprocessor_inputs(
+            bin_threshold=INPUT.INT(default=100, max=255),
+            resolution=INPUT.RESOLUTION()
+        )
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+
+    CATEGORY = "ControlNet Preprocessors/Line Extractors"
+
+    def execute(self, image, bin_threshold=100, resolution=512, **kwargs):
+        from custom_controlnet_aux.binary import BinaryDetector
+
+        return (common_annotator_call(BinaryDetector(), image, bin_threshold=bin_threshold, resolution=resolution), )
+
+
+
+NODE_CLASS_MAPPINGS = {
+    "BinaryPreprocessor": Binary_Preprocessor
+}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "BinaryPreprocessor": "Binary Lines"
+}

node_wrappers/canny.py

@@ -0,0 +1,30 @@
+from ..utils import common_annotator_call, INPUT, define_preprocessor_inputs
+import comfy.model_management as model_management
+
+class Canny_Edge_Preprocessor:
+    @classmethod
+    def INPUT_TYPES(s):
+        return define_preprocessor_inputs(
+            low_threshold=INPUT.INT(default=100, max=255),
+            high_threshold=INPUT.INT(default=200, max=255),
+            resolution=INPUT.RESOLUTION()
+        )
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+
+    CATEGORY = "ControlNet Preprocessors/Line Extractors"
+
+    def execute(self, image, low_threshold=100, high_threshold=200, resolution=512, **kwargs):
+        from custom_controlnet_aux.canny import CannyDetector
+
+        return (common_annotator_call(CannyDetector(), image, low_threshold=low_threshold, high_threshold=high_threshold, resolution=resolution), )
+
+
+
+NODE_CLASS_MAPPINGS = {
+    "CannyEdgePreprocessor": Canny_Edge_Preprocessor
+}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "CannyEdgePreprocessor": "Canny Edge"
+}

node_wrappers/color.py

@@ -0,0 +1,26 @@
+from ..utils import common_annotator_call, INPUT, define_preprocessor_inputs
+import comfy.model_management as model_management
+
+class Color_Preprocessor:
+    @classmethod
+    def INPUT_TYPES(s):
+        return define_preprocessor_inputs(resolution=INPUT.RESOLUTION())
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+
+    CATEGORY = "ControlNet Preprocessors/T2IAdapter-only"
+
+    def execute(self, image, resolution=512, **kwargs):
+        from custom_controlnet_aux.color import ColorDetector
+
+        return (common_annotator_call(ColorDetector(), image, resolution=resolution), )
+
+
+
+NODE_CLASS_MAPPINGS = {
+    "ColorPreprocessor": Color_Preprocessor
+}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "ColorPreprocessor": "Color Pallete"
+}

node_wrappers/densepose.py

@@ -0,0 +1,31 @@
+from ..utils import common_annotator_call, INPUT, define_preprocessor_inputs
+import comfy.model_management as model_management
+
+class DensePose_Preprocessor:
+    @classmethod
+    def INPUT_TYPES(s):
+        return define_preprocessor_inputs(
+            model=INPUT.COMBO(["densepose_r50_fpn_dl.torchscript", "densepose_r101_fpn_dl.torchscript"]),
+            cmap=INPUT.COMBO(["Viridis (MagicAnimate)", "Parula (CivitAI)"]),
+            resolution=INPUT.RESOLUTION()
+        )
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+
+    CATEGORY = "ControlNet Preprocessors/Faces and Poses Estimators"
+
+    def execute(self, image, model="densepose_r50_fpn_dl.torchscript", cmap="Viridis (MagicAnimate)", resolution=512):
+        from custom_controlnet_aux.densepose import DenseposeDetector
+        model = DenseposeDetector \
+                    .from_pretrained(filename=model) \
+                    .to(model_management.get_torch_device())
+        return (common_annotator_call(model, image, cmap="viridis" if "Viridis" in cmap else "parula", resolution=resolution), )
+
+
+NODE_CLASS_MAPPINGS = {
+    "DensePosePreprocessor": DensePose_Preprocessor
+}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "DensePosePreprocessor": "DensePose Estimator"
+}

node_wrappers/depth_anything.py

@@ -0,0 +1,55 @@
+from ..utils import common_annotator_call, define_preprocessor_inputs, INPUT
+import comfy.model_management as model_management
+
+class Depth_Anything_Preprocessor:
+    @classmethod
+    def INPUT_TYPES(s):
+        return define_preprocessor_inputs(
+            ckpt_name=INPUT.COMBO(
+                ["depth_anything_vitl14.pth", "depth_anything_vitb14.pth", "depth_anything_vits14.pth"]
+            ),
+            resolution=INPUT.RESOLUTION()
+        )
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+
+    CATEGORY = "ControlNet Preprocessors/Normal and Depth Estimators"
+
+    def execute(self, image, ckpt_name="depth_anything_vitl14.pth", resolution=512, **kwargs):
+        from custom_controlnet_aux.depth_anything import DepthAnythingDetector
+
+        model = DepthAnythingDetector.from_pretrained(filename=ckpt_name).to(model_management.get_torch_device())
+        out = common_annotator_call(model, image, resolution=resolution)
+        del model
+        return (out, )
+
+class Zoe_Depth_Anything_Preprocessor:
+    @classmethod
+    def INPUT_TYPES(s):
+        return define_preprocessor_inputs(
+            environment=INPUT.COMBO(["indoor", "outdoor"]),
+            resolution=INPUT.RESOLUTION()
+        )
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+
+    CATEGORY = "ControlNet Preprocessors/Normal and Depth Estimators"
+
+    def execute(self, image, environment="indoor", resolution=512, **kwargs):
+        from custom_controlnet_aux.zoe import ZoeDepthAnythingDetector
+        ckpt_name = "depth_anything_metric_depth_indoor.pt" if environment == "indoor" else "depth_anything_metric_depth_outdoor.pt"
+        model = ZoeDepthAnythingDetector.from_pretrained(filename=ckpt_name).to(model_management.get_torch_device())
+        out = common_annotator_call(model, image, resolution=resolution)
+        del model
+        return (out, )
+
+NODE_CLASS_MAPPINGS = {
+    "DepthAnythingPreprocessor": Depth_Anything_Preprocessor,
+    "Zoe_DepthAnythingPreprocessor": Zoe_Depth_Anything_Preprocessor
+}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "DepthAnythingPreprocessor": "Depth Anything",
+    "Zoe_DepthAnythingPreprocessor": "Zoe Depth Anything"
+}

node_wrappers/depth_anything_v2.py

@@ -0,0 +1,56 @@
+from ..utils import common_annotator_call, INPUT, define_preprocessor_inputs
+import comfy.model_management as model_management
+
+class Depth_Anything_V2_Preprocessor:
+    @classmethod
+    def INPUT_TYPES(s):
+        return define_preprocessor_inputs(
+            ckpt_name=INPUT.COMBO(
+                ["depth_anything_v2_vitg.pth", "depth_anything_v2_vitl.pth", "depth_anything_v2_vitb.pth", "depth_anything_v2_vits.pth"],
+                default="depth_anything_v2_vitl.pth"
+            ),
+            resolution=INPUT.RESOLUTION()
+        )
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+
+    CATEGORY = "ControlNet Preprocessors/Normal and Depth Estimators"
+
+    def execute(self, image, ckpt_name="depth_anything_v2_vitl.pth", resolution=512, **kwargs):
+        from custom_controlnet_aux.depth_anything_v2 import DepthAnythingV2Detector
+
+        model = DepthAnythingV2Detector.from_pretrained(filename=ckpt_name).to(model_management.get_torch_device())
+        out = common_annotator_call(model, image, resolution=resolution, max_depth=1)
+        del model
+        return (out, )
+
+""" class Depth_Anything_Metric_V2_Preprocessor:
+    @classmethod
+    def INPUT_TYPES(s):
+        return create_node_input_types(
+            environment=(["indoor", "outdoor"], {"default": "indoor"}),
+            max_depth=("FLOAT", {"min": 0, "max": 100, "default": 20.0, "step": 0.01})
+        )
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+
+    CATEGORY = "ControlNet Preprocessors/Normal and Depth Estimators"
+
+    def execute(self, image, environment, resolution=512, max_depth=20.0, **kwargs):
+        from custom_controlnet_aux.depth_anything_v2 import DepthAnythingV2Detector
+        filename = dict(indoor="depth_anything_v2_metric_hypersim_vitl.pth", outdoor="depth_anything_v2_metric_vkitti_vitl.pth")[environment]
+        model = DepthAnythingV2Detector.from_pretrained(filename=filename).to(model_management.get_torch_device())
+        out = common_annotator_call(model, image, resolution=resolution, max_depth=max_depth)
+        del model
+        return (out, ) """
+
+NODE_CLASS_MAPPINGS = {
+    "DepthAnythingV2Preprocessor": Depth_Anything_V2_Preprocessor,
+    #"Metric_DepthAnythingV2Preprocessor": Depth_Anything_Metric_V2_Preprocessor
+}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "DepthAnythingV2Preprocessor": "Depth Anything V2 - Relative",
+    #"Metric_DepthAnythingV2Preprocessor": "Depth Anything V2 - Metric"
+}

node_wrappers/diffusion_edge.py

@@ -0,0 +1,41 @@
+from ..utils import common_annotator_call, define_preprocessor_inputs, INPUT, run_script
+import comfy.model_management as model_management
+import sys
+
+def install_deps():
+    try:
+        import sklearn
+    except:
+        run_script([sys.executable, '-s', '-m', 'pip', 'install', 'scikit-learn'])
+
+class DiffusionEdge_Preprocessor:
+    @classmethod
+    def INPUT_TYPES(s):
+        return define_preprocessor_inputs(
+            environment=INPUT.COMBO(["indoor", "urban", "natrual"]),
+            patch_batch_size=INPUT.INT(default=4, min=1, max=16),
+            resolution=INPUT.RESOLUTION()
+        )
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+
+    CATEGORY = "ControlNet Preprocessors/Line Extractors"
+
+    def execute(self, image, environment="indoor", patch_batch_size=4, resolution=512, **kwargs):
+        install_deps()
+        from custom_controlnet_aux.diffusion_edge import DiffusionEdgeDetector
+
+        model = DiffusionEdgeDetector \
+            .from_pretrained(filename = f"diffusion_edge_{environment}.pt") \
+            .to(model_management.get_torch_device())
+        out = common_annotator_call(model, image, resolution=resolution, patch_batch_size=patch_batch_size)
+        del model
+        return (out, )
+
+NODE_CLASS_MAPPINGS = {
+    "DiffusionEdge_Preprocessor": DiffusionEdge_Preprocessor,
+}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "DiffusionEdge_Preprocessor": "Diffusion Edge (batch size ↑ => speed ↑, VRAM ↑)",
+}

node_wrappers/dsine.py

@@ -0,0 +1,31 @@
+from ..utils import common_annotator_call, define_preprocessor_inputs, INPUT
+import comfy.model_management as model_management
+
+class DSINE_Normal_Map_Preprocessor:
+    @classmethod
+    def INPUT_TYPES(s):
+        return define_preprocessor_inputs(
+            fov=INPUT.FLOAT(max=365.0, default=60.0),
+            iterations=INPUT.INT(min=1, max=20, default=5),
+            resolution=INPUT.RESOLUTION()
+        )
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+
+    CATEGORY = "ControlNet Preprocessors/Normal and Depth Estimators"
+
+    def execute(self, image, fov=60.0, iterations=5, resolution=512, **kwargs):
+        from custom_controlnet_aux.dsine import DsineDetector
+
+        model = DsineDetector.from_pretrained().to(model_management.get_torch_device())
+        out = common_annotator_call(model, image, fov=fov, iterations=iterations, resolution=resolution)
+        del model
+        return (out,)
+
+NODE_CLASS_MAPPINGS = {
+    "DSINE-NormalMapPreprocessor": DSINE_Normal_Map_Preprocessor
+}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "DSINE-NormalMapPreprocessor": "DSINE Normal Map"
+}

node_wrappers/dwpose.py

@@ -0,0 +1,160 @@
+from ..utils import common_annotator_call, define_preprocessor_inputs, INPUT
+import comfy.model_management as model_management
+import numpy as np
+import warnings
+from custom_controlnet_aux.dwpose import DwposeDetector, AnimalposeDetector
+import os
+import json
+
+DWPOSE_MODEL_NAME = "yzd-v/DWPose"
+#Trigger startup caching for onnxruntime
+GPU_PROVIDERS = ["CUDAExecutionProvider", "DirectMLExecutionProvider", "OpenVINOExecutionProvider", "ROCMExecutionProvider", "CoreMLExecutionProvider"]
+def check_ort_gpu():
+    try:
+        import onnxruntime as ort
+        for provider in GPU_PROVIDERS:
+            if provider in ort.get_available_providers():
+                return True
+        return False
+    except:
+        return False
+
+if not os.environ.get("DWPOSE_ONNXRT_CHECKED"):
+    if check_ort_gpu():
+        print("DWPose: Onnxruntime with acceleration providers detected")
+    else:
+        warnings.warn("DWPose: Onnxruntime not found or doesn't come with acceleration providers, switch to OpenCV with CPU device. DWPose might run very slowly")
+        os.environ['AUX_ORT_PROVIDERS'] = ''
+    os.environ["DWPOSE_ONNXRT_CHECKED"] = '1'
+
+class DWPose_Preprocessor:
+    @classmethod
+    def INPUT_TYPES(s):
+        return define_preprocessor_inputs(
+            detect_hand=INPUT.COMBO(["enable", "disable"]),
+            detect_body=INPUT.COMBO(["enable", "disable"]),
+            detect_face=INPUT.COMBO(["enable", "disable"]),
+            resolution=INPUT.RESOLUTION(),
+            bbox_detector=INPUT.COMBO(
+                ["yolox_l.torchscript.pt", "yolox_l.onnx", "yolo_nas_l_fp16.onnx", "yolo_nas_m_fp16.onnx", "yolo_nas_s_fp16.onnx"],
+                default="yolox_l.onnx"
+            ),
+            pose_estimator=INPUT.COMBO(
+                ["dw-ll_ucoco_384_bs5.torchscript.pt", "dw-ll_ucoco_384.onnx", "dw-ll_ucoco.onnx"],
+                default="dw-ll_ucoco_384_bs5.torchscript.pt"
+            )
+        )
+
+    RETURN_TYPES = ("IMAGE", "POSE_KEYPOINT")
+    FUNCTION = "estimate_pose"
+
+    CATEGORY = "ControlNet Preprocessors/Faces and Poses Estimators"
+
+    def estimate_pose(self, image, detect_hand="enable", detect_body="enable", detect_face="enable", resolution=512, bbox_detector="yolox_l.onnx", pose_estimator="dw-ll_ucoco_384.onnx", **kwargs):
+        if bbox_detector == "yolox_l.onnx":
+            yolo_repo = DWPOSE_MODEL_NAME
+        elif "yolox" in bbox_detector:
+            yolo_repo = "hr16/yolox-onnx"
+        elif "yolo_nas" in bbox_detector:
+            yolo_repo = "hr16/yolo-nas-fp16"
+        else:
+            raise NotImplementedError(f"Download mechanism for {bbox_detector}")
+
+        if pose_estimator == "dw-ll_ucoco_384.onnx":
+            pose_repo = DWPOSE_MODEL_NAME
+        elif pose_estimator.endswith(".onnx"):
+            pose_repo = "hr16/UnJIT-DWPose"
+        elif pose_estimator.endswith(".torchscript.pt"):
+            pose_repo = "hr16/DWPose-TorchScript-BatchSize5"
+        else:
+            raise NotImplementedError(f"Download mechanism for {pose_estimator}")
+
+        model = DwposeDetector.from_pretrained(
+            pose_repo,
+            yolo_repo,
+            det_filename=bbox_detector, pose_filename=pose_estimator,
+            torchscript_device=model_management.get_torch_device()
+        )
+        detect_hand = detect_hand == "enable"
+        detect_body = detect_body == "enable"
+        detect_face = detect_face == "enable"
+        self.openpose_dicts = []
+        def func(image, **kwargs):
+            pose_img, openpose_dict = model(image, **kwargs)
+            self.openpose_dicts.append(openpose_dict)
+            return pose_img
+
+        out = common_annotator_call(func, image, include_hand=detect_hand, include_face=detect_face, include_body=detect_body, image_and_json=True, resolution=resolution)
+        del model
+        return {
+            'ui': { "openpose_json": [json.dumps(self.openpose_dicts, indent=4)] },
+            "result": (out, self.openpose_dicts)
+        }
+
+class AnimalPose_Preprocessor:
+    @classmethod
+    def INPUT_TYPES(s):
+        return define_preprocessor_inputs(
+            bbox_detector = INPUT.COMBO(
+                ["yolox_l.torchscript.pt", "yolox_l.onnx", "yolo_nas_l_fp16.onnx", "yolo_nas_m_fp16.onnx", "yolo_nas_s_fp16.onnx"],
+                default="yolox_l.torchscript.pt"
+            ),
+            pose_estimator = INPUT.COMBO(
+                ["rtmpose-m_ap10k_256_bs5.torchscript.pt", "rtmpose-m_ap10k_256.onnx"],
+                default="rtmpose-m_ap10k_256_bs5.torchscript.pt"
+            ),
+            resolution = INPUT.RESOLUTION()
+        )
+
+    RETURN_TYPES = ("IMAGE", "POSE_KEYPOINT")
+    FUNCTION = "estimate_pose"
+
+    CATEGORY = "ControlNet Preprocessors/Faces and Poses Estimators"
+
+    def estimate_pose(self, image, resolution=512, bbox_detector="yolox_l.onnx", pose_estimator="rtmpose-m_ap10k_256.onnx", **kwargs):
+        if bbox_detector == "yolox_l.onnx":
+            yolo_repo = DWPOSE_MODEL_NAME
+        elif "yolox" in bbox_detector:
+            yolo_repo = "hr16/yolox-onnx"
+        elif "yolo_nas" in bbox_detector:
+            yolo_repo = "hr16/yolo-nas-fp16"
+        else:
+            raise NotImplementedError(f"Download mechanism for {bbox_detector}")
+
+        if pose_estimator == "dw-ll_ucoco_384.onnx":
+            pose_repo = DWPOSE_MODEL_NAME
+        elif pose_estimator.endswith(".onnx"):
+            pose_repo = "hr16/UnJIT-DWPose"
+        elif pose_estimator.endswith(".torchscript.pt"):
+            pose_repo = "hr16/DWPose-TorchScript-BatchSize5"
+        else:
+            raise NotImplementedError(f"Download mechanism for {pose_estimator}")
+
+        model = AnimalposeDetector.from_pretrained(
+            pose_repo,
+            yolo_repo,
+            det_filename=bbox_detector, pose_filename=pose_estimator,
+            torchscript_device=model_management.get_torch_device()
+        )
+
+        self.openpose_dicts = []
+        def func(image, **kwargs):
+            pose_img, openpose_dict = model(image, **kwargs)
+            self.openpose_dicts.append(openpose_dict)
+            return pose_img
+
+        out = common_annotator_call(func, image, image_and_json=True, resolution=resolution)
+        del model
+        return {
+            'ui': { "openpose_json": [json.dumps(self.openpose_dicts, indent=4)] },
+            "result": (out, self.openpose_dicts)
+        }
+
+NODE_CLASS_MAPPINGS = {
+    "DWPreprocessor": DWPose_Preprocessor,
+    "AnimalPosePreprocessor": AnimalPose_Preprocessor
+}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "DWPreprocessor": "DWPose Estimator",
+    "AnimalPosePreprocessor": "AnimalPose Estimator (AP10K)"
+}

node_wrappers/hed.py

@@ -0,0 +1,53 @@
+from ..utils import common_annotator_call, define_preprocessor_inputs, INPUT
+import comfy.model_management as model_management
+
+class HED_Preprocessor:
+    @classmethod
+    def INPUT_TYPES(s):
+        return define_preprocessor_inputs(
+            safe=INPUT.COMBO(["enable", "disable"]),
+            resolution=INPUT.RESOLUTION()
+        )
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+
+    CATEGORY = "ControlNet Preprocessors/Line Extractors"
+
+    def execute(self, image, resolution=512, **kwargs):
+        from custom_controlnet_aux.hed import HEDdetector
+
+        model = HEDdetector.from_pretrained().to(model_management.get_torch_device())
+        out = common_annotator_call(model, image, resolution=resolution, safe = kwargs["safe"] == "enable")
+        del model
+        return (out, )
+
+class Fake_Scribble_Preprocessor:
+    @classmethod
+    def INPUT_TYPES(s):
+        return define_preprocessor_inputs(
+            safe=INPUT.COMBO(["enable", "disable"]),
+            resolution=INPUT.RESOLUTION()
+        )
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+
+    CATEGORY = "ControlNet Preprocessors/Line Extractors"
+
+    def execute(self, image, resolution=512, **kwargs):
+        from custom_controlnet_aux.hed import HEDdetector
+        
+        model = HEDdetector.from_pretrained().to(model_management.get_torch_device())
+        out = common_annotator_call(model, image, resolution=resolution, scribble=True, safe=kwargs["safe"]=="enable")
+        del model
+        return (out, )
+
+NODE_CLASS_MAPPINGS = {
+    "HEDPreprocessor": HED_Preprocessor,
+    "FakeScribblePreprocessor": Fake_Scribble_Preprocessor
+}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "HEDPreprocessor": "HED Soft-Edge Lines",
+    "FakeScribblePreprocessor": "Fake Scribble Lines (aka scribble_hed)"
+}

node_wrappers/inpaint.py

@@ -0,0 +1,27 @@
+import torch
+from ..utils import INPUT
+
+class InpaintPreprocessor:
+    @classmethod
+    def INPUT_TYPES(s):
+        return dict(
+            required=dict(image=INPUT.IMAGE(), mask=INPUT.MASK())
+        )
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "preprocess"
+
+    CATEGORY = "ControlNet Preprocessors/others"
+
+    def preprocess(self, image, mask):
+        mask = torch.nn.functional.interpolate(mask.reshape((-1, 1, mask.shape[-2], mask.shape[-1])), size=(image.shape[1], image.shape[2]), mode="bilinear")
+        mask = mask.movedim(1,-1).expand((-1,-1,-1,3))
+        image = image.clone()
+        image[mask > 0.5] = -1.0  # set as masked pixel
+        return (image,)
+
+NODE_CLASS_MAPPINGS = {
+    "InpaintPreprocessor": InpaintPreprocessor
+}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "InpaintPreprocessor": "Inpaint Preprocessor"
+}

node_wrappers/leres.py

@@ -0,0 +1,32 @@
+from ..utils import common_annotator_call, define_preprocessor_inputs, INPUT
+import comfy.model_management as model_management
+
+class LERES_Depth_Map_Preprocessor:
+    @classmethod
+    def INPUT_TYPES(s):
+        return define_preprocessor_inputs(
+            rm_nearest=INPUT.FLOAT(max=100.0),
+            rm_background=INPUT.FLOAT(max=100.0),
+            boost=INPUT.COMBO(["disable", "enable"]),
+            resolution=INPUT.RESOLUTION()
+        )
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+
+    CATEGORY = "ControlNet Preprocessors/Normal and Depth Estimators"
+
+    def execute(self, image, rm_nearest=0, rm_background=0, resolution=512, boost="disable", **kwargs):
+        from custom_controlnet_aux.leres import LeresDetector
+
+        model = LeresDetector.from_pretrained().to(model_management.get_torch_device())
+        out = common_annotator_call(model, image, resolution=resolution, thr_a=rm_nearest, thr_b=rm_background, boost=boost == "enable")
+        del model
+        return (out, )
+    
+NODE_CLASS_MAPPINGS = {
+    "LeReS-DepthMapPreprocessor": LERES_Depth_Map_Preprocessor
+}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "LeReS-DepthMapPreprocessor": "LeReS Depth Map (enable boost for leres++)"
+}

node_wrappers/lineart.py

@@ -0,0 +1,30 @@
+from ..utils import common_annotator_call, define_preprocessor_inputs, INPUT
+import comfy.model_management as model_management
+
+class LineArt_Preprocessor:
+    @classmethod
+    def INPUT_TYPES(s):
+        return define_preprocessor_inputs(
+            coarse=INPUT.COMBO((["disable", "enable"])),
+            resolution=INPUT.RESOLUTION()
+        )
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+
+    CATEGORY = "ControlNet Preprocessors/Line Extractors"
+
+    def execute(self, image, resolution=512, **kwargs):
+        from custom_controlnet_aux.lineart import LineartDetector
+
+        model = LineartDetector.from_pretrained().to(model_management.get_torch_device())
+        out = common_annotator_call(model, image, resolution=resolution, coarse = kwargs["coarse"] == "enable")
+        del model
+        return (out, )
+
+NODE_CLASS_MAPPINGS = {
+    "LineArtPreprocessor": LineArt_Preprocessor
+}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "LineArtPreprocessor": "Realistic Lineart"
+}

node_wrappers/lineart_anime.py

@@ -0,0 +1,27 @@
+from ..utils import common_annotator_call, define_preprocessor_inputs, INPUT
+import comfy.model_management as model_management
+
+class AnimeLineArt_Preprocessor:
+    @classmethod
+    def INPUT_TYPES(s):
+        return define_preprocessor_inputs(resolution=INPUT.RESOLUTION())
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+
+    CATEGORY = "ControlNet Preprocessors/Line Extractors"
+
+    def execute(self, image, resolution=512, **kwargs):
+        from custom_controlnet_aux.lineart_anime import LineartAnimeDetector
+
+        model = LineartAnimeDetector.from_pretrained().to(model_management.get_torch_device())
+        out = common_annotator_call(model, image, resolution=resolution)
+        del model
+        return (out, )
+
+NODE_CLASS_MAPPINGS = {
+    "AnimeLineArtPreprocessor": AnimeLineArt_Preprocessor
+}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "AnimeLineArtPreprocessor": "Anime Lineart"
+}

node_wrappers/lineart_standard.py

@@ -0,0 +1,27 @@
+from ..utils import common_annotator_call, define_preprocessor_inputs, INPUT
+import comfy.model_management as model_management
+
+class Lineart_Standard_Preprocessor:
+    @classmethod
+    def INPUT_TYPES(s):
+        return define_preprocessor_inputs(
+            guassian_sigma=INPUT.FLOAT(default=6.0, max=100.0),
+            intensity_threshold=INPUT.INT(default=8, max=16),
+            resolution=INPUT.RESOLUTION()
+        )
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+
+    CATEGORY = "ControlNet Preprocessors/Line Extractors"
+
+    def execute(self, image, guassian_sigma=6, intensity_threshold=8, resolution=512, **kwargs):
+        from custom_controlnet_aux.lineart_standard import LineartStandardDetector
+        return (common_annotator_call(LineartStandardDetector(), image, guassian_sigma=guassian_sigma, intensity_threshold=intensity_threshold, resolution=resolution), )
+
+NODE_CLASS_MAPPINGS = {
+    "LineartStandardPreprocessor": Lineart_Standard_Preprocessor
+}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "LineartStandardPreprocessor": "Standard Lineart"
+}

node_wrappers/manga_line.py

@@ -0,0 +1,27 @@
+from ..utils import common_annotator_call, define_preprocessor_inputs, INPUT
+import comfy.model_management as model_management
+
+class Manga2Anime_LineArt_Preprocessor:
+    @classmethod
+    def INPUT_TYPES(s):
+        return define_preprocessor_inputs(resolution=INPUT.RESOLUTION())
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+
+    CATEGORY = "ControlNet Preprocessors/Line Extractors"
+
+    def execute(self, image, resolution=512, **kwargs):
+        from custom_controlnet_aux.manga_line import LineartMangaDetector
+
+        model = LineartMangaDetector.from_pretrained().to(model_management.get_torch_device())
+        out = common_annotator_call(model, image, resolution=resolution)
+        del model
+        return (out, )
+
+NODE_CLASS_MAPPINGS = {
+    "Manga2Anime_LineArt_Preprocessor": Manga2Anime_LineArt_Preprocessor
+}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "Manga2Anime_LineArt_Preprocessor": "Manga Lineart (aka lineart_anime_denoise)"
+}

node_wrappers/mediapipe_face.py

@@ -0,0 +1,39 @@
+from ..utils import common_annotator_call, define_preprocessor_inputs, INPUT, run_script
+import comfy.model_management as model_management
+import os, sys
+import subprocess, threading
+
+def install_deps():
+    try:
+        import mediapipe
+    except ImportError:
+        run_script([sys.executable, '-s', '-m', 'pip', 'install', 'mediapipe'])
+        run_script([sys.executable, '-s', '-m', 'pip', 'install', '--upgrade', 'protobuf'])
+
+class Media_Pipe_Face_Mesh_Preprocessor:
+    @classmethod
+    def INPUT_TYPES(s):
+        return define_preprocessor_inputs(
+            max_faces=INPUT.INT(default=10, min=1, max=50), #Which image has more than 50 detectable faces?
+            min_confidence=INPUT.FLOAT(default=0.5, min=0.1),
+            resolution=INPUT.RESOLUTION()
+        )
+        
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "detect"
+
+    CATEGORY = "ControlNet Preprocessors/Faces and Poses Estimators"
+
+    def detect(self, image, max_faces=10, min_confidence=0.5, resolution=512):
+        #Ref: https://github.com/Fannovel16/comfy_controlnet_preprocessors/issues/70#issuecomment-1677967369
+        install_deps()
+        from custom_controlnet_aux.mediapipe_face import MediapipeFaceDetector
+        return (common_annotator_call(MediapipeFaceDetector(), image, max_faces=max_faces, min_confidence=min_confidence, resolution=resolution), )
+
+NODE_CLASS_MAPPINGS = {
+    "MediaPipe-FaceMeshPreprocessor": Media_Pipe_Face_Mesh_Preprocessor
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "MediaPipe-FaceMeshPreprocessor": "MediaPipe Face Mesh"
+}

node_wrappers/mesh_graphormer.py

@@ -0,0 +1,158 @@
+from ..utils import common_annotator_call, define_preprocessor_inputs, INPUT, MAX_RESOLUTION, run_script
+import comfy.model_management as model_management
+import numpy as np
+import torch
+from einops import rearrange
+import os, sys
+import subprocess, threading
+import scipy.ndimage
+import cv2
+import torch.nn.functional as F
+
+def install_deps():
+    try:
+        import mediapipe
+    except ImportError:
+        run_script([sys.executable, '-s', '-m', 'pip', 'install', 'mediapipe'])
+        run_script([sys.executable, '-s', '-m', 'pip', 'install', '--upgrade', 'protobuf'])
+    
+    try:
+        import trimesh
+    except ImportError:
+        run_script([sys.executable, '-s', '-m', 'pip', 'install', 'trimesh[easy]'])
+
+#Sauce: https://github.com/comfyanonymous/ComfyUI/blob/8c6493578b3dda233e9b9a953feeaf1e6ca434ad/comfy_extras/nodes_mask.py#L309
+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)
+
+class Mesh_Graphormer_Depth_Map_Preprocessor:
+    @classmethod
+    def INPUT_TYPES(s):
+        return define_preprocessor_inputs(
+            mask_bbox_padding=("INT", {"default": 30, "min": 0, "max": 100}),
+            resolution=INPUT.RESOLUTION(),
+            mask_type=INPUT.COMBO(["based_on_depth", "tight_bboxes", "original"]),
+            mask_expand=INPUT.INT(default=5, min=-MAX_RESOLUTION, max=MAX_RESOLUTION),
+            rand_seed=INPUT.INT(default=88, min=0, max=0xffffffffffffffff),
+            detect_thr=INPUT.FLOAT(default=0.6, min=0.1),
+            presence_thr=INPUT.FLOAT(default=0.6, min=0.1)
+        )
+
+    RETURN_TYPES = ("IMAGE", "MASK")
+    RETURN_NAMES = ("IMAGE", "INPAINTING_MASK")
+    FUNCTION = "execute"
+
+    CATEGORY = "ControlNet Preprocessors/Normal and Depth Estimators"
+
+    def execute(self, image, mask_bbox_padding=30, mask_type="based_on_depth", mask_expand=5, resolution=512, rand_seed=88, detect_thr=0.6, presence_thr=0.6, **kwargs):
+        install_deps()
+        from custom_controlnet_aux.mesh_graphormer import MeshGraphormerDetector
+        model = kwargs["model"] if "model" in kwargs \
+            else MeshGraphormerDetector.from_pretrained(detect_thr=detect_thr, presence_thr=presence_thr).to(model_management.get_torch_device())
+        
+        depth_map_list = []
+        mask_list = []
+        for single_image in image:
+            np_image = np.asarray(single_image.cpu() * 255., dtype=np.uint8)
+            depth_map, mask, info = model(np_image, output_type="np", detect_resolution=resolution, mask_bbox_padding=mask_bbox_padding, seed=rand_seed)
+            if mask_type == "based_on_depth":
+                H, W = mask.shape[:2]
+                mask = cv2.resize(depth_map.copy(), (W, H))
+                mask[mask > 0] = 255
+
+            elif mask_type == "tight_bboxes":
+                mask = np.zeros_like(mask)
+                hand_bboxes = (info or {}).get("abs_boxes") or []
+                for hand_bbox in hand_bboxes: 
+                    x_min, x_max, y_min, y_max = hand_bbox
+                    mask[y_min:y_max+1, x_min:x_max+1, :] = 255 #HWC
+
+            mask = mask[:, :, :1]
+            depth_map_list.append(torch.from_numpy(depth_map.astype(np.float32) / 255.0))
+            mask_list.append(torch.from_numpy(mask.astype(np.float32) / 255.0))
+        depth_maps, masks = torch.stack(depth_map_list, dim=0), rearrange(torch.stack(mask_list, dim=0), "n h w 1 -> n 1 h w")
+        return depth_maps, expand_mask(masks, mask_expand, tapered_corners=True)
+
+def normalize_size_base_64(w, h):
+    short_side = min(w, h)
+    remainder = short_side % 64
+    return short_side - remainder + (64 if remainder > 0 else 0)
+
+class Mesh_Graphormer_With_ImpactDetector_Depth_Map_Preprocessor:
+    @classmethod
+    def INPUT_TYPES(s):
+        types = define_preprocessor_inputs(
+            # Impact pack
+            bbox_threshold=INPUT.FLOAT(default=0.5, min=0.1),
+            bbox_dilation=INPUT.INT(default=10, min=-512, max=512),
+            bbox_crop_factor=INPUT.FLOAT(default=3.0, min=1.0, max=10.0),
+            drop_size=INPUT.INT(default=10, min=1, max=MAX_RESOLUTION),
+            # Mesh Graphormer
+            mask_bbox_padding=INPUT.INT(default=30, min=0, max=100),
+            mask_type=INPUT.COMBO(["based_on_depth", "tight_bboxes", "original"]),
+            mask_expand=INPUT.INT(default=5, min=-MAX_RESOLUTION, max=MAX_RESOLUTION),
+            rand_seed=INPUT.INT(default=88, min=0, max=0xffffffffffffffff),
+            resolution=INPUT.RESOLUTION()
+        )
+        types["required"]["bbox_detector"] = ("BBOX_DETECTOR", )
+        return types
+     
+    RETURN_TYPES = ("IMAGE", "MASK")
+    RETURN_NAMES = ("IMAGE", "INPAINTING_MASK")
+    FUNCTION = "execute"
+
+    CATEGORY = "ControlNet Preprocessors/Normal and Depth Estimators"
+
+    def execute(self, image, bbox_detector, bbox_threshold=0.5, bbox_dilation=10, bbox_crop_factor=3.0, drop_size=10, resolution=512, **mesh_graphormer_kwargs):
+        install_deps()
+        from custom_controlnet_aux.mesh_graphormer import MeshGraphormerDetector
+        mesh_graphormer_node = Mesh_Graphormer_Depth_Map_Preprocessor()
+        model = MeshGraphormerDetector.from_pretrained(detect_thr=0.6, presence_thr=0.6).to(model_management.get_torch_device())
+        mesh_graphormer_kwargs["model"] = model
+
+        frames = image
+        depth_maps, masks = [], []
+        for idx in range(len(frames)):
+            frame = frames[idx:idx+1,...] #Impact Pack's BBOX_DETECTOR only supports single batch image
+            bbox_detector.setAux('face') # make default prompt as 'face' if empty prompt for CLIPSeg
+            _, segs = bbox_detector.detect(frame, bbox_threshold, bbox_dilation, bbox_crop_factor, drop_size)
+            bbox_detector.setAux(None)
+
+            n, h, w, _ = frame.shape
+            depth_map, mask = torch.zeros_like(frame), torch.zeros(n, 1, h, w)
+            for i, seg in enumerate(segs):
+                x1, y1, x2, y2 = seg.crop_region
+                cropped_image = frame[:, y1:y2, x1:x2, :]  # Never use seg.cropped_image to handle overlapping area
+                mesh_graphormer_kwargs["resolution"] = 0 #Disable resizing
+                sub_depth_map, sub_mask = mesh_graphormer_node.execute(cropped_image, **mesh_graphormer_kwargs)
+                depth_map[:, y1:y2, x1:x2, :] = sub_depth_map
+                mask[:, :, y1:y2, x1:x2] = sub_mask
+            
+            depth_maps.append(depth_map)
+            masks.append(mask)
+            
+        return (torch.cat(depth_maps), torch.cat(masks))
+    
+NODE_CLASS_MAPPINGS = {
+    "MeshGraphormer-DepthMapPreprocessor": Mesh_Graphormer_Depth_Map_Preprocessor,
+    "MeshGraphormer+ImpactDetector-DepthMapPreprocessor": Mesh_Graphormer_With_ImpactDetector_Depth_Map_Preprocessor
+}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "MeshGraphormer-DepthMapPreprocessor": "MeshGraphormer Hand Refiner",
+    "MeshGraphormer+ImpactDetector-DepthMapPreprocessor": "MeshGraphormer Hand Refiner With External Detector"
+}

node_wrappers/metric3d.py

@@ -0,0 +1,57 @@
+from ..utils import common_annotator_call, define_preprocessor_inputs, INPUT, MAX_RESOLUTION
+import comfy.model_management as model_management
+
+class Metric3D_Depth_Map_Preprocessor:
+    @classmethod
+    def INPUT_TYPES(s):
+        return define_preprocessor_inputs(
+            backbone=INPUT.COMBO(["vit-small", "vit-large", "vit-giant2"]),
+            fx=INPUT.INT(default=1000, min=1, max=MAX_RESOLUTION),
+            fy=INPUT.INT(default=1000, min=1, max=MAX_RESOLUTION),
+            resolution=INPUT.RESOLUTION()
+        )
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+
+    CATEGORY = "ControlNet Preprocessors/Normal and Depth Estimators"
+
+    def execute(self, image, backbone="vit-small", fx=1000, fy=1000, resolution=512):
+        from custom_controlnet_aux.metric3d import Metric3DDetector
+        model = Metric3DDetector.from_pretrained(filename=f"metric_depth_{backbone.replace('-', '_')}_800k.pth").to(model_management.get_torch_device())
+        cb = lambda image, **kwargs: model(image, **kwargs)[0]
+        out = common_annotator_call(cb, image, resolution=resolution, fx=fx, fy=fy, depth_and_normal=True)
+        del model
+        return (out, )
+
+class Metric3D_Normal_Map_Preprocessor:
+    @classmethod
+    def INPUT_TYPES(s):
+        return define_preprocessor_inputs(
+            backbone=INPUT.COMBO(["vit-small", "vit-large", "vit-giant2"]),
+            fx=INPUT.INT(default=1000, min=1, max=MAX_RESOLUTION),
+            fy=INPUT.INT(default=1000, min=1, max=MAX_RESOLUTION),
+            resolution=INPUT.RESOLUTION()
+        )
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+
+    CATEGORY = "ControlNet Preprocessors/Normal and Depth Estimators"
+
+    def execute(self, image, backbone="vit-small", fx=1000, fy=1000, resolution=512):
+        from custom_controlnet_aux.metric3d import Metric3DDetector
+        model = Metric3DDetector.from_pretrained(filename=f"metric_depth_{backbone.replace('-', '_')}_800k.pth").to(model_management.get_torch_device())
+        cb = lambda image, **kwargs: model(image, **kwargs)[1]
+        out = common_annotator_call(cb, image, resolution=resolution, fx=fx, fy=fy, depth_and_normal=True)
+        del model
+        return (out, )
+
+NODE_CLASS_MAPPINGS = {
+    "Metric3D-DepthMapPreprocessor": Metric3D_Depth_Map_Preprocessor,
+    "Metric3D-NormalMapPreprocessor": Metric3D_Normal_Map_Preprocessor
+}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "Metric3D-DepthMapPreprocessor": "Metric3D Depth Map",
+    "Metric3D-NormalMapPreprocessor": "Metric3D Normal Map"
+}

node_wrappers/midas.py

@@ -0,0 +1,59 @@
+from ..utils import common_annotator_call, define_preprocessor_inputs, INPUT
+import comfy.model_management as model_management
+import numpy as np
+
+class MIDAS_Normal_Map_Preprocessor:
+    @classmethod
+    def INPUT_TYPES(s):
+        return define_preprocessor_inputs(
+            a=INPUT.FLOAT(default=np.pi * 2.0, min=0.0, max=np.pi * 5.0),
+            bg_threshold=INPUT.FLOAT(default=0.1),
+            resolution=INPUT.RESOLUTION()
+        )
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+
+    CATEGORY = "ControlNet Preprocessors/Normal and Depth Estimators"
+
+    def execute(self, image, a=np.pi * 2.0, bg_threshold=0.1, resolution=512, **kwargs):
+        from custom_controlnet_aux.midas import MidasDetector
+
+        model = MidasDetector.from_pretrained().to(model_management.get_torch_device())
+        #Dirty hack :))
+        cb = lambda image, **kargs: model(image, **kargs)[1]
+        out = common_annotator_call(cb, image, resolution=resolution, a=a, bg_th=bg_threshold, depth_and_normal=True)
+        del model
+        return (out, )
+
+class MIDAS_Depth_Map_Preprocessor:
+    @classmethod
+    def INPUT_TYPES(s):
+        return define_preprocessor_inputs(
+            a=INPUT.FLOAT(default=np.pi * 2.0, min=0.0, max=np.pi * 5.0),
+            bg_threshold=INPUT.FLOAT(default=0.1),
+            resolution=INPUT.RESOLUTION()
+        )
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+
+    CATEGORY = "ControlNet Preprocessors/Normal and Depth Estimators"
+
+    def execute(self, image, a=np.pi * 2.0, bg_threshold=0.1, resolution=512, **kwargs):
+        from custom_controlnet_aux.midas import MidasDetector
+
+        # Ref: https://github.com/lllyasviel/ControlNet/blob/main/gradio_depth2image.py
+        model = MidasDetector.from_pretrained().to(model_management.get_torch_device())
+        out = common_annotator_call(model, image, resolution=resolution, a=a, bg_th=bg_threshold)
+        del model
+        return (out, )
+
+NODE_CLASS_MAPPINGS = {
+    "MiDaS-NormalMapPreprocessor": MIDAS_Normal_Map_Preprocessor,
+    "MiDaS-DepthMapPreprocessor": MIDAS_Depth_Map_Preprocessor
+}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "MiDaS-NormalMapPreprocessor": "MiDaS Normal Map",
+    "MiDaS-DepthMapPreprocessor": "MiDaS Depth Map"
+}

node_wrappers/mlsd.py

@@ -0,0 +1,31 @@
+from ..utils import common_annotator_call, define_preprocessor_inputs, INPUT
+import comfy.model_management as model_management
+import numpy as np
+
+class MLSD_Preprocessor:
+    @classmethod
+    def INPUT_TYPES(s):
+        return define_preprocessor_inputs(
+            score_threshold=INPUT.FLOAT(default=0.1, min=0.01, max=2.0),
+            dist_threshold=INPUT.FLOAT(default=0.1, min=0.01, max=20.0),
+            resolution=INPUT.RESOLUTION()
+        )
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+
+    CATEGORY = "ControlNet Preprocessors/Line Extractors"
+
+    def execute(self, image, score_threshold, dist_threshold, resolution=512, **kwargs):
+        from custom_controlnet_aux.mlsd import MLSDdetector
+
+        model = MLSDdetector.from_pretrained().to(model_management.get_torch_device())
+        out = common_annotator_call(model, image, resolution=resolution, thr_v=score_threshold, thr_d=dist_threshold)
+        return (out, )
+
+NODE_CLASS_MAPPINGS = {
+    "M-LSDPreprocessor": MLSD_Preprocessor
+}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "M-LSDPreprocessor": "M-LSD Lines"
+}

node_wrappers/normalbae.py

@@ -0,0 +1,27 @@
+from ..utils import common_annotator_call, define_preprocessor_inputs, INPUT
+import comfy.model_management as model_management
+
+class BAE_Normal_Map_Preprocessor:
+    @classmethod
+    def INPUT_TYPES(s):
+        return define_preprocessor_inputs(resolution=INPUT.RESOLUTION())
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+
+    CATEGORY = "ControlNet Preprocessors/Normal and Depth Estimators"
+
+    def execute(self, image, resolution=512, **kwargs):
+        from custom_controlnet_aux.normalbae import NormalBaeDetector
+
+        model = NormalBaeDetector.from_pretrained().to(model_management.get_torch_device())
+        out = common_annotator_call(model, image, resolution=resolution)
+        del model
+        return (out,)
+
+NODE_CLASS_MAPPINGS = {
+    "BAE-NormalMapPreprocessor": BAE_Normal_Map_Preprocessor
+}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "BAE-NormalMapPreprocessor": "BAE Normal Map"
+}

node_wrappers/oneformer.py

@@ -0,0 +1,50 @@
+from ..utils import common_annotator_call, define_preprocessor_inputs, INPUT
+import comfy.model_management as model_management
+
+class OneFormer_COCO_SemSegPreprocessor:
+    @classmethod
+    def INPUT_TYPES(s):
+        return define_preprocessor_inputs(resolution=INPUT.RESOLUTION())
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "semantic_segmentate"
+
+    CATEGORY = "ControlNet Preprocessors/Semantic Segmentation"
+
+    def semantic_segmentate(self, image, resolution=512):
+        from custom_controlnet_aux.oneformer import OneformerSegmentor
+
+        model = OneformerSegmentor.from_pretrained(filename="150_16_swin_l_oneformer_coco_100ep.pth")
+        model = model.to(model_management.get_torch_device())
+        out = common_annotator_call(model, image, resolution=resolution)
+        del model
+        return (out,)
+
+class OneFormer_ADE20K_SemSegPreprocessor:
+    @classmethod
+    def INPUT_TYPES(s):
+        return define_preprocessor_inputs(resolution=INPUT.RESOLUTION())
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "semantic_segmentate"
+
+    CATEGORY = "ControlNet Preprocessors/Semantic Segmentation"
+
+    def semantic_segmentate(self, image, resolution=512):
+        from custom_controlnet_aux.oneformer import OneformerSegmentor
+
+        model = OneformerSegmentor.from_pretrained(filename="250_16_swin_l_oneformer_ade20k_160k.pth")
+        model = model.to(model_management.get_torch_device())
+        out = common_annotator_call(model, image, resolution=resolution)
+        del model
+        return (out,)
+
+NODE_CLASS_MAPPINGS = {
+    "OneFormer-COCO-SemSegPreprocessor": OneFormer_COCO_SemSegPreprocessor,
+    "OneFormer-ADE20K-SemSegPreprocessor": OneFormer_ADE20K_SemSegPreprocessor
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "OneFormer-COCO-SemSegPreprocessor": "OneFormer COCO Segmentor",
+    "OneFormer-ADE20K-SemSegPreprocessor": "OneFormer ADE20K Segmentor"
+}

node_wrappers/openpose.py

@@ -0,0 +1,46 @@
+from ..utils import common_annotator_call, define_preprocessor_inputs, INPUT
+import comfy.model_management as model_management
+import json
+
+class OpenPose_Preprocessor:
+    @classmethod
+    def INPUT_TYPES(s):
+        return define_preprocessor_inputs(
+            detect_hand=INPUT.COMBO(["enable", "disable"]),
+            detect_body=INPUT.COMBO(["enable", "disable"]),
+            detect_face=INPUT.COMBO(["enable", "disable"]),
+            resolution=INPUT.RESOLUTION()
+        )
+        
+    RETURN_TYPES = ("IMAGE", "POSE_KEYPOINT")
+    FUNCTION = "estimate_pose"
+
+    CATEGORY = "ControlNet Preprocessors/Faces and Poses Estimators"
+
+    def estimate_pose(self, image, detect_hand, detect_body, detect_face, resolution=512, **kwargs):
+        from custom_controlnet_aux.open_pose import OpenposeDetector
+
+        detect_hand = detect_hand == "enable"
+        detect_body = detect_body == "enable"
+        detect_face = detect_face == "enable"
+
+        model = OpenposeDetector.from_pretrained().to(model_management.get_torch_device())        
+        self.openpose_dicts = []
+        def func(image, **kwargs):
+            pose_img, openpose_dict = model(image, **kwargs)
+            self.openpose_dicts.append(openpose_dict)
+            return pose_img
+        
+        out = common_annotator_call(func, image, include_hand=detect_hand, include_face=detect_face, include_body=detect_body, image_and_json=True, resolution=resolution)
+        del model
+        return {
+            'ui': { "openpose_json": [json.dumps(self.openpose_dicts, indent=4)] },
+            "result": (out, self.openpose_dicts)
+        }
+
+NODE_CLASS_MAPPINGS = {
+    "OpenposePreprocessor": OpenPose_Preprocessor,
+}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "OpenposePreprocessor": "OpenPose Pose",
+}

node_wrappers/pidinet.py

@@ -0,0 +1,30 @@
+from ..utils import common_annotator_call, define_preprocessor_inputs, INPUT
+import comfy.model_management as model_management
+
+class PIDINET_Preprocessor:
+    @classmethod
+    def INPUT_TYPES(s):
+        return define_preprocessor_inputs(
+            safe=INPUT.COMBO(["enable", "disable"]),
+            resolution=INPUT.RESOLUTION()
+        )
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+
+    CATEGORY = "ControlNet Preprocessors/Line Extractors"
+
+    def execute(self, image, safe, resolution=512, **kwargs):
+        from custom_controlnet_aux.pidi import PidiNetDetector
+
+        model = PidiNetDetector.from_pretrained().to(model_management.get_torch_device())
+        out = common_annotator_call(model, image, resolution=resolution, safe = safe == "enable")
+        del model
+        return (out, )
+
+NODE_CLASS_MAPPINGS = {
+    "PiDiNetPreprocessor": PIDINET_Preprocessor,
+}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "PiDiNetPreprocessor": "PiDiNet Soft-Edge Lines"
+}

node_wrappers/pose_keypoint_postprocess.py

@@ -0,0 +1,340 @@
+import folder_paths
+import json
+import os
+import numpy as np
+import cv2
+from PIL import ImageColor
+from einops import rearrange
+import torch
+import itertools
+
+from ..src.custom_controlnet_aux.dwpose import draw_poses, draw_animalposes, decode_json_as_poses
+
+
+"""
+Format of POSE_KEYPOINT (AP10K keypoints):
+[{
+        "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
+},...]
+Format of POSE_KEYPOINT (OpenPose keypoints):
+[{
+    "people": [
+        {
+            'pose_keypoints_2d': [[x1, y1, 1], [x2, y2, 1],..., [x17, y17, 1]]
+            "face_keypoints_2d": [[x1, y1, 1], [x2, y2, 1],..., [x68, y68, 1]],
+            "hand_left_keypoints_2d": [[x1, y1, 1], [x2, y2, 1],..., [x21, y21, 1]],
+            "hand_right_keypoints_2d":[[x1, y1, 1], [x2, y2, 1],..., [x21, y21, 1]],
+        }
+    ],
+    "canvas_height": canvas_height,
+    "canvas_width": canvas_width,
+},...]
+"""
+
+class SavePoseKpsAsJsonFile:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "pose_kps": ("POSE_KEYPOINT",),
+                "filename_prefix": ("STRING", {"default": "PoseKeypoint"})
+            }
+        }
+    RETURN_TYPES = ()
+    FUNCTION = "save_pose_kps"
+    OUTPUT_NODE = True
+    CATEGORY = "ControlNet Preprocessors/Pose Keypoint Postprocess"
+    def __init__(self):
+        self.output_dir = folder_paths.get_output_directory()
+        self.type = "output"
+        self.prefix_append = ""
+    def save_pose_kps(self, pose_kps, filename_prefix):
+        filename_prefix += self.prefix_append
+        full_output_folder, filename, counter, subfolder, filename_prefix = \
+            folder_paths.get_save_image_path(filename_prefix, self.output_dir, pose_kps[0]["canvas_width"], pose_kps[0]["canvas_height"])
+        file = f"{filename}_{counter:05}.json"
+        with open(os.path.join(full_output_folder, file), 'w') as f:
+            json.dump(pose_kps , f)
+        return {}
+
+#COCO-Wholebody doesn't have eyebrows as it inherits 68 keypoints format
+#Perhaps eyebrows can be estimated tho
+FACIAL_PARTS = ["skin", "left_eye", "right_eye", "nose", "upper_lip", "inner_mouth", "lower_lip"]
+LAPA_COLORS = dict(
+    skin="rgb(0, 153, 255)",
+    left_eye="rgb(0, 204, 153)",
+    right_eye="rgb(255, 153, 0)",
+    nose="rgb(255, 102, 255)",
+    upper_lip="rgb(102, 0, 51)",
+    inner_mouth="rgb(255, 204, 255)",
+    lower_lip="rgb(255, 0, 102)"
+)
+
+#One-based index
+def kps_idxs(start, end):
+    step = -1 if start > end else 1
+    return list(range(start-1, end+1-1, step))
+
+#Source: https://www.researchgate.net/profile/Fabrizio-Falchi/publication/338048224/figure/fig1/AS:837860722741255@1576772971540/68-facial-landmarks.jpg
+FACIAL_PART_RANGES = dict(
+    skin=kps_idxs(1, 17) + kps_idxs(27, 18),
+    nose=kps_idxs(28, 36),
+    left_eye=kps_idxs(37, 42),
+    right_eye=kps_idxs(43, 48),
+    upper_lip=kps_idxs(49, 55) + kps_idxs(65, 61),
+    lower_lip=kps_idxs(61, 68),
+    inner_mouth=kps_idxs(61, 65) + kps_idxs(55, 49)
+)
+
+def is_normalized(keypoints) -> bool:
+    point_normalized = [
+        0 <= np.abs(k[0]) <= 1 and 0 <= np.abs(k[1]) <= 1 
+        for k in keypoints 
+        if k is not None
+    ]
+    if not point_normalized:
+        return False
+    return np.all(point_normalized)
+
+class FacialPartColoringFromPoseKps:
+    @classmethod
+    def INPUT_TYPES(s):
+        input_types = {
+            "required": {"pose_kps": ("POSE_KEYPOINT",), "mode": (["point", "polygon"], {"default": "polygon"})}
+        }
+        for facial_part in FACIAL_PARTS: 
+            input_types["required"][facial_part] = ("STRING", {"default": LAPA_COLORS[facial_part], "multiline": False})
+        return input_types
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "colorize"
+    CATEGORY = "ControlNet Preprocessors/Pose Keypoint Postprocess"
+    def colorize(self, pose_kps, mode, **facial_part_colors):
+        pose_frames = pose_kps
+        np_frames = [self.draw_kps(pose_frame, mode, **facial_part_colors) for pose_frame in pose_frames]
+        np_frames = np.stack(np_frames, axis=0)
+        return (torch.from_numpy(np_frames).float() / 255.,)
+            
+    def draw_kps(self, pose_frame, mode, **facial_part_colors):
+        width, height = pose_frame["canvas_width"], pose_frame["canvas_height"]
+        canvas = np.zeros((height, width, 3), dtype=np.uint8)
+        for person, part_name in itertools.product(pose_frame["people"], FACIAL_PARTS):
+            n = len(person["face_keypoints_2d"]) // 3
+            facial_kps = rearrange(np.array(person["face_keypoints_2d"]), "(n c) -> n c", n=n, c=3)[:, :2]
+            if is_normalized(facial_kps):
+                facial_kps *= (width, height)
+            facial_kps = facial_kps.astype(np.int32)
+            part_color = ImageColor.getrgb(facial_part_colors[part_name])[:3]
+            part_contours = facial_kps[FACIAL_PART_RANGES[part_name], :]
+            if mode == "point":
+                for pt in part_contours:
+                    cv2.circle(canvas, pt, radius=2, color=part_color, thickness=-1)
+            else:
+                cv2.fillPoly(canvas, pts=[part_contours], color=part_color)
+        return canvas
+
+# https://raw.githubusercontent.com/CMU-Perceptual-Computing-Lab/openpose/master/.github/media/keypoints_pose_18.png
+BODY_PART_INDEXES = {
+    "Head": (16, 14, 0, 15, 17),
+    "Neck": (0, 1),
+    "Shoulder": (2, 5),
+    "Torso": (2, 5, 8, 11),
+    "RArm": (2, 3),
+    "RForearm": (3, 4),
+    "LArm": (5, 6),
+    "LForearm": (6, 7),
+    "RThigh": (8, 9),
+    "RLeg": (9, 10),
+    "LThigh": (11, 12),
+    "LLeg": (12, 13)
+}
+BODY_PART_DEFAULT_W_H = {
+    "Head": "256, 256",
+    "Neck": "100, 100",
+    "Shoulder": '',
+    "Torso": "350, 450",
+    "RArm": "128, 256",
+    "RForearm": "128, 256",
+    "LArm": "128, 256",
+    "LForearm": "128, 256",
+    "RThigh": "128, 256",
+    "RLeg": "128, 256",
+    "LThigh": "128, 256",
+    "LLeg": "128, 256"
+}
+
+class SinglePersonProcess:
+    @classmethod 
+    def sort_and_get_max_people(s, pose_kps):
+        for idx in range(len(pose_kps)):
+            pose_kps[idx]["people"] = sorted(pose_kps[idx]["people"], key=lambda person:person["pose_keypoints_2d"][0])
+        return pose_kps, max(len(frame["people"]) for frame in pose_kps)
+    
+    def __init__(self, pose_kps, person_idx=0) -> None:
+        self.width, self.height = pose_kps[0]["canvas_width"], pose_kps[0]["canvas_height"]
+        self.poses = [
+            self.normalize(pose_frame["people"][person_idx]["pose_keypoints_2d"])
+            if person_idx < len(pose_frame["people"]) 
+            else None
+            for pose_frame in pose_kps
+        ]
+    
+    def normalize(self, pose_kps_2d):
+        n = len(pose_kps_2d) // 3
+        pose_kps_2d = rearrange(np.array(pose_kps_2d), "(n c) -> n c", n=n, c=3)
+        pose_kps_2d[np.argwhere(pose_kps_2d[:,2]==0), :] = np.iinfo(np.int32).max // 2 #Safe large value
+        pose_kps_2d = pose_kps_2d[:, :2]
+        if is_normalized(pose_kps_2d):
+            pose_kps_2d *= (self.width, self.height)
+        return pose_kps_2d
+    
+    def get_xyxy_bboxes(self, part_name, bbox_size=(128, 256)):
+        width, height = bbox_size
+        xyxy_bboxes = {}
+        for idx, pose in enumerate(self.poses):
+            if pose is None:
+                xyxy_bboxes[idx] = (np.iinfo(np.int32).max // 2,) * 4
+                continue
+            pts = pose[BODY_PART_INDEXES[part_name], :]
+
+            #top_left = np.min(pts[:,0]), np.min(pts[:,1])
+            #bottom_right = np.max(pts[:,0]), np.max(pts[:,1])
+            #pad_width = np.maximum(width - (bottom_right[0]-top_left[0]), 0) / 2
+            #pad_height = np.maximum(height - (bottom_right[1]-top_left[1]), 0) / 2
+            #xyxy_bboxes.append((
+            #    top_left[0] - pad_width, top_left[1] - pad_height,
+            #    bottom_right[0] + pad_width, bottom_right[1] + pad_height,
+            #))
+
+            x_mid, y_mid = np.mean(pts[:, 0]), np.mean(pts[:, 1])
+            xyxy_bboxes[idx] = (
+                x_mid - width/2, y_mid - height/2,
+                x_mid + width/2, y_mid + height/2 
+            )
+        return xyxy_bboxes
+
+class UpperBodyTrackingFromPoseKps:
+    PART_NAMES = ["Head", "Neck", "Shoulder", "Torso", "RArm", "RForearm", "LArm", "LForearm"]
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "pose_kps": ("POSE_KEYPOINT",),
+                "id_include": ("STRING", {"default": '', "multiline": False}),
+                **{part_name + "_width_height": ("STRING", {"default": BODY_PART_DEFAULT_W_H[part_name], "multiline": False}) for part_name in s.PART_NAMES}
+            }
+        }
+
+    RETURN_TYPES = ("TRACKING", "STRING")
+    RETURN_NAMES = ("tracking", "prompt")
+    FUNCTION = "convert"
+    CATEGORY = "ControlNet Preprocessors/Pose Keypoint Postprocess"
+
+    def convert(self, pose_kps, id_include, **parts_width_height):
+        parts_width_height = {part_name.replace("_width_height", ''): value for part_name, value in parts_width_height.items()}
+        enabled_part_names = [part_name for part_name in self.PART_NAMES if len(parts_width_height[part_name].strip())]
+        tracked = {part_name: {} for part_name in enabled_part_names}
+        id_include = id_include.strip()
+        id_include = list(map(int, id_include.split(','))) if len(id_include) else []
+        prompt_string = ''
+        pose_kps, max_people = SinglePersonProcess.sort_and_get_max_people(pose_kps)
+
+        for person_idx in range(max_people):
+            if len(id_include) and person_idx not in id_include:
+                continue
+            processor = SinglePersonProcess(pose_kps, person_idx)
+            for part_name in enabled_part_names:
+                bbox_size = tuple(map(int, parts_width_height[part_name].split(',')))
+                part_bboxes = processor.get_xyxy_bboxes(part_name, bbox_size)
+                id_coordinates = {idx: part_bbox+(processor.width, processor.height) for idx, part_bbox in part_bboxes.items()}
+                tracked[part_name][person_idx] = id_coordinates
+
+        for class_name, class_data in tracked.items():
+            for class_id in class_data.keys():
+                class_id_str = str(class_id)
+                # Use the incoming prompt for each class name and ID
+                _class_name = class_name.replace('L', '').replace('R', '').lower()
+                prompt_string += f'"{class_id_str}.{class_name}": "({_class_name})",\n'
+
+        return (tracked, prompt_string)
+
+
+def numpy2torch(np_image: np.ndarray) -> torch.Tensor:
+    """ [H, W, C] => [B=1, H, W, C]"""
+    return torch.from_numpy(np_image.astype(np.float32) / 255).unsqueeze(0)
+
+
+class RenderPeopleKps:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "kps": ("POSE_KEYPOINT",),
+                "render_body": ("BOOLEAN", {"default": True}),
+                "render_hand": ("BOOLEAN", {"default": True}),
+                "render_face": ("BOOLEAN", {"default": True}),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "render"
+    CATEGORY = "ControlNet Preprocessors/Pose Keypoint Postprocess"
+
+    def render(self, kps, render_body, render_hand, render_face) -> tuple[np.ndarray]:
+        if isinstance(kps, list):
+            kps = kps[0]
+
+        poses, _, height, width = decode_json_as_poses(kps)
+        np_image = draw_poses(
+            poses,
+            height,
+            width,
+            render_body,
+            render_hand,
+            render_face,
+        )
+        return (numpy2torch(np_image),)
+
+class RenderAnimalKps:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "kps": ("POSE_KEYPOINT",),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "render"
+    CATEGORY = "ControlNet Preprocessors/Pose Keypoint Postprocess"
+
+    def render(self, kps) -> tuple[np.ndarray]:
+        if isinstance(kps, list):
+            kps = kps[0]
+
+        _, poses, height, width = decode_json_as_poses(kps)
+        np_image = draw_animalposes(poses, height, width)
+        return (numpy2torch(np_image),)
+
+
+NODE_CLASS_MAPPINGS = {
+    "SavePoseKpsAsJsonFile": SavePoseKpsAsJsonFile,
+    "FacialPartColoringFromPoseKps": FacialPartColoringFromPoseKps,
+    "UpperBodyTrackingFromPoseKps": UpperBodyTrackingFromPoseKps,
+    "RenderPeopleKps": RenderPeopleKps,
+    "RenderAnimalKps": RenderAnimalKps,
+}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "SavePoseKpsAsJsonFile": "Save Pose Keypoints",
+    "FacialPartColoringFromPoseKps": "Colorize Facial Parts from PoseKPS",
+    "UpperBodyTrackingFromPoseKps": "Upper Body Tracking From PoseKps (InstanceDiffusion)",
+    "RenderPeopleKps": "Render Pose JSON (Human)",
+    "RenderAnimalKps": "Render Pose JSON (Animal)",
+}

node_wrappers/recolor.py

@@ -0,0 +1,46 @@
+from ..utils import common_annotator_call, define_preprocessor_inputs, INPUT
+
+class ImageLuminanceDetector:
+    @classmethod
+    def INPUT_TYPES(s):
+        #https://github.com/Mikubill/sd-webui-controlnet/blob/416c345072c9c2066101e225964e3986abe6945e/scripts/processor.py#L1229
+        return define_preprocessor_inputs(
+            gamma_correction=INPUT.FLOAT(default=1.0, min=0.1, max=2.0),
+            resolution=INPUT.RESOLUTION()
+        )
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+
+    CATEGORY = "ControlNet Preprocessors/Recolor"
+
+    def execute(self, image, gamma_correction=1.0, resolution=512, **kwargs):
+        from custom_controlnet_aux.recolor import Recolorizer
+        return (common_annotator_call(Recolorizer(), image, mode="luminance", gamma_correction=gamma_correction , resolution=resolution), )
+
+class ImageIntensityDetector:
+    @classmethod
+    def INPUT_TYPES(s):
+        #https://github.com/Mikubill/sd-webui-controlnet/blob/416c345072c9c2066101e225964e3986abe6945e/scripts/processor.py#L1229
+        return define_preprocessor_inputs(
+            gamma_correction=INPUT.FLOAT(default=1.0, min=0.1, max=2.0),
+            resolution=INPUT.RESOLUTION()
+        )
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+
+    CATEGORY = "ControlNet Preprocessors/Recolor"
+
+    def execute(self, image, gamma_correction=1.0, resolution=512, **kwargs):
+        from custom_controlnet_aux.recolor import Recolorizer
+        return (common_annotator_call(Recolorizer(), image, mode="intensity", gamma_correction=gamma_correction , resolution=resolution), )
+
+NODE_CLASS_MAPPINGS = {
+    "ImageLuminanceDetector": ImageLuminanceDetector,
+    "ImageIntensityDetector": ImageIntensityDetector
+}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "ImageLuminanceDetector": "Image Luminance",
+    "ImageIntensityDetector": "Image Intensity"
+}

node_wrappers/scribble.py

@@ -0,0 +1,74 @@
+from ..utils import common_annotator_call, define_preprocessor_inputs, INPUT, nms
+import comfy.model_management as model_management
+import cv2
+
+class Scribble_Preprocessor:
+    @classmethod
+    def INPUT_TYPES(s):
+        return define_preprocessor_inputs(resolution=INPUT.RESOLUTION())
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+
+    CATEGORY = "ControlNet Preprocessors/Line Extractors"
+
+    def execute(self, image, resolution=512, **kwargs):
+        from custom_controlnet_aux.scribble import ScribbleDetector
+
+        model = ScribbleDetector()
+        return (common_annotator_call(model, image, resolution=resolution), )
+
+class Scribble_XDoG_Preprocessor:
+    @classmethod
+    def INPUT_TYPES(s):
+        return define_preprocessor_inputs(
+            threshold=INPUT.INT(default=32, min=1, max=64),
+            resolution=INPUT.RESOLUTION()
+        )
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+
+    CATEGORY = "ControlNet Preprocessors/Line Extractors"
+
+    def execute(self, image, threshold=32, resolution=512, **kwargs):
+        from custom_controlnet_aux.scribble import ScribbleXDog_Detector
+
+        model = ScribbleXDog_Detector()
+        return (common_annotator_call(model, image, resolution=resolution, thr_a=threshold), )
+
+class Scribble_PiDiNet_Preprocessor:
+    @classmethod
+    def INPUT_TYPES(s):
+        return define_preprocessor_inputs(
+            safe=(["enable", "disable"]),
+            resolution=INPUT.RESOLUTION()
+        )
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+
+    CATEGORY = "ControlNet Preprocessors/Line Extractors"
+
+    def execute(self, image, safe="enable", resolution=512):
+        def model(img, **kwargs):
+            from custom_controlnet_aux.pidi import PidiNetDetector
+            pidinet = PidiNetDetector.from_pretrained().to(model_management.get_torch_device())
+            result = pidinet(img, scribble=True, **kwargs)
+            result = nms(result, 127, 3.0)
+            result = cv2.GaussianBlur(result, (0, 0), 3.0)
+            result[result > 4] = 255
+            result[result < 255] = 0
+            return result
+        return (common_annotator_call(model, image, resolution=resolution, safe=safe=="enable"),)
+
+NODE_CLASS_MAPPINGS = {
+    "ScribblePreprocessor": Scribble_Preprocessor,
+    "Scribble_XDoG_Preprocessor": Scribble_XDoG_Preprocessor,
+    "Scribble_PiDiNet_Preprocessor": Scribble_PiDiNet_Preprocessor
+}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "ScribblePreprocessor": "Scribble Lines",
+    "Scribble_XDoG_Preprocessor": "Scribble XDoG Lines",
+    "Scribble_PiDiNet_Preprocessor": "Scribble PiDiNet Lines"
+}

node_wrappers/segment_anything.py

@@ -0,0 +1,27 @@
+from ..utils import common_annotator_call, define_preprocessor_inputs, INPUT
+import comfy.model_management as model_management
+
+class SAM_Preprocessor:
+    @classmethod
+    def INPUT_TYPES(s):
+        return define_preprocessor_inputs(resolution=INPUT.RESOLUTION())
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+
+    CATEGORY = "ControlNet Preprocessors/others"
+
+    def execute(self, image, resolution=512, **kwargs):
+        from custom_controlnet_aux.sam import SamDetector
+
+        mobile_sam = SamDetector.from_pretrained().to(model_management.get_torch_device())
+        out = common_annotator_call(mobile_sam, image, resolution=resolution)
+        del mobile_sam
+        return (out, )
+
+NODE_CLASS_MAPPINGS = {
+    "SAMPreprocessor": SAM_Preprocessor
+}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "SAMPreprocessor": "SAM Segmentor"
+}

node_wrappers/shuffle.py

@@ -0,0 +1,27 @@
+from ..utils import common_annotator_call, define_preprocessor_inputs, INPUT, MAX_RESOLUTION
+import comfy.model_management as model_management
+
+class Shuffle_Preprocessor:
+    @classmethod
+    def INPUT_TYPES(s):
+        return define_preprocessor_inputs(
+            resolution=INPUT.RESOLUTION(),
+            seed=INPUT.SEED()
+        )
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "preprocess"
+
+    CATEGORY = "ControlNet Preprocessors/T2IAdapter-only"
+
+    def preprocess(self, image, resolution=512, seed=0):
+        from custom_controlnet_aux.shuffle import ContentShuffleDetector
+
+        return (common_annotator_call(ContentShuffleDetector(), image, resolution=resolution, seed=seed), )
+
+NODE_CLASS_MAPPINGS = {
+    "ShufflePreprocessor": Shuffle_Preprocessor
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "ShufflePreprocessor": "Content Shuffle"
+}

node_wrappers/teed.py

@@ -0,0 +1,30 @@
+from ..utils import common_annotator_call, define_preprocessor_inputs, INPUT
+import comfy.model_management as model_management
+
+class TEED_Preprocessor:
+    @classmethod
+    def INPUT_TYPES(s):
+        return define_preprocessor_inputs(
+            safe_steps=INPUT.INT(default=2, max=10),
+            resolution=INPUT.RESOLUTION()
+        )
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+
+    CATEGORY = "ControlNet Preprocessors/Line Extractors"
+
+    def execute(self, image, safe_steps=2, resolution=512, **kwargs):
+        from custom_controlnet_aux.teed import TEDDetector
+
+        model = TEDDetector.from_pretrained().to(model_management.get_torch_device())
+        out = common_annotator_call(model, image, resolution=resolution, safe_steps=safe_steps)
+        del model
+        return (out, )
+
+NODE_CLASS_MAPPINGS = {
+    "TEEDPreprocessor": TEED_Preprocessor,
+}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "TEED_Preprocessor": "TEED Soft-Edge Lines",
+}

node_wrappers/tile.py

@@ -0,0 +1,73 @@
+from ..utils import common_annotator_call, define_preprocessor_inputs, INPUT
+
+
+class Tile_Preprocessor:
+    @classmethod
+    def INPUT_TYPES(s):
+        return define_preprocessor_inputs(
+            pyrUp_iters=INPUT.INT(default=3, min=1, max=10),
+            resolution=INPUT.RESOLUTION()
+        )
+        
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+
+    CATEGORY = "ControlNet Preprocessors/tile"
+
+    def execute(self, image, pyrUp_iters, resolution=512, **kwargs):
+        from custom_controlnet_aux.tile import TileDetector
+
+        return (common_annotator_call(TileDetector(), image, pyrUp_iters=pyrUp_iters, resolution=resolution),)
+
+class TTPlanet_TileGF_Preprocessor:
+    @classmethod
+    def INPUT_TYPES(s):
+        return define_preprocessor_inputs(
+            scale_factor=INPUT.FLOAT(default=1.00, min=1.000, max=8.00),
+            blur_strength=INPUT.FLOAT(default=2.0, min=1.0, max=10.0),
+            radius=INPUT.INT(default=7, min=1, max=20),
+            eps=INPUT.FLOAT(default=0.01, min=0.001, max=0.1, step=0.001),
+            resolution=INPUT.RESOLUTION()
+        )
+    
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+
+    CATEGORY = "ControlNet Preprocessors/tile"
+
+    def execute(self, image, scale_factor, blur_strength, radius, eps, **kwargs):
+        from custom_controlnet_aux.tile import TTPlanet_Tile_Detector_GF
+
+        return (common_annotator_call(TTPlanet_Tile_Detector_GF(), image, scale_factor=scale_factor, blur_strength=blur_strength, radius=radius, eps=eps),)
+
+class TTPlanet_TileSimple_Preprocessor:
+    @classmethod
+    def INPUT_TYPES(s):
+        return define_preprocessor_inputs(
+            scale_factor=INPUT.FLOAT(default=1.00, min=1.000, max=8.00),
+            blur_strength=INPUT.FLOAT(default=2.0, min=1.0, max=10.0),
+        )
+    
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+
+    CATEGORY = "ControlNet Preprocessors/tile"
+
+    def execute(self, image, scale_factor, blur_strength):
+        from custom_controlnet_aux.tile import TTPLanet_Tile_Detector_Simple
+
+        return (common_annotator_call(TTPLanet_Tile_Detector_Simple(), image, scale_factor=scale_factor, blur_strength=blur_strength),)
+
+
+NODE_CLASS_MAPPINGS = {
+    "TilePreprocessor": Tile_Preprocessor,
+    "TTPlanet_TileGF_Preprocessor": TTPlanet_TileGF_Preprocessor,
+    "TTPlanet_TileSimple_Preprocessor": TTPlanet_TileSimple_Preprocessor
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "TilePreprocessor": "Tile",
+    "TTPlanet_TileGF_Preprocessor": "TTPlanet Tile GuidedFilter",
+    "TTPlanet_TileSimple_Preprocessor": "TTPlanet Tile Simple"
+}

node_wrappers/uniformer.py

@@ -0,0 +1,29 @@
+from ..utils import common_annotator_call, define_preprocessor_inputs, INPUT
+import comfy.model_management as model_management
+
+class Uniformer_SemSegPreprocessor:
+    @classmethod
+    def INPUT_TYPES(s):
+        return define_preprocessor_inputs(resolution=INPUT.RESOLUTION())
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "semantic_segmentate"
+
+    CATEGORY = "ControlNet Preprocessors/Semantic Segmentation"
+
+    def semantic_segmentate(self, image, resolution=512):
+        from custom_controlnet_aux.uniformer import UniformerSegmentor
+
+        model = UniformerSegmentor.from_pretrained().to(model_management.get_torch_device())
+        out = common_annotator_call(model, image, resolution=resolution)
+        del model
+        return (out, )
+
+NODE_CLASS_MAPPINGS = {
+    "UniFormer-SemSegPreprocessor": Uniformer_SemSegPreprocessor,
+    "SemSegPreprocessor": Uniformer_SemSegPreprocessor,
+}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "UniFormer-SemSegPreprocessor": "UniFormer Segmentor",
+    "SemSegPreprocessor": "Semantic Segmentor (legacy, alias for UniFormer)",
+}

node_wrappers/unimatch.py

@@ -0,0 +1,75 @@
+from ..utils import common_annotator_call
+import comfy.model_management as model_management
+import torch
+import numpy as np
+from einops import rearrange
+import torch.nn.functional as F
+
+class Unimatch_OptFlowPreprocessor:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": dict(
+                image=("IMAGE",),
+                ckpt_name=(
+                    ["gmflow-scale1-mixdata.pth", "gmflow-scale2-mixdata.pth", "gmflow-scale2-regrefine6-mixdata.pth"],
+                    {"default": "gmflow-scale2-regrefine6-mixdata.pth"}
+                ),
+                backward_flow=("BOOLEAN", {"default": False}),
+                bidirectional_flow=("BOOLEAN", {"default": False})
+            )
+        }
+
+    RETURN_TYPES = ("OPTICAL_FLOW", "IMAGE")
+    RETURN_NAMES = ("OPTICAL_FLOW", "PREVIEW_IMAGE")
+    FUNCTION = "estimate"
+
+    CATEGORY = "ControlNet Preprocessors/Optical Flow"
+
+    def estimate(self, image, ckpt_name, backward_flow=False, bidirectional_flow=False):
+        assert len(image) > 1, "[Unimatch] Requiring as least two frames as an optical flow estimator. Only use this node on video input."    
+        from custom_controlnet_aux.unimatch import UnimatchDetector
+        tensor_images = image
+        model = UnimatchDetector.from_pretrained(filename=ckpt_name).to(model_management.get_torch_device())
+        flows, vis_flows = [], []
+        for i in range(len(tensor_images) - 1):
+            image0, image1 = np.asarray(image[i:i+2].cpu() * 255., dtype=np.uint8)
+            flow, vis_flow = model(image0, image1, output_type="np", pred_bwd_flow=backward_flow, pred_bidir_flow=bidirectional_flow)
+            flows.append(torch.from_numpy(flow).float())
+            vis_flows.append(torch.from_numpy(vis_flow).float() / 255.)
+        del model
+        return (torch.stack(flows, dim=0), torch.stack(vis_flows, dim=0))
+
+class MaskOptFlow:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": dict(optical_flow=("OPTICAL_FLOW",), mask=("MASK",))
+        }
+    
+    RETURN_TYPES = ("OPTICAL_FLOW", "IMAGE")
+    RETURN_NAMES = ("OPTICAL_FLOW", "PREVIEW_IMAGE")
+    FUNCTION = "mask_opt_flow"
+
+    CATEGORY = "ControlNet Preprocessors/Optical Flow"
+    
+    def mask_opt_flow(self, optical_flow, mask):
+        from custom_controlnet_aux.unimatch import flow_to_image
+        assert len(mask) >= len(optical_flow), f"Not enough masks to mask optical flow: {len(mask)} vs {len(optical_flow)}"
+        mask = mask[:optical_flow.shape[0]]
+        mask = F.interpolate(mask, optical_flow.shape[1:3])
+        mask = rearrange(mask, "n 1 h w -> n h w 1")
+        vis_flows = torch.stack([torch.from_numpy(flow_to_image(flow)).float() / 255. for flow in optical_flow.numpy()], dim=0)
+        vis_flows *= mask
+        optical_flow *= mask
+        return (optical_flow, vis_flows)
+
+        
+NODE_CLASS_MAPPINGS = {
+    "Unimatch_OptFlowPreprocessor": Unimatch_OptFlowPreprocessor,
+    "MaskOptFlow": MaskOptFlow
+}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "Unimatch_OptFlowPreprocessor": "Unimatch Optical Flow",
+    "MaskOptFlow": "Mask Optical Flow (DragNUWA)"
+}

node_wrappers/zoe.py

@@ -0,0 +1,27 @@
+from ..utils import common_annotator_call, define_preprocessor_inputs, INPUT
+import comfy.model_management as model_management
+
+class Zoe_Depth_Map_Preprocessor:
+    @classmethod
+    def INPUT_TYPES(s):
+        return define_preprocessor_inputs(resolution=INPUT.RESOLUTION())
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "execute"
+
+    CATEGORY = "ControlNet Preprocessors/Normal and Depth Estimators"
+
+    def execute(self, image, resolution=512, **kwargs):
+        from custom_controlnet_aux.zoe import ZoeDetector
+
+        model = ZoeDetector.from_pretrained().to(model_management.get_torch_device())
+        out = common_annotator_call(model, image, resolution=resolution)
+        del model
+        return (out, )
+
+NODE_CLASS_MAPPINGS = {
+    "Zoe-DepthMapPreprocessor": Zoe_Depth_Map_Preprocessor
+}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "Zoe-DepthMapPreprocessor": "Zoe Depth Map"
+}

pyproject.toml

@@ -0,0 +1,14 @@
+[project]
+name = "comfyui_controlnet_aux"
+description = "Plug-and-play ComfyUI node sets for making ControlNet hint images"
+version = "1.0.4-alpha.4"
+license = "LICENSE"
+dependencies = ["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"]
+
+[project.urls]
+Repository = "https://github.com/Fannovel16/comfyui_controlnet_aux"
+
+[tool.comfy]
+PublisherId = "fannovel16"
+DisplayName = "comfyui_controlnet_aux"
+Icon = ""

requirements.txt

@@ -0,0 +1,24 @@
+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