Delete controlnet_aux

controlnet_aux/.gitignore

@@ -1,178 +0,0 @@
-# Initially taken from Github's Python gitignore file
-
-# Byte-compiled / optimized / DLL files
-__pycache__/
-*.py[cod]
-*$py.class
-
-# C extensions
-*.so
-
-# tests and logs
-tests/fixtures/cached_*_text.txt
-logs/
-lightning_logs/
-lang_code_data/
-tests/outputs
-
-# Distribution / packaging
-.Python
-build/
-develop-eggs/
-dist/
-downloads/
-eggs/
-.eggs/
-lib/
-lib64/
-parts/
-sdist/
-var/
-wheels/
-*.egg-info/
-.installed.cfg
-*.egg
-MANIFEST
-
-# PyInstaller
-#  Usually these files are written by a python script from a template
-#  before PyInstaller builds the exe, so as to inject date/other infos into it.
-*.manifest
-*.spec
-
-# Installer logs
-pip-log.txt
-pip-delete-this-directory.txt
-
-# Unit test / coverage reports
-htmlcov/
-.tox/
-.nox/
-.coverage
-.coverage.*
-.cache
-nosetests.xml
-coverage.xml
-*.cover
-.hypothesis/
-.pytest_cache/
-
-# Translations
-*.mo
-*.pot
-
-# Django stuff:
-*.log
-local_settings.py
-db.sqlite3
-
-# Flask stuff:
-instance/
-.webassets-cache
-
-# Scrapy stuff:
-.scrapy
-
-# Sphinx documentation
-docs/_build/
-
-# PyBuilder
-target/
-
-# Jupyter Notebook
-.ipynb_checkpoints
-
-# IPython
-profile_default/
-ipython_config.py
-
-# pyenv
-.python-version
-
-# celery beat schedule file
-celerybeat-schedule
-
-# SageMath parsed files
-*.sage.py
-
-# Environments
-.env
-.venv
-env/
-venv/
-ENV/
-env.bak/
-venv.bak/
-
-# Spyder project settings
-.spyderproject
-.spyproject
-
-# Rope project settings
-.ropeproject
-
-# mkdocs documentation
-/site
-
-# mypy
-.mypy_cache/
-.dmypy.json
-dmypy.json
-
-# Pyre type checker
-.pyre/
-
-# vscode
-.vs
-.vscode
-
-# Pycharm
-.idea
-
-# TF code
-tensorflow_code
-
-# Models
-proc_data
-
-# examples
-runs
-/runs_old
-/wandb
-/examples/runs
-/examples/**/*.args
-/examples/rag/sweep
-
-# data
-/data
-serialization_dir
-
-# emacs
-*.*~
-debug.env
-
-# vim
-.*.swp
-
-#ctags
-tags
-
-# pre-commit
-.pre-commit*
-
-# .lock
-*.lock
-
-# DS_Store (MacOS)
-.DS_Store
-# RL pipelines may produce mp4 outputs
-*.mp4
-
-# dependencies
-/transformers
-
-# ruff
-.ruff_cache
-
-wandb
-

controlnet_aux/LICENSE.txt

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

controlnet_aux/README.md

@@ -1,127 +0,0 @@
-# ControlNet auxiliary models
-
-This is a PyPi installable package of [lllyasviel's ControlNet Annotators](https://github.com/lllyasviel/ControlNet/tree/main/annotator)
-
-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> .
-
-## Install
-
-```
-pip install -U controlnet-aux
-```
-
-To support DWPose which is dependent on MMDetection, MMCV and MMPose
-
-```
-pip install -U openmim
-mim install mmengine
-mim install "mmcv>=2.0.1"
-mim install "mmdet>=3.1.0"
-mim install "mmpose>=1.1.0"
-```
-
-## Usage
-
-You can use the processor class, which can load each of the auxiliary models with the following code
-
-```python
-import requests
-from PIL import Image
-from io import BytesIO
-
-from controlnet_aux.processor import Processor
-
-# load image
-url = "https://huggingface.co/lllyasviel/sd-controlnet-openpose/resolve/main/images/pose.png"
-
-response = requests.get(url)
-img = Image.open(BytesIO(response.content)).convert("RGB").resize((512, 512))
-
-# load processor from processor_id
-# options are:
-# ["canny", "depth_leres", "depth_leres++", "depth_midas", "depth_zoe", "lineart_anime",
-#  "lineart_coarse", "lineart_realistic", "mediapipe_face", "mlsd", "normal_bae", "normal_midas",
-#  "openpose", "openpose_face", "openpose_faceonly", "openpose_full", "openpose_hand",
-#  "scribble_hed, "scribble_pidinet", "shuffle", "softedge_hed", "softedge_hedsafe",
-#  "softedge_pidinet", "softedge_pidsafe", "dwpose"]
-processor_id = 'scribble_hed'
-processor = Processor(processor_id)
-
-processed_image = processor(img, to_pil=True)
-```
-
-Each model can be loaded individually by importing and instantiating them as follows
-
-```python
-from PIL import Image
-import requests
-from io import BytesIO
-from controlnet_aux import HEDdetector, MidasDetector, MLSDdetector, OpenposeDetector, PidiNetDetector, NormalBaeDetector, LineartDetector, LineartAnimeDetector, CannyDetector, ContentShuffleDetector, ZoeDetector, MediapipeFaceDetector, SamDetector, LeresDetector, DWposeDetector
-
-# load image
-url = "https://huggingface.co/lllyasviel/sd-controlnet-openpose/resolve/main/images/pose.png"
-
-response = requests.get(url)
-img = Image.open(BytesIO(response.content)).convert("RGB").resize((512, 512))
-
-# load checkpoints
-hed = HEDdetector.from_pretrained("lllyasviel/Annotators")
-midas = MidasDetector.from_pretrained("lllyasviel/Annotators")
-mlsd = MLSDdetector.from_pretrained("lllyasviel/Annotators")
-open_pose = OpenposeDetector.from_pretrained("lllyasviel/Annotators")
-pidi = PidiNetDetector.from_pretrained("lllyasviel/Annotators")
-normal_bae = NormalBaeDetector.from_pretrained("lllyasviel/Annotators")
-lineart = LineartDetector.from_pretrained("lllyasviel/Annotators")
-lineart_anime = LineartAnimeDetector.from_pretrained("lllyasviel/Annotators")
-zoe = ZoeDetector.from_pretrained("lllyasviel/Annotators")
-sam = SamDetector.from_pretrained("ybelkada/segment-anything", subfolder="checkpoints")
-mobile_sam = SamDetector.from_pretrained("dhkim2810/MobileSAM", model_type="vit_t", filename="mobile_sam.pt")
-leres = LeresDetector.from_pretrained("lllyasviel/Annotators")
-teed = TEEDdetector.from_pretrained("fal-ai/teed", filename="5_model.pth")
-anyline = AnylineDetector.from_pretrained(
-    "TheMistoAI/MistoLine", filename="MTEED.pth", subfolder="Anyline"
-)
-
-# specify configs, ckpts and device, or it will be downloaded automatically and use cpu by default
-# det_config: ./src/controlnet_aux/dwpose/yolox_config/yolox_l_8xb8-300e_coco.py
-# det_ckpt: https://download.openmmlab.com/mmdetection/v2.0/yolox/yolox_l_8x8_300e_coco/yolox_l_8x8_300e_coco_20211126_140236-d3bd2b23.pth
-# pose_config: ./src/controlnet_aux/dwpose/dwpose_config/dwpose-l_384x288.py
-# pose_ckpt: https://huggingface.co/wanghaofan/dw-ll_ucoco_384/resolve/main/dw-ll_ucoco_384.pth
-import torch
-device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
-dwpose = DWposeDetector(det_config=det_config, det_ckpt=det_ckpt, pose_config=pose_config, pose_ckpt=pose_ckpt, device=device)
-
-# instantiate
-canny = CannyDetector()
-content = ContentShuffleDetector()
-face_detector = MediapipeFaceDetector()
-lineart_standard = LineartStandardDetector()
-
-
-# process
-processed_image_hed = hed(img)
-processed_image_midas = midas(img)
-processed_image_mlsd = mlsd(img)
-processed_image_open_pose = open_pose(img, hand_and_face=True)
-processed_image_pidi = pidi(img, safe=True)
-processed_image_normal_bae = normal_bae(img)
-processed_image_lineart = lineart(img, coarse=True)
-processed_image_lineart_anime = lineart_anime(img)
-processed_image_zoe = zoe(img)
-processed_image_sam = sam(img)
-processed_image_leres = leres(img)
-processed_image_teed = teed(img, detect_resolution=1024)
-processed_image_anyline = anyline(img, detect_resolution=1280)
-
-processed_image_canny = canny(img)
-processed_image_content = content(img)
-processed_image_mediapipe_face = face_detector(img)
-processed_image_dwpose = dwpose(img)
-processed_image_lineart_standard = lineart_standard(img, detect_resolution=1024)
-```
-
-### Image resolution
-
-In order to maintain the image aspect ratio, `detect_resolution`, `image_resolution` and images sizes need to be using multiple of `64`.

controlnet_aux/setup.py

@@ -1,233 +0,0 @@
-# Copyright 2023 The HuggingFace Team. All rights reserved.
-#
-# 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.
-
-"""
-Simple check list from AllenNLP repo: https://github.com/allenai/allennlp/blob/main/setup.py
-
-To create the package for pypi.
-
-1. Run `make pre-release` (or `make pre-patch` for a patch release) then run `make fix-copies` to fix the index of the
-   documentation.
-
-   If releasing on a special branch, copy the updated README.md on the main branch for your the commit you will make
-   for the post-release and run `make fix-copies` on the main branch as well.
-
-2. Run Tests for Amazon Sagemaker. The documentation is located in `./tests/sagemaker/README.md`, otherwise @philschmid.
-
-3. Unpin specific versions from setup.py that use a git install.
-
-4. Checkout the release branch (v<RELEASE>-release, for example v4.19-release), and commit these changes with the
-   message: "Release: <RELEASE>" and push.
-
-5. Wait for the tests on main to be completed and be green (otherwise revert and fix bugs)
-
-6. Add a tag in git to mark the release: "git tag v<RELEASE> -m 'Adds tag v<RELEASE> for pypi' "
-   Push the tag to git: git push --tags origin v<RELEASE>-release
-
-7. Build both the sources and the wheel. Do not change anything in setup.py between
-   creating the wheel and the source distribution (obviously).
-
-   For the wheel, run: "python setup.py bdist_wheel" in the top level directory.
-   (this will build a wheel for the python version you use to build it).
-
-   For the sources, run: "python setup.py sdist"
-   You should now have a /dist directory with both .whl and .tar.gz source versions.
-
-8. Check that everything looks correct by uploading the package to the pypi test server:
-
-   twine upload dist/* -r pypitest
-   (pypi suggest using twine as other methods upload files via plaintext.)
-   You may have to specify the repository url, use the following command then:
-   twine upload dist/* -r pypitest --repository-url=https://test.pypi.org/legacy/
-
-   Check that you can install it in a virtualenv by running:
-   pip install -i https://testpypi.python.org/pypi diffusers
-
-   Check you can run the following commands:
-   python -c "from diffusers import pipeline; classifier = pipeline('text-classification'); print(classifier('What a nice release'))"
-   python -c "from diffusers import *"
-
-9. Upload the final version to actual pypi:
-   twine upload dist/* -r pypi
-
-10. Copy the release notes from RELEASE.md to the tag in github once everything is looking hunky-dory.
-
-11. Run `make post-release` (or, for a patch release, `make post-patch`). If you were on a branch for the release,
-    you need to go back to main before executing this.
-"""
-
-import os
-import re
-from distutils.core import Command
-
-from setuptools import find_packages, setup
-
-# IMPORTANT:
-# 1. all dependencies should be listed here with their version requirements if any
-# 2. once modified, run: `make deps_table_update` to update src/diffusers/dependency_versions_table.py
-_deps = [
-    "Pillow",
-    "torch",
-    "numpy",
-    "filelock",
-    "importlib_metadata",
-    "opencv-python-headless",
-    "scipy",
-    "huggingface_hub",
-    "einops",
-    "timm<=0.6.7",
-    "torchvision",
-    "scikit-image",
-]
-
-# this is a lookup table with items like:
-#
-# tokenizers: "huggingface-hub==0.8.0"
-# packaging: "packaging"
-#
-# some of the values are versioned whereas others aren't.
-deps = {
-    b: a for a, b in (re.findall(r"^(([^!=<>~]+)(?:[!=<>~].*)?$)", x)[0] for x in _deps)
-}
-
-# since we save this data in src/diffusers/dependency_versions_table.py it can be easily accessed from
-# anywhere. If you need to quickly access the data from this table in a shell, you can do so easily with:
-#
-# python -c 'import sys; from diffusers.dependency_versions_table import deps; \
-# print(" ".join([ deps[x] for x in sys.argv[1:]]))' tokenizers datasets
-#
-# Just pass the desired package names to that script as it's shown with 2 packages above.
-#
-# If diffusers is not yet installed and the work is done from the cloned repo remember to add `PYTHONPATH=src` to the script above
-#
-# You can then feed this for example to `pip`:
-#
-# pip install -U $(python -c 'import sys; from diffusers.dependency_versions_table import deps; \
-# print(" ".join([ deps[x] for x in sys.argv[1:]]))' tokenizers datasets)
-#
-
-
-def deps_list(*pkgs):
-    return [deps[pkg] for pkg in pkgs]
-
-
-class DepsTableUpdateCommand(Command):
-    """
-    A custom distutils command that updates the dependency table.
-    usage: python setup.py deps_table_update
-    """
-
-    description = "build runtime dependency table"
-    user_options = [
-        # format: (long option, short option, description).
-        (
-            "dep-table-update",
-            None,
-            "updates src/diffusers/dependency_versions_table.py",
-        ),
-    ]
-
-    def initialize_options(self):
-        pass
-
-    def finalize_options(self):
-        pass
-
-    def run(self):
-        entries = "\n".join([f'    "{k}": "{v}",' for k, v in deps.items()])
-        content = [
-            "# THIS FILE HAS BEEN AUTOGENERATED. To update:",
-            "# 1. modify the `_deps` dict in setup.py",
-            "# 2. run `make deps_table_update``",
-            "deps = {",
-            entries,
-            "}",
-            "",
-        ]
-        target = "src/controlnet_aux/dependency_versions_table.py"
-        print(f"updating {target}")
-        with open(target, "w", encoding="utf-8", newline="\n") as f:
-            f.write("\n".join(content))
-
-
-extras = {}
-
-install_requires = [
-    deps["torch"],
-    deps["importlib_metadata"],
-    deps["huggingface_hub"],
-    deps["scipy"],
-    deps["opencv-python-headless"],
-    deps["filelock"],
-    deps["numpy"],
-    deps["Pillow"],
-    deps["einops"],
-    deps["torchvision"],
-    deps["timm"],
-    deps["scikit-image"],
-]
-
-setup(
-    name="controlnet_aux",
-    version="0.0.9",  # expected format is one of x.y.z.dev0, or x.y.z.rc1 or x.y.z (no to dashes, yes to dots)
-    description="Auxillary models for controlnet",
-    long_description=open("README.md", "r", encoding="utf-8").read(),
-    long_description_content_type="text/markdown",
-    keywords="deep learning",
-    license="Apache",
-    author="The HuggingFace team",
-    author_email="patrick@huggingface.co",
-    url="https://github.com/patrickvonplaten/controlnet_aux",
-    package_dir={"": "src"},
-    packages=find_packages("src"),
-    include_package_data=True,
-    python_requires=">=3.7.0",
-    install_requires=install_requires,
-    extras_require=extras,
-    classifiers=[
-        "Development Status :: 5 - Production/Stable",
-        "Intended Audience :: Developers",
-        "Intended Audience :: Education",
-        "Intended Audience :: Science/Research",
-        "License :: OSI Approved :: Apache Software License",
-        "Operating System :: OS Independent",
-        "Programming Language :: Python :: 3",
-        "Programming Language :: Python :: 3.7",
-        "Programming Language :: Python :: 3.8",
-        "Programming Language :: Python :: 3.9",
-        "Topic :: Scientific/Engineering :: Artificial Intelligence",
-    ],
-    cmdclass={"deps_table_update": DepsTableUpdateCommand},
-    package_data={'controlnet_aux' : ['zoe/zoedepth/models/zoedepth/*.json', 'zoe/zoedepth/models/zoedepth_nk/*.json']}
-)
-
-# Release checklist
-# 1. Change the version in __init__.py and setup.py.
-# 2. Commit these changes with the message: "Release: Release"
-# 3. Add a tag in git to mark the release: "git tag RELEASE -m 'Adds tag RELEASE for pypi' "
-#    Push the tag to git: git push --tags origin main
-# 4. Run the following commands in the top-level directory:
-#      python setup.py bdist_wheel
-#      python setup.py sdist
-# 5. Upload the package to the pypi test server first:
-#      twine upload dist/* -r pypitest
-#      twine upload dist/* -r pypitest --repository-url=https://test.pypi.org/legacy/
-# 6. Check that you can install it in a virtualenv by running:
-#      pip install -i https://testpypi.python.org/pypi diffusers
-#      diffusers env
-#      diffusers test
-# 7. Upload the final version to actual pypi:
-#      twine upload dist/* -r pypi
-# 8. Add release notes to the tag in github once everything is looking hunky-dory.
-# 9. Update the version in __init__.py, setup.py to the new version "-dev" and push to master

controlnet_aux/src/controlnet_aux.egg-info/PKG-INFO

@@ -1,163 +0,0 @@
-Metadata-Version: 2.1
-Name: controlnet_aux
-Version: 0.0.9
-Summary: Auxillary models for controlnet
-Home-page: https://github.com/patrickvonplaten/controlnet_aux
-Author: The HuggingFace team
-Author-email: patrick@huggingface.co
-License: Apache
-Keywords: deep learning
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Intended Audience :: Developers
-Classifier: Intended Audience :: Education
-Classifier: Intended Audience :: Science/Research
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
-Requires-Python: >=3.7.0
-Description-Content-Type: text/markdown
-License-File: LICENSE.txt
-Requires-Dist: torch
-Requires-Dist: importlib_metadata
-Requires-Dist: huggingface_hub
-Requires-Dist: scipy
-Requires-Dist: opencv-python-headless
-Requires-Dist: filelock
-Requires-Dist: numpy
-Requires-Dist: Pillow
-Requires-Dist: einops
-Requires-Dist: torchvision
-Requires-Dist: timm<=0.6.7
-Requires-Dist: scikit-image
-
-# ControlNet auxiliary models
-
-This is a PyPi installable package of [lllyasviel's ControlNet Annotators](https://github.com/lllyasviel/ControlNet/tree/main/annotator)
-
-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> .
-
-## Install
-
-```
-pip install -U controlnet-aux
-```
-
-To support DWPose which is dependent on MMDetection, MMCV and MMPose
-
-```
-pip install -U openmim
-mim install mmengine
-mim install "mmcv>=2.0.1"
-mim install "mmdet>=3.1.0"
-mim install "mmpose>=1.1.0"
-```
-
-## Usage
-
-You can use the processor class, which can load each of the auxiliary models with the following code
-
-```python
-import requests
-from PIL import Image
-from io import BytesIO
-
-from controlnet_aux.processor import Processor
-
-# load image
-url = "https://huggingface.co/lllyasviel/sd-controlnet-openpose/resolve/main/images/pose.png"
-
-response = requests.get(url)
-img = Image.open(BytesIO(response.content)).convert("RGB").resize((512, 512))
-
-# load processor from processor_id
-# options are:
-# ["canny", "depth_leres", "depth_leres++", "depth_midas", "depth_zoe", "lineart_anime",
-#  "lineart_coarse", "lineart_realistic", "mediapipe_face", "mlsd", "normal_bae", "normal_midas",
-#  "openpose", "openpose_face", "openpose_faceonly", "openpose_full", "openpose_hand",
-#  "scribble_hed, "scribble_pidinet", "shuffle", "softedge_hed", "softedge_hedsafe",
-#  "softedge_pidinet", "softedge_pidsafe", "dwpose"]
-processor_id = 'scribble_hed'
-processor = Processor(processor_id)
-
-processed_image = processor(img, to_pil=True)
-```
-
-Each model can be loaded individually by importing and instantiating them as follows
-
-```python
-from PIL import Image
-import requests
-from io import BytesIO
-from controlnet_aux import HEDdetector, MidasDetector, MLSDdetector, OpenposeDetector, PidiNetDetector, NormalBaeDetector, LineartDetector, LineartAnimeDetector, CannyDetector, ContentShuffleDetector, ZoeDetector, MediapipeFaceDetector, SamDetector, LeresDetector, DWposeDetector
-
-# load image
-url = "https://huggingface.co/lllyasviel/sd-controlnet-openpose/resolve/main/images/pose.png"
-
-response = requests.get(url)
-img = Image.open(BytesIO(response.content)).convert("RGB").resize((512, 512))
-
-# load checkpoints
-hed = HEDdetector.from_pretrained("lllyasviel/Annotators")
-midas = MidasDetector.from_pretrained("lllyasviel/Annotators")
-mlsd = MLSDdetector.from_pretrained("lllyasviel/Annotators")
-open_pose = OpenposeDetector.from_pretrained("lllyasviel/Annotators")
-pidi = PidiNetDetector.from_pretrained("lllyasviel/Annotators")
-normal_bae = NormalBaeDetector.from_pretrained("lllyasviel/Annotators")
-lineart = LineartDetector.from_pretrained("lllyasviel/Annotators")
-lineart_anime = LineartAnimeDetector.from_pretrained("lllyasviel/Annotators")
-zoe = ZoeDetector.from_pretrained("lllyasviel/Annotators")
-sam = SamDetector.from_pretrained("ybelkada/segment-anything", subfolder="checkpoints")
-mobile_sam = SamDetector.from_pretrained("dhkim2810/MobileSAM", model_type="vit_t", filename="mobile_sam.pt")
-leres = LeresDetector.from_pretrained("lllyasviel/Annotators")
-teed = TEEDdetector.from_pretrained("fal-ai/teed", filename="5_model.pth")
-anyline = AnylineDetector.from_pretrained(
-    "TheMistoAI/MistoLine", filename="MTEED.pth", subfolder="Anyline"
-)
-
-# specify configs, ckpts and device, or it will be downloaded automatically and use cpu by default
-# det_config: ./src/controlnet_aux/dwpose/yolox_config/yolox_l_8xb8-300e_coco.py
-# det_ckpt: https://download.openmmlab.com/mmdetection/v2.0/yolox/yolox_l_8x8_300e_coco/yolox_l_8x8_300e_coco_20211126_140236-d3bd2b23.pth
-# pose_config: ./src/controlnet_aux/dwpose/dwpose_config/dwpose-l_384x288.py
-# pose_ckpt: https://huggingface.co/wanghaofan/dw-ll_ucoco_384/resolve/main/dw-ll_ucoco_384.pth
-import torch
-device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
-dwpose = DWposeDetector(det_config=det_config, det_ckpt=det_ckpt, pose_config=pose_config, pose_ckpt=pose_ckpt, device=device)
-
-# instantiate
-canny = CannyDetector()
-content = ContentShuffleDetector()
-face_detector = MediapipeFaceDetector()
-lineart_standard = LineartStandardDetector()
-
-
-# process
-processed_image_hed = hed(img)
-processed_image_midas = midas(img)
-processed_image_mlsd = mlsd(img)
-processed_image_open_pose = open_pose(img, hand_and_face=True)
-processed_image_pidi = pidi(img, safe=True)
-processed_image_normal_bae = normal_bae(img)
-processed_image_lineart = lineart(img, coarse=True)
-processed_image_lineart_anime = lineart_anime(img)
-processed_image_zoe = zoe(img)
-processed_image_sam = sam(img)
-processed_image_leres = leres(img)
-processed_image_teed = teed(img, detect_resolution=1024)
-processed_image_anyline = anyline(img, detect_resolution=1280)
-
-processed_image_canny = canny(img)
-processed_image_content = content(img)
-processed_image_mediapipe_face = face_detector(img)
-processed_image_dwpose = dwpose(img)
-processed_image_lineart_standard = lineart_standard(img, detect_resolution=1024)
-```
-
-### Image resolution
-
-In order to maintain the image aspect ratio, `detect_resolution`, `image_resolution` and images sizes need to be using multiple of `64`.

controlnet_aux/src/controlnet_aux.egg-info/SOURCES.txt

@@ -1,166 +0,0 @@
-LICENSE.txt
-README.md
-setup.py
-src/controlnet_aux/__init__.py
-src/controlnet_aux/processor.py
-src/controlnet_aux/util.py
-src/controlnet_aux.egg-info/PKG-INFO
-src/controlnet_aux.egg-info/SOURCES.txt
-src/controlnet_aux.egg-info/dependency_links.txt
-src/controlnet_aux.egg-info/requires.txt
-src/controlnet_aux.egg-info/top_level.txt
-src/controlnet_aux/anyline/__init__.py
-src/controlnet_aux/canny/__init__.py
-src/controlnet_aux/dwpose/__init__.py
-src/controlnet_aux/dwpose/util.py
-src/controlnet_aux/dwpose/wholebody.py
-src/controlnet_aux/dwpose/dwpose_config/__init__.py
-src/controlnet_aux/dwpose/dwpose_config/dwpose-l_384x288.py
-src/controlnet_aux/dwpose/yolox_config/__init__.py
-src/controlnet_aux/dwpose/yolox_config/yolox_l_8xb8-300e_coco.py
-src/controlnet_aux/hed/__init__.py
-src/controlnet_aux/leres/__init__.py
-src/controlnet_aux/leres/leres/Resnet.py
-src/controlnet_aux/leres/leres/Resnext_torch.py
-src/controlnet_aux/leres/leres/__init__.py
-src/controlnet_aux/leres/leres/depthmap.py
-src/controlnet_aux/leres/leres/multi_depth_model_woauxi.py
-src/controlnet_aux/leres/leres/net_tools.py
-src/controlnet_aux/leres/leres/network_auxi.py
-src/controlnet_aux/leres/pix2pix/__init__.py
-src/controlnet_aux/leres/pix2pix/models/__init__.py
-src/controlnet_aux/leres/pix2pix/models/base_model.py
-src/controlnet_aux/leres/pix2pix/models/base_model_hg.py
-src/controlnet_aux/leres/pix2pix/models/networks.py
-src/controlnet_aux/leres/pix2pix/models/pix2pix4depth_model.py
-src/controlnet_aux/leres/pix2pix/options/__init__.py
-src/controlnet_aux/leres/pix2pix/options/base_options.py
-src/controlnet_aux/leres/pix2pix/options/test_options.py
-src/controlnet_aux/leres/pix2pix/util/__init__.py
-src/controlnet_aux/leres/pix2pix/util/util.py
-src/controlnet_aux/lineart/__init__.py
-src/controlnet_aux/lineart_anime/__init__.py
-src/controlnet_aux/lineart_standard/__init__.py
-src/controlnet_aux/mediapipe_face/__init__.py
-src/controlnet_aux/mediapipe_face/mediapipe_face_common.py
-src/controlnet_aux/midas/__init__.py
-src/controlnet_aux/midas/api.py
-src/controlnet_aux/midas/utils.py
-src/controlnet_aux/midas/midas/__init__.py
-src/controlnet_aux/midas/midas/base_model.py
-src/controlnet_aux/midas/midas/blocks.py
-src/controlnet_aux/midas/midas/dpt_depth.py
-src/controlnet_aux/midas/midas/midas_net.py
-src/controlnet_aux/midas/midas/midas_net_custom.py
-src/controlnet_aux/midas/midas/transforms.py
-src/controlnet_aux/midas/midas/vit.py
-src/controlnet_aux/mlsd/__init__.py
-src/controlnet_aux/mlsd/utils.py
-src/controlnet_aux/mlsd/models/__init__.py
-src/controlnet_aux/mlsd/models/mbv2_mlsd_large.py
-src/controlnet_aux/mlsd/models/mbv2_mlsd_tiny.py
-src/controlnet_aux/normalbae/__init__.py
-src/controlnet_aux/normalbae/nets/NNET.py
-src/controlnet_aux/normalbae/nets/__init__.py
-src/controlnet_aux/normalbae/nets/baseline.py
-src/controlnet_aux/normalbae/nets/submodules/__init__.py
-src/controlnet_aux/normalbae/nets/submodules/decoder.py
-src/controlnet_aux/normalbae/nets/submodules/encoder.py
-src/controlnet_aux/normalbae/nets/submodules/submodules.py
-src/controlnet_aux/normalbae/nets/submodules/efficientnet_repo/__init__.py
-src/controlnet_aux/normalbae/nets/submodules/efficientnet_repo/caffe2_benchmark.py
-src/controlnet_aux/normalbae/nets/submodules/efficientnet_repo/caffe2_validate.py
-src/controlnet_aux/normalbae/nets/submodules/efficientnet_repo/hubconf.py
-src/controlnet_aux/normalbae/nets/submodules/efficientnet_repo/onnx_export.py
-src/controlnet_aux/normalbae/nets/submodules/efficientnet_repo/onnx_optimize.py
-src/controlnet_aux/normalbae/nets/submodules/efficientnet_repo/onnx_to_caffe.py
-src/controlnet_aux/normalbae/nets/submodules/efficientnet_repo/onnx_validate.py
-src/controlnet_aux/normalbae/nets/submodules/efficientnet_repo/setup.py
-src/controlnet_aux/normalbae/nets/submodules/efficientnet_repo/utils.py
-src/controlnet_aux/normalbae/nets/submodules/efficientnet_repo/validate.py
-src/controlnet_aux/normalbae/nets/submodules/efficientnet_repo/geffnet/__init__.py
-src/controlnet_aux/normalbae/nets/submodules/efficientnet_repo/geffnet/config.py
-src/controlnet_aux/normalbae/nets/submodules/efficientnet_repo/geffnet/conv2d_layers.py
-src/controlnet_aux/normalbae/nets/submodules/efficientnet_repo/geffnet/efficientnet_builder.py
-src/controlnet_aux/normalbae/nets/submodules/efficientnet_repo/geffnet/gen_efficientnet.py
-src/controlnet_aux/normalbae/nets/submodules/efficientnet_repo/geffnet/helpers.py
-src/controlnet_aux/normalbae/nets/submodules/efficientnet_repo/geffnet/mobilenetv3.py
-src/controlnet_aux/normalbae/nets/submodules/efficientnet_repo/geffnet/model_factory.py
-src/controlnet_aux/normalbae/nets/submodules/efficientnet_repo/geffnet/version.py
-src/controlnet_aux/normalbae/nets/submodules/efficientnet_repo/geffnet/activations/__init__.py
-src/controlnet_aux/normalbae/nets/submodules/efficientnet_repo/geffnet/activations/activations.py
-src/controlnet_aux/normalbae/nets/submodules/efficientnet_repo/geffnet/activations/activations_jit.py
-src/controlnet_aux/normalbae/nets/submodules/efficientnet_repo/geffnet/activations/activations_me.py
-src/controlnet_aux/open_pose/__init__.py
-src/controlnet_aux/open_pose/body.py
-src/controlnet_aux/open_pose/face.py
-src/controlnet_aux/open_pose/hand.py
-src/controlnet_aux/open_pose/model.py
-src/controlnet_aux/open_pose/util.py
-src/controlnet_aux/pidi/__init__.py
-src/controlnet_aux/pidi/model.py
-src/controlnet_aux/segment_anything/__init__.py
-src/controlnet_aux/segment_anything/automatic_mask_generator.py
-src/controlnet_aux/segment_anything/build_sam.py
-src/controlnet_aux/segment_anything/predictor.py
-src/controlnet_aux/segment_anything/modeling/__init__.py
-src/controlnet_aux/segment_anything/modeling/common.py
-src/controlnet_aux/segment_anything/modeling/image_encoder.py
-src/controlnet_aux/segment_anything/modeling/mask_decoder.py
-src/controlnet_aux/segment_anything/modeling/prompt_encoder.py
-src/controlnet_aux/segment_anything/modeling/sam.py
-src/controlnet_aux/segment_anything/modeling/tiny_vit_sam.py
-src/controlnet_aux/segment_anything/modeling/transformer.py
-src/controlnet_aux/segment_anything/utils/__init__.py
-src/controlnet_aux/segment_anything/utils/amg.py
-src/controlnet_aux/segment_anything/utils/onnx.py
-src/controlnet_aux/segment_anything/utils/transforms.py
-src/controlnet_aux/shuffle/__init__.py
-src/controlnet_aux/teed/Fsmish.py
-src/controlnet_aux/teed/Xsmish.py
-src/controlnet_aux/teed/__init__.py
-src/controlnet_aux/teed/ted.py
-src/controlnet_aux/zoe/__init__.py
-src/controlnet_aux/zoe/zoedepth/__init__.py
-src/controlnet_aux/zoe/zoedepth/models/__init__.py
-src/controlnet_aux/zoe/zoedepth/models/builder.py
-src/controlnet_aux/zoe/zoedepth/models/depth_model.py
-src/controlnet_aux/zoe/zoedepth/models/model_io.py
-src/controlnet_aux/zoe/zoedepth/models/base_models/__init__.py
-src/controlnet_aux/zoe/zoedepth/models/base_models/midas.py
-src/controlnet_aux/zoe/zoedepth/models/base_models/midas_repo/__init__.py
-src/controlnet_aux/zoe/zoedepth/models/base_models/midas_repo/hubconf.py
-src/controlnet_aux/zoe/zoedepth/models/base_models/midas_repo/midas/__init__.py
-src/controlnet_aux/zoe/zoedepth/models/base_models/midas_repo/midas/base_model.py
-src/controlnet_aux/zoe/zoedepth/models/base_models/midas_repo/midas/blocks.py
-src/controlnet_aux/zoe/zoedepth/models/base_models/midas_repo/midas/dpt_depth.py
-src/controlnet_aux/zoe/zoedepth/models/base_models/midas_repo/midas/midas_net.py
-src/controlnet_aux/zoe/zoedepth/models/base_models/midas_repo/midas/midas_net_custom.py
-src/controlnet_aux/zoe/zoedepth/models/base_models/midas_repo/midas/model_loader.py
-src/controlnet_aux/zoe/zoedepth/models/base_models/midas_repo/midas/transforms.py
-src/controlnet_aux/zoe/zoedepth/models/base_models/midas_repo/midas/backbones/__init__.py
-src/controlnet_aux/zoe/zoedepth/models/base_models/midas_repo/midas/backbones/beit.py
-src/controlnet_aux/zoe/zoedepth/models/base_models/midas_repo/midas/backbones/levit.py
-src/controlnet_aux/zoe/zoedepth/models/base_models/midas_repo/midas/backbones/next_vit.py
-src/controlnet_aux/zoe/zoedepth/models/base_models/midas_repo/midas/backbones/swin.py
-src/controlnet_aux/zoe/zoedepth/models/base_models/midas_repo/midas/backbones/swin2.py
-src/controlnet_aux/zoe/zoedepth/models/base_models/midas_repo/midas/backbones/swin_common.py
-src/controlnet_aux/zoe/zoedepth/models/base_models/midas_repo/midas/backbones/utils.py
-src/controlnet_aux/zoe/zoedepth/models/base_models/midas_repo/midas/backbones/vit.py
-src/controlnet_aux/zoe/zoedepth/models/layers/__init__.py
-src/controlnet_aux/zoe/zoedepth/models/layers/attractor.py
-src/controlnet_aux/zoe/zoedepth/models/layers/dist_layers.py
-src/controlnet_aux/zoe/zoedepth/models/layers/localbins_layers.py
-src/controlnet_aux/zoe/zoedepth/models/layers/patch_transformer.py
-src/controlnet_aux/zoe/zoedepth/models/zoedepth/__init__.py
-src/controlnet_aux/zoe/zoedepth/models/zoedepth/config_zoedepth.json
-src/controlnet_aux/zoe/zoedepth/models/zoedepth/config_zoedepth_kitti.json
-src/controlnet_aux/zoe/zoedepth/models/zoedepth/zoedepth_v1.py
-src/controlnet_aux/zoe/zoedepth/models/zoedepth_nk/__init__.py
-src/controlnet_aux/zoe/zoedepth/models/zoedepth_nk/config_zoedepth_nk.json
-src/controlnet_aux/zoe/zoedepth/models/zoedepth_nk/zoedepth_nk_v1.py
-src/controlnet_aux/zoe/zoedepth/utils/__init__.py
-src/controlnet_aux/zoe/zoedepth/utils/arg_utils.py
-src/controlnet_aux/zoe/zoedepth/utils/config.py
-src/controlnet_aux/zoe/zoedepth/utils/easydict/__init__.py
-tests/test_controlnet_aux.py

controlnet_aux/src/controlnet_aux.egg-info/dependency_links.txt

@@ -1 +0,0 @@
-

controlnet_aux/src/controlnet_aux.egg-info/requires.txt

@@ -1,12 +0,0 @@
-torch
-importlib_metadata
-huggingface_hub
-scipy
-opencv-python-headless
-filelock
-numpy
-Pillow
-einops
-torchvision
-timm<=0.6.7
-scikit-image

controlnet_aux/src/controlnet_aux.egg-info/top_level.txt

@@ -1 +0,0 @@
-controlnet_aux

controlnet_aux/src/controlnet_aux/__init__.py

@@ -1,5 +0,0 @@
-__version__ = "0.0.9"
-
-from .canny import CannyDetector
-from .open_pose import OpenposeDetector
-

controlnet_aux/src/controlnet_aux/canny/__init__.py

@@ -1,36 +0,0 @@
-import warnings
-import cv2
-import numpy as np
-from PIL import Image
-from ..util import HWC3, resize_image
-
-class CannyDetector:
-    def __call__(self, input_image=None, low_threshold=100, high_threshold=200, detect_resolution=512, image_resolution=512, output_type=None, **kwargs):
-        if "img" in kwargs:
-            warnings.warn("img is deprecated, please use `input_image=...` instead.", DeprecationWarning)
-            input_image = kwargs.pop("img")
-        
-        if input_image is None:
-            raise ValueError("input_image must be defined.")
-
-        if not isinstance(input_image, np.ndarray):
-            input_image = np.array(input_image, dtype=np.uint8)
-            output_type = output_type or "pil"
-        else:
-            output_type = output_type or "np"
-        
-        input_image = HWC3(input_image)
-        input_image = resize_image(input_image, detect_resolution)
-
-        detected_map = cv2.Canny(input_image, low_threshold, high_threshold)
-        detected_map = HWC3(detected_map)      
-         
-        img = resize_image(input_image, image_resolution)
-        H, W, C = img.shape
-
-        detected_map = cv2.resize(detected_map, (W, H), interpolation=cv2.INTER_LINEAR)
-        
-        if output_type == "pil":
-            detected_map = Image.fromarray(detected_map)
-            
-        return detected_map

controlnet_aux/src/controlnet_aux/open_pose/LICENSE

@@ -1,108 +0,0 @@
-OPENPOSE: MULTIPERSON KEYPOINT DETECTION
-SOFTWARE LICENSE AGREEMENT
-ACADEMIC OR NON-PROFIT ORGANIZATION NONCOMMERCIAL RESEARCH USE ONLY
-
-BY USING OR DOWNLOADING THE SOFTWARE, YOU ARE AGREEING TO THE TERMS OF THIS LICENSE AGREEMENT.  IF YOU DO NOT AGREE WITH THESE TERMS, YOU MAY NOT USE OR DOWNLOAD THE SOFTWARE.
-
-This is a license agreement ("Agreement") between your academic institution or non-profit organization or self (called "Licensee" or "You" in this Agreement) and Carnegie Mellon University (called "Licensor" in this Agreement).  All rights not specifically granted to you in this Agreement are reserved for Licensor. 
-
-RESERVATION OF OWNERSHIP AND GRANT OF LICENSE: 
-Licensor retains exclusive ownership of any copy of the Software (as defined below) licensed under this Agreement and hereby grants to Licensee a personal, non-exclusive, 
-non-transferable license to use the Software for noncommercial research purposes, without the right to sublicense, pursuant to the terms and conditions of this Agreement.  As used in this Agreement, the term "Software" means (i) the actual copy of all or any portion of code for program routines made accessible to Licensee by Licensor pursuant to this Agreement, inclusive of backups, updates, and/or merged copies permitted hereunder or subsequently supplied by Licensor,  including all or any file structures, programming instructions, user interfaces and screen formats and sequences as well as any and all documentation and instructions related to it, and (ii) all or any derivatives and/or modifications created or made by You to any of the items specified in (i).
-
-CONFIDENTIALITY: Licensee acknowledges that the Software is proprietary to Licensor, and as such, Licensee agrees to receive all such materials in confidence and use the Software only in accordance with the terms of this Agreement.  Licensee agrees to use reasonable effort to protect the Software from unauthorized use, reproduction, distribution, or publication.
-
-COPYRIGHT: The Software is owned by Licensor and is protected by United 
-States copyright laws and applicable international treaties and/or conventions.
-
-PERMITTED USES:  The Software may be used for your own noncommercial internal research purposes. You understand and agree that Licensor is not obligated to implement any suggestions and/or feedback you might provide regarding the Software, but to the extent Licensor does so, you are not entitled to any compensation related thereto.
-
-DERIVATIVES: You may create derivatives of or make modifications to the Software, however, You agree that all and any such derivatives and modifications will be owned by Licensor and become a part of the Software licensed to You under this Agreement.  You may only use such derivatives and modifications for your own noncommercial internal research purposes, and you may not otherwise use, distribute or copy such derivatives and modifications in violation of this Agreement.
-
-BACKUPS:  If Licensee is an organization, it may make that number of copies of the Software necessary for internal noncommercial use at a single site within its organization provided that all information appearing in or on the original labels, including the copyright and trademark notices are copied onto the labels of the copies.
-
-USES NOT PERMITTED:  You may not distribute, copy or use the Software except as explicitly permitted herein. Licensee has not been granted any trademark license as part of this Agreement and may not use the name or mark “OpenPose", "Carnegie Mellon" or any renditions thereof without the prior written permission of Licensor.
-
-You may not sell, rent, lease, sublicense, lend, time-share or transfer, in whole or in part, or provide third parties access to prior or present versions (or any parts thereof) of the Software.
-
-ASSIGNMENT: You may not assign this Agreement or your rights hereunder without the prior written consent of Licensor. Any attempted assignment without such consent shall be null and void.
-
-TERM: The term of the license granted by this Agreement is from Licensee's acceptance of this Agreement by downloading the Software or by using the Software until terminated as provided below.
-
-The Agreement automatically terminates without notice if you fail to comply with any provision of this Agreement.  Licensee may terminate this Agreement by ceasing using the Software.  Upon any termination of this Agreement, Licensee will delete any and all copies of the Software. You agree that all provisions which operate to protect the proprietary rights of Licensor shall remain in force should breach occur and that the obligation of confidentiality described in this Agreement is binding in perpetuity and, as such, survives the term of the Agreement.
-
-FEE: Provided Licensee abides completely by the terms and conditions of this Agreement, there is no fee due to Licensor for Licensee's use of the Software in accordance with this Agreement.
-
-DISCLAIMER OF WARRANTIES:  THE SOFTWARE IS PROVIDED "AS-IS" WITHOUT WARRANTY OF ANY KIND INCLUDING ANY WARRANTIES OF PERFORMANCE OR MERCHANTABILITY OR FITNESS FOR A PARTICULAR USE OR PURPOSE OR OF NON-INFRINGEMENT.  LICENSEE BEARS ALL RISK RELATING TO QUALITY AND PERFORMANCE OF THE SOFTWARE AND RELATED MATERIALS.
-
-SUPPORT AND MAINTENANCE: No Software support or training by the Licensor is provided as part of this Agreement.  
-
-EXCLUSIVE REMEDY AND LIMITATION OF LIABILITY: To the maximum extent permitted under applicable law, Licensor shall not be liable for direct, indirect, special, incidental, or consequential damages or lost profits related to Licensee's use of and/or inability to use the Software, even if Licensor is advised of the possibility of such damage.
-
-EXPORT REGULATION: Licensee agrees to comply with any and all applicable 
-U.S. export control laws, regulations, and/or other laws related to embargoes and sanction programs administered by the Office of Foreign Assets Control.
-
-SEVERABILITY: If any provision(s) of this Agreement shall be held to be invalid, illegal, or unenforceable by a court or other tribunal of competent jurisdiction, the validity, legality and enforceability of the remaining provisions shall not in any way be affected or impaired thereby.
-
-NO IMPLIED WAIVERS: No failure or delay by Licensor in enforcing any right or remedy under this Agreement shall be construed as a waiver of any future or other exercise of such right or remedy by Licensor.
-
-GOVERNING LAW: This Agreement shall be construed and enforced in accordance with the laws of the Commonwealth of Pennsylvania without reference to conflict of laws principles.  You consent to the personal jurisdiction of the courts of this County and waive their rights to venue outside of Allegheny County, Pennsylvania.
-
-ENTIRE AGREEMENT AND AMENDMENTS: This Agreement constitutes the sole and entire agreement between Licensee and Licensor as to the matter set forth herein and supersedes any previous agreements, understandings, and arrangements between the parties relating hereto.
-
-
-
-************************************************************************
-
-THIRD-PARTY SOFTWARE NOTICES AND INFORMATION
-
-This project incorporates material from the project(s) listed below (collectively, "Third Party Code").  This Third Party Code is licensed to you under their original license terms set forth below.  We reserves all other rights not expressly granted, whether by implication, estoppel or otherwise.
- 
-1.	Caffe, version 1.0.0, (https://github.com/BVLC/caffe/)
-
-COPYRIGHT
-
-All contributions by the University of California:
-Copyright (c) 2014-2017 The Regents of the University of California (Regents)
-All rights reserved.
-
-All other contributions:
-Copyright (c) 2014-2017, the respective contributors
-All rights reserved.
-
-Caffe uses a shared copyright model: each contributor holds copyright over
-their contributions to Caffe. The project versioning records all such
-contribution and copyright details. If a contributor wants to further mark
-their specific copyright on a particular contribution, they should indicate
-their copyright solely in the commit message of the change when it is
-committed.
-
-LICENSE
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met: 
-
-1. Redistributions of source code must retain the above copyright notice, this
-   list of conditions and the following disclaimer. 
-2. Redistributions in binary form must reproduce the above copyright notice,
-   this list of conditions and the following disclaimer in the documentation
-   and/or other materials provided with the distribution. 
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-CONTRIBUTION AGREEMENT
-
-By contributing to the BVLC/caffe repository through pull-request, comment,
-or otherwise, the contributor releases their content to the
-license and copyright terms herein.
-
-************END OF THIRD-PARTY SOFTWARE NOTICES AND INFORMATION**********

controlnet_aux/src/controlnet_aux/open_pose/__init__.py

@@ -1,234 +0,0 @@
-# Openpose
-# Original from CMU https://github.com/CMU-Perceptual-Computing-Lab/openpose
-# 2nd Edited by https://github.com/Hzzone/pytorch-openpose
-# 3rd Edited by ControlNet
-# 4th Edited by ControlNet (added face and correct hands)
-# 5th Edited by ControlNet (Improved JSON serialization/deserialization, and lots of bug fixs)
-# This preprocessor is licensed by CMU for non-commercial use only.
-
-
-import os
-
-os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"
-
-import json
-import warnings
-from typing import Callable, List, NamedTuple, Tuple, Union
-
-import cv2
-import numpy as np
-import torch
-from huggingface_hub import hf_hub_download
-from PIL import Image
-
-from ..util import HWC3, resize_image
-from . import util
-from .body import Body, BodyResult, Keypoint
-from .face import Face
-from .hand import Hand
-
-HandResult = List[Keypoint]
-FaceResult = List[Keypoint]
-
-class PoseResult(NamedTuple):
-    body: BodyResult
-    left_hand: Union[HandResult, None]
-    right_hand: Union[HandResult, None]
-    face: Union[FaceResult, None]
-
-def draw_poses(poses: List[PoseResult], H, W, draw_body=True, draw_hand=True, draw_face=True):
-    """
-    Draw the detected poses on an empty canvas.
-
-    Args:
-        poses (List[PoseResult]): A list of PoseResult objects containing the detected poses.
-        H (int): The height of the canvas.
-        W (int): The width of the canvas.
-        draw_body (bool, optional): Whether to draw body keypoints. Defaults to True.
-        draw_hand (bool, optional): Whether to draw hand keypoints. Defaults to True.
-        draw_face (bool, optional): Whether to draw face keypoints. Defaults to True.
-
-    Returns:
-        numpy.ndarray: A 3D numpy array representing the canvas with the drawn poses.
-    """
-    canvas = np.zeros(shape=(H, W, 3), dtype=np.uint8)
-
-    for pose in poses:
-        if draw_body:
-            canvas = util.draw_bodypose(canvas, pose.body.keypoints)
-
-        if draw_hand:
-            canvas = util.draw_handpose(canvas, pose.left_hand)
-            canvas = util.draw_handpose(canvas, pose.right_hand)
-
-        if draw_face:
-            canvas = util.draw_facepose(canvas, pose.face)
-
-    return canvas
-    
-    
-class OpenposeDetector:
-    """
-    A class for detecting human poses in images using the Openpose model.
-
-    Attributes:
-        model_dir (str): Path to the directory where the pose models are stored.
-    """
-    def __init__(self, body_estimation, hand_estimation=None, face_estimation=None):
-        self.body_estimation = body_estimation
-        self.hand_estimation = hand_estimation
-        self.face_estimation = face_estimation
-
-    @classmethod
-    def from_pretrained(cls, pretrained_model_or_path, filename=None, hand_filename=None, face_filename=None, cache_dir=None, local_files_only=False):
-
-        if pretrained_model_or_path == "lllyasviel/ControlNet":
-            filename = filename or "annotator/ckpts/body_pose_model.pth"
-            hand_filename = hand_filename or "annotator/ckpts/hand_pose_model.pth"
-            face_filename = face_filename or "facenet.pth"
-
-            face_pretrained_model_or_path = "lllyasviel/Annotators"
-        else:
-            filename = filename or "body_pose_model.pth"
-            hand_filename = hand_filename or "hand_pose_model.pth"
-            face_filename = face_filename or "facenet.pth"
-
-            face_pretrained_model_or_path = pretrained_model_or_path
-
-        if os.path.isdir(pretrained_model_or_path):
-            body_model_path = os.path.join(pretrained_model_or_path, filename)
-            hand_model_path = os.path.join(pretrained_model_or_path, hand_filename)
-            face_model_path = os.path.join(face_pretrained_model_or_path, face_filename)
-        else:
-            body_model_path = hf_hub_download(pretrained_model_or_path, filename, cache_dir=cache_dir, local_files_only=local_files_only)
-            hand_model_path = hf_hub_download(pretrained_model_or_path, hand_filename, cache_dir=cache_dir, local_files_only=local_files_only)
-            face_model_path = hf_hub_download(face_pretrained_model_or_path, face_filename, cache_dir=cache_dir, local_files_only=local_files_only)
-
-        body_estimation = Body(body_model_path)
-        hand_estimation = Hand(hand_model_path)
-        face_estimation = Face(face_model_path)
-
-        return cls(body_estimation, hand_estimation, face_estimation)
-
-    def to(self, device):
-        self.body_estimation.to(device)
-        self.hand_estimation.to(device)
-        self.face_estimation.to(device)
-        return self
-
-    def detect_hands(self, body: BodyResult, oriImg) -> Tuple[Union[HandResult, None], Union[HandResult, None]]:
-        left_hand = None
-        right_hand = None
-        H, W, _ = oriImg.shape
-        for x, y, w, is_left in util.handDetect(body, oriImg):
-            peaks = self.hand_estimation(oriImg[y:y+w, x:x+w, :]).astype(np.float32)
-            if peaks.ndim == 2 and peaks.shape[1] == 2:
-                peaks[:, 0] = np.where(peaks[:, 0] < 1e-6, -1, peaks[:, 0] + x) / float(W)
-                peaks[:, 1] = np.where(peaks[:, 1] < 1e-6, -1, peaks[:, 1] + y) / float(H)
-                
-                hand_result = [
-                    Keypoint(x=peak[0], y=peak[1])
-                    for peak in peaks
-                ]
-
-                if is_left:
-                    left_hand = hand_result
-                else:
-                    right_hand = hand_result
-
-        return left_hand, right_hand
-
-    def detect_face(self, body: BodyResult, oriImg) -> Union[FaceResult, None]:
-        face = util.faceDetect(body, oriImg)
-        if face is None:
-            return None
-        
-        x, y, w = face
-        H, W, _ = oriImg.shape
-        heatmaps = self.face_estimation(oriImg[y:y+w, x:x+w, :])
-        peaks = self.face_estimation.compute_peaks_from_heatmaps(heatmaps).astype(np.float32)
-        if peaks.ndim == 2 and peaks.shape[1] == 2:
-            peaks[:, 0] = np.where(peaks[:, 0] < 1e-6, -1, peaks[:, 0] + x) / float(W)
-            peaks[:, 1] = np.where(peaks[:, 1] < 1e-6, -1, peaks[:, 1] + y) / float(H)
-            return [
-                Keypoint(x=peak[0], y=peak[1])
-                for peak in peaks
-            ]
-        
-        return None
-
-    def detect_poses(self, oriImg, include_hand=False, include_face=False) -> List[PoseResult]:
-        """
-        Detect poses in the given image.
-            Args:
-                oriImg (numpy.ndarray): The input image for pose detection.
-                include_hand (bool, optional): Whether to include hand detection. Defaults to False.
-                include_face (bool, optional): Whether to include face detection. Defaults to False.
-
-        Returns:
-            List[PoseResult]: A list of PoseResult objects containing the detected poses.
-        """
-        oriImg = oriImg[:, :, ::-1].copy()
-        H, W, C = oriImg.shape
-        with torch.no_grad():
-            candidate, subset = self.body_estimation(oriImg)
-            bodies = self.body_estimation.format_body_result(candidate, subset)
-
-            results = []
-            for body in bodies:
-                left_hand, right_hand, face = (None,) * 3
-                if include_hand:
-                    left_hand, right_hand = self.detect_hands(body, oriImg)
-                if include_face:
-                    face = self.detect_face(body, oriImg)
-                
-                results.append(PoseResult(BodyResult(
-                    keypoints=[
-                        Keypoint(
-                            x=keypoint.x / float(W),
-                            y=keypoint.y / float(H)
-                        ) if keypoint is not None else None
-                        for keypoint in body.keypoints
-                    ], 
-                    total_score=body.total_score,
-                    total_parts=body.total_parts
-                ), left_hand, right_hand, face))
-            
-            return results
-        
-    def __call__(self, input_image, detect_resolution=512, image_resolution=512, include_body=True, include_hand=False, include_face=False, hand_and_face=None, output_type="pil", **kwargs):
-        if hand_and_face is not None:
-            warnings.warn("hand_and_face is deprecated. Use include_hand and include_face instead.", DeprecationWarning)
-            include_hand = hand_and_face
-            include_face = hand_and_face
-
-        if "return_pil" in kwargs:
-            warnings.warn("return_pil is deprecated. Use output_type instead.", DeprecationWarning)
-            output_type = "pil" if kwargs["return_pil"] else "np"
-        if type(output_type) is bool:
-            warnings.warn("Passing `True` or `False` to `output_type` is deprecated and will raise an error in future versions")
-            if output_type:
-                output_type = "pil"
-
-        if not isinstance(input_image, np.ndarray):
-            input_image = np.array(input_image, dtype=np.uint8)
-
-        input_image = HWC3(input_image)
-        input_image = resize_image(input_image, detect_resolution)
-        H, W, C = input_image.shape
-        
-        poses = self.detect_poses(input_image, include_hand, include_face)
-        canvas = draw_poses(poses, H, W, draw_body=include_body, draw_hand=include_hand, draw_face=include_face) 
-
-        detected_map = canvas
-        detected_map = HWC3(detected_map)
-        
-        img = resize_image(input_image, image_resolution)
-        H, W, C = img.shape
-
-        detected_map = cv2.resize(detected_map, (W, H), interpolation=cv2.INTER_LINEAR)
-
-        if output_type == "pil":
-            detected_map = Image.fromarray(detected_map)
-
-        return detected_map

controlnet_aux/src/controlnet_aux/open_pose/body.py

@@ -1,260 +0,0 @@
-import math
-from typing import List, NamedTuple, Union
-
-import cv2
-import numpy as np
-import torch
-from scipy.ndimage.filters import gaussian_filter
-
-from . import util
-from .model import bodypose_model
-
-
-class Keypoint(NamedTuple):
-    x: float
-    y: float
-    score: float = 1.0
-    id: int = -1
-
-
-class BodyResult(NamedTuple):
-    # Note: Using `Union` instead of `|` operator as the ladder is a Python
-    # 3.10 feature.
-    # Annotator code should be Python 3.8 Compatible, as controlnet repo uses
-    # Python 3.8 environment.
-    # https://github.com/lllyasviel/ControlNet/blob/d3284fcd0972c510635a4f5abe2eeb71dc0de524/environment.yaml#L6
-    keypoints: List[Union[Keypoint, None]]
-    total_score: float
-    total_parts: int
-
-
-class Body(object):
-    def __init__(self, model_path):
-        self.model = bodypose_model()
-        model_dict = util.transfer(self.model, torch.load(model_path))
-        self.model.load_state_dict(model_dict)
-        self.model.eval()
-
-    def to(self, device):
-        self.model.to(device)
-        return self
-
-    def __call__(self, oriImg):
-        device = next(iter(self.model.parameters())).device
-        # scale_search = [0.5, 1.0, 1.5, 2.0]
-        scale_search = [0.5]
-        boxsize = 368
-        stride = 8
-        padValue = 128
-        thre1 = 0.1
-        thre2 = 0.05
-        multiplier = [x * boxsize / oriImg.shape[0] for x in scale_search]
-        heatmap_avg = np.zeros((oriImg.shape[0], oriImg.shape[1], 19))
-        paf_avg = np.zeros((oriImg.shape[0], oriImg.shape[1], 38))
-
-        for m in range(len(multiplier)):
-            scale = multiplier[m]
-            imageToTest = util.smart_resize_k(oriImg, fx=scale, fy=scale)
-            imageToTest_padded, pad = util.padRightDownCorner(imageToTest, stride, padValue)
-            im = np.transpose(np.float32(imageToTest_padded[:, :, :, np.newaxis]), (3, 2, 0, 1)) / 256 - 0.5
-            im = np.ascontiguousarray(im)
-
-            data = torch.from_numpy(im).float()
-            data = data.to(device)
-            # data = data.permute([2, 0, 1]).unsqueeze(0).float()
-            with torch.no_grad():
-                Mconv7_stage6_L1, Mconv7_stage6_L2 = self.model(data)
-            Mconv7_stage6_L1 = Mconv7_stage6_L1.cpu().numpy()
-            Mconv7_stage6_L2 = Mconv7_stage6_L2.cpu().numpy()
-
-            # extract outputs, resize, and remove padding
-            # heatmap = np.transpose(np.squeeze(net.blobs[output_blobs.keys()[1]].data), (1, 2, 0))  # output 1 is heatmaps
-            heatmap = np.transpose(np.squeeze(Mconv7_stage6_L2), (1, 2, 0))  # output 1 is heatmaps
-            heatmap = util.smart_resize_k(heatmap, fx=stride, fy=stride)
-            heatmap = heatmap[:imageToTest_padded.shape[0] - pad[2], :imageToTest_padded.shape[1] - pad[3], :]
-            heatmap = util.smart_resize(heatmap, (oriImg.shape[0], oriImg.shape[1]))
-
-            # paf = np.transpose(np.squeeze(net.blobs[output_blobs.keys()[0]].data), (1, 2, 0))  # output 0 is PAFs
-            paf = np.transpose(np.squeeze(Mconv7_stage6_L1), (1, 2, 0))  # output 0 is PAFs
-            paf = util.smart_resize_k(paf, fx=stride, fy=stride)
-            paf = paf[:imageToTest_padded.shape[0] - pad[2], :imageToTest_padded.shape[1] - pad[3], :]
-            paf = util.smart_resize(paf, (oriImg.shape[0], oriImg.shape[1]))
-
-            heatmap_avg += heatmap_avg + heatmap / len(multiplier)
-            paf_avg += + paf / len(multiplier)
-
-        all_peaks = []
-        peak_counter = 0
-
-        for part in range(18):
-            map_ori = heatmap_avg[:, :, part]
-            one_heatmap = gaussian_filter(map_ori, sigma=3)
-
-            map_left = np.zeros(one_heatmap.shape)
-            map_left[1:, :] = one_heatmap[:-1, :]
-            map_right = np.zeros(one_heatmap.shape)
-            map_right[:-1, :] = one_heatmap[1:, :]
-            map_up = np.zeros(one_heatmap.shape)
-            map_up[:, 1:] = one_heatmap[:, :-1]
-            map_down = np.zeros(one_heatmap.shape)
-            map_down[:, :-1] = one_heatmap[:, 1:]
-
-            peaks_binary = np.logical_and.reduce(
-                (one_heatmap >= map_left, one_heatmap >= map_right, one_heatmap >= map_up, one_heatmap >= map_down, one_heatmap > thre1))
-            peaks = list(zip(np.nonzero(peaks_binary)[1], np.nonzero(peaks_binary)[0]))  # note reverse
-            peaks_with_score = [x + (map_ori[x[1], x[0]],) for x in peaks]
-            peak_id = range(peak_counter, peak_counter + len(peaks))
-            peaks_with_score_and_id = [peaks_with_score[i] + (peak_id[i],) for i in range(len(peak_id))]
-
-            all_peaks.append(peaks_with_score_and_id)
-            peak_counter += len(peaks)
-
-        # find connection in the specified sequence, center 29 is in the position 15
-        limbSeq = [[2, 3], [2, 6], [3, 4], [4, 5], [6, 7], [7, 8], [2, 9], [9, 10], \
-                   [10, 11], [2, 12], [12, 13], [13, 14], [2, 1], [1, 15], [15, 17], \
-                   [1, 16], [16, 18], [3, 17], [6, 18]]
-        # the middle joints heatmap correpondence
-        mapIdx = [[31, 32], [39, 40], [33, 34], [35, 36], [41, 42], [43, 44], [19, 20], [21, 22], \
-                  [23, 24], [25, 26], [27, 28], [29, 30], [47, 48], [49, 50], [53, 54], [51, 52], \
-                  [55, 56], [37, 38], [45, 46]]
-
-        connection_all = []
-        special_k = []
-        mid_num = 10
-
-        for k in range(len(mapIdx)):
-            score_mid = paf_avg[:, :, [x - 19 for x in mapIdx[k]]]
-            candA = all_peaks[limbSeq[k][0] - 1]
-            candB = all_peaks[limbSeq[k][1] - 1]
-            nA = len(candA)
-            nB = len(candB)
-            indexA, indexB = limbSeq[k]
-            if (nA != 0 and nB != 0):
-                connection_candidate = []
-                for i in range(nA):
-                    for j in range(nB):
-                        vec = np.subtract(candB[j][:2], candA[i][:2])
-                        norm = math.sqrt(vec[0] * vec[0] + vec[1] * vec[1])
-                        norm = max(0.001, norm)
-                        vec = np.divide(vec, norm)
-
-                        startend = list(zip(np.linspace(candA[i][0], candB[j][0], num=mid_num), \
-                                            np.linspace(candA[i][1], candB[j][1], num=mid_num)))
-
-                        vec_x = np.array([score_mid[int(round(startend[I][1])), int(round(startend[I][0])), 0] \
-                                          for I in range(len(startend))])
-                        vec_y = np.array([score_mid[int(round(startend[I][1])), int(round(startend[I][0])), 1] \
-                                          for I in range(len(startend))])
-
-                        score_midpts = np.multiply(vec_x, vec[0]) + np.multiply(vec_y, vec[1])
-                        score_with_dist_prior = sum(score_midpts) / len(score_midpts) + min(
-                            0.5 * oriImg.shape[0] / norm - 1, 0)
-                        criterion1 = len(np.nonzero(score_midpts > thre2)[0]) > 0.8 * len(score_midpts)
-                        criterion2 = score_with_dist_prior > 0
-                        if criterion1 and criterion2:
-                            connection_candidate.append(
-                                [i, j, score_with_dist_prior, score_with_dist_prior + candA[i][2] + candB[j][2]])
-
-                connection_candidate = sorted(connection_candidate, key=lambda x: x[2], reverse=True)
-                connection = np.zeros((0, 5))
-                for c in range(len(connection_candidate)):
-                    i, j, s = connection_candidate[c][0:3]
-                    if (i not in connection[:, 3] and j not in connection[:, 4]):
-                        connection = np.vstack([connection, [candA[i][3], candB[j][3], s, i, j]])
-                        if (len(connection) >= min(nA, nB)):
-                            break
-
-                connection_all.append(connection)
-            else:
-                special_k.append(k)
-                connection_all.append([])
-
-        # last number in each row is the total parts number of that person
-        # the second last number in each row is the score of the overall configuration
-        subset = -1 * np.ones((0, 20))
-        candidate = np.array([item for sublist in all_peaks for item in sublist])
-
-        for k in range(len(mapIdx)):
-            if k not in special_k:
-                partAs = connection_all[k][:, 0]
-                partBs = connection_all[k][:, 1]
-                indexA, indexB = np.array(limbSeq[k]) - 1
-
-                for i in range(len(connection_all[k])):  # = 1:size(temp,1)
-                    found = 0
-                    subset_idx = [-1, -1]
-                    for j in range(len(subset)):  # 1:size(subset,1):
-                        if subset[j][indexA] == partAs[i] or subset[j][indexB] == partBs[i]:
-                            subset_idx[found] = j
-                            found += 1
-
-                    if found == 1:
-                        j = subset_idx[0]
-                        if subset[j][indexB] != partBs[i]:
-                            subset[j][indexB] = partBs[i]
-                            subset[j][-1] += 1
-                            subset[j][-2] += candidate[partBs[i].astype(int), 2] + connection_all[k][i][2]
-                    elif found == 2:  # if found 2 and disjoint, merge them
-                        j1, j2 = subset_idx
-                        membership = ((subset[j1] >= 0).astype(int) + (subset[j2] >= 0).astype(int))[:-2]
-                        if len(np.nonzero(membership == 2)[0]) == 0:  # merge
-                            subset[j1][:-2] += (subset[j2][:-2] + 1)
-                            subset[j1][-2:] += subset[j2][-2:]
-                            subset[j1][-2] += connection_all[k][i][2]
-                            subset = np.delete(subset, j2, 0)
-                        else:  # as like found == 1
-                            subset[j1][indexB] = partBs[i]
-                            subset[j1][-1] += 1
-                            subset[j1][-2] += candidate[partBs[i].astype(int), 2] + connection_all[k][i][2]
-
-                    # if find no partA in the subset, create a new subset
-                    elif not found and k < 17:
-                        row = -1 * np.ones(20)
-                        row[indexA] = partAs[i]
-                        row[indexB] = partBs[i]
-                        row[-1] = 2
-                        row[-2] = sum(candidate[connection_all[k][i, :2].astype(int), 2]) + connection_all[k][i][2]
-                        subset = np.vstack([subset, row])
-        # delete some rows of subset which has few parts occur
-        deleteIdx = []
-        for i in range(len(subset)):
-            if subset[i][-1] < 4 or subset[i][-2] / subset[i][-1] < 0.4:
-                deleteIdx.append(i)
-        subset = np.delete(subset, deleteIdx, axis=0)
-
-        # subset: n*20 array, 0-17 is the index in candidate, 18 is the total score, 19 is the total parts
-        # candidate: x, y, score, id
-        return candidate, subset
-    
-    @staticmethod
-    def format_body_result(candidate: np.ndarray, subset: np.ndarray) -> List[BodyResult]:
-        """
-        Format the body results from the candidate and subset arrays into a list of BodyResult objects.
-        
-        Args:
-            candidate (np.ndarray): An array of candidates containing the x, y coordinates, score, and id
-                for each body part.
-            subset (np.ndarray): An array of subsets containing indices to the candidate array for each
-                person detected. The last two columns of each row hold the total score and total parts
-                of the person.
-
-        Returns:
-            List[BodyResult]: A list of BodyResult objects, where each object represents a person with
-                detected keypoints, total score, and total parts.
-        """
-        return [
-            BodyResult(
-                keypoints=[
-                    Keypoint(
-                        x=candidate[candidate_index][0],
-                        y=candidate[candidate_index][1],
-                        score=candidate[candidate_index][2],
-                        id=candidate[candidate_index][3]
-                    ) if candidate_index != -1 else None
-                    for candidate_index in person[:18].astype(int)
-                ],
-                total_score=person[18],
-                total_parts=person[19]
-            )
-            for person in subset
-        ]

controlnet_aux/src/controlnet_aux/open_pose/face.py

@@ -1,364 +0,0 @@
-import logging
-
-import numpy as np
-import torch
-import torch.nn.functional as F
-from torch.nn import Conv2d, MaxPool2d, Module, ReLU, init
-from torchvision.transforms import ToPILImage, ToTensor
-
-from . import util
-
-
-class FaceNet(Module):
-    """Model the cascading heatmaps. """
-    def __init__(self):
-        super(FaceNet, self).__init__()
-        # cnn to make feature map
-        self.relu = ReLU()
-        self.max_pooling_2d = MaxPool2d(kernel_size=2, stride=2)
-        self.conv1_1 = Conv2d(in_channels=3, out_channels=64,
-                              kernel_size=3, stride=1, padding=1)
-        self.conv1_2 = Conv2d(
-            in_channels=64, out_channels=64, kernel_size=3, stride=1,
-            padding=1)
-        self.conv2_1 = Conv2d(
-            in_channels=64, out_channels=128, kernel_size=3, stride=1,
-            padding=1)
-        self.conv2_2 = Conv2d(
-            in_channels=128, out_channels=128, kernel_size=3, stride=1,
-            padding=1)
-        self.conv3_1 = Conv2d(
-            in_channels=128, out_channels=256, kernel_size=3, stride=1,
-            padding=1)
-        self.conv3_2 = Conv2d(
-            in_channels=256, out_channels=256, kernel_size=3, stride=1,
-            padding=1)
-        self.conv3_3 = Conv2d(
-            in_channels=256, out_channels=256, kernel_size=3, stride=1,
-            padding=1)
-        self.conv3_4 = Conv2d(
-            in_channels=256, out_channels=256, kernel_size=3, stride=1,
-            padding=1)
-        self.conv4_1 = Conv2d(
-            in_channels=256, out_channels=512, kernel_size=3, stride=1,
-            padding=1)
-        self.conv4_2 = Conv2d(
-            in_channels=512, out_channels=512, kernel_size=3, stride=1,
-            padding=1)
-        self.conv4_3 = Conv2d(
-            in_channels=512, out_channels=512, kernel_size=3, stride=1,
-            padding=1)
-        self.conv4_4 = Conv2d(
-            in_channels=512, out_channels=512, kernel_size=3, stride=1,
-            padding=1)
-        self.conv5_1 = Conv2d(
-            in_channels=512, out_channels=512, kernel_size=3, stride=1,
-            padding=1)
-        self.conv5_2 = Conv2d(
-            in_channels=512, out_channels=512, kernel_size=3, stride=1,
-            padding=1)
-        self.conv5_3_CPM = Conv2d(
-            in_channels=512, out_channels=128, kernel_size=3, stride=1,
-            padding=1)
-
-        # stage1
-        self.conv6_1_CPM = Conv2d(
-            in_channels=128, out_channels=512, kernel_size=1, stride=1,
-            padding=0)
-        self.conv6_2_CPM = Conv2d(
-            in_channels=512, out_channels=71, kernel_size=1, stride=1,
-            padding=0)
-
-        # stage2
-        self.Mconv1_stage2 = Conv2d(
-            in_channels=199, out_channels=128, kernel_size=7, stride=1,
-            padding=3)
-        self.Mconv2_stage2 = Conv2d(
-            in_channels=128, out_channels=128, kernel_size=7, stride=1,
-            padding=3)
-        self.Mconv3_stage2 = Conv2d(
-            in_channels=128, out_channels=128, kernel_size=7, stride=1,
-            padding=3)
-        self.Mconv4_stage2 = Conv2d(
-            in_channels=128, out_channels=128, kernel_size=7, stride=1,
-            padding=3)
-        self.Mconv5_stage2 = Conv2d(
-            in_channels=128, out_channels=128, kernel_size=7, stride=1,
-            padding=3)
-        self.Mconv6_stage2 = Conv2d(
-            in_channels=128, out_channels=128, kernel_size=1, stride=1,
-            padding=0)
-        self.Mconv7_stage2 = Conv2d(
-            in_channels=128, out_channels=71, kernel_size=1, stride=1,
-            padding=0)
-
-        # stage3
-        self.Mconv1_stage3 = Conv2d(
-            in_channels=199, out_channels=128, kernel_size=7, stride=1,
-            padding=3)
-        self.Mconv2_stage3 = Conv2d(
-            in_channels=128, out_channels=128, kernel_size=7, stride=1,
-            padding=3)
-        self.Mconv3_stage3 = Conv2d(
-            in_channels=128, out_channels=128, kernel_size=7, stride=1,
-            padding=3)
-        self.Mconv4_stage3 = Conv2d(
-            in_channels=128, out_channels=128, kernel_size=7, stride=1,
-            padding=3)
-        self.Mconv5_stage3 = Conv2d(
-            in_channels=128, out_channels=128, kernel_size=7, stride=1,
-            padding=3)
-        self.Mconv6_stage3 = Conv2d(
-            in_channels=128, out_channels=128, kernel_size=1, stride=1,
-            padding=0)
-        self.Mconv7_stage3 = Conv2d(
-            in_channels=128, out_channels=71, kernel_size=1, stride=1,
-            padding=0)
-
-        # stage4
-        self.Mconv1_stage4 = Conv2d(
-            in_channels=199, out_channels=128, kernel_size=7, stride=1,
-            padding=3)
-        self.Mconv2_stage4 = Conv2d(
-            in_channels=128, out_channels=128, kernel_size=7, stride=1,
-            padding=3)
-        self.Mconv3_stage4 = Conv2d(
-            in_channels=128, out_channels=128, kernel_size=7, stride=1,
-            padding=3)
-        self.Mconv4_stage4 = Conv2d(
-            in_channels=128, out_channels=128, kernel_size=7, stride=1,
-            padding=3)
-        self.Mconv5_stage4 = Conv2d(
-            in_channels=128, out_channels=128, kernel_size=7, stride=1,
-            padding=3)
-        self.Mconv6_stage4 = Conv2d(
-            in_channels=128, out_channels=128, kernel_size=1, stride=1,
-            padding=0)
-        self.Mconv7_stage4 = Conv2d(
-            in_channels=128, out_channels=71, kernel_size=1, stride=1,
-            padding=0)
-
-        # stage5
-        self.Mconv1_stage5 = Conv2d(
-            in_channels=199, out_channels=128, kernel_size=7, stride=1,
-            padding=3)
-        self.Mconv2_stage5 = Conv2d(
-            in_channels=128, out_channels=128, kernel_size=7, stride=1,
-            padding=3)
-        self.Mconv3_stage5 = Conv2d(
-            in_channels=128, out_channels=128, kernel_size=7, stride=1,
-            padding=3)
-        self.Mconv4_stage5 = Conv2d(
-            in_channels=128, out_channels=128, kernel_size=7, stride=1,
-            padding=3)
-        self.Mconv5_stage5 = Conv2d(
-            in_channels=128, out_channels=128, kernel_size=7, stride=1,
-            padding=3)
-        self.Mconv6_stage5 = Conv2d(
-            in_channels=128, out_channels=128, kernel_size=1, stride=1,
-            padding=0)
-        self.Mconv7_stage5 = Conv2d(
-            in_channels=128, out_channels=71, kernel_size=1, stride=1,
-            padding=0)
-
-        # stage6
-        self.Mconv1_stage6 = Conv2d(
-            in_channels=199, out_channels=128, kernel_size=7, stride=1,
-            padding=3)
-        self.Mconv2_stage6 = Conv2d(
-            in_channels=128, out_channels=128, kernel_size=7, stride=1,
-            padding=3)
-        self.Mconv3_stage6 = Conv2d(
-            in_channels=128, out_channels=128, kernel_size=7, stride=1,
-            padding=3)
-        self.Mconv4_stage6 = Conv2d(
-            in_channels=128, out_channels=128, kernel_size=7, stride=1,
-            padding=3)
-        self.Mconv5_stage6 = Conv2d(
-            in_channels=128, out_channels=128, kernel_size=7, stride=1,
-            padding=3)
-        self.Mconv6_stage6 = Conv2d(
-            in_channels=128, out_channels=128, kernel_size=1, stride=1,
-            padding=0)
-        self.Mconv7_stage6 = Conv2d(
-            in_channels=128, out_channels=71, kernel_size=1, stride=1,
-            padding=0)
-
-        for m in self.modules():
-            if isinstance(m, Conv2d):
-                init.constant_(m.bias, 0)
-
-    def forward(self, x):
-        """Return a list of heatmaps."""
-        heatmaps = []
-
-        h = self.relu(self.conv1_1(x))
-        h = self.relu(self.conv1_2(h))
-        h = self.max_pooling_2d(h)
-        h = self.relu(self.conv2_1(h))
-        h = self.relu(self.conv2_2(h))
-        h = self.max_pooling_2d(h)
-        h = self.relu(self.conv3_1(h))
-        h = self.relu(self.conv3_2(h))
-        h = self.relu(self.conv3_3(h))
-        h = self.relu(self.conv3_4(h))
-        h = self.max_pooling_2d(h)
-        h = self.relu(self.conv4_1(h))
-        h = self.relu(self.conv4_2(h))
-        h = self.relu(self.conv4_3(h))
-        h = self.relu(self.conv4_4(h))
-        h = self.relu(self.conv5_1(h))
-        h = self.relu(self.conv5_2(h))
-        h = self.relu(self.conv5_3_CPM(h))
-        feature_map = h
-
-        # stage1
-        h = self.relu(self.conv6_1_CPM(h))
-        h = self.conv6_2_CPM(h)
-        heatmaps.append(h)
-
-        # stage2
-        h = torch.cat([h, feature_map], dim=1)  # channel concat
-        h = self.relu(self.Mconv1_stage2(h))
-        h = self.relu(self.Mconv2_stage2(h))
-        h = self.relu(self.Mconv3_stage2(h))
-        h = self.relu(self.Mconv4_stage2(h))
-        h = self.relu(self.Mconv5_stage2(h))
-        h = self.relu(self.Mconv6_stage2(h))
-        h = self.Mconv7_stage2(h)
-        heatmaps.append(h)
-
-        # stage3
-        h = torch.cat([h, feature_map], dim=1)  # channel concat
-        h = self.relu(self.Mconv1_stage3(h))
-        h = self.relu(self.Mconv2_stage3(h))
-        h = self.relu(self.Mconv3_stage3(h))
-        h = self.relu(self.Mconv4_stage3(h))
-        h = self.relu(self.Mconv5_stage3(h))
-        h = self.relu(self.Mconv6_stage3(h))
-        h = self.Mconv7_stage3(h)
-        heatmaps.append(h)
-
-        # stage4
-        h = torch.cat([h, feature_map], dim=1)  # channel concat
-        h = self.relu(self.Mconv1_stage4(h))
-        h = self.relu(self.Mconv2_stage4(h))
-        h = self.relu(self.Mconv3_stage4(h))
-        h = self.relu(self.Mconv4_stage4(h))
-        h = self.relu(self.Mconv5_stage4(h))
-        h = self.relu(self.Mconv6_stage4(h))
-        h = self.Mconv7_stage4(h)
-        heatmaps.append(h)
-
-        # stage5
-        h = torch.cat([h, feature_map], dim=1)  # channel concat
-        h = self.relu(self.Mconv1_stage5(h))
-        h = self.relu(self.Mconv2_stage5(h))
-        h = self.relu(self.Mconv3_stage5(h))
-        h = self.relu(self.Mconv4_stage5(h))
-        h = self.relu(self.Mconv5_stage5(h))
-        h = self.relu(self.Mconv6_stage5(h))
-        h = self.Mconv7_stage5(h)
-        heatmaps.append(h)
-
-        # stage6
-        h = torch.cat([h, feature_map], dim=1)  # channel concat
-        h = self.relu(self.Mconv1_stage6(h))
-        h = self.relu(self.Mconv2_stage6(h))
-        h = self.relu(self.Mconv3_stage6(h))
-        h = self.relu(self.Mconv4_stage6(h))
-        h = self.relu(self.Mconv5_stage6(h))
-        h = self.relu(self.Mconv6_stage6(h))
-        h = self.Mconv7_stage6(h)
-        heatmaps.append(h)
-
-        return heatmaps
-
-
-LOG = logging.getLogger(__name__)
-TOTEN = ToTensor()
-TOPIL = ToPILImage()
-
-
-params = {
-    'gaussian_sigma': 2.5,
-    'inference_img_size': 736,  # 368, 736, 1312
-    'heatmap_peak_thresh': 0.1,
-    'crop_scale': 1.5,
-    'line_indices': [
-        [0, 1], [1, 2], [2, 3], [3, 4], [4, 5], [5, 6],
-        [6, 7], [7, 8], [8, 9], [9, 10], [10, 11], [11, 12], [12, 13],
-        [13, 14], [14, 15], [15, 16],
-        [17, 18], [18, 19], [19, 20], [20, 21],
-        [22, 23], [23, 24], [24, 25], [25, 26],
-        [27, 28], [28, 29], [29, 30],
-        [31, 32], [32, 33], [33, 34], [34, 35],
-        [36, 37], [37, 38], [38, 39], [39, 40], [40, 41], [41, 36],
-        [42, 43], [43, 44], [44, 45], [45, 46], [46, 47], [47, 42],
-        [48, 49], [49, 50], [50, 51], [51, 52], [52, 53], [53, 54],
-        [54, 55], [55, 56], [56, 57], [57, 58], [58, 59], [59, 48],
-        [60, 61], [61, 62], [62, 63], [63, 64], [64, 65], [65, 66],
-        [66, 67], [67, 60]
-    ],
-}
-
-
-class Face(object):
-    """
-    The OpenPose face landmark detector model.
-
-    Args:
-        inference_size: set the size of the inference image size, suggested:
-            368, 736, 1312, default 736
-        gaussian_sigma: blur the heatmaps, default 2.5
-        heatmap_peak_thresh: return landmark if over threshold, default 0.1
-
-    """
-    def __init__(self, face_model_path,
-                 inference_size=None,
-                 gaussian_sigma=None,
-                 heatmap_peak_thresh=None):
-        self.inference_size = inference_size or params["inference_img_size"]
-        self.sigma = gaussian_sigma or params['gaussian_sigma']
-        self.threshold = heatmap_peak_thresh or params["heatmap_peak_thresh"]
-        self.model = FaceNet()
-        self.model.load_state_dict(torch.load(face_model_path))
-        self.model.eval()
-
-    def to(self, device):
-        self.model.to(device)
-        return self
-
-    def __call__(self, face_img):
-        device = next(iter(self.model.parameters())).device
-        H, W, C = face_img.shape
-
-        w_size = 384
-        x_data = torch.from_numpy(util.smart_resize(face_img, (w_size, w_size))).permute([2, 0, 1]) / 256.0 - 0.5
-
-        x_data = x_data.to(device)
-
-        with torch.no_grad():
-            hs = self.model(x_data[None, ...])
-            heatmaps = F.interpolate(
-                hs[-1],
-                (H, W),
-                mode='bilinear', align_corners=True).cpu().numpy()[0]
-        return heatmaps
-
-    def compute_peaks_from_heatmaps(self, heatmaps):
-        all_peaks = []
-        for part in range(heatmaps.shape[0]):
-            map_ori = heatmaps[part].copy()
-            binary = np.ascontiguousarray(map_ori > 0.05, dtype=np.uint8)
-
-            if np.sum(binary) == 0:
-                continue
-
-            positions = np.where(binary > 0.5)
-            intensities = map_ori[positions]
-            mi = np.argmax(intensities)
-            y, x = positions[0][mi], positions[1][mi]
-            all_peaks.append([x, y])
-
-        return np.array(all_peaks)

controlnet_aux/src/controlnet_aux/open_pose/hand.py

@@ -1,90 +0,0 @@
-import cv2
-import numpy as np
-import torch
-from scipy.ndimage.filters import gaussian_filter
-from skimage.measure import label
-
-from . import util
-from .model import handpose_model
-
-
-class Hand(object):
-    def __init__(self, model_path):
-        self.model = handpose_model()
-        model_dict = util.transfer(self.model, torch.load(model_path))
-        self.model.load_state_dict(model_dict)
-        self.model.eval()
-
-    def to(self, device):
-        self.model.to(device)
-        return self
-
-    def __call__(self, oriImgRaw):
-        device = next(iter(self.model.parameters())).device
-        scale_search = [0.5, 1.0, 1.5, 2.0]
-        # scale_search = [0.5]
-        boxsize = 368
-        stride = 8
-        padValue = 128
-        thre = 0.05
-        multiplier = [x * boxsize for x in scale_search]
-
-        wsize = 128
-        heatmap_avg = np.zeros((wsize, wsize, 22))
-
-        Hr, Wr, Cr = oriImgRaw.shape
-
-        oriImg = cv2.GaussianBlur(oriImgRaw, (0, 0), 0.8)
-
-        for m in range(len(multiplier)):
-            scale = multiplier[m]
-            imageToTest = util.smart_resize(oriImg, (scale, scale))
-
-            imageToTest_padded, pad = util.padRightDownCorner(imageToTest, stride, padValue)
-            im = np.transpose(np.float32(imageToTest_padded[:, :, :, np.newaxis]), (3, 2, 0, 1)) / 256 - 0.5
-            im = np.ascontiguousarray(im)
-
-            data = torch.from_numpy(im).float()
-            data = data.to(device)
-
-            with torch.no_grad():
-                output = self.model(data).cpu().numpy()
-
-            # extract outputs, resize, and remove padding
-            heatmap = np.transpose(np.squeeze(output), (1, 2, 0))  # output 1 is heatmaps
-            heatmap = util.smart_resize_k(heatmap, fx=stride, fy=stride)
-            heatmap = heatmap[:imageToTest_padded.shape[0] - pad[2], :imageToTest_padded.shape[1] - pad[3], :]
-            heatmap = util.smart_resize(heatmap, (wsize, wsize))
-
-            heatmap_avg += heatmap / len(multiplier)
-
-        all_peaks = []
-        for part in range(21):
-            map_ori = heatmap_avg[:, :, part]
-            one_heatmap = gaussian_filter(map_ori, sigma=3)
-            binary = np.ascontiguousarray(one_heatmap > thre, dtype=np.uint8)
-
-            if np.sum(binary) == 0:
-                all_peaks.append([0, 0])
-                continue
-            label_img, label_numbers = label(binary, return_num=True, connectivity=binary.ndim)
-            max_index = np.argmax([np.sum(map_ori[label_img == i]) for i in range(1, label_numbers + 1)]) + 1
-            label_img[label_img != max_index] = 0
-            map_ori[label_img == 0] = 0
-
-            y, x = util.npmax(map_ori)
-            y = int(float(y) * float(Hr) / float(wsize))
-            x = int(float(x) * float(Wr) / float(wsize))
-            all_peaks.append([x, y])
-        return np.array(all_peaks)
-
-if __name__ == "__main__":
-    hand_estimation = Hand('../model/hand_pose_model.pth')
-
-    # test_image = '../images/hand.jpg'
-    test_image = '../images/hand.jpg'
-    oriImg = cv2.imread(test_image)  # B,G,R order
-    peaks = hand_estimation(oriImg)
-    canvas = util.draw_handpose(oriImg, peaks, True)
-    cv2.imshow('', canvas)
-    cv2.waitKey(0)

controlnet_aux/src/controlnet_aux/open_pose/model.py

@@ -1,217 +0,0 @@
-import torch
-from collections import OrderedDict
-
-import torch
-import torch.nn as nn
-
-def make_layers(block, no_relu_layers):
-    layers = []
-    for layer_name, v in block.items():
-        if 'pool' in layer_name:
-            layer = nn.MaxPool2d(kernel_size=v[0], stride=v[1],
-                                    padding=v[2])
-            layers.append((layer_name, layer))
-        else:
-            conv2d = nn.Conv2d(in_channels=v[0], out_channels=v[1],
-                               kernel_size=v[2], stride=v[3],
-                               padding=v[4])
-            layers.append((layer_name, conv2d))
-            if layer_name not in no_relu_layers:
-                layers.append(('relu_'+layer_name, nn.ReLU(inplace=True)))
-
-    return nn.Sequential(OrderedDict(layers))
-
-class bodypose_model(nn.Module):
-    def __init__(self):
-        super(bodypose_model, self).__init__()
-
-        # these layers have no relu layer
-        no_relu_layers = ['conv5_5_CPM_L1', 'conv5_5_CPM_L2', 'Mconv7_stage2_L1',\
-                          'Mconv7_stage2_L2', 'Mconv7_stage3_L1', 'Mconv7_stage3_L2',\
-                          'Mconv7_stage4_L1', 'Mconv7_stage4_L2', 'Mconv7_stage5_L1',\
-                          'Mconv7_stage5_L2', 'Mconv7_stage6_L1', 'Mconv7_stage6_L1']
-        blocks = {}
-        block0 = OrderedDict([
-                      ('conv1_1', [3, 64, 3, 1, 1]),
-                      ('conv1_2', [64, 64, 3, 1, 1]),
-                      ('pool1_stage1', [2, 2, 0]),
-                      ('conv2_1', [64, 128, 3, 1, 1]),
-                      ('conv2_2', [128, 128, 3, 1, 1]),
-                      ('pool2_stage1', [2, 2, 0]),
-                      ('conv3_1', [128, 256, 3, 1, 1]),
-                      ('conv3_2', [256, 256, 3, 1, 1]),
-                      ('conv3_3', [256, 256, 3, 1, 1]),
-                      ('conv3_4', [256, 256, 3, 1, 1]),
-                      ('pool3_stage1', [2, 2, 0]),
-                      ('conv4_1', [256, 512, 3, 1, 1]),
-                      ('conv4_2', [512, 512, 3, 1, 1]),
-                      ('conv4_3_CPM', [512, 256, 3, 1, 1]),
-                      ('conv4_4_CPM', [256, 128, 3, 1, 1])
-                  ])
-
-
-        # Stage 1
-        block1_1 = OrderedDict([
-                        ('conv5_1_CPM_L1', [128, 128, 3, 1, 1]),
-                        ('conv5_2_CPM_L1', [128, 128, 3, 1, 1]),
-                        ('conv5_3_CPM_L1', [128, 128, 3, 1, 1]),
-                        ('conv5_4_CPM_L1', [128, 512, 1, 1, 0]),
-                        ('conv5_5_CPM_L1', [512, 38, 1, 1, 0])
-                    ])
-
-        block1_2 = OrderedDict([
-                        ('conv5_1_CPM_L2', [128, 128, 3, 1, 1]),
-                        ('conv5_2_CPM_L2', [128, 128, 3, 1, 1]),
-                        ('conv5_3_CPM_L2', [128, 128, 3, 1, 1]),
-                        ('conv5_4_CPM_L2', [128, 512, 1, 1, 0]),
-                        ('conv5_5_CPM_L2', [512, 19, 1, 1, 0])
-                    ])
-        blocks['block1_1'] = block1_1
-        blocks['block1_2'] = block1_2
-
-        self.model0 = make_layers(block0, no_relu_layers)
-
-        # Stages 2 - 6
-        for i in range(2, 7):
-            blocks['block%d_1' % i] = OrderedDict([
-                    ('Mconv1_stage%d_L1' % i, [185, 128, 7, 1, 3]),
-                    ('Mconv2_stage%d_L1' % i, [128, 128, 7, 1, 3]),
-                    ('Mconv3_stage%d_L1' % i, [128, 128, 7, 1, 3]),
-                    ('Mconv4_stage%d_L1' % i, [128, 128, 7, 1, 3]),
-                    ('Mconv5_stage%d_L1' % i, [128, 128, 7, 1, 3]),
-                    ('Mconv6_stage%d_L1' % i, [128, 128, 1, 1, 0]),
-                    ('Mconv7_stage%d_L1' % i, [128, 38, 1, 1, 0])
-                ])
-
-            blocks['block%d_2' % i] = OrderedDict([
-                    ('Mconv1_stage%d_L2' % i, [185, 128, 7, 1, 3]),
-                    ('Mconv2_stage%d_L2' % i, [128, 128, 7, 1, 3]),
-                    ('Mconv3_stage%d_L2' % i, [128, 128, 7, 1, 3]),
-                    ('Mconv4_stage%d_L2' % i, [128, 128, 7, 1, 3]),
-                    ('Mconv5_stage%d_L2' % i, [128, 128, 7, 1, 3]),
-                    ('Mconv6_stage%d_L2' % i, [128, 128, 1, 1, 0]),
-                    ('Mconv7_stage%d_L2' % i, [128, 19, 1, 1, 0])
-                ])
-
-        for k in blocks.keys():
-            blocks[k] = make_layers(blocks[k], no_relu_layers)
-
-        self.model1_1 = blocks['block1_1']
-        self.model2_1 = blocks['block2_1']
-        self.model3_1 = blocks['block3_1']
-        self.model4_1 = blocks['block4_1']
-        self.model5_1 = blocks['block5_1']
-        self.model6_1 = blocks['block6_1']
-
-        self.model1_2 = blocks['block1_2']
-        self.model2_2 = blocks['block2_2']
-        self.model3_2 = blocks['block3_2']
-        self.model4_2 = blocks['block4_2']
-        self.model5_2 = blocks['block5_2']
-        self.model6_2 = blocks['block6_2']
-
-
-    def forward(self, x):
-
-        out1 = self.model0(x)
-
-        out1_1 = self.model1_1(out1)
-        out1_2 = self.model1_2(out1)
-        out2 = torch.cat([out1_1, out1_2, out1], 1)
-
-        out2_1 = self.model2_1(out2)
-        out2_2 = self.model2_2(out2)
-        out3 = torch.cat([out2_1, out2_2, out1], 1)
-
-        out3_1 = self.model3_1(out3)
-        out3_2 = self.model3_2(out3)
-        out4 = torch.cat([out3_1, out3_2, out1], 1)
-
-        out4_1 = self.model4_1(out4)
-        out4_2 = self.model4_2(out4)
-        out5 = torch.cat([out4_1, out4_2, out1], 1)
-
-        out5_1 = self.model5_1(out5)
-        out5_2 = self.model5_2(out5)
-        out6 = torch.cat([out5_1, out5_2, out1], 1)
-
-        out6_1 = self.model6_1(out6)
-        out6_2 = self.model6_2(out6)
-
-        return out6_1, out6_2
-
-class handpose_model(nn.Module):
-    def __init__(self):
-        super(handpose_model, self).__init__()
-
-        # these layers have no relu layer
-        no_relu_layers = ['conv6_2_CPM', 'Mconv7_stage2', 'Mconv7_stage3',\
-                          'Mconv7_stage4', 'Mconv7_stage5', 'Mconv7_stage6']
-        # stage 1
-        block1_0 = OrderedDict([
-                ('conv1_1', [3, 64, 3, 1, 1]),
-                ('conv1_2', [64, 64, 3, 1, 1]),
-                ('pool1_stage1', [2, 2, 0]),
-                ('conv2_1', [64, 128, 3, 1, 1]),
-                ('conv2_2', [128, 128, 3, 1, 1]),
-                ('pool2_stage1', [2, 2, 0]),
-                ('conv3_1', [128, 256, 3, 1, 1]),
-                ('conv3_2', [256, 256, 3, 1, 1]),
-                ('conv3_3', [256, 256, 3, 1, 1]),
-                ('conv3_4', [256, 256, 3, 1, 1]),
-                ('pool3_stage1', [2, 2, 0]),
-                ('conv4_1', [256, 512, 3, 1, 1]),
-                ('conv4_2', [512, 512, 3, 1, 1]),
-                ('conv4_3', [512, 512, 3, 1, 1]),
-                ('conv4_4', [512, 512, 3, 1, 1]),
-                ('conv5_1', [512, 512, 3, 1, 1]),
-                ('conv5_2', [512, 512, 3, 1, 1]),
-                ('conv5_3_CPM', [512, 128, 3, 1, 1])
-            ])
-
-        block1_1 = OrderedDict([
-            ('conv6_1_CPM', [128, 512, 1, 1, 0]),
-            ('conv6_2_CPM', [512, 22, 1, 1, 0])
-        ])
-
-        blocks = {}
-        blocks['block1_0'] = block1_0
-        blocks['block1_1'] = block1_1
-
-        # stage 2-6
-        for i in range(2, 7):
-            blocks['block%d' % i] = OrderedDict([
-                    ('Mconv1_stage%d' % i, [150, 128, 7, 1, 3]),
-                    ('Mconv2_stage%d' % i, [128, 128, 7, 1, 3]),
-                    ('Mconv3_stage%d' % i, [128, 128, 7, 1, 3]),
-                    ('Mconv4_stage%d' % i, [128, 128, 7, 1, 3]),
-                    ('Mconv5_stage%d' % i, [128, 128, 7, 1, 3]),
-                    ('Mconv6_stage%d' % i, [128, 128, 1, 1, 0]),
-                    ('Mconv7_stage%d' % i, [128, 22, 1, 1, 0])
-                ])
-
-        for k in blocks.keys():
-            blocks[k] = make_layers(blocks[k], no_relu_layers)
-
-        self.model1_0 = blocks['block1_0']
-        self.model1_1 = blocks['block1_1']
-        self.model2 = blocks['block2']
-        self.model3 = blocks['block3']
-        self.model4 = blocks['block4']
-        self.model5 = blocks['block5']
-        self.model6 = blocks['block6']
-
-    def forward(self, x):
-        out1_0 = self.model1_0(x)
-        out1_1 = self.model1_1(out1_0)
-        concat_stage2 = torch.cat([out1_1, out1_0], 1)
-        out_stage2 = self.model2(concat_stage2)
-        concat_stage3 = torch.cat([out_stage2, out1_0], 1)
-        out_stage3 = self.model3(concat_stage3)
-        concat_stage4 = torch.cat([out_stage3, out1_0], 1)
-        out_stage4 = self.model4(concat_stage4)
-        concat_stage5 = torch.cat([out_stage4, out1_0], 1)
-        out_stage5 = self.model5(concat_stage5)
-        concat_stage6 = torch.cat([out_stage5, out1_0], 1)
-        out_stage6 = self.model6(concat_stage6)
-        return out_stage6

controlnet_aux/src/controlnet_aux/open_pose/util.py

@@ -1,383 +0,0 @@
-import math
-import numpy as np
-import cv2
-from typing import List, Tuple, Union
-
-from .body import BodyResult, Keypoint
-
-eps = 0.01
-
-
-def smart_resize(x, s):
-    Ht, Wt = s
-    if x.ndim == 2:
-        Ho, Wo = x.shape
-        Co = 1
-    else:
-        Ho, Wo, Co = x.shape
-    if Co == 3 or Co == 1:
-        k = float(Ht + Wt) / float(Ho + Wo)
-        return cv2.resize(x, (int(Wt), int(Ht)), interpolation=cv2.INTER_AREA if k < 1 else cv2.INTER_LANCZOS4)
-    else:
-        return np.stack([smart_resize(x[:, :, i], s) for i in range(Co)], axis=2)
-
-
-def smart_resize_k(x, fx, fy):
-    if x.ndim == 2:
-        Ho, Wo = x.shape
-        Co = 1
-    else:
-        Ho, Wo, Co = x.shape
-    Ht, Wt = Ho * fy, Wo * fx
-    if Co == 3 or Co == 1:
-        k = float(Ht + Wt) / float(Ho + Wo)
-        return cv2.resize(x, (int(Wt), int(Ht)), interpolation=cv2.INTER_AREA if k < 1 else cv2.INTER_LANCZOS4)
-    else:
-        return np.stack([smart_resize_k(x[:, :, i], fx, fy) for i in range(Co)], axis=2)
-
-
-def padRightDownCorner(img, stride, padValue):
-    h = img.shape[0]
-    w = img.shape[1]
-
-    pad = 4 * [None]
-    pad[0] = 0 # up
-    pad[1] = 0 # left
-    pad[2] = 0 if (h % stride == 0) else stride - (h % stride) # down
-    pad[3] = 0 if (w % stride == 0) else stride - (w % stride) # right
-
-    img_padded = img
-    pad_up = np.tile(img_padded[0:1, :, :]*0 + padValue, (pad[0], 1, 1))
-    img_padded = np.concatenate((pad_up, img_padded), axis=0)
-    pad_left = np.tile(img_padded[:, 0:1, :]*0 + padValue, (1, pad[1], 1))
-    img_padded = np.concatenate((pad_left, img_padded), axis=1)
-    pad_down = np.tile(img_padded[-2:-1, :, :]*0 + padValue, (pad[2], 1, 1))
-    img_padded = np.concatenate((img_padded, pad_down), axis=0)
-    pad_right = np.tile(img_padded[:, -2:-1, :]*0 + padValue, (1, pad[3], 1))
-    img_padded = np.concatenate((img_padded, pad_right), axis=1)
-
-    return img_padded, pad
-
-
-def transfer(model, model_weights):
-    transfered_model_weights = {}
-    for weights_name in model.state_dict().keys():
-        transfered_model_weights[weights_name] = model_weights['.'.join(weights_name.split('.')[1:])]
-    return transfered_model_weights
-
-
-def draw_bodypose(canvas: np.ndarray, keypoints: List[Keypoint]) -> np.ndarray:
-    """
-    Draw keypoints and limbs representing body pose on a given canvas.
-
-    Args:
-        canvas (np.ndarray): A 3D numpy array representing the canvas (image) on which to draw the body pose.
-        keypoints (List[Keypoint]): A list of Keypoint objects representing the body keypoints to be drawn.
-
-    Returns:
-        np.ndarray: A 3D numpy array representing the modified canvas with the drawn body pose.
-
-    Note:
-        The function expects the x and y coordinates of the keypoints to be normalized between 0 and 1.
-    """
-    H, W, C = canvas.shape
-    stickwidth = 4
-
-    limbSeq = [
-        [2, 3], [2, 6], [3, 4], [4, 5], 
-        [6, 7], [7, 8], [2, 9], [9, 10], 
-        [10, 11], [2, 12], [12, 13], [13, 14], 
-        [2, 1], [1, 15], [15, 17], [1, 16], 
-        [16, 18],
-    ]
-
-    colors = [[255, 0, 0], [255, 85, 0], [255, 170, 0], [255, 255, 0], [170, 255, 0], [85, 255, 0], [0, 255, 0], \
-              [0, 255, 85], [0, 255, 170], [0, 255, 255], [0, 170, 255], [0, 85, 255], [0, 0, 255], [85, 0, 255], \
-              [170, 0, 255], [255, 0, 255], [255, 0, 170], [255, 0, 85]]
-
-    for (k1_index, k2_index), color in zip(limbSeq, colors):
-        keypoint1 = keypoints[k1_index - 1]
-        keypoint2 = keypoints[k2_index - 1]
-
-        if keypoint1 is None or keypoint2 is None:
-            continue
-
-        Y = np.array([keypoint1.x, keypoint2.x]) * float(W)
-        X = np.array([keypoint1.y, keypoint2.y]) * float(H)
-        mX = np.mean(X)
-        mY = np.mean(Y)
-        length = ((X[0] - X[1]) ** 2 + (Y[0] - Y[1]) ** 2) ** 0.5
-        angle = math.degrees(math.atan2(X[0] - X[1], Y[0] - Y[1]))
-        polygon = cv2.ellipse2Poly((int(mY), int(mX)), (int(length / 2), stickwidth), int(angle), 0, 360, 1)
-        cv2.fillConvexPoly(canvas, polygon, [int(float(c) * 0.6) for c in color])
-
-    for keypoint, color in zip(keypoints, colors):
-        if keypoint is None:
-            continue
-
-        x, y = keypoint.x, keypoint.y
-        x = int(x * W)
-        y = int(y * H)
-        cv2.circle(canvas, (int(x), int(y)), 4, color, thickness=-1)
-
-    return canvas
-
-
-def draw_handpose(canvas: np.ndarray, keypoints: Union[List[Keypoint], None]) -> np.ndarray:
-    import matplotlib
-    """
-    Draw keypoints and connections representing hand pose on a given canvas.
-
-    Args:
-        canvas (np.ndarray): A 3D numpy array representing the canvas (image) on which to draw the hand pose.
-        keypoints (List[Keypoint]| None): A list of Keypoint objects representing the hand keypoints to be drawn
-                                          or None if no keypoints are present.
-
-    Returns:
-        np.ndarray: A 3D numpy array representing the modified canvas with the drawn hand pose.
-
-    Note:
-        The function expects the x and y coordinates of the keypoints to be normalized between 0 and 1.
-    """
-    if not keypoints:
-        return canvas
-    
-    H, W, C = canvas.shape
-
-    edges = [[0, 1], [1, 2], [2, 3], [3, 4], [0, 5], [5, 6], [6, 7], [7, 8], [0, 9], [9, 10], \
-             [10, 11], [11, 12], [0, 13], [13, 14], [14, 15], [15, 16], [0, 17], [17, 18], [18, 19], [19, 20]]
-
-    for ie, (e1, e2) in enumerate(edges):
-        k1 = keypoints[e1]
-        k2 = keypoints[e2]
-        if k1 is None or k2 is None:
-            continue
-        
-        x1 = int(k1.x * W)
-        y1 = int(k1.y * H)
-        x2 = int(k2.x * W)
-        y2 = int(k2.y * H)
-        if x1 > eps and y1 > eps and x2 > eps and y2 > eps:
-            cv2.line(canvas, (x1, y1), (x2, y2), matplotlib.colors.hsv_to_rgb([ie / float(len(edges)), 1.0, 1.0]) * 255, thickness=2)
-
-    for keypoint in keypoints:
-        x, y = keypoint.x, keypoint.y
-        x = int(x * W)
-        y = int(y * H)
-        if x > eps and y > eps:
-            cv2.circle(canvas, (x, y), 4, (0, 0, 255), thickness=-1)
-    return canvas
-
-
-def draw_facepose(canvas: np.ndarray, keypoints: Union[List[Keypoint], None]) -> np.ndarray:
-    """
-    Draw keypoints representing face pose on a given canvas.
-
-    Args:
-        canvas (np.ndarray): A 3D numpy array representing the canvas (image) on which to draw the face pose.
-        keypoints (List[Keypoint]| None): A list of Keypoint objects representing the face keypoints to be drawn
-                                          or None if no keypoints are present.
-
-    Returns:
-        np.ndarray: A 3D numpy array representing the modified canvas with the drawn face pose.
-
-    Note:
-        The function expects the x and y coordinates of the keypoints to be normalized between 0 and 1.
-    """    
-    if not keypoints:
-        return canvas
-    
-    H, W, C = canvas.shape
-    for keypoint in keypoints:
-        x, y = keypoint.x, keypoint.y
-        x = int(x * W)
-        y = int(y * H)
-        if x > eps and y > eps:
-            cv2.circle(canvas, (x, y), 3, (255, 255, 255), thickness=-1)
-    return canvas
-
-
-# detect hand according to body pose keypoints
-# please refer to https://github.com/CMU-Perceptual-Computing-Lab/openpose/blob/master/src/openpose/hand/handDetector.cpp
-def handDetect(body: BodyResult, oriImg) -> List[Tuple[int, int, int, bool]]:
-    """
-    Detect hands in the input body pose keypoints and calculate the bounding box for each hand.
-
-    Args:
-        body (BodyResult): A BodyResult object containing the detected body pose keypoints.
-        oriImg (numpy.ndarray): A 3D numpy array representing the original input image.
-
-    Returns:
-        List[Tuple[int, int, int, bool]]: A list of tuples, each containing the coordinates (x, y) of the top-left
-                                          corner of the bounding box, the width (height) of the bounding box, and
-                                          a boolean flag indicating whether the hand is a left hand (True) or a
-                                          right hand (False).
-
-    Notes:
-        - The width and height of the bounding boxes are equal since the network requires squared input.
-        - The minimum bounding box size is 20 pixels.
-    """
-    ratioWristElbow = 0.33
-    detect_result = []
-    image_height, image_width = oriImg.shape[0:2]
-    
-    keypoints = body.keypoints
-    # right hand: wrist 4, elbow 3, shoulder 2
-    # left hand: wrist 7, elbow 6, shoulder 5
-    left_shoulder = keypoints[5]
-    left_elbow = keypoints[6]
-    left_wrist = keypoints[7]
-    right_shoulder = keypoints[2]
-    right_elbow = keypoints[3]
-    right_wrist = keypoints[4]
-
-    # if any of three not detected
-    has_left = all(keypoint is not None for keypoint in (left_shoulder, left_elbow, left_wrist))
-    has_right = all(keypoint is not None for keypoint in (right_shoulder, right_elbow, right_wrist))
-    if not (has_left or has_right):
-        return []
-    
-    hands = []
-    #left hand
-    if has_left:
-        hands.append([
-            left_shoulder.x, left_shoulder.y,
-            left_elbow.x, left_elbow.y,
-            left_wrist.x, left_wrist.y,
-            True
-        ])
-    # right hand
-    if has_right:
-        hands.append([
-            right_shoulder.x, right_shoulder.y,
-            right_elbow.x, right_elbow.y,
-            right_wrist.x, right_wrist.y,
-            False
-        ])
-
-    for x1, y1, x2, y2, x3, y3, is_left in hands:
-        # pos_hand = pos_wrist + ratio * (pos_wrist - pos_elbox) = (1 + ratio) * pos_wrist - ratio * pos_elbox
-        # handRectangle.x = posePtr[wrist*3] + ratioWristElbow * (posePtr[wrist*3] - posePtr[elbow*3]);
-        # handRectangle.y = posePtr[wrist*3+1] + ratioWristElbow * (posePtr[wrist*3+1] - posePtr[elbow*3+1]);
-        # const auto distanceWristElbow = getDistance(poseKeypoints, person, wrist, elbow);
-        # const auto distanceElbowShoulder = getDistance(poseKeypoints, person, elbow, shoulder);
-        # handRectangle.width = 1.5f * fastMax(distanceWristElbow, 0.9f * distanceElbowShoulder);
-        x = x3 + ratioWristElbow * (x3 - x2)
-        y = y3 + ratioWristElbow * (y3 - y2)
-        distanceWristElbow = math.sqrt((x3 - x2) ** 2 + (y3 - y2) ** 2)
-        distanceElbowShoulder = math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
-        width = 1.5 * max(distanceWristElbow, 0.9 * distanceElbowShoulder)
-        # x-y refers to the center --> offset to topLeft point
-        # handRectangle.x -= handRectangle.width / 2.f;
-        # handRectangle.y -= handRectangle.height / 2.f;
-        x -= width / 2
-        y -= width / 2  # width = height
-        # overflow the image
-        if x < 0: x = 0
-        if y < 0: y = 0
-        width1 = width
-        width2 = width
-        if x + width > image_width: width1 = image_width - x
-        if y + width > image_height: width2 = image_height - y
-        width = min(width1, width2)
-        # the max hand box value is 20 pixels
-        if width >= 20:
-            detect_result.append((int(x), int(y), int(width), is_left))
-
-    '''
-    return value: [[x, y, w, True if left hand else False]].
-    width=height since the network require squared input.
-    x, y is the coordinate of top left 
-    '''
-    return detect_result
-
-
-# Written by Lvmin
-def faceDetect(body: BodyResult, oriImg) -> Union[Tuple[int, int, int], None]:
-    """
-    Detect the face in the input body pose keypoints and calculate the bounding box for the face.
-
-    Args:
-        body (BodyResult): A BodyResult object containing the detected body pose keypoints.
-        oriImg (numpy.ndarray): A 3D numpy array representing the original input image.
-
-    Returns:
-        Tuple[int, int, int] | None: A tuple containing the coordinates (x, y) of the top-left corner of the
-                                   bounding box and the width (height) of the bounding box, or None if the
-                                   face is not detected or the bounding box width is less than 20 pixels.
-
-    Notes:
-        - The width and height of the bounding box are equal.
-        - The minimum bounding box size is 20 pixels.
-    """
-    # left right eye ear 14 15 16 17
-    image_height, image_width = oriImg.shape[0:2]
-    
-    keypoints = body.keypoints
-    head = keypoints[0]
-    left_eye = keypoints[14]
-    right_eye = keypoints[15]
-    left_ear = keypoints[16]
-    right_ear = keypoints[17]
-    
-    if head is None or all(keypoint is None for keypoint in (left_eye, right_eye, left_ear, right_ear)):
-        return None
-
-    width = 0.0
-    x0, y0 = head.x, head.y
-
-    if left_eye is not None:
-        x1, y1 = left_eye.x, left_eye.y
-        d = max(abs(x0 - x1), abs(y0 - y1))
-        width = max(width, d * 3.0)
-
-    if right_eye is not None:
-        x1, y1 = right_eye.x, right_eye.y
-        d = max(abs(x0 - x1), abs(y0 - y1))
-        width = max(width, d * 3.0)
-
-    if left_ear is not None:
-        x1, y1 = left_ear.x, left_ear.y
-        d = max(abs(x0 - x1), abs(y0 - y1))
-        width = max(width, d * 1.5)
-
-    if right_ear is not None:
-        x1, y1 = right_ear.x, right_ear.y
-        d = max(abs(x0 - x1), abs(y0 - y1))
-        width = max(width, d * 1.5)
-
-    x, y = x0, y0
-
-    x -= width
-    y -= width
-
-    if x < 0:
-        x = 0
-
-    if y < 0:
-        y = 0
-
-    width1 = width * 2
-    width2 = width * 2
-
-    if x + width > image_width:
-        width1 = image_width - x
-
-    if y + width > image_height:
-        width2 = image_height - y
-
-    width = min(width1, width2)
-
-    if width >= 20:
-        return int(x), int(y), int(width)
-    else:
-        return None
-
-
-# get max index of 2d array
-def npmax(array):
-    arrayindex = array.argmax(1)
-    arrayvalue = array.max(1)
-    i = arrayvalue.argmax()
-    j = arrayindex[i]
-    return i, j

controlnet_aux/src/controlnet_aux/util.py

@@ -1,146 +0,0 @@
-import os
-import random
-
-import cv2
-import numpy as np
-import torch
-
-annotator_ckpts_path = os.path.join(os.path.dirname(__file__), 'ckpts')
-
-
-def HWC3(x):
-    assert x.dtype == np.uint8
-    if x.ndim == 2:
-        x = x[:, :, None]
-    assert x.ndim == 3
-    H, W, C = x.shape
-    assert C == 1 or C == 3 or C == 4
-    if C == 3:
-        return x
-    if C == 1:
-        return np.concatenate([x, x, x], axis=2)
-    if C == 4:
-        color = x[:, :, 0:3].astype(np.float32)
-        alpha = x[:, :, 3:4].astype(np.float32) / 255.0
-        y = color * alpha + 255.0 * (1.0 - alpha)
-        y = y.clip(0, 255).astype(np.uint8)
-        return y
-
-
-def make_noise_disk(H, W, C, F):
-    noise = np.random.uniform(low=0, high=1, size=((H // F) + 2, (W // F) + 2, C))
-    noise = cv2.resize(noise, (W + 2 * F, H + 2 * F), interpolation=cv2.INTER_CUBIC)
-    noise = noise[F: F + H, F: F + W]
-    noise -= np.min(noise)
-    noise /= np.max(noise)
-    if C == 1:
-        noise = noise[:, :, None]
-    return noise
-
-
-def nms(x, t, s):
-    x = cv2.GaussianBlur(x.astype(np.float32), (0, 0), s)
-
-    f1 = np.array([[0, 0, 0], [1, 1, 1], [0, 0, 0]], dtype=np.uint8)
-    f2 = np.array([[0, 1, 0], [0, 1, 0], [0, 1, 0]], dtype=np.uint8)
-    f3 = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]], dtype=np.uint8)
-    f4 = np.array([[0, 0, 1], [0, 1, 0], [1, 0, 0]], dtype=np.uint8)
-
-    y = np.zeros_like(x)
-
-    for f in [f1, f2, f3, f4]:
-        np.putmask(y, cv2.dilate(x, kernel=f) == x, x)
-
-    z = np.zeros_like(y, dtype=np.uint8)
-    z[y > t] = 255
-    return z
-
-def min_max_norm(x):
-    x -= np.min(x)
-    x /= np.maximum(np.max(x), 1e-5)
-    return x
-
-
-def safe_step(x, step=2):
-    y = x.astype(np.float32) * float(step + 1)
-    y = y.astype(np.int32).astype(np.float32) / float(step)
-    return y
-
-
-def img2mask(img, H, W, low=10, high=90):
-    assert img.ndim == 3 or img.ndim == 2
-    assert img.dtype == np.uint8
-
-    if img.ndim == 3:
-        y = img[:, :, random.randrange(0, img.shape[2])]
-    else:
-        y = img
-
-    y = cv2.resize(y, (W, H), interpolation=cv2.INTER_CUBIC)
-
-    if random.uniform(0, 1) < 0.5:
-        y = 255 - y
-
-    return y < np.percentile(y, random.randrange(low, high))
-
-
-def resize_image(input_image, resolution):
-    H, W, C = input_image.shape
-    H = float(H)
-    W = float(W)
-    k = float(resolution) / min(H, W)
-    H *= k
-    W *= k
-    H = int(np.round(H / 64.0)) * 64
-    W = int(np.round(W / 64.0)) * 64
-    img = cv2.resize(input_image, (W, H), interpolation=cv2.INTER_LANCZOS4 if k > 1 else cv2.INTER_AREA)
-    return img
-
-
-def torch_gc():
-    if torch.cuda.is_available():
-        torch.cuda.empty_cache()
-        torch.cuda.ipc_collect()
-
-
-def ade_palette():
-    """ADE20K palette that maps each class to RGB values."""
-    return [[120, 120, 120], [180, 120, 120], [6, 230, 230], [80, 50, 50],
-            [4, 200, 3], [120, 120, 80], [140, 140, 140], [204, 5, 255],
-            [230, 230, 230], [4, 250, 7], [224, 5, 255], [235, 255, 7],
-            [150, 5, 61], [120, 120, 70], [8, 255, 51], [255, 6, 82],
-            [143, 255, 140], [204, 255, 4], [255, 51, 7], [204, 70, 3],
-            [0, 102, 200], [61, 230, 250], [255, 6, 51], [11, 102, 255],
-            [255, 7, 71], [255, 9, 224], [9, 7, 230], [220, 220, 220],
-            [255, 9, 92], [112, 9, 255], [8, 255, 214], [7, 255, 224],
-            [255, 184, 6], [10, 255, 71], [255, 41, 10], [7, 255, 255],
-            [224, 255, 8], [102, 8, 255], [255, 61, 6], [255, 194, 7],
-            [255, 122, 8], [0, 255, 20], [255, 8, 41], [255, 5, 153],
-            [6, 51, 255], [235, 12, 255], [160, 150, 20], [0, 163, 255],
-            [140, 140, 140], [250, 10, 15], [20, 255, 0], [31, 255, 0],
-            [255, 31, 0], [255, 224, 0], [153, 255, 0], [0, 0, 255],
-            [255, 71, 0], [0, 235, 255], [0, 173, 255], [31, 0, 255],
-            [11, 200, 200], [255, 82, 0], [0, 255, 245], [0, 61, 255],
-            [0, 255, 112], [0, 255, 133], [255, 0, 0], [255, 163, 0],
-            [255, 102, 0], [194, 255, 0], [0, 143, 255], [51, 255, 0],
-            [0, 82, 255], [0, 255, 41], [0, 255, 173], [10, 0, 255],
-            [173, 255, 0], [0, 255, 153], [255, 92, 0], [255, 0, 255],
-            [255, 0, 245], [255, 0, 102], [255, 173, 0], [255, 0, 20],
-            [255, 184, 184], [0, 31, 255], [0, 255, 61], [0, 71, 255],
-            [255, 0, 204], [0, 255, 194], [0, 255, 82], [0, 10, 255],
-            [0, 112, 255], [51, 0, 255], [0, 194, 255], [0, 122, 255],
-            [0, 255, 163], [255, 153, 0], [0, 255, 10], [255, 112, 0],
-            [143, 255, 0], [82, 0, 255], [163, 255, 0], [255, 235, 0],
-            [8, 184, 170], [133, 0, 255], [0, 255, 92], [184, 0, 255],
-            [255, 0, 31], [0, 184, 255], [0, 214, 255], [255, 0, 112],
-            [92, 255, 0], [0, 224, 255], [112, 224, 255], [70, 184, 160],
-            [163, 0, 255], [153, 0, 255], [71, 255, 0], [255, 0, 163],
-            [255, 204, 0], [255, 0, 143], [0, 255, 235], [133, 255, 0],
-            [255, 0, 235], [245, 0, 255], [255, 0, 122], [255, 245, 0],
-            [10, 190, 212], [214, 255, 0], [0, 204, 255], [20, 0, 255],
-            [255, 255, 0], [0, 153, 255], [0, 41, 255], [0, 255, 204],
-            [41, 0, 255], [41, 255, 0], [173, 0, 255], [0, 245, 255],
-            [71, 0, 255], [122, 0, 255], [0, 255, 184], [0, 92, 255],
-            [184, 255, 0], [0, 133, 255], [255, 214, 0], [25, 194, 194],
-            [102, 255, 0], [92, 0, 255]]
-

controlnet_aux/tests/test_controlnet_aux.py

@@ -1,126 +0,0 @@
-import os
-import shutil
-from io import BytesIO
-
-import numpy as np
-import pytest
-import requests
-from PIL import Image
-
-from controlnet_aux import (CannyDetector, ContentShuffleDetector, HEDdetector,
-                            LeresDetector, LineartAnimeDetector,
-                            LineartDetector, MediapipeFaceDetector,
-                            MidasDetector, MLSDdetector, NormalBaeDetector,
-                            OpenposeDetector, PidiNetDetector, SamDetector,
-                            ZoeDetector, DWposeDetector)
-
-OUTPUT_DIR = "tests/outputs"
-
-def output(name, img):
-    img.save(os.path.join(OUTPUT_DIR, "{:s}.png".format(name)))
-
-def common(name, processor, img):
-    output(name, processor(img))
-    output(name + "_pil_np", Image.fromarray(processor(img, output_type="np")))
-    output(name + "_np_np", Image.fromarray(processor(np.array(img, dtype=np.uint8), output_type="np")))
-    output(name + "_np_pil", processor(np.array(img, dtype=np.uint8), output_type="pil"))
-    output(name + "_scaled", processor(img, detect_resolution=640, image_resolution=768))
-
-def return_pil(name, processor, img):
-    output(name + "_pil_false", Image.fromarray(processor(img, return_pil=False)))
-    output(name + "_pil_true", processor(img, return_pil=True))
-
-@pytest.fixture(scope="module")
-def img():
-    if os.path.exists(OUTPUT_DIR):
-        shutil.rmtree(OUTPUT_DIR)
-    os.mkdir(OUTPUT_DIR)
-    url = "https://huggingface.co/lllyasviel/sd-controlnet-openpose/resolve/main/images/pose.png"
-    response = requests.get(url)
-    img = Image.open(BytesIO(response.content)).convert("RGB").resize((512, 512))
-    return img
-
-def test_canny(img):
-    canny = CannyDetector()
-    common("canny", canny, img)
-    output("canny_img", canny(img=img))
-
-def test_hed(img):
-    hed = HEDdetector.from_pretrained("lllyasviel/Annotators")
-    common("hed", hed, img)
-    return_pil("hed", hed, img)
-    output("hed_safe", hed(img, safe=True))
-    output("hed_scribble", hed(img, scribble=True))
-
-def test_leres(img):
-    leres = LeresDetector.from_pretrained("lllyasviel/Annotators")
-    common("leres", leres, img)
-    output("leres_boost", leres(img, boost=True))
-
-def test_lineart(img):
-    lineart = LineartDetector.from_pretrained("lllyasviel/Annotators")
-    common("lineart", lineart, img)
-    return_pil("lineart", lineart, img)
-    output("lineart_coarse", lineart(img, coarse=True))
-
-def test_lineart_anime(img):
-    lineart_anime = LineartAnimeDetector.from_pretrained("lllyasviel/Annotators")
-    common("lineart_anime", lineart_anime, img)
-    return_pil("lineart_anime", lineart_anime, img)
-
-def test_mediapipe_face(img):
-    mediapipe = MediapipeFaceDetector()
-    common("mediapipe", mediapipe, img)
-    output("mediapipe_image", mediapipe(image=img))
-
-def test_midas(img):
-    midas = MidasDetector.from_pretrained("lllyasviel/Annotators")
-    common("midas", midas, img)
-    output("midas_normal", midas(img, depth_and_normal=True)[1])
-
-def test_mlsd(img):
-    mlsd = MLSDdetector.from_pretrained("lllyasviel/Annotators")
-    common("mlsd", mlsd, img)
-    return_pil("mlsd", mlsd, img)
-
-def test_normalbae(img):
-    normal_bae = NormalBaeDetector.from_pretrained("lllyasviel/Annotators")
-    common("normal_bae", normal_bae, img)
-    return_pil("normal_bae", normal_bae, img)
-
-def test_openpose(img):
-    openpose = OpenposeDetector.from_pretrained("lllyasviel/Annotators")
-    common("openpose", openpose, img)
-    return_pil("openpose", openpose, img)
-    output("openpose_hand_and_face_false", openpose(img, hand_and_face=False))
-    output("openpose_hand_and_face_true", openpose(img, hand_and_face=True))
-    output("openpose_face", openpose(img, include_body=True, include_hand=False, include_face=True))
-    output("openpose_faceonly", openpose(img, include_body=False, include_hand=False, include_face=True))
-    output("openpose_full", openpose(img, include_body=True, include_hand=True, include_face=True))
-    output("openpose_hand", openpose(img, include_body=True, include_hand=True, include_face=False))
-
-def test_pidi(img):
-    pidi = PidiNetDetector.from_pretrained("lllyasviel/Annotators")
-    common("pidi", pidi, img)
-    return_pil("pidi", pidi, img)
-    output("pidi_safe", pidi(img, safe=True))
-    output("pidi_scribble", pidi(img, scribble=True))
-
-def test_sam(img):
-    sam = SamDetector.from_pretrained("ybelkada/segment-anything", subfolder="checkpoints")
-    common("sam", sam, img)
-    output("sam_image", sam(image=img))
-
-def test_shuffle(img):
-    shuffle = ContentShuffleDetector()
-    common("shuffle", shuffle, img)
-    return_pil("shuffle", shuffle, img)
-
-def test_zoe(img):
-    zoe = ZoeDetector.from_pretrained("lllyasviel/Annotators")
-    common("zoe", zoe, img)
-
-def test_dwpose(img):
-    dwpose = DWposeDetector()
-    common("dwpose", dwpose, img)
-    return_pil("dwpose", dwpose, img)