Upload extensions using SD-Hub extension

.gitattributes

@@ -33,3 +33,147 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+extensions/advanced_euler_sampler_extension/img/xyz_grid-0000-114514.jpg filter=lfs diff=lfs merge=lfs -text
+extensions/artjiggler/thesaurus.jsonl filter=lfs diff=lfs merge=lfs -text
+extensions/canvas-zoom/dist/templates/frontend/assets/index-0c8f6dbd.js.map filter=lfs diff=lfs merge=lfs -text
+extensions/canvas-zoom/dist/v1_1_v1_5_1/templates/frontend/assets/index-2a280c06.js.map filter=lfs diff=lfs merge=lfs -text
+extensions/diffusion-noise-alternatives-webui/images/ColorGrade.png filter=lfs diff=lfs merge=lfs -text
+extensions/diffusion-noise-alternatives-webui/images/GrainCompare.png filter=lfs diff=lfs merge=lfs -text
+extensions/latent-upscale/assets/default.png filter=lfs diff=lfs merge=lfs -text
+extensions/latent-upscale/assets/img2img_latent_upscale_process.png filter=lfs diff=lfs merge=lfs -text
+extensions/latent-upscale/assets/nearest-exact-normal1.png filter=lfs diff=lfs merge=lfs -text
+extensions/latent-upscale/assets/nearest-exact-normal2.png filter=lfs diff=lfs merge=lfs -text
+extensions/latent-upscale/assets/nearest-exact-simple1.png filter=lfs diff=lfs merge=lfs -text
+extensions/latent-upscale/assets/nearest-exact-simple2.png filter=lfs diff=lfs merge=lfs -text
+extensions/latent-upscale/assets/nearest-exact-simple8.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd-canvas-editor/doc/images/overall.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd-canvas-editor/doc/images/panels.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd-canvas-editor/doc/images/photos.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd-civitai-browser-plus_fix/aria2/lin/aria2 filter=lfs diff=lfs merge=lfs -text
+extensions/sd-civitai-browser-plus_fix/aria2/win/aria2.exe filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-Lora-queue-helper/docs/output_sample.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-agentattention/samples/xyz_grid-2415-1-desk.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-agentattention/samples/xyz_grid-2417-1-goldfinch,[[:space:]]Carduelis[[:space:]]carduelis.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-agentattention/samples/xyz_grid-2418-1-bell[[:space:]]pepper.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-agentattention/samples/xyz_grid-2419-1-bicycle.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-agentattention/samples/xyz_grid-2428-1-desk.jpg filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-birefnet/sd-webui-birefnet.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-cads/samples/comparison.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-cads/samples/grid-7069.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-cads/samples/grid-7070.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-cardmaster/docked-detail-view.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-cardmaster/preview.gif filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-cardmaster/toma-chan[[:space:]]alt.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-cardmaster/toma-chan.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-cutoff/images/cover.jpg filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-cutoff/images/sample-1.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-cutoff/images/sample-2.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-cutoff/images/sample-3.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-cutoff/images/sample-4.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-cutoff/images/sample-4_small.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-cutoff/images/sample-5.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-cutoff/images/sample-5_small.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-diffusion-cg/examples/xl_off.jpg filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-diffusion-cg/examples/xl_on.jpg filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-ditail/assets/Intro-a.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-ditail/assets/Intro-b.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-ditail/assets/Intro-vertical.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-ditail/assets/Intro.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-dycfg/images/05.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-dycfg/images/09.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-fabric/static/example_2_default.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-fabric/static/example_2_feedback.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-fabric/static/example_3_10.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-fabric/static/example_3_feedback.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-fabric/static/fabric_demo.gif filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-image-comparison/tab.gif filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-img2txt/sd-webui-img2txt.gif filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-incantations/images/xyz_grid-0463-3.jpg filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-incantations/images/xyz_grid-0469-4.jpg filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-incantations/images/xyz_grid-2652-1419902843-cinematic[[:space:]]4K[[:space:]]photo[[:space:]]of[[:space:]]a[[:space:]]dog[[:space:]]riding[[:space:]]a[[:space:]]bus[[:space:]]and[[:space:]]eating[[:space:]]cake[[:space:]]and[[:space:]]wearing[[:space:]]headphones.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-incantations/images/xyz_grid-2660-1590472902-A[[:space:]]photo[[:space:]]of[[:space:]]a[[:space:]]lion[[:space:]]and[[:space:]]a[[:space:]]grizzly[[:space:]]bear[[:space:]]and[[:space:]]a[[:space:]]tiger[[:space:]]in[[:space:]]the[[:space:]]woods.jpg filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-incantations/images/xyz_grid-3040-1-a[[:space:]]puppy[[:space:]]and[[:space:]]a[[:space:]]kitten[[:space:]]on[[:space:]]the[[:space:]]moon.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-incantations/images/xyz_grid-3348-1590472902-A[[:space:]]photo[[:space:]]of[[:space:]]a[[:space:]]lion[[:space:]]and[[:space:]]a[[:space:]]grizzly[[:space:]]bear[[:space:]]and[[:space:]]a[[:space:]]tiger[[:space:]]in[[:space:]]the[[:space:]]woods.jpg filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-llul/images/llul_yuv420p.mp4 filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-llul/images/mask_effect.jpg filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-lora-masks/images/example.02.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-lora-masks/images/example.03.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-matview/images/sample1.jpg filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-panorama-tools/images/example_2.jpg filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-panorama-tools/images/example_3.jpg filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-panorama-tools/images/panorama_tools_ui_screenshot.jpg filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-picbatchwork/bin/ebsynth.dll filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-picbatchwork/bin/ebsynth.exe filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-picbatchwork/img/2.gif filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-pixelart/examples/custom_palette_demo.mp4 filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-samplers-scheduler/images/example2.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-samplers-scheduler/images/example3.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-semantic-guidance/samples/comparison.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-semantic-guidance/samples/enhance.jpg filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-smea/sample.jpg filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-smea/sample2.jpg filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-timemachine/images/tm_result.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-vectorscope-cc/samples/XYZ.jpg filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-xl_vec/images/crop_top.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-xl_vec/images/mult.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-xl_vec/images/original_size.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-xyz-addon/img/Extra-Network-Weight.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-xyz-addon/img/Multi-Axis-2.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-xyz-addon/img/Multi-Axis-3.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-xyz-addon/img/Prompt-SR-Combinations.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-xyz-addon/img/Prompt-SR-P.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-xyz-addon/img/Prompt-SR-Permutations-1-2.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-xyz-addon/img/Prompt-SR-Permutations-2.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-xyz-addon/img/Prompt-SR-Permutations.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-xyz-addon/img/Prompt-SR.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd_extension-prompt_formatter/Twemoji.Mozilla.ttf filter=lfs diff=lfs merge=lfs -text
+extensions/sd_webui_masactrl/resources/img/xyz_grid-0010-1508457017.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd_webui_masactrl-ash/resources/img/xyz_grid-0010-1508457017.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd_webui_realtime_lcm_canvas/preview.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd_webui_realtime_lcm_canvas/scripts/models/models--Lykon--dreamshaper-7/blobs/6d0f6f2e3f7f0133e7684e8dffd7d0dfb1f2b09ddaf327763214449cc7a36574 filter=lfs diff=lfs merge=lfs -text
+extensions/sd_webui_realtime_lcm_canvas/scripts/models/models--Lykon--dreamshaper-7/blobs/79d051410ce59a337cb358d79a3e81b9e0c691c34fcc7625ecfebf6a5db233a4 filter=lfs diff=lfs merge=lfs -text
+extensions/sd_webui_realtime_lcm_canvas/scripts/models/models--Lykon--dreamshaper-7/blobs/a6f6744cfbcfe4fa9d236a231fd67e248389df7187dc15d52f16d9e9872105ff filter=lfs diff=lfs merge=lfs -text
+extensions/sd_webui_sghm/preview.png filter=lfs diff=lfs merge=lfs -text
+extensions/sd_webui_sghm/sghm/models/SGHM filter=lfs diff=lfs merge=lfs -text
+extensions/ssasd/images/sample.png filter=lfs diff=lfs merge=lfs -text
+extensions/ssasd/images/sample2.png filter=lfs diff=lfs merge=lfs -text
+extensions/ssasd/images/sample3.png filter=lfs diff=lfs merge=lfs -text
+extensions/stable-diffusion-webui-composable-lora/readme/changelog_2023-04-08.png filter=lfs diff=lfs merge=lfs -text
+extensions/stable-diffusion-webui-composable-lora/readme/fig11.png filter=lfs diff=lfs merge=lfs -text
+extensions/stable-diffusion-webui-composable-lora/readme/fig12.png filter=lfs diff=lfs merge=lfs -text
+extensions/stable-diffusion-webui-composable-lora/readme/fig13.png filter=lfs diff=lfs merge=lfs -text
+extensions/stable-diffusion-webui-composable-lora/readme/fig8.png filter=lfs diff=lfs merge=lfs -text
+extensions/stable-diffusion-webui-composable-lora/readme/fig9.png filter=lfs diff=lfs merge=lfs -text
+extensions/stable-diffusion-webui-dumpunet/images/IN00.jpg filter=lfs diff=lfs merge=lfs -text
+extensions/stable-diffusion-webui-dumpunet/images/IN05.jpg filter=lfs diff=lfs merge=lfs -text
+extensions/stable-diffusion-webui-dumpunet/images/OUT06.jpg filter=lfs diff=lfs merge=lfs -text
+extensions/stable-diffusion-webui-dumpunet/images/OUT11.jpg filter=lfs diff=lfs merge=lfs -text
+extensions/stable-diffusion-webui-dumpunet/images/README_00_01_color.png filter=lfs diff=lfs merge=lfs -text
+extensions/stable-diffusion-webui-dumpunet/images/README_00_01_gray.png filter=lfs diff=lfs merge=lfs -text
+extensions/stable-diffusion-webui-dumpunet/images/README_02.png filter=lfs diff=lfs merge=lfs -text
+extensions/stable-diffusion-webui-dumpunet/images/attn-IN01.png filter=lfs diff=lfs merge=lfs -text
+extensions/stable-diffusion-webui-dumpunet/images/attn-OUT10.png filter=lfs diff=lfs merge=lfs -text
+extensions/stable-diffusion-webui-hires-fix-progressive/img/highres.png filter=lfs diff=lfs merge=lfs -text
+extensions/stable-diffusion-webui-hires-fix-progressive/img/pg_10x12.png filter=lfs diff=lfs merge=lfs -text
+extensions/stable-diffusion-webui-hires-fix-progressive/img/pg_1x120.png filter=lfs diff=lfs merge=lfs -text
+extensions/stable-diffusion-webui-hires-fix-progressive/img/pg_2x60.png filter=lfs diff=lfs merge=lfs -text
+extensions/stable-diffusion-webui-hires-fix-progressive/img/pg_3x40.png filter=lfs diff=lfs merge=lfs -text
+extensions/stable-diffusion-webui-hires-fix-progressive/img/pg_4x15.png filter=lfs diff=lfs merge=lfs -text
+extensions/stable-diffusion-webui-hires-fix-progressive/img/pg_4x23.png filter=lfs diff=lfs merge=lfs -text
+extensions/stable-diffusion-webui-hires-fix-progressive/img/pg_4x3.png filter=lfs diff=lfs merge=lfs -text
+extensions/stable-diffusion-webui-hires-fix-progressive/img/pg_4x30.png filter=lfs diff=lfs merge=lfs -text
+extensions/stable-diffusion-webui-hires-fix-progressive/img/pg_4x5.png filter=lfs diff=lfs merge=lfs -text
+extensions/stable-diffusion-webui-hires-fix-progressive/img/pg_4x8.png filter=lfs diff=lfs merge=lfs -text
+extensions/stable-diffusion-webui-hires-fix-progressive/img/pg_6x20.png filter=lfs diff=lfs merge=lfs -text
+extensions/stable-diffusion-webui-hires-fix-progressive/img/pg_8x15.png filter=lfs diff=lfs merge=lfs -text
+extensions/stable-diffusion-webui-hires-fix-progressive/img/std_10.png filter=lfs diff=lfs merge=lfs -text
+extensions/stable-diffusion-webui-hires-fix-progressive/img/std_120.png filter=lfs diff=lfs merge=lfs -text
+extensions/stable-diffusion-webui-hires-fix-progressive/img/std_20.png filter=lfs diff=lfs merge=lfs -text
+extensions/stable-diffusion-webui-hires-fix-progressive/img/std_30.png filter=lfs diff=lfs merge=lfs -text
+extensions/stable-diffusion-webui-hires-fix-progressive/img/std_60.png filter=lfs diff=lfs merge=lfs -text
+extensions/stable-diffusion-webui-hires-fix-progressive/img/std_90.png filter=lfs diff=lfs merge=lfs -text
+extensions/stable-diffusion-webui-intm/images/IMAGE.png filter=lfs diff=lfs merge=lfs -text
+extensions/stable-diffusion-webui-rembg/preview.png filter=lfs diff=lfs merge=lfs -text
+extensions/stable-diffusion-webui-sonar/img/momentum.png filter=lfs diff=lfs merge=lfs -text
+extensions/stable-diffusion-webui-tripclipskip/images/xy_plot.jpg filter=lfs diff=lfs merge=lfs -text
+extensions/stable-diffusion-webui-two-shot/gradio-3.16.2-py3-none-any.whl filter=lfs diff=lfs merge=lfs -text

extensions/1-sd-dynamic-thresholding/.github/FUNDING.yml

@@ -0,0 +1 @@
+github: mcmonkey4eva

extensions/1-sd-dynamic-thresholding/.github/workflows/publish.yml

@@ -0,0 +1,21 @@
+name: Publish to Comfy registry
+on:
+  workflow_dispatch:
+  push:
+    branches:
+      - master
+    paths:
+      - "pyproject.toml"
+
+jobs:
+  publish-node:
+    name: Publish Custom Node to registry
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v4
+      - name: Publish Custom Node
+        uses: Comfy-Org/publish-node-action@main
+        with:
+          ## Add your own personal access token to your Github Repository secrets and reference it here.
+          personal_access_token: ${{ secrets.REGISTRY_ACCESS_TOKEN }}

extensions/1-sd-dynamic-thresholding/.gitignore

@@ -0,0 +1 @@
+__pycache__/

extensions/1-sd-dynamic-thresholding/LICENSE.txt

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

extensions/1-sd-dynamic-thresholding/README.md

@@ -0,0 +1,120 @@
+# Stable Diffusion Dynamic Thresholding (CFG Scale Fix)
+
+### Concept
+
+Extension for [SwarmUI](https://github.com/mcmonkeyprojects/SwarmUI), [ComfyUI](https://github.com/comfyanonymous/ComfyUI), and [AUTOMATIC1111 Stable Diffusion WebUI](https://github.com/AUTOMATIC1111/stable-diffusion-webui) that enables a way to use higher CFG Scales without color issues.
+
+This works by clamping latents between steps. You can read more [here](https://github.com/AUTOMATIC1111/stable-diffusion-webui/pull/3962) or [here](https://github.com/AUTOMATIC1111/stable-diffusion-webui/issues/3268) or [this tweet](https://twitter.com/Birchlabs/status/1582165379832348672).
+
+--------------
+
+### Credit
+
+The core functionality of this PR was originally developed by [Birch-san](https://github.com/Birch-san) and ported to the WebUI by [dtan3847](https://github.com/dtan3847), then converted to an Auto WebUI extension and given a UI by [mcmonkey4eva](https://github.com/mcmonkey4eva), further development and research done by [mcmonkey4eva](https://github.com/mcmonkey4eva) and JDMLeverton. Ported by ComfyUI by [TwoDukes](https://github.com/TwoDukes) and [mcmonkey4eva](https://github.com/mcmonkey4eva). Ported to SwarmUI by [mcmonkey4eva](https://github.com/mcmonkey4eva).
+
+--------------
+
+### Examples
+
+![img](github/cat_demo_1.jpg)
+
+![img](github/ui.png)
+
+
+--------------
+
+### Demo Grid
+
+View at <https://sd.mcmonkey.org/dynthresh/>.
+
+![img](github/grid_preview.png)
+
+(Was generated via [this YAML config](https://gist.github.com/mcmonkey4eva/fccd29172f44424dfc0217a482c824f6) for the [Infinite Grid Generator](https://github.com/mcmonkeyprojects/sd-infinity-grid-generator-script))
+
+--------------
+
+### Installation and Usage
+
+#### SwarmUI
+
+- Supported out-of-the-box on default installations.
+    - If using a custom installation, just make sure the backend you use has this repo installed per the instructions specific to the backend as written below.
+- It's under the "Display Advanced Options" parameter checkbox.
+
+#### Auto WebUI
+
+- You must have the [AUTOMATIC1111 Stable Diffusion WebUI](https://github.com/AUTOMATIC1111/stable-diffusion-webui) already installed and working. Refer to that project's readme for help with that.
+- Open the WebUI, go to the `Extensions` tab
+- -EITHER- Option **A**:
+    - go to the `Available` tab with
+    - click `Load from` (with the default list)
+    - Scroll down to find `Dynamic Thresholding (CFG Scale Fix)`, or use `CTRL+F` to find it
+- -OR- Option **B**:
+    - Click on `Install from URL`
+    - Copy/paste this project's URL into the `URL for extension's git repository` textbox: `https://github.com/mcmonkeyprojects/sd-dynamic-thresholding`
+- Click `Install`
+- Restart or reload the WebUI
+- Go to txt2img or img2img
+- Check the `Enable Dynamic Thresholding (CFG Scale Fix)` box
+- Read the info on-page and set the sliders where you want em.
+- Click generate.
+
+
+#### ComfyUI
+
+- Must have [ComfyUI](https://github.com/comfyanonymous/ComfyUI) already installed and working. Refer to that project's readme for help with that.
+- -EITHER- Option **A**: (TODO: Manager install)
+- -OR- Option **B**:
+    - `cd ComfyUI/custom_nodes`
+    - `git clone https://github.com/mcmonkeyprojects/sd-dynamic-thresholding`
+    - restart ComfyUI
+    - Add node `advanced/mcmonkey/DynamicThresholdingSimple` (or `Full`)
+    - Link your model to the input, and then link the output model to your KSampler's input
+
+![img](github/comfy_node.png)
+
+--------------
+
+### Supported Auto WebUI Extensions
+
+- This can be configured within the [Infinity Grid Generator](https://github.com/mcmonkeyprojects/sd-infinity-grid-generator-script#supported-extensions) extension, see the readme of that project for details.
+
+### ComfyUI Compatibility
+
+- This would work with any variant of the `KSampler` node, including custom ones, so long as they do not totally override the internal sampling function (most don't).
+
+----------------------
+
+### Licensing pre-note:
+
+This is an open source project, provided entirely freely, for everyone to use and contribute to.
+
+If you make any changes that could benefit the community as a whole, please contribute upstream.
+
+### The short of the license is:
+
+You can do basically whatever you want, except you may not hold any developer liable for what you do with the software.
+
+### The long version of the license follows:
+
+The MIT License (MIT)
+
+Copyright (c) 2023 Alex "mcmonkey" Goodwin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

extensions/1-sd-dynamic-thresholding/__init__.py

@@ -0,0 +1,6 @@
+from . import dynthres_comfyui
+
+NODE_CLASS_MAPPINGS = {
+    "DynamicThresholdingSimple": dynthres_comfyui.DynamicThresholdingSimpleComfyNode,
+    "DynamicThresholdingFull": dynthres_comfyui.DynamicThresholdingComfyNode,
+}

extensions/1-sd-dynamic-thresholding/dynthres_comfyui.py

@@ -0,0 +1,86 @@
+from .dynthres_core import DynThresh
+
+class DynamicThresholdingComfyNode:
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "model": ("MODEL",),
+                "mimic_scale": ("FLOAT", {"default": 7.0, "min": 0.0, "max": 100.0, "step": 0.5}),
+                "threshold_percentile": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.01}),
+                "mimic_mode": (DynThresh.Modes, ),
+                "mimic_scale_min": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 100.0, "step": 0.5}),
+                "cfg_mode": (DynThresh.Modes, ),
+                "cfg_scale_min": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 100.0, "step": 0.5}),
+                "sched_val": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 100.0, "step": 0.01}),
+                "separate_feature_channels": (["enable", "disable"], ),
+                "scaling_startpoint": (DynThresh.Startpoints, ),
+                "variability_measure": (DynThresh.Variabilities, ),
+                "interpolate_phi": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.01}),
+                }
+        }
+
+    RETURN_TYPES = ("MODEL",)
+    FUNCTION = "patch"
+    CATEGORY = "advanced/mcmonkey"
+
+    def patch(self, model, mimic_scale, threshold_percentile, mimic_mode, mimic_scale_min, cfg_mode, cfg_scale_min, sched_val, separate_feature_channels, scaling_startpoint, variability_measure, interpolate_phi):
+
+        dynamic_thresh = DynThresh(mimic_scale, threshold_percentile, mimic_mode, mimic_scale_min, cfg_mode, cfg_scale_min, sched_val, 0, 999, separate_feature_channels == "enable", scaling_startpoint, variability_measure, interpolate_phi)
+        
+        def sampler_dyn_thresh(args):
+            input = args["input"]
+            cond = input - args["cond"]
+            uncond = input - args["uncond"]
+            cond_scale = args["cond_scale"]
+            time_step = model.model.model_sampling.timestep(args["sigma"])
+            time_step = time_step[0].item()
+            dynamic_thresh.step = 999 - time_step
+
+            if cond_scale == mimic_scale:
+                return input - (uncond + (cond - uncond) * cond_scale)
+            else:
+                return input - dynamic_thresh.dynthresh(cond, uncond, cond_scale, None)
+
+        m = model.clone()
+        m.set_model_sampler_cfg_function(sampler_dyn_thresh)
+        return (m, )
+
+class DynamicThresholdingSimpleComfyNode:
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "model": ("MODEL",),
+                "mimic_scale": ("FLOAT", {"default": 7.0, "min": 0.0, "max": 100.0, "step": 0.5}),
+                "threshold_percentile": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.01}),
+                }
+        }
+
+    RETURN_TYPES = ("MODEL",)
+    FUNCTION = "patch"
+    CATEGORY = "advanced/mcmonkey"
+
+    def patch(self, model, mimic_scale, threshold_percentile):
+
+        dynamic_thresh = DynThresh(mimic_scale, threshold_percentile, "CONSTANT", 0, "CONSTANT", 0, 0, 0, 999, False, "MEAN", "AD", 1)
+        
+        def sampler_dyn_thresh(args):
+            input = args["input"]
+            cond = input - args["cond"]
+            uncond = input - args["uncond"]
+            cond_scale = args["cond_scale"]
+            time_step = model.model.model_sampling.timestep(args["sigma"])
+            time_step = time_step[0].item()
+            dynamic_thresh.step = 999 - time_step
+
+            if cond_scale == mimic_scale:
+                return input - (uncond + (cond - uncond) * cond_scale)
+            else:
+                return input - dynamic_thresh.dynthresh(cond, uncond, cond_scale, None)
+
+        m = model.clone()
+        m.set_model_sampler_cfg_function(sampler_dyn_thresh)
+        return (m, )

extensions/1-sd-dynamic-thresholding/dynthres_core.py

@@ -0,0 +1,167 @@
+import torch, math
+
+######################### DynThresh Core #########################
+
+class DynThresh:
+
+    Modes = ["Constant", "Linear Down", "Cosine Down", "Half Cosine Down", "Linear Up", "Cosine Up", "Half Cosine Up", "Power Up", "Power Down", "Linear Repeating", "Cosine Repeating", "Sawtooth"]
+    Startpoints = ["MEAN", "ZERO"]
+    Variabilities = ["AD", "STD"]
+
+    def __init__(self, mimic_scale, threshold_percentile, mimic_mode, mimic_scale_min, cfg_mode, cfg_scale_min, sched_val, experiment_mode, max_steps, separate_feature_channels, scaling_startpoint, variability_measure, interpolate_phi):
+        self.mimic_scale = mimic_scale
+        self.threshold_percentile = threshold_percentile
+        self.mimic_mode = mimic_mode
+        self.cfg_mode = cfg_mode
+        self.max_steps = max_steps
+        self.cfg_scale_min = cfg_scale_min
+        self.mimic_scale_min = mimic_scale_min
+        self.experiment_mode = experiment_mode
+        self.sched_val = sched_val
+        self.sep_feat_channels = separate_feature_channels
+        self.scaling_startpoint = scaling_startpoint
+        self.variability_measure = variability_measure
+        self.interpolate_phi = interpolate_phi
+
+    def interpret_scale(self, scale, mode, min):
+        scale -= min
+        max = self.max_steps - 1
+        frac = self.step / max
+        if mode == "Constant":
+            pass
+        elif mode == "Linear Down":
+            scale *= 1.0 - frac
+        elif mode == "Half Cosine Down":
+            scale *= math.cos(frac)
+        elif mode == "Cosine Down":
+            scale *= math.cos(frac * 1.5707)
+        elif mode == "Linear Up":
+            scale *= frac
+        elif mode == "Half Cosine Up":
+            scale *= 1.0 - math.cos(frac)
+        elif mode == "Cosine Up":
+            scale *= 1.0 - math.cos(frac * 1.5707)
+        elif mode == "Power Up":
+            scale *= math.pow(frac, self.sched_val)
+        elif mode == "Power Down":
+            scale *= 1.0 - math.pow(frac, self.sched_val)
+        elif mode == "Linear Repeating":
+            portion = (frac * self.sched_val) % 1.0
+            scale *= (0.5 - portion) * 2 if portion < 0.5 else (portion - 0.5) * 2
+        elif mode == "Cosine Repeating":
+            scale *= math.cos(frac * 6.28318 * self.sched_val) * 0.5 + 0.5
+        elif mode == "Sawtooth":
+            scale *= (frac * self.sched_val) % 1.0
+        scale += min
+        return scale
+
+    def dynthresh(self, cond, uncond, cfg_scale, weights):
+        mimic_scale = self.interpret_scale(self.mimic_scale, self.mimic_mode, self.mimic_scale_min)
+        cfg_scale = self.interpret_scale(cfg_scale, self.cfg_mode, self.cfg_scale_min)
+        # uncond shape is (batch, 4, height, width)
+        conds_per_batch = cond.shape[0] / uncond.shape[0]
+        assert conds_per_batch == int(conds_per_batch), "Expected # of conds per batch to be constant across batches"
+        cond_stacked = cond.reshape((-1, int(conds_per_batch)) + uncond.shape[1:])
+
+        ### Normal first part of the CFG Scale logic, basically
+        diff = cond_stacked - uncond.unsqueeze(1)
+        if weights is not None:
+            diff = diff * weights
+        relative = diff.sum(1)
+
+        ### Get the normal result for both mimic and normal scale
+        mim_target = uncond + relative * mimic_scale
+        cfg_target = uncond + relative * cfg_scale
+        ### If we weren't doing mimic scale, we'd just return cfg_target here
+
+        ### Now recenter the values relative to their average rather than absolute, to allow scaling from average
+        mim_flattened = mim_target.flatten(2)
+        cfg_flattened = cfg_target.flatten(2)
+        mim_means = mim_flattened.mean(dim=2).unsqueeze(2)
+        cfg_means = cfg_flattened.mean(dim=2).unsqueeze(2)
+        mim_centered = mim_flattened - mim_means
+        cfg_centered = cfg_flattened - cfg_means
+
+        if self.sep_feat_channels:
+            if self.variability_measure == 'STD':
+                mim_scaleref = mim_centered.std(dim=2).unsqueeze(2)
+                cfg_scaleref = cfg_centered.std(dim=2).unsqueeze(2)
+            else: # 'AD'
+                mim_scaleref = mim_centered.abs().max(dim=2).values.unsqueeze(2)
+                cfg_scaleref = torch.quantile(cfg_centered.abs(), self.threshold_percentile, dim=2).unsqueeze(2)
+
+        else:
+            if self.variability_measure == 'STD':
+                mim_scaleref = mim_centered.std()
+                cfg_scaleref = cfg_centered.std()
+            else: # 'AD'
+                mim_scaleref = mim_centered.abs().max()
+                cfg_scaleref = torch.quantile(cfg_centered.abs(), self.threshold_percentile)
+
+        if self.scaling_startpoint == 'ZERO':
+            scaling_factor = mim_scaleref / cfg_scaleref
+            result = cfg_flattened * scaling_factor
+
+        else: # 'MEAN'
+            if self.variability_measure == 'STD':
+                cfg_renormalized = (cfg_centered / cfg_scaleref) * mim_scaleref
+            else: # 'AD'
+                ### Get the maximum value of all datapoints (with an optional threshold percentile on the uncond)
+                max_scaleref = torch.maximum(mim_scaleref, cfg_scaleref)
+                ### Clamp to the max
+                cfg_clamped = cfg_centered.clamp(-max_scaleref, max_scaleref)
+                ### Now shrink from the max to normalize and grow to the mimic scale (instead of the CFG scale)
+                cfg_renormalized = (cfg_clamped / max_scaleref) * mim_scaleref
+
+            ### Now add it back onto the averages to get into real scale again and return
+            result = cfg_renormalized + cfg_means
+
+        actual_res = result.unflatten(2, mim_target.shape[2:])
+
+        if self.interpolate_phi != 1.0:
+            actual_res = actual_res * self.interpolate_phi + cfg_target * (1.0 - self.interpolate_phi)
+
+        if self.experiment_mode == 1:
+            num = actual_res.cpu().numpy()
+            for y in range(0, 64):
+                for x in range (0, 64):
+                    if num[0][0][y][x] > 1.0:
+                        num[0][1][y][x] *= 0.5
+                    if num[0][1][y][x] > 1.0:
+                        num[0][1][y][x] *= 0.5
+                    if num[0][2][y][x] > 1.5:
+                        num[0][2][y][x] *= 0.5
+            actual_res = torch.from_numpy(num).to(device=uncond.device)
+        elif self.experiment_mode == 2:
+            num = actual_res.cpu().numpy()
+            for y in range(0, 64):
+                for x in range (0, 64):
+                    over_scale = False
+                    for z in range(0, 4):
+                        if abs(num[0][z][y][x]) > 1.5:
+                            over_scale = True
+                    if over_scale:
+                        for z in range(0, 4):
+                            num[0][z][y][x] *= 0.7
+            actual_res = torch.from_numpy(num).to(device=uncond.device)
+        elif self.experiment_mode == 3:
+            coefs = torch.tensor([
+                #  R       G        B      W
+                [0.298,   0.207,  0.208, 0.0], # L1
+                [0.187,   0.286,  0.173, 0.0], # L2
+                [-0.158,  0.189,  0.264, 0.0], # L3
+                [-0.184, -0.271, -0.473, 1.0], # L4
+            ], device=uncond.device)
+            res_rgb = torch.einsum("laxy,ab -> lbxy", actual_res, coefs)
+            max_r, max_g, max_b, max_w = res_rgb[0][0].max(), res_rgb[0][1].max(), res_rgb[0][2].max(), res_rgb[0][3].max()
+            max_rgb = max(max_r, max_g, max_b)
+            print(f"test max = r={max_r}, g={max_g}, b={max_b}, w={max_w}, rgb={max_rgb}")
+            if self.step / (self.max_steps - 1) > 0.2:
+                if max_rgb < 2.0 and max_w < 3.0:
+                    res_rgb /= max_rgb / 2.4
+            else:
+                if max_rgb > 2.4 and max_w > 3.0:
+                    res_rgb /= max_rgb / 2.4
+            actual_res = torch.einsum("laxy,ab -> lbxy", res_rgb, coefs.inverse())
+
+        return actual_res

extensions/1-sd-dynamic-thresholding/dynthres_unipc.py

@@ -0,0 +1,111 @@
+import gradio as gr
+import torch
+import math
+import traceback
+from modules import shared
+try:
+    from modules.models.diffusion import uni_pc
+except Exception as e:
+    from modules import unipc as uni_pc
+
+######################### UniPC Implementation logic #########################
+
+# The majority of this is straight from modules.models/diffusion/uni_pc/sampler.py
+# Unfortunately that's not an easy middle-injection point, so, just copypasta'd it all
+# It's like they designed it to intentionally be as difficult to inject into as possible :(
+# (It has hooks but not in useful locations)
+# I stripped the original comments for brevity.
+# Some never-used code (scheduler modes, noise modes, guidance modes) have been removed as well for brevity.
+# The actual impl comes down to just the last line in particular, and the `before_sample` insert to track step count.
+
+class CustomUniPCSampler(uni_pc.sampler.UniPCSampler):
+    def __init__(self, model, **kwargs):
+        super().__init__(model, *kwargs)
+    @torch.no_grad()
+    def sample(self, S, batch_size, shape, conditioning=None, callback=None, normals_sequence=None, img_callback=None,
+               quantize_x0=False, eta=0., mask=None, x0=None, temperature=1., noise_dropout=0., score_corrector=None,
+               corrector_kwargs=None, verbose=True, x_T=None, log_every_t=100, unconditional_guidance_scale=1.,
+               unconditional_conditioning=None, **kwargs):
+        if conditioning is not None:
+            if isinstance(conditioning, dict):
+                ctmp = conditioning[list(conditioning.keys())[0]]
+                while isinstance(ctmp, list): ctmp = ctmp[0]
+                cbs = ctmp.shape[0]
+                if cbs != batch_size:
+                    print(f"Warning: Got {cbs} conditionings but batch-size is {batch_size}")
+
+            elif isinstance(conditioning, list):
+                for ctmp in conditioning:
+                    if ctmp.shape[0] != batch_size:
+                        print(f"Warning: Got {cbs} conditionings but batch-size is {batch_size}")
+            else:
+                if conditioning.shape[0] != batch_size:
+                    print(f"Warning: Got {conditioning.shape[0]} conditionings but batch-size is {batch_size}")
+        C, H, W = shape
+        size = (batch_size, C, H, W)
+        device = self.model.betas.device
+        if x_T is None:
+            img = torch.randn(size, device=device)
+        else:
+            img = x_T
+        ns = uni_pc.uni_pc.NoiseScheduleVP('discrete', alphas_cumprod=self.alphas_cumprod)
+        model_type = "v" if self.model.parameterization == "v" else "noise"
+        model_fn = CustomUniPC_model_wrapper(lambda x, t, c: self.model.apply_model(x, t, c), ns, model_type=model_type, guidance_scale=unconditional_guidance_scale, dt_data=self.main_class)
+        self.main_class.step = 0
+        def before_sample(x, t, cond, uncond):
+            self.main_class.step += 1
+            return self.before_sample(x, t, cond, uncond)
+        uni_pc_inst = uni_pc.uni_pc.UniPC(model_fn, ns, predict_x0=True, thresholding=False, variant=shared.opts.uni_pc_variant, condition=conditioning, unconditional_condition=unconditional_conditioning, before_sample=before_sample, after_sample=self.after_sample, after_update=self.after_update)
+        x = uni_pc_inst.sample(img, steps=S, skip_type=shared.opts.uni_pc_skip_type, method="multistep", order=shared.opts.uni_pc_order, lower_order_final=shared.opts.uni_pc_lower_order_final)
+        return x.to(device), None
+
+def CustomUniPC_model_wrapper(model, noise_schedule, model_type="noise", model_kwargs={}, guidance_scale=1.0, dt_data=None):
+    def expand_dims(v, dims):
+        return v[(...,) + (None,)*(dims - 1)]
+    def get_model_input_time(t_continuous):
+        return (t_continuous - 1. / noise_schedule.total_N) * 1000.
+    def noise_pred_fn(x, t_continuous, cond=None):
+        if t_continuous.reshape((-1,)).shape[0] == 1:
+            t_continuous = t_continuous.expand((x.shape[0]))
+        t_input = get_model_input_time(t_continuous)
+        if cond is None:
+            output = model(x, t_input, None, **model_kwargs)
+        else:
+            output = model(x, t_input, cond, **model_kwargs)
+        if model_type == "noise":
+            return output
+        elif model_type == "v":
+            alpha_t, sigma_t = noise_schedule.marginal_alpha(t_continuous), noise_schedule.marginal_std(t_continuous)
+            dims = x.dim()
+            return expand_dims(alpha_t, dims) * output + expand_dims(sigma_t, dims) * x
+    def model_fn(x, t_continuous, condition, unconditional_condition):
+        if t_continuous.reshape((-1,)).shape[0] == 1:
+            t_continuous = t_continuous.expand((x.shape[0]))
+        if guidance_scale == 1. or unconditional_condition is None:
+            return noise_pred_fn(x, t_continuous, cond=condition)
+        else:
+            x_in = torch.cat([x] * 2)
+            t_in = torch.cat([t_continuous] * 2)
+            if isinstance(condition, dict):
+                assert isinstance(unconditional_condition, dict)
+                c_in = dict()
+                for k in condition:
+                    if isinstance(condition[k], list):
+                        c_in[k] = [torch.cat([
+                            unconditional_condition[k][i],
+                            condition[k][i]]) for i in range(len(condition[k]))]
+                    else:
+                        c_in[k] = torch.cat([
+                            unconditional_condition[k],
+                            condition[k]])
+            elif isinstance(condition, list):
+                c_in = list()
+                assert isinstance(unconditional_condition, list)
+                for i in range(len(condition)):
+                    c_in.append(torch.cat([unconditional_condition[i], condition[i]]))
+            else:
+                c_in = torch.cat([unconditional_condition, condition])
+            noise_uncond, noise = noise_pred_fn(x_in, t_in, cond=c_in).chunk(2)
+            #return noise_uncond + guidance_scale * (noise - noise_uncond)
+            return dt_data.dynthresh(noise, noise_uncond, guidance_scale, None)
+    return model_fn

extensions/1-sd-dynamic-thresholding/javascript/active.js

@@ -0,0 +1,68 @@
+let dynthres_update_enabled = function() {
+    return Array.from(arguments);
+};
+
+(function(){
+    let accordions = {};
+    let enabled = {};
+    onUiUpdate(() => {
+        let accordion_id_prefix = "#dynthres_";
+        let extension_checkbox_class = ".dynthres-enabled";
+
+        dynthres_update_enabled = function() {
+            let res = Array.from(arguments);
+            let tabname = res[1] ? "img2img" : "txt2img";
+
+            let checkbox = accordions[tabname]?.querySelector(extension_checkbox_class + ' input');
+            checkbox?.dispatchEvent(new Event('change'));
+
+            return res;
+        };
+
+        function attachEnabledButtonListener(checkbox, accordion) {
+            let span = accordion.querySelector('.label-wrap span');
+            let badge = document.createElement('input');
+            badge.type = "checkbox";
+            badge.checked = checkbox.checked;
+            badge.addEventListener('click', (e) => {
+                checkbox.checked = !checkbox.checked;
+                badge.checked = checkbox.checked;
+                checkbox.dispatchEvent(new Event('change'));
+                e.stopPropagation();
+            });
+
+            badge.className = checkbox.className;
+            badge.classList.add('primary');
+            span.insertBefore(badge, span.firstChild);
+            let space = document.createElement('span');
+            space.innerHTML = " ";
+            span.insertBefore(space, badge.nextSibling);
+
+            checkbox.addEventListener('change', () => {
+                let badge = accordion.querySelector('.label-wrap span input');
+                badge.checked = checkbox.checked;
+            });
+            checkbox.parentNode.style.display = "none";
+        }
+
+        if (Object.keys(accordions).length < 2) {
+            let accordion = gradioApp().querySelector(accordion_id_prefix + 'txt2img');
+            if (accordion) {
+                accordions.txt2img = accordion;
+            }
+            accordion = gradioApp().querySelector(accordion_id_prefix + 'img2img');
+            if (accordion) {
+                accordions.img2img = accordion;
+            }
+        }
+
+        if (Object.keys(accordions).length > 0 && accordions.txt2img && !enabled.txt2img) {
+            enabled.txt2img = accordions.txt2img.querySelector(extension_checkbox_class + ' input');
+            attachEnabledButtonListener(enabled.txt2img, accordions.txt2img);
+        }
+        if (Object.keys(accordions).length > 0 && accordions.img2img && !enabled.img2img) {
+            enabled.img2img = accordions.img2img.querySelector(extension_checkbox_class + ' input');
+            attachEnabledButtonListener(enabled.img2img, accordions.img2img);
+        }
+    });
+})();

extensions/1-sd-dynamic-thresholding/pyproject.toml

@@ -0,0 +1,13 @@
+[project]
+name = "sd-dynamic-thresholding"
+description = "Adds nodes for Dynamic Thresholding, CFG scheduling, and related techniques"
+version = "1.0.1"
+license = { file = "LICENSE.txt" }
+
+[project.urls]
+Repository = "https://github.com/mcmonkeyprojects/sd-dynamic-thresholding"
+
+[tool.comfy]
+PublisherId = "mcmonkey"
+DisplayName = "Dynamic Thresholding"
+Icon = ""

extensions/1-sd-dynamic-thresholding/scripts/dynamic_thresholding.py

@@ -0,0 +1,270 @@
+##################
+# Stable Diffusion Dynamic Thresholding (CFG Scale Fix)
+#
+# Author: Alex 'mcmonkey' Goodwin
+# GitHub URL: https://github.com/mcmonkeyprojects/sd-dynamic-thresholding
+# Created: 2022/01/26
+# Last updated: 2023/01/30
+#
+# For usage help, view the README.md file in the extension root, or via the GitHub page.
+#
+##################
+
+import gradio as gr
+import torch, traceback
+import dynthres_core
+from modules import scripts, script_callbacks, sd_samplers, sd_samplers_compvis, sd_samplers_common
+try:
+    import dynthres_unipc
+except Exception as e:
+    print(f"\n\n======\nError! UniPC sampler support failed to load! Is your WebUI up to date?\n(Error: {e})\n======")
+try:
+    from modules.sd_samplers_kdiffusion import CFGDenoiserKDiffusion as cfgdenoisekdiff
+    IS_AUTO_16 = True
+except Exception as e:
+    print(f"\n\n======\nWarning! Using legacy KDiff version! Is your WebUI up to date?\n======")
+    from modules.sd_samplers_kdiffusion import CFGDenoiser as cfgdenoisekdiff
+    IS_AUTO_16 = False
+
+DISABLE_VISIBILITY = True
+
+######################### Data values #########################
+MODES_WITH_VALUE = ["Power Up", "Power Down", "Linear Repeating", "Cosine Repeating", "Sawtooth"]
+
+######################### Script class entrypoint #########################
+class Script(scripts.Script):
+
+    def title(self):
+        return "Dynamic Thresholding (CFG Scale Fix)"
+
+    def show(self, is_img2img):
+        return scripts.AlwaysVisible
+
+    def ui(self, is_img2img):
+        def vis_change(is_vis):
+            return {"visible": is_vis, "__type__": "update"}
+        # "Dynamic Thresholding (CFG Scale Fix)"
+        dtrue = gr.Checkbox(value=True, visible=False)
+        dfalse = gr.Checkbox(value=False, visible=False)
+        with gr.Accordion("Dynamic Thresholding (CFG Scale Fix)", open=False, elem_id="dynthres_" + ("img2img" if is_img2img else "txt2img")):
+            with gr.Row():
+                enabled = gr.Checkbox(value=False, label="Enable Dynamic Thresholding (CFG Scale Fix)", elem_classes=["dynthres-enabled"], elem_id='dynthres_enabled')
+            with gr.Group():
+                gr.HTML(value=f"View <a style=\"border-bottom: 1px #00ffff dotted;\" href=\"https://github.com/mcmonkeyprojects/sd-dynamic-thresholding/wiki/Usage-Tips\">the wiki for usage tips.</a><br><br>", elem_id='dynthres_wiki_link')
+                mimic_scale = gr.Slider(minimum=1.0, maximum=30.0, step=0.5, label='Mimic CFG Scale', value=7.0, elem_id='dynthres_mimic_scale')
+                with gr.Accordion("Advanced Options", open=False, elem_id='dynthres_advanced_opts'):
+                    with gr.Row():
+                        threshold_percentile = gr.Slider(minimum=90.0, value=100.0, maximum=100.0, step=0.05, label='Top percentile of latents to clamp', elem_id='dynthres_threshold_percentile')
+                        interpolate_phi = gr.Slider(minimum=0.0, maximum=1.0, step=0.01, label="Interpolate Phi", value=1.0, elem_id='dynthres_interpolate_phi')
+                    with gr.Row():
+                        mimic_mode = gr.Dropdown(dynthres_core.DynThresh.Modes, value="Constant", label="Mimic Scale Scheduler", elem_id='dynthres_mimic_mode')
+                        cfg_mode = gr.Dropdown(dynthres_core.DynThresh.Modes, value="Constant", label="CFG Scale Scheduler", elem_id='dynthres_cfg_mode')
+                    mimic_scale_min = gr.Slider(minimum=0.0, maximum=30.0, step=0.5, visible=DISABLE_VISIBILITY, label="Minimum value of the Mimic Scale Scheduler", elem_id='dynthres_mimic_scale_min')
+                    cfg_scale_min = gr.Slider(minimum=0.0, maximum=30.0, step=0.5, visible=DISABLE_VISIBILITY, label="Minimum value of the CFG Scale Scheduler", elem_id='dynthres_cfg_scale_min')
+                    sched_val = gr.Slider(minimum=0.0, maximum=40.0, step=0.5, value=4.0, visible=DISABLE_VISIBILITY, label="Scheduler Value", info="Value unique to the scheduler mode - for Power Up/Down, this is the power. For Linear/Cosine Repeating, this is the number of repeats per image.", elem_id='dynthres_sched_val')
+                    with gr.Row():
+                        separate_feature_channels = gr.Checkbox(value=True, label="Separate Feature Channels", elem_id='dynthres_separate_feature_channels')
+                        scaling_startpoint = gr.Radio(["ZERO", "MEAN"], value="MEAN", label="Scaling Startpoint")
+                        variability_measure = gr.Radio(["STD", "AD"], value="AD", label="Variability Measure")
+        def should_show_scheduler_value(cfg_mode, mimic_mode):
+            sched_vis = cfg_mode in MODES_WITH_VALUE or mimic_mode in MODES_WITH_VALUE or DISABLE_VISIBILITY
+            return vis_change(sched_vis), vis_change(mimic_mode != "Constant" or DISABLE_VISIBILITY), vis_change(cfg_mode != "Constant" or DISABLE_VISIBILITY)
+        cfg_mode.change(should_show_scheduler_value, inputs=[cfg_mode, mimic_mode], outputs=[sched_val, mimic_scale_min, cfg_scale_min])
+        mimic_mode.change(should_show_scheduler_value, inputs=[cfg_mode, mimic_mode], outputs=[sched_val, mimic_scale_min, cfg_scale_min])
+        enabled.change(
+            _js="dynthres_update_enabled",
+            fn=None,
+            inputs=[enabled, dtrue if is_img2img else dfalse],
+            show_progress = False)
+        self.infotext_fields = (
+            (enabled, lambda d: gr.Checkbox.update(value="Dynamic thresholding enabled" in d)),
+            (mimic_scale, "Mimic scale"),
+            (separate_feature_channels, "Separate Feature Channels"),
+            (scaling_startpoint, lambda d: gr.Radio.update(value=d.get("Scaling Startpoint", "MEAN"))),
+            (variability_measure, lambda d: gr.Radio.update(value=d.get("Variability Measure", "AD"))),
+            (interpolate_phi, "Interpolate Phi"),
+            (threshold_percentile, "Threshold percentile"),
+            (mimic_scale_min, "Mimic scale minimum"),
+            (mimic_mode, lambda d: gr.Dropdown.update(value=d.get("Mimic mode", "Constant"))),
+            (cfg_mode, lambda d: gr.Dropdown.update(value=d.get("CFG mode", "Constant"))),
+            (cfg_scale_min, "CFG scale minimum"),
+            (sched_val, "Scheduler value"))
+        return [enabled, mimic_scale, threshold_percentile, mimic_mode, mimic_scale_min, cfg_mode, cfg_scale_min, sched_val, separate_feature_channels, scaling_startpoint, variability_measure, interpolate_phi]
+
+    last_id = 0
+
+    def process_batch(self, p, enabled, mimic_scale, threshold_percentile, mimic_mode, mimic_scale_min, cfg_mode, cfg_scale_min, sched_val, separate_feature_channels, scaling_startpoint, variability_measure, interpolate_phi, batch_number, prompts, seeds, subseeds):
+        enabled = getattr(p, 'dynthres_enabled', enabled)
+        if not enabled:
+            return
+        orig_sampler_name = p.sampler_name
+        orig_latent_sampler_name = getattr(p, 'latent_sampler', None)
+        if orig_sampler_name in ["DDIM", "PLMS"]:
+            raise RuntimeError(f"Cannot use sampler {orig_sampler_name} with Dynamic Thresholding")
+        if orig_latent_sampler_name in ["DDIM", "PLMS"]:
+            raise RuntimeError(f"Cannot use secondary sampler {orig_latent_sampler_name} with Dynamic Thresholding")
+        if 'UniPC' in (orig_sampler_name, orig_latent_sampler_name) and p.enable_hr:
+            raise RuntimeError(f"UniPC does not support Hires Fix. Auto WebUI silently swaps to DDIM for this, which DynThresh does not support. Please swap to a sampler capable of img2img processing for HR Fix to work.")
+        mimic_scale = getattr(p, 'dynthres_mimic_scale', mimic_scale)
+        separate_feature_channels = getattr(p, 'dynthres_separate_feature_channels', separate_feature_channels)
+        scaling_startpoint = getattr(p, 'dynthres_scaling_startpoint', scaling_startpoint)
+        variability_measure = getattr(p, 'dynthres_variability_measure', variability_measure)
+        interpolate_phi = getattr(p, 'dynthres_interpolate_phi', interpolate_phi)
+        threshold_percentile = getattr(p, 'dynthres_threshold_percentile', threshold_percentile)
+        mimic_mode = getattr(p, 'dynthres_mimic_mode', mimic_mode)
+        mimic_scale_min = getattr(p, 'dynthres_mimic_scale_min', mimic_scale_min)
+        cfg_mode = getattr(p, 'dynthres_cfg_mode', cfg_mode)
+        cfg_scale_min = getattr(p, 'dynthres_cfg_scale_min', cfg_scale_min)
+        experiment_mode = getattr(p, 'dynthres_experiment_mode', 0)
+        sched_val = getattr(p, 'dynthres_scheduler_val', sched_val)
+        p.extra_generation_params["Dynamic thresholding enabled"] = True
+        p.extra_generation_params["Mimic scale"] = mimic_scale
+        p.extra_generation_params["Separate Feature Channels"] = separate_feature_channels
+        p.extra_generation_params["Scaling Startpoint"] = scaling_startpoint
+        p.extra_generation_params["Variability Measure"] = variability_measure
+        p.extra_generation_params["Interpolate Phi"] = interpolate_phi
+        p.extra_generation_params["Threshold percentile"] = threshold_percentile
+        p.extra_generation_params["Sampler"] = orig_sampler_name
+        if mimic_mode != "Constant":
+            p.extra_generation_params["Mimic mode"] = mimic_mode
+            p.extra_generation_params["Mimic scale minimum"] = mimic_scale_min
+        if cfg_mode != "Constant":
+            p.extra_generation_params["CFG mode"] = cfg_mode
+            p.extra_generation_params["CFG scale minimum"] = cfg_scale_min
+        if cfg_mode in MODES_WITH_VALUE or mimic_mode in MODES_WITH_VALUE:
+            p.extra_generation_params["Scheduler value"] = sched_val
+        # Note: the ID number is to protect the edge case of multiple simultaneous runs with different settings
+        Script.last_id += 1
+        # Percentage to portion
+        threshold_percentile *= 0.01
+
+        def make_sampler(orig_sampler_name):
+            fixed_sampler_name = f"{orig_sampler_name}_dynthres{Script.last_id}"
+
+            # Make a placeholder sampler
+            sampler = sd_samplers.all_samplers_map[orig_sampler_name]
+            dt_data = dynthres_core.DynThresh(mimic_scale, threshold_percentile, mimic_mode, mimic_scale_min, cfg_mode, cfg_scale_min, sched_val, experiment_mode, p.steps, separate_feature_channels, scaling_startpoint, variability_measure, interpolate_phi)
+            if orig_sampler_name == "UniPC":
+                def unipc_constructor(model):
+                    return CustomVanillaSDSampler(dynthres_unipc.CustomUniPCSampler, model, dt_data)
+                new_sampler = sd_samplers_common.SamplerData(fixed_sampler_name, unipc_constructor, sampler.aliases, sampler.options)
+            else:
+                def new_constructor(model):
+                    result = sampler.constructor(model)
+                    cfg = CustomCFGDenoiser(result if IS_AUTO_16 else result.model_wrap_cfg.inner_model, dt_data)
+                    result.model_wrap_cfg = cfg
+                    return result
+                new_sampler = sd_samplers_common.SamplerData(fixed_sampler_name, new_constructor, sampler.aliases, sampler.options)
+            return fixed_sampler_name, new_sampler
+
+        # Apply for usage
+        p.orig_sampler_name = orig_sampler_name
+        p.orig_latent_sampler_name = orig_latent_sampler_name
+        p.fixed_samplers = []
+
+        if orig_latent_sampler_name:
+            latent_sampler_name, latent_sampler = make_sampler(orig_latent_sampler_name)
+            sd_samplers.all_samplers_map[latent_sampler_name] = latent_sampler
+            p.fixed_samplers.append(latent_sampler_name)
+            p.latent_sampler = latent_sampler_name
+
+        if orig_sampler_name != orig_latent_sampler_name:
+            p.sampler_name, new_sampler = make_sampler(orig_sampler_name)
+            sd_samplers.all_samplers_map[p.sampler_name] = new_sampler
+            p.fixed_samplers.append(p.sampler_name)
+        else:
+            p.sampler_name = p.latent_sampler
+
+        if p.sampler is not None:
+            p.sampler = sd_samplers.create_sampler(p.sampler_name, p.sd_model)
+
+    def postprocess_batch(self, p, enabled, mimic_scale, threshold_percentile, mimic_mode, mimic_scale_min, cfg_mode, cfg_scale_min, sched_val, separate_feature_channels, scaling_startpoint, variability_measure, interpolate_phi, batch_number, images):
+        if not enabled or not hasattr(p, 'orig_sampler_name'):
+            return
+        p.sampler_name = p.orig_sampler_name
+        if p.orig_latent_sampler_name:
+            p.latent_sampler = p.orig_latent_sampler_name
+        for added_sampler in p.fixed_samplers:
+            del sd_samplers.all_samplers_map[added_sampler]
+        del p.fixed_samplers
+        del p.orig_sampler_name
+        del p.orig_latent_sampler_name
+
+######################### CompVis Implementation logic #########################
+
+class CustomVanillaSDSampler(sd_samplers_compvis.VanillaStableDiffusionSampler):
+    def __init__(self, constructor, sd_model, dt_data):
+        super().__init__(constructor, sd_model)
+        self.sampler.main_class = dt_data
+
+######################### K-Diffusion Implementation logic #########################
+
+class CustomCFGDenoiser(cfgdenoisekdiff):
+    def __init__(self, model, dt_data):
+        super().__init__(model)
+        self.main_class = dt_data
+
+    def combine_denoised(self, x_out, conds_list, uncond, cond_scale):
+        if isinstance(uncond, dict) and 'crossattn' in uncond:
+            uncond = uncond['crossattn']
+        denoised_uncond = x_out[-uncond.shape[0]:]
+        # conds_list shape is (batch, cond, 2)
+        weights = torch.tensor(conds_list, device=uncond.device).select(2, 1)
+        weights = weights.reshape(*weights.shape, 1, 1, 1)
+        self.main_class.step = self.step
+        if hasattr(self, 'total_steps'):
+            self.main_class.max_steps = self.total_steps
+
+        if self.main_class.experiment_mode >= 4 and self.main_class.experiment_mode <= 5:
+            # https://arxiv.org/pdf/2305.08891.pdf "Rescale CFG". It's not good, but if you want to test it, just set experiment_mode = 4 + phi.
+            denoised = torch.clone(denoised_uncond)
+            fi = self.main_class.experiment_mode - 4.0
+            for i, conds in enumerate(conds_list):
+                for cond_index, weight in conds:
+                    xcfg = (denoised_uncond[i] + (x_out[cond_index] - denoised_uncond[i]) * (cond_scale * weight))
+                    xrescaled = xcfg * (torch.std(x_out[cond_index]) / torch.std(xcfg))
+                    xfinal = fi * xrescaled + (1.0 - fi) * xcfg
+                    denoised[i] = xfinal
+            return denoised
+
+        return self.main_class.dynthresh(x_out[:-uncond.shape[0]], denoised_uncond, cond_scale, weights)
+
+######################### XYZ Plot Script Support logic #########################
+
+def make_axis_options():
+    xyz_grid = [x for x in scripts.scripts_data if x.script_class.__module__ in ("xyz_grid.py", "scripts.xyz_grid")][0].module
+    def apply_mimic_scale(p, x, xs):
+        if x != 0:
+            setattr(p, "dynthres_enabled", True)
+            setattr(p, "dynthres_mimic_scale", x)
+        else:
+            setattr(p, "dynthres_enabled", False)
+    def confirm_scheduler(p, xs):
+        for x in xs:
+            if x not in dynthres_core.DynThresh.Modes:
+                raise RuntimeError(f"Unknown Scheduler: {x}")
+    extra_axis_options = [
+        xyz_grid.AxisOption("[DynThres] Mimic Scale", float, apply_mimic_scale),
+        xyz_grid.AxisOption("[DynThres] Separate Feature Channels", int,
+                            xyz_grid.apply_field("dynthres_separate_feature_channels")),
+        xyz_grid.AxisOption("[DynThres] Scaling Startpoint", str, xyz_grid.apply_field("dynthres_scaling_startpoint"), choices=lambda:['ZERO', 'MEAN']),
+        xyz_grid.AxisOption("[DynThres] Variability Measure", str, xyz_grid.apply_field("dynthres_variability_measure"), choices=lambda:['STD', 'AD']),
+        xyz_grid.AxisOption("[DynThres] Interpolate Phi", float, xyz_grid.apply_field("dynthres_interpolate_phi")),
+        xyz_grid.AxisOption("[DynThres] Threshold Percentile", float, xyz_grid.apply_field("dynthres_threshold_percentile")),
+        xyz_grid.AxisOption("[DynThres] Mimic Scheduler", str, xyz_grid.apply_field("dynthres_mimic_mode"), confirm=confirm_scheduler, choices=lambda: dynthres_core.DynThresh.Modes),
+        xyz_grid.AxisOption("[DynThres] Mimic minimum", float, xyz_grid.apply_field("dynthres_mimic_scale_min")),
+        xyz_grid.AxisOption("[DynThres] CFG Scheduler", str, xyz_grid.apply_field("dynthres_cfg_mode"), confirm=confirm_scheduler, choices=lambda: dynthres_core.DynThresh.Modes),
+        xyz_grid.AxisOption("[DynThres] CFG minimum", float, xyz_grid.apply_field("dynthres_cfg_scale_min")),
+        xyz_grid.AxisOption("[DynThres] Scheduler value", float, xyz_grid.apply_field("dynthres_scheduler_val"))
+    ]
+    if not any("[DynThres]" in x.label for x in xyz_grid.axis_options):
+        xyz_grid.axis_options.extend(extra_axis_options)
+
+def callback_before_ui():
+    try:
+        make_axis_options()
+    except Exception as e:
+        traceback.print_exc()
+        print(f"Failed to add support for X/Y/Z Plot Script because: {e}")
+
+script_callbacks.on_before_ui(callback_before_ui)

extensions/ABG_extension/.gitignore

@@ -0,0 +1 @@
+scripts/__pycache__

extensions/ABG_extension/README.md

@@ -0,0 +1,32 @@
+<h3 align="center">
+<b>ABG extension</b>
+</h3>
+
+<p align="center">
+	<a href="https://github.com/KutsuyaYuki/ABG_extension/stargazers"><img src="https://img.shields.io/github/stars/KutsuyaYuki/ABG_extension?style=for-the-badge"></a>
+	<a href="https://github.com/KutsuyaYuki/ABG_extension/issues"><img src="https://img.shields.io/github/issues/KutsuyaYuki/ABG_extension?style=for-the-badge"></a>
+	<a href="https://github.com/KutsuyaYuki/ABG_extension/commits/main"><img src="https://img.shields.io/github/last-commit/KutsuyaYuki/ABG_extension?style=for-the-badge"></a>
+</p>
+
+## Installation
+
+ 1. Install extension by going to Extensions tab -> Install from URL -> Paste github URL and click Install.
+ 2. After it's installed, go back to the Installed tab in Extensions and press Apply and restart UI.
+ 3. Installation finished.
+ 4. If the script does not show up or work, please restart the WebUI.
+
+## Usage
+
+### txt2img
+
+ 1. In the bottom of the WebUI in Script, select **ABG Remover**.
+ 2. Select the desired options: **Only save background free pictures** or **Do not auto save**.
+ 3. Generate an image and you will see the result in the output area.
+
+### img2img
+
+ 1. In the bottom of the WebUI in Script, select **ABG Remover**.
+ 2. Select the desired options: **Only save background free pictures** or **Do not auto save**.
+ 3. **IMPORTANT**: Set **Denoising strength** to a low value, like **0.01**
+
+Based on https://huggingface.co/spaces/skytnt/anime-remove-background

extensions/ABG_extension/install.py

@@ -0,0 +1,11 @@
+import launch
+
+for dep in ['onnx', 'onnxruntime', 'numpy']:
+    if not launch.is_installed(dep):
+        launch.run_pip(f"install {dep}", f"{dep} for ABG_extension")
+
+if not launch.is_installed("cv2"):
+    launch.run_pip("install opencv-python", "opencv-python")
+
+if not launch.is_installed("PIL"):
+    launch.run_pip("install Pillow", "Pillow")

extensions/ABG_extension/scripts/app.py

@@ -0,0 +1,183 @@
+import random
+import modules.scripts as scripts
+from modules import images
+from modules.processing import process_images, Processed
+from modules.processing import Processed
+from modules.shared import opts, cmd_opts, state
+
+import gradio as gr
+import huggingface_hub
+import onnxruntime as rt
+import copy
+import numpy as np
+import cv2
+from PIL import Image as im, ImageDraw
+
+
+# Declare Execution Providers
+providers = ['CUDAExecutionProvider', 'CPUExecutionProvider']
+
+# Download and host the model
+model_path = huggingface_hub.hf_hub_download(
+    "skytnt/anime-seg", "isnetis.onnx")
+rmbg_model = rt.InferenceSession(model_path, providers=providers)
+
+# Function to get mask
+def get_mask(img, s=1024):
+    # Resize the img to a square shape with dimension s
+    # Convert img pixel values from integers 0-255 to float 0-1
+    img = (img / 255).astype(np.float32)
+    # get the amount of dimensions of img
+    dim = img.shape[2]
+    # Convert the input image to RGB format if it has an alpha channel
+    if dim == 4:
+        img = img[..., :3]
+        dim = 3
+    # Get height and width of the image
+    h, w = h0, w0 = img.shape[:-1]
+    # IF height is greater than width, set h as s and w as s*width/height
+    # ELSE, set w as s and h as s*height/width
+    h, w = (s, int(s * w / h)) if h > w else (int(s * h / w), s)
+    # Calculate padding for height and width
+    ph, pw = s - h, s - w
+    # Create a 1024x1024x3 array of 0's
+    img_input = np.zeros([s, s, dim], dtype=np.float32)
+    # Resize the original image to (w,h) and then pad with the calculated ph,pw
+    img_input[ph // 2:ph // 2 + h, pw //
+              2:pw // 2 + w] = cv2.resize(img, (w, h))
+    # Change the axes
+    img_input = np.transpose(img_input, (2, 0, 1))
+    # Add an extra axis (1,0)
+    img_input = img_input[np.newaxis, :]
+    # Run the model to get the mask
+    mask = rmbg_model.run(None, {'img': img_input})[0][0]
+    # Transpose axis
+    mask = np.transpose(mask, (1, 2, 0))
+    # Crop it to the images original dimensions (h0,w0)
+    mask = mask[ph // 2:ph // 2 + h, pw // 2:pw // 2 + w]
+    # Resize the mask to original image size (h0,w0)
+    mask = cv2.resize(mask, (w0, h0))[:, :, np.newaxis]
+    return mask
+
+### Function to remove background
+def rmbg_fn(img):
+    # Call get_mask() to get the mask
+    mask = get_mask(img)
+    # Multiply the image and the mask together to get the output image
+    img = (mask * img + 255 * (1 - mask)).astype(np.uint8)
+    # Convert mask value back to int 0-255
+    mask = (mask * 255).astype(np.uint8)
+    # Concatenate the output image and mask
+    img = np.concatenate([img, mask], axis=2, dtype=np.uint8)
+    # Stacking 3 identical copies of the mask for displaying
+    mask = mask.repeat(3, axis=2)
+    return mask, img
+
+
+class Script(scripts.Script):
+    is_txt2img = False
+
+    # Function to set title
+    def title(self):
+        return "ABG Remover"
+
+    def ui(self, is_img2img):
+
+        with gr.Column():
+            only_save_background_free_pictures = gr.Checkbox(
+                label='Only save background free pictures')
+            do_not_auto_save = gr.Checkbox(label='Do not auto save')
+            with gr.Row():
+                custom_background = gr.Checkbox(label='Custom Background')
+                custom_background_color = gr.ColorPicker(
+                    label='Background Color', default='#ff0000')
+            custom_background_random = gr.Checkbox(
+                label='Random Custom Background')
+
+        return [only_save_background_free_pictures, do_not_auto_save, custom_background, custom_background_color, custom_background_random]
+
+    # Function to show the script
+    def show(self, is_img2img):
+        return True
+
+    # Function to run the script
+    def run(self, p, only_save_background_free_pictures, do_not_auto_save, custom_background, custom_background_color, custom_background_random):
+        # If only_save_background_free_pictures is true, set do_not_save_samples to true
+        if only_save_background_free_pictures:
+            p.do_not_save_samples = True
+
+        # Create a process_images object
+        proc = process_images(p)
+
+        has_grid = False
+
+        unwanted_grid_because_of_img_count = len(
+            proc.images) < 2 and opts.grid_only_if_multiple
+        if (opts.return_grid or opts.grid_save) and not p.do_not_save_grid and not unwanted_grid_because_of_img_count:
+            has_grid = True
+
+        # Loop through all the images in proc
+        for i in range(len(proc.images)):
+            # Separate the background from the foreground
+            nmask, nimg = rmbg_fn(np.array(proc.images[i]))
+
+            # Check the number of channels in the nimg array, select only the first 3 or 4 channels
+            num_channels = nimg.shape[2]
+            if num_channels > 4:
+                nimg = nimg[:, :, :4]
+                
+            # Ensure the data type is uint8 and convert the image back to a format that can be saved
+            nimg = nimg.astype(np.uint8)
+            img = im.fromarray(nimg)
+
+            # If only_save_background_free_pictures is true, check if the image has a background
+            if custom_background or custom_background_random:
+                # If custom_background_random is true, set the background color to a random color
+                if custom_background_random:
+                    custom_background_color = (random.randint(0, 255), random.randint(0, 255), random.randint(0, 255))
+
+                # Create a new image with the same size as the original image
+                background = im.new('RGBA', img.size, custom_background_color)
+
+                # Draw a colored rectangle onto the new image
+                draw = ImageDraw.Draw(background)
+                draw.rectangle([(0, 0), img.size],
+                               fill=custom_background_color)
+
+                # Merge the two images
+                img = im.alpha_composite(background, img)
+
+            # determine output path
+            outpath = p.outpath_grids if has_grid and i == 0 else p.outpath_samples
+
+            # If we are saving all images, save the mask and the image
+            if not only_save_background_free_pictures:
+                mask = im.fromarray(nmask)
+                # Dot not save the new images if checkbox is checked
+                if not do_not_auto_save:
+                    # Save the new images
+                    images.save_image(
+                        mask, outpath, "mask_", proc.seed + i, proc.prompt, "png", info=proc.info, p=p)
+                    images.save_image(
+                        img, outpath, "img_", proc.seed + i, proc.prompt, "png", info=proc.info, p=p)
+                # Add the images to the proc object
+                proc.images.append(mask)
+                proc.images.append(img)
+            # If we are only saving background-free images, save the image and replace it in the proc object
+            else:
+                proc.images[i] = img
+
+            # Check if automatic saving is enabled
+            if not do_not_auto_save:
+                # Check if the image is the first one and has a grid
+                if has_grid and i == 0:
+                    # Save the image
+                    images.save_image(img, p.outpath_grids, "grid", p.all_seeds[0], p.all_prompts[0],
+                                      opts.grid_format, info=proc.info, short_filename=not opts.grid_extended_filename, p=p)
+                else:
+                    # Save the image
+                    images.save_image(img, outpath, "", proc.seed,
+                                      proc.prompt, "png", info=proc.info, p=p)
+
+        # Return the proc object
+        return proc

extensions/Automatic1111-Geeky-Remb/LICENSE

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

extensions/Automatic1111-Geeky-Remb/README.md

@@ -0,0 +1,258 @@
+# GeekyRemB: Advanced Background Removal for Automatic1111 Web UI
+
+update 8/18/2024 
+
+Key Updates to the Code:
+
+New Methods in GeekyRemB Class:
+a) parse_aspect_ratio(self, aspect_ratio_input):
+This method interprets the user's aspect ratio input. It can handle:
+
+Ratio strings (e.g., "16:9")
+Decimal values (e.g., "1.77")
+Standard terms (e.g., "portrait", "landscape")
+
+b) calculate_new_dimensions(self, orig_width, orig_height, scale, aspect_ratio):
+This method calculates the new dimensions based on the original size, scale, and aspect ratio.
+Updated remove_background Method:
+The method now uses parse_aspect_ratio and calculate_new_dimensions to determine the new image dimensions.
+UI Changes:
+The foreground_aspect_ratio input is now a gr.Textbox with a more descriptive placeholder, allowing for more flexible input.
+
+How to Use the New Aspect Ratio Feature:
+
+Basic Usage:
+In the "Foreground Adjustments" section, you'll find an input field labeled "Aspect Ratio". Here are the ways you can use it:
+a) Leave it blank: This will maintain the original aspect ratio of your image.
+b) Enter a ratio: You can input ratios like "16:9", "4:3", "1:1", etc. The format is "width:height".
+c) Use decimal values: You can enter a single number representing width divided by height, e.g., "1.77" for 16:9.
+d) Use standard terms: You can enter "portrait", "landscape", or "square".
+Examples:
+
+For a widescreen format, enter "16:9"
+For a traditional TV format, enter "4:3"
+For a square image, enter "1:1" or "square"
+For a vertical video format, you might enter "9:16"
+For a slight landscape format, you could enter "1.2" (which is equivalent to 6:5)
+
+
+Combining with Scale:
+The aspect ratio works in conjunction with the "Scale" slider. Here's how they interact:
+
+Scale determines the overall size of the image relative to its original size.
+Aspect ratio determines the shape of the image.
+
+For example:
+
+If you set scale to 1.5 and aspect ratio to "16:9", the image will be enlarged by 50% and shaped to a 16:9 ratio.
+If you set scale to 0.5 and aspect ratio to "1:1", the image will be shrunk by 50% and made square.
+
+
+Special Considerations:
+
+If you enter an invalid aspect ratio, the script will default to maintaining the original aspect ratio.
+The aspect ratio is applied before other transformations like rotation or flipping.
+When using custom terms like "portrait" or "landscape", the script uses preset ratios (3:4 for portrait, 4:3 for landscape).
+
+
+Tips for Best Results:
+
+For precise control, use numeric ratios (like "16:9") rather than terms like "landscape".
+If you're targeting a specific output size, you may need to experiment with both the scale and aspect ratio settings.
+Remember that extreme changes in aspect ratio might distort your image, especially if it contains people or recognizable objects.
+
+
+Interaction with Other Features:
+
+The aspect ratio is applied before positioning (X and Y position) and rotation.
+If you're using a background image, you might want to consider its aspect ratio when setting the foreground aspect ratio for a cohesive look.
+
+
+<img width="1249" alt="Screenshot 2024-08-18 230754" src="https://github.com/user-attachments/assets/a876427e-30b1-42fa-b0d0-ff1d41cb6aa6">
+
+
+
+
+![download](https://github.com/user-attachments/assets/9a23a8aa-9ab8-4c6a-ae1a-44879b4a696d)
+
+## Overview
+
+GeekyRemB is a powerful extension for Automatic1111 that provides advanced background removal and image/video manipulation capabilities. It is a port of the ComfyUI node, bringing its functionality to the Automatic1111 environment. The extension allows users to remove backgrounds from images and videos, apply various effects, and manipulate foreground elements with precision.
+
+## Key Features
+
+- Background removal for images and videos
+- Support for multiple background removal models
+- Chroma key functionality
+- Foreground manipulation (scaling, rotation, positioning)
+- Various image effects (edge detection, shadow, color adjustments)
+- Mask processing options
+- Custom output dimensions
+- Video background support
+
+## How to Use
+
+1. Install the extension by placing the `geeky_remb.py` file in the `scripts` folder of your Automatic1111 installation.
+2. Restart Automatic1111 or reload the UI.
+3. Navigate to the "GeekyRemB" tab in the Automatic1111 interface.
+4. Choose your input type (Image or Video) and upload your content.
+5. Adjust the settings as needed (described in detail below).
+6. Click the "Run GeekyRemB" button to process your input.
+
+## UI Settings and Their Functions
+
+### Input/Output Settings
+
+- **Input Type**: Choose between "Image" or "Video" as your input source.
+- **Foreground Image/Video**: Upload your image or video file to be processed.
+- **Output Type**: Select whether you want the output to be an "Image" or "Video".
+
+### Foreground Adjustments
+
+- **Scale**: Adjust the size of the foreground element (0.1 to 5.0).
+- **Aspect Ratio**: Modify the aspect ratio of the foreground (0.1 to 10.0).
+- **X Position**: Move the foreground horizontally (-1000 to 1000 pixels).
+- **Y Position**: Move the foreground vertically (-1000 to 1000 pixels).
+- **Rotation**: Rotate the foreground (-360 to 360 degrees).
+- **Opacity**: Adjust the transparency of the foreground (0.0 to 1.0).
+- **Flip Horizontal**: Mirror the foreground horizontally.
+- **Flip Vertical**: Mirror the foreground vertically.
+
+### Background Options
+
+- **Remove Background**: Toggle background removal on/off.
+- **Background Mode**: Choose between "transparent", "color", "image", or "video" backgrounds.
+- **Background Color**: Select a color when "color" mode is chosen.
+- **Background Image**: Upload an image to use as the background.
+- **Background Video**: Upload a video to use as the background.
+
+### Advanced Settings
+
+#### Removal Settings
+
+- **Model**: Select the background removal model (e.g., "u2net", "isnet-general-use").
+- **Output Format**: Choose between "RGBA" (with transparency) or "RGB".
+- **Alpha Matting**: Enable for improved edge detection in complex images.
+- **Alpha Matting Foreground Threshold**: Adjust sensitivity for foreground detection (0-255).
+- **Alpha Matting Background Threshold**: Adjust sensitivity for background detection (0-255).
+- **Post Process Mask**: Apply additional processing to the generated mask.
+
+#### Chroma Key Settings
+
+- **Chroma Key**: Choose a color ("none", "green", "blue", "red") for chroma keying.
+- **Chroma Threshold**: Adjust the sensitivity of the chroma key effect (0-255).
+- **Color Tolerance**: Set the range of colors to be considered part of the chroma key (0-255).
+
+#### Effects
+
+- **Invert Mask**: Invert the generated mask.
+- **Feather Amount**: Soften the edges of the mask (0-100).
+- **Edge Detection**: Apply an edge detection effect.
+- **Edge Thickness**: Adjust the thickness of detected edges (1-10).
+- **Edge Color**: Choose the color for detected edges.
+- **Shadow**: Add a shadow effect to the foreground.
+- **Shadow Blur**: Adjust the blurriness of the shadow (0-20).
+- **Shadow Opacity**: Set the transparency of the shadow (0.0-1.0).
+- **Color Adjustment**: Enable color adjustments for the result.
+- **Brightness**: Adjust the brightness of the result (0.0-2.0).
+- **Contrast**: Adjust the contrast of the result (0.0-2.0).
+- **Saturation**: Adjust the color saturation of the result (0.0-2.0).
+- **Mask Blur**: Apply blur to the mask (0-100).
+- **Mask Expansion**: Expand or contract the mask (-100 to 100).
+
+### Output Settings
+
+- **Image Format**: Choose the output format for images (PNG, JPEG, WEBP).
+- **Video Format**: Select the output format for videos (MP4, AVI, MOV).
+- **Video Quality**: Adjust the quality of the output video (0-100).
+- **Use Custom Dimensions**: Enable to specify custom output dimensions.
+- **Custom Width**: Set a custom width for the output.
+- **Custom Height**: Set a custom height for the output.
+
+## Technical Implementation for Developers
+
+The GeekyRemB extension is implemented as a Python class (`GeekyRemB`) with several key methods:
+
+1. `__init__`: Initializes the class and prepares for background removal sessions.
+
+2. `apply_chroma_key`: Implements chroma key functionality using OpenCV.
+
+3. `process_mask`: Handles mask processing operations like inversion, feathering, and expansion.
+
+4. `remove_background`: The core method that processes images, removing backgrounds and applying effects.
+
+5. `process_frame`: Processes individual video frames.
+
+6. `process_video`: Handles video processing, including background video integration.
+
+The UI is built using Gradio components, with the `on_ui_tabs` function setting up the interface. Key functions include:
+
+- `update_input_type`, `update_output_type`, `update_background_mode`, `update_custom_dimensions`: Dynamic UI updates based on user selections.
+- `process_image` and `process_video`: Wrapper functions for image and video processing.
+- `run_geeky_remb`: The main function that orchestrates the entire process based on user inputs.
+
+The extension uses libraries like `rembg` for background removal, `PIL` for image processing, `cv2` for video handling, and `numpy` for array operations.
+
+Developers can extend the functionality by adding new background removal models, implementing additional effects, or enhancing video processing capabilities. The modular structure allows for easy integration of new features.
+
+## Performance Considerations
+
+- Background removal and video processing can be computationally intensive. Consider implementing progress bars or asynchronous processing for better user experience with large files.
+- The extension currently processes videos frame-by-frame. For longer videos, consider implementing batch processing or multi-threading for improved performance.
+- Memory usage can be high when processing large images or videos. Implement memory management techniques for handling large files.
+
+## Future Enhancements
+
+Potential areas for improvement include:
+- Support for more background removal models
+- Advanced video editing features (e.g., keyframe animation for foreground properties)
+- Integration with other Automatic1111 extensions or workflows
+- GPU acceleration for video processing
+- Real-time preview for adjustments
+
+This extension provides a powerful set of tools for background removal and image/video manipulation, bringing the capabilities of the ComfyUI node to the Automatic1111 environment.
+
+## Troubleshooting
+
+- If the background removal is imperfect, try adjusting the alpha matting thresholds or using a different model.
+- For subjects with similar colors to the background, experiment with the chroma key feature in combination with AI removal.
+- If the resulting image looks unnatural, play with the shadow and color adjustment settings to better integrate the subject with the new background.
+
+## Contributing
+
+We welcome contributions to GeekyRemB! If you have ideas for improvements or new features, feel free to open an issue or submit a pull request.
+
+## License
+
+GeekyRemB is released under the MIT License. Feel free to use, modify, and distribute it as you see fit.
+
+## Acknowledgments
+
+GeekyRemB is built upon the excellent [rembg](https://github.com/danielgatis/rembg) library and integrates seamlessly with the Automatic1111 Stable Diffusion Web UI. We're grateful to the developers of these projects for their fantastic work.
+
+---
+
+<img width="1247" alt="Screenshot 2024-08-08 123752" src="https://github.com/user-attachments/assets/2491ce81-09a7-4d8a-9bdc-58d48f82dfaf">
+
+
+<img width="1235" alt="Screenshot 2024-08-08 124700" src="https://github.com/user-attachments/assets/cd672db7-97fe-4c1b-b8a3-2b50fb152d04">
+
+
+<img width="1238" alt="Screenshot 2024-08-08 123732" src="https://github.com/user-attachments/assets/f7b91764-041e-4ae6-a46a-a81eaa8692c9">
+
+
+
+
+We hope you enjoy using GeekyRemB to create stunning images with ease! If you find it useful, consider starring the repository and sharing it with your friends and colleagues.
+
+The gap that allows for full and free rotation will become important later, for right now it's a fun and useful ediging feature, in the future it's going to allow for something pretty neat with animation. 
+
+![image (3)](https://github.com/user-attachments/assets/d1bee6f4-b558-46c1-8541-571af0e1a997)
+
+To things that may come
+
+<img width="1245" alt="Screenshot 2024-08-18 234435" src="https://github.com/user-attachments/assets/86a720ad-a0e3-4c86-8fed-d90e60d62a50">
+
+<img width="1256" alt="Screenshot 2024-08-18 234617" src="https://github.com/user-attachments/assets/d92bc8a8-1393-4b49-9de3-a4375239613f">
+<img width="1234" alt="Screenshot 2024-08-18 234630" src="https://github.com/user-attachments/assets/5c2e8039-94b5-4d2a-904a-7b87b07ac578">
+

extensions/Automatic1111-Geeky-Remb/__init__.py

@@ -0,0 +1,4 @@
+from .geeky_remb import GeekyRemBExtras
+
+def __init__():
+    return [GeekyRemBExtras()]

extensions/Automatic1111-Geeky-Remb/install.py

@@ -0,0 +1,7 @@
+import launch
+
+if not launch.is_installed("rembg"):
+    launch.run_pip("install rembg", "requirement for Geeky RemB")
+
+if not launch.is_installed("opencv-python"):
+    launch.run_pip("install opencv-python", "requirement for Geeky RemB")

extensions/Automatic1111-Geeky-Remb/requirements.txt

@@ -0,0 +1,6 @@
+rembg
+numpy
+opencv-python
+Pillow
+onnxruntime-gpu
+onnxruntime

extensions/Automatic1111-Geeky-Remb/scripts/geeky-remb.py

@@ -0,0 +1,475 @@
+import os
+import numpy as np
+from rembg import remove, new_session
+from PIL import Image, ImageOps, ImageFilter, ImageEnhance
+import cv2
+from tqdm import tqdm
+import gradio as gr
+from modules import script_callbacks, shared
+import torch
+import tempfile
+
+class GeekyRemB:
+    def __init__(self):
+        self.session = None
+
+    def apply_chroma_key(self, image, color, threshold, color_tolerance=20):
+        hsv = cv2.cvtColor(image, cv2.COLOR_RGB2HSV)
+        if color == "green":
+            lower = np.array([40 - color_tolerance, 40, 40])
+            upper = np.array([80 + color_tolerance, 255, 255])
+        elif color == "blue":
+            lower = np.array([90 - color_tolerance, 40, 40])
+            upper = np.array([130 + color_tolerance, 255, 255])
+        elif color == "red":
+            lower = np.array([0, 40, 40])
+            upper = np.array([20 + color_tolerance, 255, 255])
+        else:
+            return np.zeros(image.shape[:2], dtype=np.uint8)
+
+        mask = cv2.inRange(hsv, lower, upper)
+        mask = 255 - cv2.threshold(mask, threshold, 255, cv2.THRESH_BINARY)[1]
+        return mask
+
+    def process_mask(self, mask, invert_mask, feather_amount, mask_blur, mask_expansion):
+        if invert_mask:
+            mask = 255 - mask
+
+        if mask_expansion != 0:
+            kernel = np.ones((abs(mask_expansion), abs(mask_expansion)), np.uint8)
+            if mask_expansion > 0:
+                mask = cv2.dilate(mask, kernel, iterations=1)
+            else:
+                mask = cv2.erode(mask, kernel, iterations=1)
+
+        if feather_amount > 0:
+            mask = cv2.GaussianBlur(mask, (0, 0), sigmaX=feather_amount)
+
+        if mask_blur > 0:
+            mask = cv2.GaussianBlur(mask, (0, 0), sigmaX=mask_blur)
+
+        return mask
+
+    def parse_aspect_ratio(self, aspect_ratio_input):
+        if not aspect_ratio_input:
+            return None
+        
+        if ':' in aspect_ratio_input:
+            try:
+                w, h = map(float, aspect_ratio_input.split(':'))
+                return w / h
+            except ValueError:
+                return None
+        
+        try:
+            return float(aspect_ratio_input)
+        except ValueError:
+            pass
+
+        standard_ratios = {
+            '4:3': 4/3,
+            '16:9': 16/9,
+            '21:9': 21/9,
+            '1:1': 1,
+            'square': 1,
+            'portrait': 3/4,
+            'landscape': 4/3
+        }
+        
+        return standard_ratios.get(aspect_ratio_input.lower())
+
+    def calculate_new_dimensions(self, orig_width, orig_height, scale, aspect_ratio):
+        new_width = int(orig_width * scale)
+        
+        if aspect_ratio is None:
+            new_height = int(orig_height * scale)
+        else:
+            new_height = int(new_width / aspect_ratio)
+        
+        return new_width, new_height
+
+    def remove_background(self, image, background_image, model, alpha_matting, alpha_matting_foreground_threshold, 
+                          alpha_matting_background_threshold, post_process_mask, chroma_key, chroma_threshold,
+                          color_tolerance, background_mode, background_color, output_format="RGBA", 
+                          invert_mask=False, feather_amount=0, edge_detection=False, 
+                          edge_thickness=1, edge_color="#FFFFFF", shadow=False, shadow_blur=5, 
+                          shadow_opacity=0.5, color_adjustment=False, brightness=1.0, contrast=1.0, 
+                          saturation=1.0, x_position=0, y_position=0, rotation=0, opacity=1.0, 
+                          flip_horizontal=False, flip_vertical=False, mask_blur=0, mask_expansion=0,
+                          foreground_scale=1.0, foreground_aspect_ratio=None, remove_bg=True,
+                          use_custom_dimensions=False, custom_width=None, custom_height=None,
+                          output_dimension_source="Foreground"):
+        if self.session is None or self.session.model_name != model:
+            self.session = new_session(model)
+
+        bg_color = tuple(int(background_color.lstrip('#')[i:i+2], 16) for i in (0, 2, 4)) + (255,)
+        edge_color = tuple(int(edge_color.lstrip('#')[i:i+2], 16) for i in (0, 2, 4))
+
+        pil_image = image if isinstance(image, Image.Image) else Image.fromarray(np.clip(255. * image[0].cpu().numpy(), 0, 255).astype(np.uint8))
+        original_image = np.array(pil_image)
+
+        if chroma_key != "none":
+            chroma_mask = self.apply_chroma_key(original_image, chroma_key, chroma_threshold, color_tolerance)
+            input_mask = chroma_mask
+        else:
+            input_mask = None
+
+        if remove_bg:
+            removed_bg = remove(
+                pil_image,
+                session=self.session,
+                alpha_matting=alpha_matting,
+                alpha_matting_foreground_threshold=alpha_matting_foreground_threshold,
+                alpha_matting_background_threshold=alpha_matting_background_threshold,
+                post_process_mask=post_process_mask,
+            )
+            rembg_mask = np.array(removed_bg)[:, :, 3]
+        else:
+            removed_bg = pil_image.convert("RGBA")
+            rembg_mask = np.full(pil_image.size[::-1], 255, dtype=np.uint8)
+
+        if input_mask is not None:
+            final_mask = cv2.bitwise_and(rembg_mask, input_mask)
+        else:
+            final_mask = rembg_mask
+
+        final_mask = self.process_mask(final_mask, invert_mask, feather_amount, mask_blur, mask_expansion)
+
+        orig_width, orig_height = pil_image.size
+        bg_width, bg_height = background_image.size if background_image else (orig_width, orig_height)
+
+        if use_custom_dimensions and custom_width and custom_height:
+            output_width, output_height = int(custom_width), int(custom_height)
+        elif output_dimension_source == "Background" and background_image:
+            output_width, output_height = bg_width, bg_height
+        else:
+            output_width, output_height = orig_width, orig_height
+
+        aspect_ratio = self.parse_aspect_ratio(foreground_aspect_ratio)
+        new_width, new_height = self.calculate_new_dimensions(orig_width, orig_height, foreground_scale, aspect_ratio)
+
+        fg_image = pil_image.resize((new_width, new_height), Image.LANCZOS)
+        fg_mask = Image.fromarray(final_mask).resize((new_width, new_height), Image.LANCZOS)
+
+        if background_mode == "transparent":
+            result = Image.new("RGBA", (output_width, output_height), (0, 0, 0, 0))
+        elif background_mode == "color":
+            result = Image.new("RGBA", (output_width, output_height), bg_color)
+        else:  # background_mode == "image"
+            if background_image is not None:
+                result = background_image.resize((output_width, output_height), Image.LANCZOS).convert("RGBA")
+            else:
+                result = Image.new("RGBA", (output_width, output_height), (0, 0, 0, 0))
+
+        if flip_horizontal:
+            fg_image = fg_image.transpose(Image.FLIP_LEFT_RIGHT)
+            fg_mask = fg_mask.transpose(Image.FLIP_LEFT_RIGHT)
+        if flip_vertical:
+            fg_image = fg_image.transpose(Image.FLIP_TOP_BOTTOM)
+            fg_mask = fg_mask.transpose(Image.FLIP_TOP_BOTTOM)
+
+        fg_image = fg_image.rotate(rotation, resample=Image.BICUBIC, expand=True)
+        fg_mask = fg_mask.rotate(rotation, resample=Image.BICUBIC, expand=True)
+
+        paste_x = x_position + (output_width - fg_image.width) // 2
+        paste_y = y_position + (output_height - fg_image.height) // 2
+
+        fg_rgba = fg_image.convert("RGBA")
+        fg_with_opacity = Image.new("RGBA", fg_rgba.size, (0, 0, 0, 0))
+        for x in range(fg_rgba.width):
+            for y in range(fg_rgba.height):
+                r, g, b, a = fg_rgba.getpixel((x, y))
+                fg_with_opacity.putpixel((x, y), (r, g, b, int(a * opacity)))
+
+        fg_mask_with_opacity = fg_mask.point(lambda p: int(p * opacity))
+
+        result.paste(fg_with_opacity, (paste_x, paste_y), fg_mask_with_opacity)
+
+        if edge_detection:
+            edge_mask = cv2.Canny(np.array(fg_mask), 100, 200)
+            edge_mask = cv2.dilate(edge_mask, np.ones((edge_thickness, edge_thickness), np.uint8), iterations=1)
+            edge_overlay = Image.new("RGBA", (output_width, output_height), (0, 0, 0, 0))
+            edge_overlay.paste(Image.new("RGB", fg_image.size, edge_color), (paste_x, paste_y), Image.fromarray(edge_mask))
+            result = Image.alpha_composite(result, edge_overlay)
+
+        if shadow:
+            shadow_mask = fg_mask.filter(ImageFilter.GaussianBlur(shadow_blur))
+            shadow_image = Image.new("RGBA", (output_width, output_height), (0, 0, 0, 0))
+            shadow_image.paste((0, 0, 0, int(255 * shadow_opacity)), (paste_x, paste_y), shadow_mask)
+            result = Image.alpha_composite(result, shadow_image.filter(ImageFilter.GaussianBlur(shadow_blur)))
+
+        if color_adjustment:
+            enhancer = ImageEnhance.Brightness(result)
+            result = enhancer.enhance(brightness)
+            enhancer = ImageEnhance.Contrast(result)
+            result = enhancer.enhance(contrast)
+            enhancer = ImageEnhance.Color(result)
+            result = enhancer.enhance(saturation)
+
+        if output_format == "RGB":
+            result = result.convert("RGB")
+
+        return result, fg_mask
+
+    def process_frame(self, frame, *args):
+        pil_frame = Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
+        processed_frame, _ = self.remove_background(pil_frame, *args)
+        return cv2.cvtColor(np.array(processed_frame), cv2.COLOR_RGB2BGR)
+
+    def process_video(self, input_path, output_path, background_video_path, *args):
+        cap = cv2.VideoCapture(input_path)
+        fps = cap.get(cv2.CAP_PROP_FPS)
+        width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+        height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        
+        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+        out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
+
+        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        
+        if background_video_path:
+            bg_cap = cv2.VideoCapture(background_video_path)
+            bg_total_frames = int(bg_cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        
+        for frame_num in tqdm(range(total_frames), desc="Processing video"):
+            ret, frame = cap.read()
+            if not ret:
+                break
+            
+            if background_video_path:
+                bg_frame_num = frame_num % bg_total_frames
+                bg_cap.set(cv2.CAP_PROP_POS_FRAMES, bg_frame_num)
+                bg_ret, bg_frame = bg_cap.read()
+                if bg_ret:
+                    bg_frame_resized = cv2.resize(bg_frame, (width, height))
+                    args = list(args)
+                    args[1] = Image.fromarray(cv2.cvtColor(bg_frame_resized, cv2.COLOR_BGR2RGB))
+                    args = tuple(args)
+            
+            processed_frame = self.process_frame(frame, *args)
+            out.write(processed_frame)
+
+        cap.release()
+        if background_video_path:
+            bg_cap.release()
+        out.release()
+
+        # Convert output video to MP4 container
+        temp_output = output_path + "_temp.mp4"
+        os.rename(output_path, temp_output)
+        os.system(f"ffmpeg -i {temp_output} -c copy {output_path}")
+        os.remove(temp_output)
+
+
+def on_ui_tabs():
+    with gr.Blocks(analytics_enabled=False) as geeky_remb_tab:
+        gr.Markdown("# GeekyRemB: Background Removal and Image/Video Manipulation")
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                input_type = gr.Radio(["Image", "Video"], label="Input Type", value="Image")
+                foreground_input = gr.Image(label="Foreground Image", type="pil", visible=True)
+                foreground_video = gr.Video(label="Foreground Video", visible=False)
+                run_button = gr.Button(label="Run GeekyRemB")
+
+                with gr.Group():
+                    gr.Markdown("### Foreground Adjustments")
+                    foreground_scale = gr.Slider(label="Scale", minimum=0.1, maximum=5.0, value=1.0, step=0.1)
+                    foreground_aspect_ratio = gr.Textbox(
+                        label="Aspect Ratio",
+                        placeholder="e.g., 16:9, 4:3, 1:1, portrait, landscape, or leave blank for original",
+                        value=""
+                    )
+                    x_position = gr.Slider(label="X Position", minimum=-1000, maximum=1000, value=0, step=1)
+                    y_position = gr.Slider(label="Y Position", minimum=-1000, maximum=1000, value=0, step=1)
+                    rotation = gr.Slider(label="Rotation", minimum=-360, maximum=360, value=0, step=0.1)
+                    opacity = gr.Slider(label="Opacity", minimum=0.0, maximum=1.0, value=1.0, step=0.01)
+                    flip_horizontal = gr.Checkbox(label="Flip Horizontal", value=False)
+                    flip_vertical = gr.Checkbox(label="Flip Vertical", value=False)
+
+            with gr.Column(scale=1):
+                result_type = gr.Radio(["Image", "Video"], label="Output Type", value="Image")
+                result_image = gr.Image(label="Result Image", type="pil", visible=True)
+                result_video = gr.Video(label="Result Video", visible=False)
+                
+                with gr.Group():
+                    gr.Markdown("### Background Options")
+                    remove_background = gr.Checkbox(label="Remove Background", value=True)
+                    background_mode = gr.Radio(label="Background Mode", choices=["transparent", "color", "image", "video"], value="transparent")
+                    background_color = gr.ColorPicker(label="Background Color", value="#000000", visible=False)
+                    background_image = gr.Image(label="Background Image", type="pil", visible=False)
+                    background_video = gr.Video(label="Background Video", visible=False)
+
+        with gr.Accordion("Advanced Settings", open=False):
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("### Removal Settings")
+                    model = gr.Dropdown(label="Model", choices=["u2net", "u2netp", "u2net_human_seg", "u2net_cloth_seg", "silueta", "isnet-general-use", "isnet-anime"], value="u2net")
+                    output_format = gr.Radio(label="Output Format", choices=["RGBA", "RGB"], value="RGBA")
+                    alpha_matting = gr.Checkbox(label="Alpha Matting", value=False)
+                    alpha_matting_foreground_threshold = gr.Slider(label="Alpha Matting Foreground Threshold", minimum=0, maximum=255, value=240, step=1)
+                    alpha_matting_background_threshold = gr.Slider(label="Alpha Matting Background Threshold", minimum=0, maximum=255, value=10, step=1)
+                    post_process_mask = gr.Checkbox(label="Post Process Mask", value=False)
+                
+                with gr.Column():
+                    gr.Markdown("### Chroma Key Settings")
+                    chroma_key = gr.Dropdown(label="Chroma Key", choices=["none", "green", "blue", "red"], value="none")
+                    chroma_threshold = gr.Slider(label="Chroma Threshold", minimum=0, maximum=255, value=30, step=1)
+                    color_tolerance = gr.Slider(label="Color Tolerance", minimum=0, maximum=255, value=20, step=1)
+                
+                with gr.Column():
+                    gr.Markdown("### Effects")
+                    invert_mask = gr.Checkbox(label="Invert Mask", value=False)
+                    feather_amount = gr.Slider(label="Feather Amount", minimum=0, maximum=100, value=0, step=1)
+                    edge_detection = gr.Checkbox(label="Edge Detection", value=False)
+                    edge_thickness = gr.Slider(label="Edge Thickness", minimum=1, maximum=10, value=1, step=1)
+                    edge_color = gr.ColorPicker(label="Edge Color", value="#FFFFFF")
+                    shadow = gr.Checkbox(label="Shadow", value=False)
+                    shadow_blur = gr.Slider(label="Shadow Blur", minimum=0, maximum=20, value=5, step=1)
+                    shadow_opacity = gr.Slider(label="Shadow Opacity", minimum=0.0, maximum=1.0, value=0.5, step=0.1)
+                    color_adjustment = gr.Checkbox(label="Color Adjustment", value=False)
+                    brightness = gr.Slider(label="Brightness", minimum=0.0, maximum=2.0, value=1.0, step=0.1)
+                    contrast = gr.Slider(label="Contrast", minimum=0.0, maximum=2.0, value=1.0, step=0.1)
+                    saturation = gr.Slider(label="Saturation", minimum=0.0, maximum=2.0, value=1.0, step=0.1)
+                    mask_blur = gr.Slider(label="Mask Blur", minimum=0, maximum=100, value=0, step=1)
+                    mask_expansion = gr.Slider(label="Mask Expansion", minimum=-100, maximum=100, value=0, step=1)
+
+            with gr.Row():
+                gr.Markdown("### Output Settings")
+                image_format = gr.Dropdown(label="Image Format", choices=["PNG", "JPEG", "WEBP"], value="PNG")
+                video_format = gr.Dropdown(label="Video Format", choices=["MP4", "AVI", "MOV"], value="MP4")
+                video_quality = gr.Slider(label="Video Quality", minimum=0, maximum=100, value=95, step=1)
+                use_custom_dimensions = gr.Checkbox(label="Use Custom Dimensions", value=False)
+                custom_width = gr.Number(label="Custom Width", value=512, visible=False)
+                custom_height = gr.Number(label="Custom Height", value=512, visible=False)
+                output_dimension_source = gr.Radio(
+                    label="Output Dimension Source",
+                    choices=["Foreground", "Background"],
+                    value="Foreground",
+                    visible=True
+                )
+
+        def update_input_type(choice):
+            return {
+                foreground_input: gr.update(visible=choice == "Image"),
+                foreground_video: gr.update(visible=choice == "Video"),
+            }
+
+        def update_output_type(choice):
+            return {
+                result_image: gr.update(visible=choice == "Image"),
+                result_video: gr.update(visible=choice == "Video"),
+            }
+
+        def update_background_mode(mode):
+            return {
+                background_color: gr.update(visible=mode == "color"),
+                background_image: gr.update(visible=mode == "image"),
+                background_video: gr.update(visible=mode == "video"),
+            }
+
+        def update_custom_dimensions(use_custom):
+            return {
+                custom_width: gr.update(visible=use_custom),
+                custom_height: gr.update(visible=use_custom),
+                output_dimension_source: gr.update(visible=not use_custom)
+            }
+
+        def process_image(image, background_image, *args):
+            geeky_remb = GeekyRemB()
+            result, _ = geeky_remb.remove_background(image, background_image, *args)
+            return result
+
+        def process_video(video_path, background_video_path, *args):
+            geeky_remb = GeekyRemB()
+            with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as temp_file:
+                output_path = temp_file.name
+            geeky_remb.process_video(video_path, output_path, background_video_path, *args)
+            return output_path
+
+        def run_geeky_remb(input_type, foreground_input, foreground_video, result_type, model, output_format, 
+                           alpha_matting, alpha_matting_foreground_threshold, alpha_matting_background_threshold, 
+                           post_process_mask, chroma_key, chroma_threshold, color_tolerance, background_mode, 
+                           background_color, background_image, background_video, invert_mask, feather_amount, 
+                           edge_detection, edge_thickness, edge_color, shadow, shadow_blur, shadow_opacity, 
+                           color_adjustment, brightness, contrast, saturation, x_position, y_position, rotation, 
+                           opacity, flip_horizontal, flip_vertical, mask_blur, mask_expansion, foreground_scale, 
+                           foreground_aspect_ratio, remove_background, image_format, video_format, video_quality,
+                           use_custom_dimensions, custom_width, custom_height, output_dimension_source):
+            
+            args = (model, alpha_matting, alpha_matting_foreground_threshold,
+                    alpha_matting_background_threshold, post_process_mask, chroma_key, chroma_threshold,
+                    color_tolerance, background_mode, background_color, output_format,
+                    invert_mask, feather_amount, edge_detection, edge_thickness, edge_color, shadow, shadow_blur,
+                    shadow_opacity, color_adjustment, brightness, contrast, saturation, x_position,
+                    y_position, rotation, opacity, flip_horizontal, flip_vertical, mask_blur,
+                    mask_expansion, foreground_scale, foreground_aspect_ratio, remove_background,
+                    use_custom_dimensions, custom_width, custom_height, output_dimension_source)
+
+            if input_type == "Image" and result_type == "Image":
+                result = process_image(foreground_input, background_image, *args)
+                if image_format != "PNG":
+                    result = result.convert("RGB")
+                with tempfile.NamedTemporaryFile(delete=False, suffix=f".{image_format.lower()}") as temp_file:
+                    result.save(temp_file.name, format=image_format, quality=95 if image_format == "JPEG" else None)
+                    return temp_file.name, None
+            elif input_type == "Video" and result_type == "Video":
+                output_video = process_video(foreground_video, background_video if background_mode == "video" else None, *args)
+                if video_format != "MP4":
+                    temp_output = output_video + f"_temp.{video_format.lower()}"
+                    os.system(f"ffmpeg -i {output_video} -c:v libx264 -crf {int(20 - (video_quality / 5))} {temp_output}")
+                    os.remove(output_video)
+                    output_video = temp_output
+                return None, output_video
+            elif input_type == "Image" and result_type == "Video":
+                with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as temp_file:
+                    output_path = temp_file.name
+                frame = cv2.cvtColor(np.array(foreground_input), cv2.COLOR_RGB2BGR)
+                height, width = frame.shape[:2]
+                fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+                out = cv2.VideoWriter(output_path, fourcc, 24, (width, height))
+                for _ in range(24 * 5):  # 5 seconds at 24 fps
+                    out.write(frame)
+                out.release()
+                return None, process_video(output_path, background_video if background_mode == "video" else None, *args)
+            elif input_type == "Video" and result_type == "Image":
+                cap = cv2.VideoCapture(foreground_video)
+                ret, frame = cap.read()
+                cap.release()
+                if ret:
+                    pil_frame = Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
+                    result = process_image(pil_frame, background_image, *args)
+                    if image_format != "PNG":
+                        result = result.convert("RGB")
+                    with tempfile.NamedTemporaryFile(delete=False, suffix=f".{image_format.lower()}") as temp_file:
+                        result.save(temp_file.name, format=image_format, quality=95 if image_format == "JPEG" else None)
+                        return temp_file.name, None
+                else:
+                    return None, None
+
+        input_type.change(update_input_type, inputs=[input_type], outputs=[foreground_input, foreground_video])
+        result_type.change(update_output_type, inputs=[result_type], outputs=[result_image, result_video])
+        background_mode.change(update_background_mode, inputs=[background_mode], outputs=[background_color, background_image, background_video])
+        use_custom_dimensions.change(update_custom_dimensions, inputs=[use_custom_dimensions], outputs=[custom_width, custom_height, output_dimension_source])
+
+        run_button.click(
+            fn=run_geeky_remb,
+            inputs=[
+                input_type, foreground_input, foreground_video, result_type,
+                model, output_format, alpha_matting, alpha_matting_foreground_threshold,
+                alpha_matting_background_threshold, post_process_mask, chroma_key, chroma_threshold,
+                color_tolerance, background_mode, background_color, background_image, background_video,
+                invert_mask, feather_amount, edge_detection, edge_thickness, edge_color,
+                shadow, shadow_blur, shadow_opacity, color_adjustment, brightness, contrast,
+                saturation, x_position, y_position, rotation, opacity, flip_horizontal,
+                flip_vertical, mask_blur, mask_expansion, foreground_scale, foreground_aspect_ratio,
+                remove_background, image_format, video_format, video_quality,
+                use_custom_dimensions, custom_width, custom_height, output_dimension_source
+            ],
+            outputs=[result_image, result_video]
+        )
+
+    return [(geeky_remb_tab, "GeekyRemB", "geeky_remb_tab")]
+
+
+script_callbacks.on_ui_tabs(on_ui_tabs)

extensions/CFGRescale_For_Forge/LICENSE

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

extensions/CFGRescale_For_Forge/README.md

@@ -0,0 +1,6 @@
+# CFGRescale_For_Forge
+The CFGRescale extension from A1111, adjusted for Forge.
+
+Taken from https://github.com/Seshelle/CFG_Rescale_webui and modified to be integrated in forge (https://github.com/lllyasviel/stable-diffusion-webui-forge).
+
+Just drop the folders in your Forge folder and enable it in the web interface. Defaulted to 0.7 rescale. Personally, I like using Cfg at 3.0 with LCM Lora.

extensions/CFGRescale_For_Forge/extensions-builtin/sd_forge_cfgrescale/scripts/forge_cfgrescale.py

@@ -0,0 +1,45 @@
+import gradio as gr
+
+from modules import scripts
+from ldm_patched.contrib.external_cfgrescale import RescaleCFG
+
+opRescaleCFG = RescaleCFG()
+
+class CFGRescaleForForge(scripts.Script):
+    def title(self):
+        return "CFGRescale Integrated"
+
+    def show(self, is_img2img):
+        # make this extension visible in both txt2img and img2img tab.
+        return scripts.AlwaysVisible
+
+    def ui(self, *args, **kwargs):
+        with gr.Accordion(open=False, label=self.title()):
+            cfgrescale_enabled = gr.Checkbox(label='Enabled', value=True)
+            multiplier = gr.Slider(label='Multiplier', minimum=0, maximum=1, step=0.01, value=0.7)
+
+        return cfgrescale_enabled, multiplier
+
+    def process_before_every_sampling(self, p, *script_args, **kwargs):
+        # This will be called before every sampling.
+        # If you use highres fix, this will be called twice.
+
+        cfgrescale_enabled, multiplier = script_args
+
+        if not cfgrescale_enabled:
+            return
+
+        unet = p.sd_model.forge_objects.unet
+
+        unet = opRescaleCFG.patch(unet, multiplier)[0]
+
+        p.sd_model.forge_objects.unet = unet
+
+        # Below codes will add some logs to the texts below the image outputs on UI.
+        # The extra_generation_params does not influence results.
+        p.extra_generation_params.update(dict(
+            cfgrescale_enabled=cfgrescale_enabled,
+            multiplier=multiplier,
+        ))
+
+        return

extensions/CFGRescale_For_Forge/ldm_patched/contrib/external_cfgrescale.py

@@ -0,0 +1,44 @@
+import torch
+
+class RescaleCFG:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": { "model": ("MODEL",),
+                              "multiplier": ("FLOAT", {"default": 0.7, "min": 0.0, "max": 1.0, "step": 0.01}),
+                              }}
+    RETURN_TYPES = ("MODEL",)
+    FUNCTION = "patch"
+
+    CATEGORY = "advanced/model"
+
+    def patch(self, model, multiplier):
+        def rescale_cfg(args):
+            cond = args["cond"]
+            uncond = args["uncond"]
+            cond_scale = args["cond_scale"]
+            sigma = args["sigma"]
+            sigma = sigma.view(sigma.shape[:1] + (1,) * (cond.ndim - 1))
+            x_orig = args["input"]
+
+            #rescale cfg has to be done on v-pred model output
+            x = x_orig / (sigma * sigma + 1.0)
+            cond = ((x - (x_orig - cond)) * (sigma ** 2 + 1.0) ** 0.5) / (sigma)
+            uncond = ((x - (x_orig - uncond)) * (sigma ** 2 + 1.0) ** 0.5) / (sigma)
+
+            #rescalecfg
+            x_cfg = uncond + cond_scale * (cond - uncond)
+            ro_pos = torch.std(cond, dim=(1,2,3), keepdim=True)
+            ro_cfg = torch.std(x_cfg, dim=(1,2,3), keepdim=True)
+
+            x_rescaled = x_cfg * (ro_pos / ro_cfg)
+            x_final = multiplier * x_rescaled + (1.0 - multiplier) * x_cfg
+
+            return x_orig - (x - x_final * sigma / (sigma * sigma + 1.0) ** 0.5)
+
+        m = model.clone()
+        m.set_model_sampler_cfg_function(rescale_cfg)
+        return (m, )
+
+NODE_CLASS_MAPPINGS = {
+    "RescaleCFG": RescaleCFG,
+}

extensions/CFG_Rescale_webui/.gitignore

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

extensions/CFG_Rescale_webui/LICENSE

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

extensions/CFG_Rescale_webui/README.md

@@ -0,0 +1,10 @@
+# CFG_Rescale_webui
+Adds a CFG rescale option to A1111 webui for vpred models. Implements features described in https://arxiv.org/pdf/2305.08891.pdf
+
+When installed, you will see a CFG slider below appear below the seed selection.
+
+The recommended settings from the paper is 0.7 CFG rescale. The paper recommends using it at 7.5 CFG, but I find that the default 7.0 CFG works just fine as well.
+If you notice your images are dull or muddy, try setting CFG Rescale to 0.5 and/or turning on color fix.
+
+# Extra Features
+Auto color fix: CFG rescale can result in the color palette of the image becoming smaller, resulting in muddy or brown images. Turning this on attempts to return the image colors to full range again, making it appear more vibrant and natural.

extensions/CFG_Rescale_webui/scripts/CFGRescale.py

@@ -0,0 +1,225 @@
+import math
+import torch
+import re
+import gradio as gr
+import numpy as np
+import modules.scripts as scripts
+import modules.images as saving
+from modules import devices, processing, shared, sd_samplers_kdiffusion, sd_samplers_compvis, script_callbacks
+from modules.processing import Processed
+from modules.shared import opts, state
+from ldm.models.diffusion import ddim
+from PIL import Image
+
+from ldm.modules.diffusionmodules.util import make_ddim_sampling_parameters, noise_like
+
+re_prompt_cfgr = re.compile(r"<cfg_rescale:([^>]+)>")
+
+class Script(scripts.Script):
+
+    def __init__(self):
+        self.old_denoising = sd_samplers_kdiffusion.CFGDenoiser.combine_denoised
+        self.old_schedule = ddim.DDIMSampler.make_schedule
+        self.old_sample = ddim.DDIMSampler.p_sample_ddim
+        globals()['enable_furry_cocks'] = True
+
+        def find_module(module_names):
+            if isinstance(module_names, str):
+                module_names = [s.strip() for s in module_names.split(",")]
+            for data in scripts.scripts_data:
+                if data.script_class.__module__ in module_names and hasattr(data, "module"):
+                    return data.module
+            return None
+
+        def rescale_opt(p, x, xs):
+            globals()['cfg_rescale_fi'] = x
+            globals()['enable_furry_cocks'] = False
+
+        xyz_grid = find_module("xyz_grid.py, xy_grid.py")
+        if xyz_grid:
+            extra_axis_options = [xyz_grid.AxisOption("Rescale CFG", float, rescale_opt)]
+            xyz_grid.axis_options.extend(extra_axis_options)
+
+    def title(self):
+        return "CFG Rescale Extension"
+
+    def show(self, is_img2img):
+        return scripts.AlwaysVisible
+
+    def ui(self, is_img2img):
+        with gr.Accordion("CFG Rescale", open=True, elem_id="cfg_rescale"):
+            rescale = gr.Slider(label="CFG Rescale", show_label=False, minimum=0.0, maximum=1.0, step=0.01, value=0.0)
+            with gr.Row():
+                recolor = gr.Checkbox(label="Auto Color Fix", default=False)
+                rec_strength = gr.Slider(label="Fix Strength", interactive=True, visible=False,
+                                         elem_id=self.elem_id("rec_strength"), minimum=0.1, maximum=10.0, step=0.1,
+                                         value=1.0)
+                show_original = gr.Checkbox(label="Keep Original Images", elem_id=self.elem_id("show_original"), visible=False, default=False)
+
+            def show_recolor_strength(rec_checked):
+                return [gr.update(visible=rec_checked), gr.update(visible=rec_checked)]
+
+            recolor.change(
+                fn=show_recolor_strength,
+                inputs=recolor,
+                outputs=[rec_strength, show_original]
+            )
+
+        self.infotext_fields = [
+            (rescale, "CFG Rescale"),
+            (recolor, "Auto Color Fix")
+        ]
+        self.paste_field_names = []
+        for _, field_name in self.infotext_fields:
+            self.paste_field_names.append(field_name)
+        return [rescale, recolor, rec_strength, show_original]
+
+    def cfg_replace(self, x_out, conds_list, uncond, cond_scale):
+        denoised_uncond = x_out[-uncond.shape[0]:]
+        denoised = torch.clone(denoised_uncond)
+        fi = globals()['cfg_rescale_fi']
+
+        for i, conds in enumerate(conds_list):
+            for cond_index, weight in conds:
+                if fi == 0:
+                    denoised[i] += (x_out[cond_index] - denoised_uncond[i]) * (weight * cond_scale)
+                else:
+                    xcfg = (denoised_uncond[i] + (x_out[cond_index] - denoised_uncond[i]) * (cond_scale * weight))
+                    xrescaled = (torch.std(x_out[cond_index]) / torch.std(xcfg))
+                    xfinal = fi * xrescaled + (1.0 - fi)
+                    denoised[i] = xfinal * xcfg
+
+        return denoised
+
+    def process(self, p, rescale, recolor, rec_strength, show_original):
+
+        if globals()['enable_furry_cocks']:
+            # parse <cfg_rescale:[number]> from prompt for override
+            rescale_override = None
+            def found(m):
+                nonlocal rescale_override
+                try:
+                    rescale_override = float(m.group(1))
+                except ValueError:
+                    rescale_override = None
+                return ""
+            p.prompt = re.sub(re_prompt_cfgr, found, p.prompt)
+            if rescale_override is not None:
+                rescale = rescale_override
+            
+            globals()['cfg_rescale_fi'] = rescale
+        else:
+            # rescale value is being set from xyz_grid
+            rescale = globals()['cfg_rescale_fi']
+        globals()['enable_furry_cocks'] = True
+
+        sd_samplers_kdiffusion.CFGDenoiser.combine_denoised = self.cfg_replace
+
+        if rescale > 0:
+            p.extra_generation_params["CFG Rescale"] = rescale
+
+        if recolor:
+            p.extra_generation_params["Auto Color Fix Strength"] = rec_strength
+            p.do_not_save_samples = True
+
+    def postprocess_batch_list(self, p, pp, rescale, recolor, rec_strength, show_original, batch_number):
+        if recolor and show_original:
+            num = len(pp.images)
+            for i in range(num):
+                pp.images.append(pp.images[i])
+                p.prompts.append(p.prompts[i])
+                p.negative_prompts.append(p.negative_prompts[i])
+                p.seeds.append(p.seeds[i])
+                p.subseeds.append(p.subseeds[i])
+
+    def postprocess(self, p, processed, rescale, recolor, rec_strength, show_original):
+        sd_samplers_kdiffusion.CFGDenoiser.combine_denoised = self.old_denoising
+
+        def postfix(img, rec_strength):
+            prec = 0.0005 * rec_strength
+            r, g, b = img.split()
+
+            # softer effect
+            # r_min, r_max = np.percentile(r, p), np.percentile(r, 100.0 - p)
+            # g_min, g_max = np.percentile(g, p), np.percentile(g, 100.0 - p)
+            # b_min, b_max = np.percentile(b, p), np.percentile(b, 100.0 - p)
+
+            rh, rbins = np.histogram(r, 256, (0, 256))
+            tmp = np.where(rh > rh.sum() * prec)[0]
+            r_min = tmp.min()
+            r_max = tmp.max()
+
+            gh, gbins = np.histogram(g, 256, (0, 256))
+            tmp = np.where(gh > gh.sum() * prec)[0]
+            g_min = tmp.min()
+            g_max = tmp.max()
+
+            bh, bbins = np.histogram(b, 256, (0, 256))
+            tmp = np.where(bh > bh.sum() * prec)[0]
+            b_min = tmp.min()
+            b_max = tmp.max()
+
+            r = r.point(lambda i: int(255 * (min(max(i, r_min), r_max) - r_min) / (r_max - r_min)))
+            g = g.point(lambda i: int(255 * (min(max(i, g_min), g_max) - g_min) / (g_max - g_min)))
+            b = b.point(lambda i: int(255 * (min(max(i, b_min), b_max) - b_min) / (b_max - b_min)))
+
+            new_img = Image.merge("RGB", (r, g, b))
+
+            return new_img
+
+        if recolor:
+            grab = 0
+            n_img = len(processed.images)
+            for i in range(n_img):
+                doit = False
+
+                if show_original:
+                    check = i
+                    if opts.return_grid:
+                        if i == 0:
+                            continue
+                        else:
+                            check = check - 1
+                    doit = check % (p.batch_size * 2) >= p.batch_size
+                else:
+                    if n_img > 1 and i != 0:
+                        doit = True
+                    elif n_img == 1 or not opts.return_grid:
+                        doit = True
+
+                if doit:
+                    res_img = postfix(processed.images[i], rec_strength)
+                    if opts.samples_save:
+                        ind = grab
+                        grab += 1
+                        prompt_infotext = processing.create_infotext(p, p.all_prompts, p.all_seeds, p.all_subseeds,
+                                                                     index=ind)
+                        # Save images to disk
+                        if opts.samples_save:
+                                saving.save_image(processed.images[i], p.outpath_samples, "", seed=p.all_seeds[ind],
+                                                  prompt=p.all_prompts[ind],
+                                                  info=prompt_infotext, p=p, suffix="colorfix")
+                                saving.save_image(res_img, p.outpath_samples, "", seed=p.all_seeds[ind],
+                                                  prompt=p.all_prompts[ind],
+                                                  info=prompt_infotext, p=p, suffix="colorfix")
+
+                    processed.images[i] = res_img
+
+
+def on_infotext_pasted(infotext, params):
+    if "CFG Rescale" not in params:
+        params["CFG Rescale"] = 0
+
+        if "CFG Rescale φ" in params:
+            params["CFG Rescale"] = params["CFG Rescale φ"]
+            del params["CFG Rescale φ"]
+
+        if "CFG Rescale phi" in params and scripts.scripts_txt2img.script("Neutral Prompt") is None:
+            params["CFG Rescale"] = params["CFG Rescale phi"]
+            del params["CFG Rescale phi"]
+
+    if "DDIM Trailing" not in params:
+        params["DDIM Trailing"] = False
+
+
+script_callbacks.on_infotext_pasted(on_infotext_pasted)

extensions/CharacteristicGuidanceWebUI/LICENSE

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

extensions/CharacteristicGuidanceWebUI/README.md

@@ -0,0 +1,184 @@
+# Characteristic Guidance Web UI (enhanced sampling for high CFG scale)
+
+## About
+Characteristic Guidance Web UI is an extension of for the Stable Diffusion web UI (AUTOMATIC1111). It offers a theory-backed guidance sampling method with improved sample and control quality at high CFG scale (10-30). 
+
+This is the official implementation of [Characteristic Guidance: Non-linear Correction for Diffusion Model at Large Guidance Scale](https://arxiv.org/abs/2312.07586). We are happy to announce that this work has been accepted by ICML 2024.
+
+## News
+
+We release the Turbo version of characteristic guidance. 
+  - Easier to use: much fewer parameters to choose
+  - Speed optimization (~2x faster)
+  - Stability improvement (better convergence at initial steps)
+    
+Please try the Turbo version by swiching to the branch Turbo_dev. （If you are forge user, please use Karras schedule or unipic to avoid artifacts）
+
+## Features
+Characteristic guidance offers improved sample generation and control at high CFG scale. Try characteristic guidance for
+- Detail refinement
+- Fixing quality issues, like
+  - Weird colors and styles
+  - Bad anatomy (not guaranteed :rofl:, works better on Stable Diffusion XL)
+  - Strange backgrounds
+    
+Characteristic guidance is compatible with every existing sampling methods in Stable Diffusion WebUI. It now have preliminary support for **Forge UI** and ControlNet.
+![1girl running mountain grass](https://github.com/scraed/CharacteristicGuidance/blob/master/static/images/1girl%2C%20running%2C%20mountain%2C%20grass.jpg?raw=true) 
+![newspaper news english](https://github.com/scraed/CharacteristicGuidance/blob/master/static/images/newspaper%20news%20english.jpg?raw=true)
+![1girl, handstand, sports, close_up](https://github.com/scraed/CharacteristicGuidance/blob/master/static/images/1girl%20handstand%20sports%20close_up.jpg?raw=true)
+![StrawberryPancake](https://github.com/scraed/CharacteristicGuidance/blob/master/static/images/StrawberryPancake.jpg?raw=true)
+![1girl, kimono](https://scraed.github.io/CharacteristicGuidance/static/images/1girl%20kimono.jpg?raw=true)
+
+For more information and previews, please visit our project website: [Characteristic Guidance Project Website](https://scraed.github.io/CharacteristicGuidance/). 
+
+Q&A: What's the difference with [Dynamical Thresholding](https://github.com/mcmonkeyprojects/sd-dynamic-thresholding)?
+
+They are distinct and independent methods, can be used either independently or in conjunction.
+
+- **Characteristic Guidance**: Corrects both context and color, works at the given CFG scale, iteratively corrects **input** of the U-net according to the Fokker-Planck equation. 
+- **Dynamical Thresholding**:  Mainly focusing on color, works to mimic lower CFG scales, clips and rescales **output** of the U-net.
+
+Using [Characteristic Guidance](#) and Dynamical Thresholding simutaneously may further reduce saturation.
+
+![1girl_handstand_sportswear_gym](https://github.com/scraed/CharacteristicGuidance/blob/master/static/images/1girl_handstand_sportswear_gym.jpg?raw=true) 
+
+## Prerequisites
+Before installing and using the Characteristic Guidance Web UI, ensure that you have the following prerequisites met:
+
+- **Stable Diffusion WebUI (AUTOMATIC1111)**: Your system must have the [Stable Diffusion WebUI](https://github.com/AUTOMATIC1111/stable-diffusion-webui) by AUTOMATIC1111 installed. This interface is the foundation on which the Characteristic Guidance Web UI operates.
+- **Version Requirement**: The extension is developed for Stable Diffusion WebUI **v1.6.0 or higher**. It may works for previous versions but not guaranteed.
+
+## Installation
+Follow these steps to install the Characteristic Guidance Web UI extension:
+
+1. Navigate to the "Extensions" tab in the Stable Diffusion web UI.
+2. In the "Extensions" tab, select the "Install from URL" option.
+3. Enter the URL `https://github.com/scraed/CharacteristicGuidanceWebUI.git` into the "URL for extension's git repository" field.
+4. Click on the "Install" button.
+5. After waiting for several seconds, a confirmation message should appear indicating successful installation: "Installed into stable-diffusion-webui\extensions\CharacteristicGuidanceWebUI. Use the Installed tab to restart".
+6. Proceed to the "Installed" tab. Here, click "Check for updates", followed by "Apply and restart UI" for the changes to take effect. Note: Use these buttons for future updates to the CharacteristicGuidanceWebUI as well.
+
+## Usage
+The Characteristic Guidance Web UI features an interactive interface for both txt2img and img2img mode. 
+![Gradio UI for CharacteristicGuidanceWebUI](https://github.com/scraed/CharacteristicGuidanceWebUI/blob/main/CHGextension_pic.PNG?raw=true)
+
+**The characteristic guidance is slow compared to classifier-free guidance. We recommend the user to generate image with classifier-free guidance at first, then try characteristic guidance with the same prompt and seed to enhance the image.**
+
+### Activation
+- `Enable` Checkbox: Toggles the activation of the Characteristic Guidance features.
+
+### Visualization and Testing
+- `Check Convergence` Button: Allows users to test and visualize the convergence of their settings. Adjust the regularization parameters if the convergence is not satisfactory.
+
+In practice, convergence is not always guaranteed. **If characteristic guidance fails to converge at a certain time step, classifier-free guidance will be adopted at that time step**. 
+
+Below are the parameters you can adjust to customize the behavior of the guidance correction:
+
+### Basic Parameters
+- `Regularization Strength`: Range 0.0 to 10.0 (default: 1). Adjusts the strength of regularization at the beginning of sampling, larger regularization means easier convergence and closer alignment with CFG (Classifier Free Guidance).
+- `Regularization Range Over Time`: Range 0.01 to 10.0 (default: 1). Modifies the range of time being regularized, larger time means slow decay in regularization strength hence more time steps being regularized, affecting convergence difficulty and the extent of correction.
+- `Max Num. Characteristic Iteration`: Range 1 to 50 (default: 50). Determines the maximum number of characteristic iterations per sampling time step.
+- `Num. Basis for Correction`: Range 0 to 10 (default: 0). Sets the number of bases for correction, influencing the amount of correction and convergence behavior. More basis means better quality but harder convergence. Basis number = 0 means batch-wise correction, > 0 means channel-wise correction. 
+- `CHG Start Step`: Range 0 to 0.25 (default: 0). Characteristic guidance begins to influence the process from the specified percentage of steps, indicated by `CHG Start Step`.
+- `CHG End Step`: Range 0.25 to 1 (default: 0). Characteristic guidance ceases to have an effect from the specified percentage of steps, denoted by `CHG End Step`. Setting this value to approximately 0.4 can significantly speed up the generation process without substantially altering the outcome.
+- `ControlNet Compatible Mode`
+  - `More Prompt`: Controlnet is turned off when iteratively solving characteristic guidance correction.
+  - `More ControlNet`: Controlnet is turned on when iteratively solving characteristic guidance correction.
+
+### Advanced Parameters
+- `Reuse Correction of Previous Iteration`: Range 0.0 to 1.0 (default: 1.0). Controls the reuse of correction from previous iterations to reduce abrupt changes during generation.
+- `Log 10 Tolerance for Iteration Convergence`: Range -6 to -2 (default: -4). Adjusts the tolerance for iteration convergence, trading off between speed and image quality.
+- `Iteration Step Size`: Range 0 to 1 (default: 1.0). Sets the step size for each iteration, affecting the speed of convergence.
+- `Regularization Annealing Speed`: Range 0.0 to 1.0 (default: 0.4). How fast the regularization strength decay to desired rate. Smaller value potentially easing convergence.
+- `Regularization Annealing Strength`: Range 0.0 to 5 (default: 0.5). Determines the how important regularization annealing is in characteristic guidance interations. Higher value means higher priority to bring regularization level to specified regularization strength. Affecting the balance between annealing and convergence.
+- `AA Iteration Memory Size`: Range 1 to 10 (default: 2). Specifies the memory size for AA (Anderson Acceleration) iterations, influencing convergence speed and stability.
+
+
+Please experiment with different settings, especially **regularization strength and time range**, to achieve better convergence for your specific use case. (According to my experience, high CFG scale need relatively large regularization strength and time range for convergence, while low CFG scale prefers lower regularization strength and time range for more guidance correction.)
+
+### How to Set Parameters (Preliminary Guide)
+Here is my recommended approach for parameter setting:
+
+1. Start by running characteristic guidance with the default parameters (Use `Regularization Strength`=5 for Stable Diffusion XL).
+2. Verify convergence by clicking the `Check Convergence` button.
+3. If convergence is achieved easily:
+   - Decrease the `Regularization Strength` and `Regularization Range Over Time` to enhance correction.
+   - If the `Regularization Strength` is already minimal, consider increasing the `Num. Basis for Correction` for improved performance.
+4. If convergence is not reached:
+   - Increment the `Max Num. Characteristic Iteration` to allow for additional iterations.
+   - Should convergence still not occur, raise the `Regularization Strength` and `Regularization Range Over Time` for increased regularization.
+
+
+
+## Updates
+### July 9, 2024: Release Turbo_dev branch.
+- New technique to stablize the iteration at beginning steps
+- Avoid redundant iteration steps to accelerate generation. 
+
+
+### June 24, 2024: Preliminary Support for Forge.
+- **Thanks to our team member [@charrywhite](https://github.com/charrywhite)**: The UI now have preliminary supports [forge](https://github.com/lllyasviel/stable-diffusion-webui-forge).
+- Fixed minor incompatibility with WebUI v1.9
+
+
+### February 3, 2024: New parameters accelerating the generation.
+- **Thanks to [@v0xie](https://github.com/v0xie)**: The UI now supports two more parameters.
+- `CHG Start Step`: Range 0 to 0.25 (default: 0). Characteristic guidance begins to influence the process from the specified percentage of steps, indicated by `CHG Start Step`.
+- `CHG End Step`: Range 0.25 to 1 (default: 0). Characteristic guidance ceases to have an effect from the specified percentage of steps, denoted by `CHG End Step`. Setting this value to approximately 0.4 can significantly **speed up** the generation process without substantially altering the outcome.
+
+### January 28, 2024: Modify how parameter `Reuse Correction of Previous Iteration` works
+- **Effect**: Move parameter `Reuse Correction of Previous Iteration` to advanced parameters. Its default value is set to 1 to accelerate convergence. It is now using the same update direction as the case `Reuse Correction of Previous Iteration` = 0 regardless of its value. 
+- **User Action Required**: Please delete "ui-config.json" from the stable diffusion WebUI root directory for the update to take effect.
+- **Issue**: Infotext with `Reuse Correction of Previous Iteration` > 0 may not generate the same image as previous version.
+
+### January 28, 2024: Allow Num. Basis for Correction = 0
+- **Effect**: Now the Num. Basis for Correction can takes value 0 which means batch-wise correction instead of channel-wise correction. It is a more suitable default value since it converges faster.
+- **User Action Required**: Please delete "ui-config.json" from the stable diffusion WebUI root directory for the update to take effect.
+
+### January 14, 2024: Bug fix: allow prompts with more than 75 tokens
+- **Effect**: Now the extension still works if the prompt have more than 75 tokens.
+
+### January 13, 2024: Add support for V-Prediction model 
+- **Effect**: Now the extension supports models trained in V-prediction mode.
+
+### January 12, 2024: Add support for 'AND' prompt combination 
+- **Effect**: Now the extension supports the 'AND' word in positive prompt.
+- **Current Limitations**: Note that characteristic guidance only give correction between positive and negative prompt. Therefore positive prompts combined by 'AND' will be averaged when computing the correction.
+
+### January 8, 2024: Improved Guidance Settings
+- **Extended Settings Range**: `Regularization Strength` & `Regularization Range Over Time` can now go up to 10.
+- **Effect**: Reproduce classifier-free guidance results at high values of `Regularization Strength` & `Regularization Range Over Time`.
+- **User Action Required**: Please delete "ui-config.json" from the stable diffusion WebUI root directory for the update to take effect.
+
+### January 6, 2024: Integration of ControlNet
+- **Early Support**: We're excited to announce preliminary support for ControlNet.
+- **Current Limitations**: As this is an early stage, expect some developmental issues. The integration of ControlNet and characteristic guidance remains a scientific open problem (which I am investigating). Known issues include:
+   - Iterations failing to converge when ControlNet is in reference mode.
+
+### January 3, 2024: UI Enhancement for Infotext
+- **Thanks to [@w-e-w](https://github.com/w-e-w)**: The UI now supports infotext reading.
+- **How to Use**: Check out this [PR](https://github.com/scraed/CharacteristicGuidanceWebUI/pull/1) for detailed instructions.
+
+
+## Compatibility and Issues
+
+### July 9, 2024: Bad Turbo_dev branch output on Forge.
+- Sometimes the generated images has wierd artifacts on Forge Turbo_dev. Please use Karras schedule to avoid it.
+
+### June 24, 2024: Inconsistent Forge Implementation.
+- Note that the current forge implementation of CHG does not always generate the same image as CHG on WebUI. See this [pull request](https://github.com/scraed/CharacteristicGuidanceWebUI/pull/13). We are still investigating why it happends.
+
+
+## Citation
+If you utilize characteristic guidance in your research or projects, please consider citing our paper:
+```bibtex
+@misc{zheng2023characteristic,
+      title={Characteristic Guidance: Non-linear Correction for DDPM at Large Guidance Scale},
+      author={Candi Zheng and Yuan Lan},
+      year={2023},
+      eprint={2312.07586},
+      archivePrefix={arXiv},
+      primaryClass={cs.CV}
+}
+
+

extensions/CharacteristicGuidanceWebUI/scripts/CHGextension.py

@@ -0,0 +1,439 @@
+import modules.scripts as scripts
+import gradio as gr
+
+import io
+import json
+import matplotlib.pyplot as plt
+from PIL import Image
+import numpy as np
+import inspect
+import torch
+from modules import prompt_parser, devices, sd_samplers_common
+import re
+from modules.shared import opts, state
+import modules.shared as shared
+from modules.script_callbacks import CFGDenoiserParams, cfg_denoiser_callback
+from modules.script_callbacks import CFGDenoisedParams, cfg_denoised_callback
+from modules.script_callbacks import AfterCFGCallbackParams, cfg_after_cfg_callback
+import k_diffusion.utils as utils
+from k_diffusion.external import CompVisVDenoiser, CompVisDenoiser
+from modules.sd_samplers_timesteps import CompVisTimestepsDenoiser, CompVisTimestepsVDenoiser
+from modules.sd_samplers_cfg_denoiser import CFGDenoiser, catenate_conds, subscript_cond, pad_cond
+from modules import script_callbacks
+from scripts.CharaIte import Chara_iteration
+
+try:
+    from modules_forge import forge_sampler
+    isForge = True
+except Exception:
+    isForge = False
+
+######## Infotext processing ##########
+quote_swap = str.maketrans('\'"', '"\'')
+
+
+def pares_infotext(infotext, params):
+    # parse infotext decode json string
+    try:
+        params['CHG'] = json.loads(params['CHG'].translate(quote_swap))
+    except Exception:
+        pass
+
+
+script_callbacks.on_infotext_pasted(pares_infotext)
+#######################################
+
+
+if not isForge:
+    from scripts.webui_CHG import CHGdenoiserConstruct
+    exec( CHGdenoiserConstruct() )
+else:
+    from scripts.forge_CHG import CHGdenoiserConstruct
+    import scripts.forge_CHG as forge_CHG
+    exec( CHGdenoiserConstruct() )
+
+
+
+class ExtensionTemplateScript(scripts.Script):
+    # Extension title in menu UI
+    def title(self):
+        return "Characteristic Guidance"
+
+    # Decide to show menu in txt2img or img2img
+    # - in "txt2img" -> is_img2img is `False`
+    # - in "img2img" -> is_img2img is `True`
+    #
+    # below code always show extension menu
+    def show(self, is_img2img):
+        return scripts.AlwaysVisible
+
+    def update_plot(self):
+        from modules.sd_samplers_cfg_denoiser import CFGDenoiser
+        try:
+            res, ite_num, reg = CFGDenoiser.ite_infos
+            res = np.array([r[:, 0, 0, 0].cpu().numpy() for r in res]).T
+            ite_num = np.array([r.cpu().numpy() for r in ite_num]).T
+            reg = np.array([r.cpu().numpy() for r in reg]).T
+            if len(res) == 0:
+                raise Exception('res has not been written yet')
+        except Exception as e:
+            res, ite_num, reg = [np.linspace(1, 0., 50)], [np.ones(50) * 10], [np.linspace(1, 0., 50)]
+            print("The following exception occured when reading iteration info, demo plot is returned")
+            print(e)
+
+
+        try:
+            res_thres = CFGDenoiser.res_thres
+            reg_ini = CFGDenoiser.reg_ini
+            reg_range = CFGDenoiser.reg_range 
+            noise_base = CFGDenoiser.noise_base
+            start_step = CFGDenoiser.chg_start_step
+        except:
+            res_thres = 0.1
+            reg_ini=1
+            reg_range=1
+            noise_base = 1
+            start_step = 0
+        # Create legend
+        from matplotlib.patches import Patch
+        legend_elements = [Patch(facecolor='green', label='Converged'),
+                           Patch(facecolor='yellow', label='Barely Converged'),
+                           Patch(facecolor='red', label='Not Converged')]
+        def get_title(reg_ini, reg_range, noise_base, num_no_converge, pos_no_converge):
+            title = ""
+            prompts = ["Nice! All iterations converged.\n ",
+            "Lowering the regularization strength may be better.\n ",
+            "One iteration not converge, but it is OK.\n ",
+            "Two or more iteration not converge, maybe you should increase regularization strength.\n ",
+            "Steps in the middle didn't converge, maybe you should increase regularization time range.\n ",
+            "The regularization strength is already small. Increasing the number of basis worth a try.\n ",
+            "If you think context changed too much, increase the regularization strength. \n ",
+            "Increase the regularization strength may be better.\n ",
+            "If you think context changed too little, lower the regularization strength. \n ",
+            "If you think context changed too little, lower the regularization time range. \n ",
+            "Number of Basis maybe too high, try lowering it. \n "
+            ]
+            if num_no_converge <=0:
+                title += prompts[0]
+            if num_no_converge <=0 and reg_ini > 0.5:
+                title += prompts[1]
+            if num_no_converge == 1:
+                title += prompts[2]
+                title += prompts[7]
+            if num_no_converge >1:
+                title += prompts[3]
+                title += prompts[7]
+            if pos_no_converge > 0.3:
+                title += prompts[4]
+            if num_no_converge <=0 and reg_ini <= 0.5:
+                title += prompts[5]
+            if num_no_converge <=0 and reg_ini < 5:
+                title += prompts[6]
+            if num_no_converge <=0 and reg_ini >= 5:
+                title += prompts[8]
+                title += prompts[9]
+            if num_no_converge >=2 and noise_base >2:
+                title += prompts[10]
+            alltitles = title.split("\n")[:-1]
+            n = np.random.randint(len(alltitles))
+            return alltitles[n]
+        # Create bar plot
+        fig, axs = plt.subplots(len(res), 1, figsize=(10, 4.5 * len(res)))
+        if len(res) > 1:
+            # Example plotting code
+            for i in range(len(res)):
+                num_no_converge = 0
+                pos_no_converge = 0
+                for j, r in enumerate(res[i]):
+                    if r >= res_thres:
+                        num_no_converge+=1
+                        pos_no_converge = max(j,pos_no_converge)
+                pos_no_converge = pos_no_converge/(len(res[i])+1)
+                # Categorize each result and assign colors
+                colors = ['green' if r < res_thres else 'yellow' if r < 10 * res_thres else 'red' for r in res[i]]
+                axs[i].bar(np.arange(len(ite_num[i]))+start_step, ite_num[i], color=colors)
+                # Create legend
+                axs[i].legend(handles=legend_elements, loc='upper right')
+
+                # Add labels and title
+                axs[i].set_xlabel('Diffusion Step')
+                axs[i].set_ylabel('Num. Characteristic Iteration')
+                ax2 = axs[i].twinx()
+                ax2.plot(np.arange(len(ite_num[i]))+start_step, reg[i], linewidth=4, color='C1', label='Regularization Level')
+                ax2.set_ylabel('Regularization Level')
+                ax2.set_ylim(bottom=0.)
+                ax2.legend(loc='upper left')
+                title = get_title(reg_ini, reg_range, noise_base, num_no_converge, pos_no_converge)
+                ax2.set_title(title)
+                ax2.autoscale()
+            # axs[i].set_title('Convergence Status of Iterations for Each Step')
+        elif len(res) == 1:
+            num_no_converge = 0
+            pos_no_converge = 0
+            for j, r in enumerate(res[0]):
+                if r >= res_thres:
+                    num_no_converge+=1
+                    pos_no_converge = max(j,pos_no_converge)
+            pos_no_converge = pos_no_converge/(len(res[0])+1)
+            colors = ['green' if r < res_thres else 'yellow' if r < 10 * res_thres else 'red' for r in res[0]]
+            axs.bar(np.arange(len(ite_num[0]))+start_step, ite_num[0], color=colors)
+            # Create legend
+            axs.legend(handles=legend_elements, loc='upper right')
+
+            # Add labels and title
+            axs.set_xlabel('Diffusion Step')
+            axs.set_ylabel('Num. Characteristic Iteration')
+            ax2 = axs.twinx()
+            title = get_title(reg_ini, reg_range, noise_base, num_no_converge, pos_no_converge)
+            ax2.plot(np.arange(len(ite_num[0]))+start_step, reg[0], linewidth=4, color='C1', label='Regularization Level')
+            ax2.set_ylabel('Regularization Level')
+            ax2.set_ylim(bottom=0.)
+            ax2.legend(loc='upper left')
+            ax2.set_title(title)
+            ax2.autoscale()
+        else:
+            pass
+            # axs.set_title('Convergence Status of Iterations for Each Step')
+        # Convert the Matplotlib plot to a PIL Image
+        buf = io.BytesIO()
+        plt.savefig(buf, format='png')
+        buf.seek(0)
+        img = Image.open(buf)
+
+        plt.close()  # Close the plot
+        return img
+
+    # Setup menu ui detail
+    def ui(self, is_img2img):
+        with gr.Accordion('Characteristic Guidance (CHG)', open=False):
+            reg_ini = gr.Slider(
+                minimum=0.0,
+                maximum=10.,
+                step=0.1,
+                value=1.,
+                label="Regularization Strength ( → Easier Convergence, Closer to Classfier-Free. Please try various values)",
+            )
+            reg_range = gr.Slider(
+                minimum=0.01,
+                maximum=10.,
+                step=0.01,
+                value=1.,
+                label="Regularization Range Over Time ( ← Harder Convergence, More Correction. Please try various values)",
+            )
+            ite = gr.Slider(
+                minimum=1,
+                maximum=50,
+                step=1,
+                value=50,
+                label="Max Num. Characteristic Iteration ( → Slow but Better Convergence)",
+            )
+            noise_base = gr.Slider(
+                minimum=0,
+                maximum=10,
+                step=1,
+                value=0,
+                label="Num. Basis for Correction ( ← Less Correction, Better Convergence)",
+            )
+            with gr.Row(open=True):
+                start_step = gr.Slider(
+                    minimum=0.0,
+                    maximum=0.25,
+                    step=0.01,
+                    value=0.0,
+                    label="CHG Start Step ( Use CFG before Percent of Steps. )",
+                )
+                stop_step = gr.Slider(
+                    minimum=0.25,
+                    maximum=1.0,
+                    step=0.01,
+                    value=1.0,
+                    label="CHG End Step ( Use CFG after Percent of Steps. )",
+                )
+            with gr.Accordion('Advanced', open=False):
+                chara_decay = gr.Slider(
+                    minimum=0.,
+                    maximum=1.,
+                    step=0.01,
+                    value=1.,
+                    label="Reuse Correction of Previous Iteration ( → Suppress Abrupt Changes During Generation  )",
+                )
+                res = gr.Slider(
+                    minimum=-6,
+                    maximum=-2,
+                    step=0.1,
+                    value=-4.,
+                    label="Log 10 Tolerance for Iteration Convergence ( → Faster Convergence, Lower Quality)",
+                )
+                lr = gr.Slider(
+                    minimum=0,
+                    maximum=1,
+                    step=0.01,
+                    value=1.,
+                    label="Iteration Step Size ( → Faster Convergence)",
+                )
+                reg_size = gr.Slider(
+                    minimum=0.0,
+                    maximum=1.,
+                    step=0.1,
+                    value=0.4,
+                    label="Regularization Annealing Speed ( ← Slower, Maybe Easier Convergence)",
+                )
+                reg_w = gr.Slider(
+                    minimum=0.0,
+                    maximum=5,
+                    step=0.01,
+                    value=0.5,
+                    label="Regularization Annealing Strength ( ← Stronger Annealing, Slower, Maybe Better Convergence )",
+                )
+                aa_dim = gr.Slider(
+                    minimum=1,
+                    maximum=10,
+                    step=1,
+                    value=2,
+                    label="AA Iteration Memory Size ( → Faster Convergence, Maybe Unstable)",
+                )
+            with gr.Row():
+                checkbox = gr.Checkbox(
+                    False,
+                    label="Enable"
+                ) 
+                markdown = gr.Markdown("[How to set parameters? Check our github!](https://github.com/scraed/CharacteristicGuidanceWebUI/tree/main)")
+                radio = gr.Radio(
+                    choices=["More Prompt", "More ControlNet"], 
+                    label="ControlNet Compatible Mode", 
+                    value = "More ControlNet"
+                    )
+            with gr.Blocks() as demo:
+                image = gr.Image()
+                button = gr.Button("Check Convergence (Please Adjust Regularization Strength & Range Over Time If Not Converged)")
+
+                button.click(fn=self.update_plot, outputs=image)
+            # with gr.Blocks(show_footer=False) as blocks:
+            #        image = gr.Image(show_label=False)
+            #        blocks.load(fn=self.update_plot, inputs=None, outputs=image,
+            #                        show_progress=False, every=5)
+
+        def get_chg_parameter(key, default=None):
+            def get_parameters(d):
+                return d.get('CHG', {}).get(key, default)
+            return get_parameters
+
+
+        self.infotext_fields = [
+            (checkbox, lambda d: 'CHG' in d),
+            (reg_ini, get_chg_parameter('RegS')),
+            (reg_range, get_chg_parameter('RegR')),
+            (ite, get_chg_parameter('MaxI')),
+            (noise_base, get_chg_parameter('NBasis')),
+            (chara_decay, get_chg_parameter('Reuse')),
+            (res, get_chg_parameter('Tol')),
+            (lr, get_chg_parameter('IteSS')),
+            (reg_size, get_chg_parameter('ASpeed')),
+            (reg_w, get_chg_parameter('AStrength')),
+            (aa_dim, get_chg_parameter('AADim')),
+            (radio, get_chg_parameter('CMode')),
+            (start_step, get_chg_parameter('StartStep')),
+            (stop_step, get_chg_parameter('StopStep'))
+        ]
+
+        # TODO: add more UI components (cf. https://gradio.app/docs/#components)
+        return [reg_ini, reg_range, ite, noise_base, chara_decay, res, lr, reg_size, reg_w, aa_dim, checkbox, markdown, radio, start_step, stop_step]
+
+    def process(self, p, reg_ini, reg_range, ite, noise_base, chara_decay, res, lr, reg_size, reg_w, aa_dim,
+                      checkbox, markdown, radio, start_step, stop_step, **kwargs):
+        if checkbox:
+            # info text will have to be written hear otherwise params.txt will not have the infotext of CHG
+            # write parameters to extra_generation_params["CHG"] as json dict with double and single quotes swapped
+            parameters = {
+                'RegS': reg_ini,
+                'RegR': reg_range,
+                'MaxI': ite,
+                'NBasis': noise_base,
+                'Reuse': chara_decay,
+                'Tol': res,
+                'IteSS': lr,
+                'ASpeed': reg_size,
+                'AStrength': reg_w,
+                'AADim': aa_dim,
+                'CMode': radio,
+                'StartStep': start_step,
+                'StopStep': stop_step,
+            }
+            p.extra_generation_params["CHG"] = json.dumps(parameters).translate(quote_swap)
+            print("Characteristic Guidance parameters registered")
+
+    # Extension main process
+    # Type: (StableDiffusionProcessing, List<UI>) -> (Processed)
+    # args is [StableDiffusionProcessing, UI1, UI2, ...]
+    def process_batch(self, p, reg_ini, reg_range, ite, noise_base, chara_decay, res, lr, reg_size, reg_w, aa_dim,
+                      checkbox, markdown, radio, start_step, stop_step, **kwargs):
+        def modified_sample(sample):
+            def wrapper(self, conditioning, unconditional_conditioning, seeds, subseeds, subseed_strength, prompts):
+                # modules = sys.modules
+                if checkbox:
+                    # from ssd_samplers_chg_denoiser import CFGDenoiser as CHGDenoiser
+                    print("Characteristic Guidance modifying the CFGDenoiser")
+
+
+                    original_forward = CFGDenoiser.forward
+                    def _call_forward(self, *args, **kwargs):
+                        if self.chg_start_step <= self.step < self.chg_stop_step:
+                            return CHGDenoiser.forward(self, *args, **kwargs)
+                        else:
+                            return original_forward(self, *args, **kwargs)
+                    CFGDenoiser.forward = _call_forward
+                    #CFGDenoiser.Chara_iteration = Chara_iteration
+                    print('*********cfg denoiser res thres def ************')
+                    CFGDenoiser.res_thres = 10 ** res
+                    CFGDenoiser.noise_base = noise_base
+                    CFGDenoiser.lr_chara = lr
+                    CFGDenoiser.ite = ite
+                    CFGDenoiser.reg_size = reg_size
+                    if reg_ini<=5:
+                        CFGDenoiser.reg_ini = reg_ini
+                    else:
+                        k = 0.8898
+                        CFGDenoiser.reg_ini = np.exp(k*(reg_ini-5))/np.exp(0)/k + 5 - 1/k
+                    if reg_range<=5:
+                        CFGDenoiser.reg_range = reg_range
+                    else:
+                        k = 0.8898
+                        CFGDenoiser.reg_range = np.exp(k*(reg_range-5))/np.exp(0)/k + 5 - 1/k
+                    CFGDenoiser.reg_w = reg_w
+                    CFGDenoiser.ite_infos = [[], [], []]
+                    CFGDenoiser.dxs_buffer = None
+                    CFGDenoiser.abt_buffer = None
+                    CFGDenoiser.aa_dim = aa_dim
+                    CFGDenoiser.chara_decay = chara_decay
+                    CFGDenoiser.process_p = p
+                    CFGDenoiser.radio_controlnet = radio
+                    constrain_step = lambda total_step, step_pct: max(0, min(round(total_step * step_pct), total_step))
+                    CFGDenoiser.chg_start_step = constrain_step(p.steps, start_step)
+                    CFGDenoiser.chg_stop_step = constrain_step(p.steps, stop_step)
+                    # CFGDenoiser.CFGdecayS = CFGdecayS
+                    try:
+                        print("Characteristic Guidance sampling:")
+                        result = sample(conditioning, unconditional_conditioning, seeds, subseeds, subseed_strength,
+                                        prompts)
+
+                    except Exception as e:
+                        raise e
+                    finally:
+                        print("Characteristic Guidance recorded iterations info for " + str(len(CFGDenoiser.ite_infos[0])) + " steps"  )
+                        print("Characteristic Guidance recovering the CFGDenoiser")
+                        CFGDenoiser.forward = original_forward
+                        # del CFGDenoiser.CFGdecayS
+                else:
+                    result = sample(conditioning, unconditional_conditioning, seeds, subseeds, subseed_strength,
+                                    prompts)
+                return result
+
+            return wrapper
+
+        # TODO: get UI info through UI object angle, checkbox
+        if checkbox:
+            print("Characteristic Guidance enabled, warpping the sample method")
+            p.sample = modified_sample(p.sample).__get__(p)
+
+        # print(p.sampler_name)
+

extensions/CharacteristicGuidanceWebUI/scripts/CharaIte.py

@@ -0,0 +1,530 @@
+import modules.scripts as scripts
+import gradio as gr
+
+import io
+import json
+import matplotlib.pyplot as plt
+from PIL import Image
+import numpy as np
+import inspect
+import torch
+from modules import prompt_parser, devices, sd_samplers_common
+import re
+from modules.shared import opts, state
+import modules.shared as shared
+from modules.script_callbacks import CFGDenoiserParams, cfg_denoiser_callback
+from modules.script_callbacks import CFGDenoisedParams, cfg_denoised_callback
+from modules.script_callbacks import AfterCFGCallbackParams, cfg_after_cfg_callback
+import k_diffusion.utils as utils
+from k_diffusion.external import CompVisVDenoiser, CompVisDenoiser
+from modules.sd_samplers_timesteps import CompVisTimestepsDenoiser, CompVisTimestepsVDenoiser
+from modules.sd_samplers_cfg_denoiser import CFGDenoiser, catenate_conds, subscript_cond, pad_cond
+from modules import script_callbacks
+import copy
+
+try:
+    from modules_forge import forge_sampler
+    isForge = True
+except Exception:
+    isForge = False
+
+def solve_least_squares(A, B):
+    # print(A.shape)
+    # print(B.shape)
+    # Compute C = A^T A
+    # min_eigenvalues = torch.min( torch.linalg.eigvalsh(C), dim=-1 )
+    # eps_e = torch.maximum( min_eigenvalues, min_eigenvalues.new_ones(min_eigenvalues.shape)*1e-3 )[...,]
+    C = torch.matmul(A.transpose(-2, -1), A)  # + eps_e*torch.eye(A.shape[-1], device=A.device)
+    # Compute the pseudo-inverse of C
+    U, S, Vh = torch.linalg.svd(C.float(), full_matrices=False)
+    D_inv = torch.diag_embed(1.0 / torch.maximum(S, torch.ones_like(S) * 1e-4))
+    C_inv = Vh.transpose(-1,-2).matmul(D_inv).matmul(U.transpose(-1,-2))
+
+    # Compute X = C_inv A^T B
+    X = torch.matmul(torch.matmul(C_inv, A.transpose(-2, -1)), B)
+    return X
+
+
+def split_basis(g, n):
+    # Define the number of quantiles, n
+
+    # Flatten the last two dimensions of g for easier processing
+    g_flat = g.view(g.shape[0], g.shape[1], -1)  # Shape will be (6, 4, 64*64)
+
+    # Calculate quantiles
+    quantiles = torch.quantile(g_flat, torch.linspace(0, 1, n + 1, device=g.device), dim=-1).permute(1, 2, 0)
+
+    # Initialize an empty tensor for the output
+    output = torch.zeros(*g.shape, n, device=g.device)
+
+    # Use broadcasting and comparisons to fill the output tensor
+    for i in range(n):
+        lower = quantiles[..., i][..., None, None]
+        upper = quantiles[..., i + 1][..., None, None]
+        if i < n - 1:
+            mask = (g >= lower) & (g < upper)
+        else:
+            mask = (g >= lower) & (g <= upper)
+        output[..., i] = g * mask
+
+    # Reshape output to the desired shape
+    output = output.view(*g.shape, n)
+    return output
+
+def proj_least_squares(A, B, reg):
+    # print(A.shape)
+    # print(B.shape)
+    # Compute C = A^T A
+    C = torch.matmul(A.transpose(-2, -1), A) + reg * torch.eye(A.shape[-1], device=A.device)
+
+    # Compute the eigenvalues and eigenvectors of C
+    eigenvalues, eigenvectors = torch.linalg.eigh(C)
+    # eigenvalues = torch.maximum( eigenvalues,eigenvalues*0+1e-3  )
+
+    # Diagonal matrix with non-zero eigenvalues in the diagonal
+    D_inv = torch.diag_embed(1.0 / torch.maximum(eigenvalues, torch.ones_like(eigenvalues) * 1e-4))
+
+    # Compute the pseudo-inverse of C
+    C_inv = torch.matmul(torch.matmul(eigenvectors, D_inv), eigenvectors.transpose(-2, -1))
+
+    # Compute X = C_inv A^T B
+    B_proj = torch.matmul(A, torch.matmul(torch.matmul(C_inv, A.transpose(-2, -1)), B))
+    return B_proj
+
+
+def Chara_iteration(self, *args, **kwargs):
+    # print('Chara_iteration Working')
+    if not isForge:
+        dxs, x_in, sigma_in, tensor, uncond, cond_scale, image_cond_in, is_edit_model, skip_uncond, make_condition_dict, batch_cond_uncond, batch_size = args 
+        cond_in=kwargs["cond_in"]
+        x_out = kwargs["x_out"]
+        # function being evaluated must have x_in and cond_in as first and second input
+        def x_out_evaluation(x_in, cond_in, sigma_in, image_cond_in):
+            return self.inner_model(x_in, sigma_in, cond=make_condition_dict(cond_in, image_cond_in))
+        def eps_evaluation(x_in, cond_in, t_in, image_cond_in):
+            return self.inner_model.get_eps(x_in, t_in, cond=make_condition_dict(cond_in, image_cond_in))
+        def v_evaluation(x_in, cond_in, t_in, image_cond_in):
+            return self.inner_model.get_v(x_in, t_in, cond=make_condition_dict(cond_in, image_cond_in))
+        def eps_legacy_evaluation(x_in, cond_in, t_in, image_cond_in):
+            return self.inner_model(x_in, t_in, cond=make_condition_dict(cond_in, image_cond_in))
+        if tensor.shape[1] == uncond.shape[1] or skip_uncond:
+            if batch_cond_uncond:
+                def evaluation(func, x_in, conds, *args, **kwargs):
+                    tensor, uncond, cond_in = conds
+                    return func(x_in, cond_in, *args, **kwargs)
+            else:
+                def evaluation(func, x_in, conds, *args, **kwargs):
+                    x_out = torch.zeros_like(x_in)
+                    tensor, uncond, cond_in = conds
+                    for batch_offset in range(0, x_out.shape[0], batch_size):
+                        a = batch_offset
+                        b = a + batch_size
+                        x_out[a:b] = func(x_in[a:b],subscript_cond(cond_in, a, b), *[arg[a:b] for arg in args], **kwargs)
+                    return x_out
+        else:
+            def evaluation(func, x_in, conds, *args, **kwargs):
+                x_out = torch.zeros_like(x_in)
+                tensor, uncond, cond_in = conds
+                batch_Size = batch_size*2 if batch_cond_uncond else batch_size
+                for batch_offset in range(0, tensor.shape[0], batch_Size):
+                    a = batch_offset
+                    b = min(a + batch_Size, tensor.shape[0])
+
+                    if not is_edit_model:
+                        c_crossattn = subscript_cond(tensor, a, b)
+                    else:
+                        c_crossattn = torch.cat([tensor[a:b]], uncond)
+
+                    x_out[a:b] = func(x_in[a:b], c_crossattn, *[arg[a:b] for arg in args], **kwargs)
+
+                if not skip_uncond:
+                    x_out[-uncond.shape[0]:] = func(x_in[-uncond.shape[0]:], uncond, *[arg[-uncond.shape[0]:] for arg in args], **kwargs)
+
+                return x_out
+        if is_edit_model or skip_uncond:
+            return evaluation(x_out_evaluation, x_in, (tensor, uncond, cond_in), sigma_in, image_cond_in)
+        else:
+            evaluations = [eps_evaluation, v_evaluation, eps_legacy_evaluation, evaluation]
+            ite_paras = [dxs, x_in, sigma_in, tensor, uncond, cond_scale, image_cond_in, is_edit_model, skip_uncond, make_condition_dict, batch_cond_uncond, batch_size, cond_in, x_out]
+            dxs_add = chara_ite_inner_loop(self, evaluations, ite_paras)
+            return evaluation(x_out_evaluation, x_in + dxs_add, (tensor, uncond, cond_in), sigma_in, image_cond_in)
+    else:
+        model,dxs,x_in, sigma_in,cond_scale,uncond, c = args
+        # print('dxs', dxs)
+        # print('x_in', (x_in.dtype))
+        # print('x_in',(x_in))
+        # print('sigma_in',sigma_in)
+        # print('cond_scale',cond_scale)
+        # print('uncond',uncond)
+        def evaluation(func, x_in, t_in, c):
+            # tensor, uncond, cond_in = conds
+            # print('x_in eval',x_in.shape)
+            return func(x_in, t_in, c)
+
+        def eps_evaluation(x_in, t_in, c):
+            # print('x_in',x_in.dtype)
+            # print('t_in',t_in.dtype)
+            x_out = model.apply_model(x_in,t_in,**c)
+            # print('x_out',x_out.dtype)
+            t_in_expand = t_in.view(t_in.shape[:1] + (1,) * (x_in.ndim - 1))
+            eps_out = (x_in - x_out)#/t_in_expand.half() # t_in_expand = ((1- abt)/abt)**0.5
+            # This eps_out here is actually ((1- abt)/abt)**0.5*eps
+            return eps_out
+
+        def v_evaluation(x_in, t_in, c):
+            #print('model v evaluation')
+            x_out = model.apply_model(x_in, t_in, **c)
+            t_in_expand = t_in.view(t_in.shape[:1] + (1,) * (x_in.ndim - 1))
+            sigma_data = model.model_sampling.sigma_data
+            v_out = (x_in* sigma_data**2 - (sigma_data**2 + t_in_expand**2)*x_out)/(t_in_expand*sigma_data*(t_in_expand**2+sigma_data**2)** 0.5)
+            return v_out
+
+        def x_out_evaluation(x_in, t_in, c):
+            # t_in_expand = t_in.view(t_in.shape[:1] + (1,) * (x_in.ndim - 1))
+            # x_in =  x_in*((t_in_expand ** 2 + 1 ** 2) ** 0.5)
+            # print('x out evaluation control', c['control']['middle'])
+            x_out = model.apply_model(x_in, t_in,**c)
+            return x_out
+
+        def eps_legacy_evaluation(x_in, t_in, c):
+            return self.inner_model(x_in, t_in, **c)
+            # return self.inner_model.get_eps(x_in, t_in, cond=make_condition_dict(cond_in, image_cond_in))
+        evaluations = [eps_evaluation, v_evaluation, None, evaluation]
+        ite_paras = [model,dxs,x_in, sigma_in,cond_scale,uncond, c]
+        dxs_add = chara_ite_inner_loop(self, evaluations, ite_paras)
+        # print('dxs_add',dxs_add)
+        return evaluation(x_out_evaluation, x_in + dxs_add, sigma_in, c)
+
+def chara_ite_inner_loop(self, evaluations, ite_paras):
+    eps_evaluation, v_evaluation, eps_legacy_evaluation, evaluation = evaluations
+    if isForge:
+        model,dxs,x_in, sigma_in,cond_scale,uncond, c = ite_paras
+        # print('inside inner loop control',c['control']['middle'])
+        sigma_in = sigma_in.to(x_in.device)
+    else:
+        dxs, x_in, sigma_in, tensor, uncond, cond_scale, image_cond_in, is_edit_model, skip_uncond, make_condition_dict, batch_cond_uncond, batch_size, cond_in, x_out = ite_paras
+    if dxs is None:
+        dxs = torch.zeros_like(x_in[-uncond.shape[0]:])
+    if self.radio_controlnet == "More Prompt":
+        control_net_weights = []
+        for script in self.process_p.scripts.scripts:
+            if script.title() == "ControlNet":
+                try:
+                    for param in script.latest_network.control_params:
+                        control_net_weights.append(param.weight)
+                        param.weight = 0.
+                except:
+                    pass
+
+    res_thres = self.res_thres
+    
+    num_x_in_cond = len(x_in[:-uncond.shape[0]])//len(dxs)
+    # print('x_in',x_in.shape)
+    # print('uncond',uncond.shape[0])
+    h = cond_scale*num_x_in_cond
+
+    if isinstance(self.inner_model, CompVisDenoiser):
+        # print('sigma_in',sigma_in.device)
+        # print('inner model log sigma',self.inner_model.log_sigmas.device)
+        t_in = self.inner_model.sigma_to_t(sigma_in.to(self.inner_model.log_sigmas.device),quantize=True)
+        abt = self.inner_model.inner_model.alphas_cumprod.to(t_in.device)[t_in.long()]
+        c_out, c_in = [utils.append_dims(x, x_in.ndim) for x in self.inner_model.get_scalings(sigma_in)]
+    elif isinstance(self.inner_model, CompVisVDenoiser):
+        t_in = self.inner_model.sigma_to_t(sigma_in.to(self.inner_model.log_sigmas.device),quantize=True)
+        abt = self.inner_model.inner_model.alphas_cumprod.to(t_in.device)[t_in.long()]
+        c_skip, c_out, c_in = [utils.append_dims(x, x_in.ndim) for x in self.inner_model.get_scalings(sigma_in)]
+    elif isinstance(self.inner_model, CompVisTimestepsDenoiser) or isinstance(self.inner_model,
+                                                                                CompVisTimestepsVDenoiser):
+        if isForge:
+            abt_table = self.alphas
+            def timestep(sigma,abt_table):
+                abt = (1/(1+sigma**2)).to(sigma.device)
+                dists = abt - abt_table.to(sigma.device)[:, None]
+                return dists.abs().argmin(dim=0).view(sigma.shape).to(sigma.device)
+            t_in = timestep(sigma_in,abt_table)
+            print('timestep t_in',t_in)
+        else:
+            t_in = sigma_in
+        abt = self.alphas.to(t_in.device)[t_in.long()]
+    else:
+        raise NotImplementedError()
+
+
+    scale = ((1 - abt) ** 0.5)[-uncond.shape[0]:, None, None, None].to(x_in.device)
+    scale_f = ((abt) ** 0.5)[-uncond.shape[0]:, None, None, None].to(x_in.device)
+    abt_current = abt[-uncond.shape[0]:, None, None, None].to(x_in.device)
+    abt_smallest = self.inner_model.inner_model.alphas_cumprod[-1].to(x_in.device)
+    # x_in_cond = x_in[:-uncond.shape[0]]
+    # x_in_uncond = x_in[-uncond.shape[0]:]
+    # print("alphas_cumprod",-torch.log(self.inner_model.inner_model.alphas_cumprod))
+    # print("betas",torch.sum(self.inner_model.inner_model.betas))
+
+    dxs_Anderson = []
+    g_Anderson = []
+
+    def AndersonAccR(dxs, g, reg_level, reg_target, pre_condition=None, m=3):
+        batch = dxs.shape[0]
+        x_shape = dxs.shape[1:]
+        reg_residual_form = reg_level
+        g_flat = g.reshape(batch, -1)
+        dxs_flat = dxs.reshape(batch, -1)
+        res_g = self.reg_size * (reg_residual_form[:, None] - reg_target[:, None])
+        res_dxs = reg_residual_form[:, None]
+        g_Anderson.append(torch.cat((g_flat, res_g), dim=-1))
+        dxs_Anderson.append(torch.cat((dxs_flat, res_dxs), dim=-1))
+
+        if len(g_Anderson) < 2:
+            return dxs, g, res_dxs[:, 0], res_g[:, 0]
+        else:
+            g_Anderson[-2] = g_Anderson[-1] - g_Anderson[-2]
+            dxs_Anderson[-2] = dxs_Anderson[-1] - dxs_Anderson[-2]
+            if len(g_Anderson) > m:
+                del dxs_Anderson[0]
+                del g_Anderson[0]
+            gA = torch.cat([g[..., None] for g in g_Anderson[:-1]], dim=-1)
+            gB = g_Anderson[-1][..., None]
+
+            gA_norm = torch.maximum(torch.sum(gA ** 2, dim=-2, keepdim=True) ** 0.5, torch.ones_like(gA) * 1e-4)
+            # print("gA_norm ",gA_norm.shape)
+            # gB_norm = torch.sum( gB**2, dim = -2 , keepdim=True )**0.5 + 1e-6
+            # gamma = solve_least_squares(gA/gA_norm, gB)
+            gamma = torch.linalg.lstsq(gA / gA_norm, gB).solution
+            if torch.sum( torch.isnan(gamma) ) > 0:
+                gamma = solve_least_squares(gA/gA_norm, gB)
+            xA = torch.cat([x[..., None] for x in dxs_Anderson[:-1]], dim=-1)
+            xB = dxs_Anderson[-1][..., None]
+            # print("xO print",xB.shape, xA.shape, gA_norm.shape, gamma.shape)
+            xO = xB - (xA / gA_norm).matmul(gamma)
+            gO = gB - (gA / gA_norm).matmul(gamma)
+            dxsO = xO[:, :-1].reshape(batch, *x_shape)
+            dgO = gO[:, :-1].reshape(batch, *x_shape)
+            resxO = xO[:, -1, 0]
+            resgO = gO[:, -1, 0]
+            # print("xO",xO.shape)
+            # print("gO",gO.shape)
+            # print("gamma",gamma.shape)
+            return dxsO, dgO, resxO, resgO
+
+    def downsample_reg_g(dx, g_1, reg):
+        # DDec_dx = DDec(dx)
+        # down_DDec_dx = downsample(DDec_dx, factor=factor)
+        # DEnc_dx = DEnc(down_DDec_dx)
+        # return DEnc_dx
+
+        if g_1 is None:
+            return dx
+        elif self.noise_base >= 1:
+            # return g_1*torch.sum(g_1*dx, dim = (-1,-2), keepdim=True )/torch.sum( g_1**2, dim = (-1,-2) , keepdim=True )
+            A = g_1.reshape(g_1.shape[0] * g_1.shape[1], g_1.shape[2] * g_1.shape[3], g_1.shape[4])
+            B = dx.reshape(dx.shape[0] * dx.shape[1], -1, 1)
+            regl = reg[:, None].expand(-1, dx.shape[1]).reshape(dx.shape[0] * dx.shape[1], 1, 1)
+            dx_proj = proj_least_squares(A, B, regl)
+
+            return dx_proj.reshape(*dx.shape)
+        else:
+            # return g_1*torch.sum(g_1*dx, dim = (-1,-2), keepdim=True )/torch.sum( g_1**2, dim = (-1,-2) , keepdim=True )
+            A = g_1.reshape(g_1.shape[0], g_1.shape[1]* g_1.shape[2] * g_1.shape[3], g_1.shape[4])
+            B = dx.reshape(dx.shape[0], -1, 1)
+            regl = reg[:, None].reshape(dx.shape[0], 1, 1)
+            dx_proj = proj_least_squares(A, B, regl)
+
+            return dx_proj.reshape(*dx.shape)
+    g_1 = None
+
+    reg_level = torch.zeros(dxs.shape[0], device=dxs.device) + max(5,self.reg_ini)
+    reg_target_level = self.reg_ini * (abt_smallest / abt_current[:, 0, 0, 0]) ** (1 / self.reg_range)
+    Converged = False
+    eps0_ch, eps1_ch = torch.zeros_like(dxs), torch.zeros_like(dxs)
+    best_res_el = torch.mean(dxs, dim=(-1, -2, -3), keepdim=True) + 100
+    best_res = 100
+    best_dxs = torch.zeros_like(dxs)
+    res_max = torch.zeros(dxs.shape[0], device=dxs.device)
+    n_iterations = self.ite
+
+    if self.dxs_buffer is not None:
+        abt_prev = self.abt_buffer
+        dxs = self.dxs_buffer
+        # if self.CFGdecayS:
+        dxs = dxs * ((abt_prev - abt_current * abt_prev) / (abt_current - abt_current * abt_prev))
+        # print(abt_prev.shape, abt_current.shape, self.dxs_buffer.shape)
+        dxs = self.chara_decay * dxs
+    iteration_counts = 0
+    for iteration in range(n_iterations):
+        # print(f'********* ite {iteration} *********')
+        # important to keep iteration content consistent
+        # Supoort AND prompt combination by using multiple dxs for condition part
+        def compute_correction_direction(dxs):
+            if isForge:
+                c_copy = copy.deepcopy(c)
+            # print('num_x_in_cond',num_x_in_cond)
+            # print('(h - 1) * dxs[:,None,...]', ((h - 1) * dxs[:,None,...]).shape)
+            dxs_cond_part = torch.cat( [*( [(h - 1) * dxs[:,None,...]]*num_x_in_cond )], axis=1 ).view( (dxs.shape[0]*num_x_in_cond, *dxs.shape[1:]) )
+            dxs_add = torch.cat([ dxs_cond_part, h * dxs], axis=0)
+            if isinstance(self.inner_model, CompVisDenoiser):
+                if isForge:
+                    eps_out = evaluation(eps_evaluation, x_in + dxs_add, sigma_in,c_copy)
+                    pred_eps_uncond = eps_out[:-uncond.shape[0]] # forge: c_crossatten[0]: uncondition
+                    eps_cond_batch = eps_out[-uncond.shape[0]:] # forge: c_crossatten[1]: condition
+                    # print('pred_eps_uncond', pred_eps_uncond.dtype)
+                    # print('eps_cond_batch', eps_cond_batch.dtype)
+                    eps_cond_batch_target_shape = ( len(eps_cond_batch)//num_x_in_cond, num_x_in_cond, *(eps_cond_batch.shape[1:]) )
+                    pred_eps_cond = torch.mean( eps_cond_batch.view(eps_cond_batch_target_shape), dim=1, keepdim=False )
+                    # print("scale_f", scale_f)
+                    # print('(pred_eps_uncond - pred_eps_cond)',(pred_eps_uncond - pred_eps_cond))
+                    # print('pred_eps_cond', pred_eps_cond)
+                    # print('scale/c_in',scale / c_in[-uncond.shape[0]:])
+                    # print("c_in", c_in[-uncond.shape[0]:])
+                    ggg = (pred_eps_uncond - pred_eps_cond) #* (scale / c_in[-uncond.shape[0]:])
+                    # print('ggg',ggg)
+                else:
+                    eps_out = evaluation(eps_evaluation, x_in * c_in + dxs_add * c_in, (tensor, uncond, cond_in), t_in, image_cond_in)
+                    pred_eps_uncond = eps_out[-uncond.shape[0]:]
+                    eps_cond_batch = eps_out[:-uncond.shape[0]]
+                    eps_cond_batch_target_shape = ( len(eps_cond_batch)//num_x_in_cond, num_x_in_cond, *(eps_cond_batch.shape[1:]) )
+                    pred_eps_cond = torch.mean( eps_cond_batch.view(eps_cond_batch_target_shape), dim=1, keepdim=False )
+                    ggg = (pred_eps_uncond - pred_eps_cond) * scale / c_in[-uncond.shape[0]:]
+            elif isinstance(self.inner_model, CompVisVDenoiser):
+                if isForge:
+                    v_out = evaluation(v_evaluation, x_in+dxs_add,sigma_in,c_copy)
+                    eps_out = -c_out*x_in + c_skip**0.5*v_out
+                    pred_eps_uncond = eps_out[:-uncond.shape[0]] # forge: c_crossatten[0]: uncondition
+                    eps_cond_batch = eps_out[-uncond.shape[0]:] # forge: c_crossatten[1]: condition
+                else:
+                    v_out = evaluation(v_evaluation, x_in * c_in + dxs_add * c_in, (tensor, uncond, cond_in), t_in, image_cond_in)
+                    eps_out = -c_out*x_in + c_skip**0.5*v_out
+                    pred_eps_uncond = eps_out[-uncond.shape[0]:]
+                    eps_cond_batch = eps_out[:-uncond.shape[0]]
+                eps_cond_batch_target_shape = ( len(eps_cond_batch)//num_x_in_cond, num_x_in_cond, *(eps_cond_batch.shape[1:]) )
+                pred_eps_cond = torch.mean( eps_cond_batch.view(eps_cond_batch_target_shape), dim=1, keepdim=False )
+                ggg = (pred_eps_uncond - pred_eps_cond) * scale / c_in[-uncond.shape[0]:]
+            elif isinstance(self.inner_model, CompVisTimestepsDenoiser) or isinstance(self.inner_model,
+                                                                                    CompVisTimestepsVDenoiser):
+                #eps_out = self.inner_model(x_in + dxs_add, t_in, cond=cond)
+                if isForge:
+                    eps_out = evaluation(eps_evaluation, x_in + dxs_add, sigma_in, c_copy)
+                    pred_eps_uncond = eps_out[:-uncond.shape[0]]  # forge: c_crossatten[0]: uncondition
+                    eps_cond_batch = eps_out[-uncond.shape[0]:]  # forge: c_crossatten[1]: condition
+                    # print('pred_eps_uncond', pred_eps_uncond.dtype)
+                    # print('eps_cond_batch', eps_cond_batch.dtype)
+                    eps_cond_batch_target_shape = (
+                    len(eps_cond_batch) // num_x_in_cond, num_x_in_cond, *(eps_cond_batch.shape[1:]))
+                    pred_eps_cond = torch.mean(eps_cond_batch.view(eps_cond_batch_target_shape), dim=1, keepdim=False)
+                    ggg = (pred_eps_uncond - pred_eps_cond)  # * (scale / c_in[-uncond.shape[0]:])
+                else:
+                    eps_out = evaluation(eps_legacy_evaluation, x_in + dxs_add, (tensor, uncond, cond_in), t_in, image_cond_in)
+                    pred_eps_uncond = eps_out[-uncond.shape[0]:]
+                    eps_cond_batch = eps_out[:-uncond.shape[0]]
+                    eps_cond_batch_target_shape = ( len(eps_cond_batch)//num_x_in_cond, num_x_in_cond, *(eps_cond_batch.shape[1:]) )
+                    pred_eps_cond = torch.mean( eps_cond_batch.view(eps_cond_batch_target_shape), dim=1, keepdim=False )
+                    ggg = (pred_eps_uncond - pred_eps_cond) * scale
+            else:
+                raise NotImplementedError()
+            return ggg
+
+        # dxs = 0*dxs # for debug, need to command
+        ggg = compute_correction_direction(dxs)
+        # print('ggg',ggg)
+        # print("print(reg_level.shape)", reg_level.shape)
+        g = dxs - downsample_reg_g(ggg, g_1, reg_level)
+        if g_1 is None:
+            g_basis = -compute_correction_direction(dxs*0)
+            g_1 = split_basis(g_basis, max( self.noise_base,1 ) )
+            # if self.Projg:
+            #        g_1 = split_basis( g, self.noise_base)
+            # else:
+            #        g_1 = split_basis( ggg, self.noise_base)
+            # if self.CFGdecayS and self.dxs_buffer is not None:
+            #     g_1 = torch.cat( [g_1, self.dxs_buffer[:,:,:,:,None]], dim=-1 )
+            # if self.noise_base > 0:
+            #    noise_base = torch.randn(g_1.shape[0],g_1.shape[1],g_1.shape[2],g_1.shape[3],self.noise_base, device=g_1.device)
+            #    g_1 = torch.cat([g_1, noise_base], dim=-1)
+            if self.noise_base >=1:
+                g_1_norm = torch.sum(g_1 ** 2, dim=(-2, -3), keepdim=True) ** 0.5
+                g_1 = g_1 / torch.maximum(g_1_norm, torch.ones_like(
+                    g_1_norm) * 1e-4)  # + self.noise_level*noise/torch.sum( noise**2, dim = (-1,-2) , keepdim=True )
+            else:
+                g_1_norm = torch.sum(g_1 ** 2, dim=(-2, -3, -4), keepdim=True) ** 0.5
+                g_1 = g_1 / torch.maximum(g_1_norm, torch.ones_like(
+                    g_1_norm) * 1e-4)  # + self.noise_level*noise/torch.sum( noise**2, dim = (-1,-2) , keepdim=True )
+        # Compute regularization level
+        reg_Acc = (reg_level * self.reg_w) ** 0.5
+        reg_target = (reg_target_level * self.reg_w) ** 0.5
+        # Compute residual
+        g_flat_res = g.reshape(dxs.shape[0], -1)
+        reg_g = self.reg_size * (reg_Acc[:, None] - reg_target[:, None])
+        g_flat_res_reg = torch.cat((g_flat_res, reg_g), dim=-1)
+
+        res_x = ((torch.mean((g_flat_res) ** 2, dim=(-1), keepdim=False)) ** 0.5)[:, None, None, None]
+        res_el = ((torch.mean((g_flat_res_reg) ** 2, dim=(-1), keepdim=False)) ** 0.5)[:, None, None, None]
+        # reg_res = torch.mean( (self.reg_size*torch.abs(reg_level - reg_target))**2 )**0.5
+        # reg_res = torch.mean( self.reg_size*torch.abs(reg_level - self.reg_level)/g.shape[-1]/g.shape[-2] )**0.5
+
+        res = torch.mean(res_el)  # + reg_res
+        # if res < best_res:
+        #    best_res = res
+        #    best_dxs = dxs
+
+        if iteration == 0:
+            best_res_el = res_el
+            best_dxs = dxs
+            not_converged = torch.ones_like(res_el).bool()
+        # update eps if residual is better
+        res_mask = torch.logical_and(res_el < best_res_el, not_converged).int()
+        best_res_el = res_mask * res_el + (1 - res_mask) * best_res_el
+        # print(res_mask.shape, dxs.shape, best_dxs.shape)
+        best_dxs = res_mask * dxs + (1 - res_mask) * best_dxs
+        # eps0_ch, eps1_ch = res_mask*pred_eps_uncond + (1-res_mask)*eps0_ch, res_mask*pred_eps_cond + (1-res_mask)*eps1_ch
+
+        res_max = torch.max(best_res_el)
+        # print("res_x",  torch.max( res_x ), "reg", torch.max( reg_level), "reg_target", reg_target, "res", res_max )
+        not_converged = torch.logical_and(res_el >= res_thres, not_converged)
+        # print("not_converged", not_converged.shape)
+        # torch._dynamo.graph_break()
+        if res_max < res_thres:
+            Converged = True
+            break
+        # v = beta*v + (1-beta)*g**2
+        # m = beta_m*m + (1-beta_m)*g
+        # g/(v**0.5+eps_delta)
+        if self.noise_base >=1:
+            aa_dim = self.aa_dim
+        else:
+            aa_dim = 1
+        dxs_Acc, g_Acc, reg_dxs_Acc, reg_g_Acc = AndersonAccR(dxs, g, reg_Acc, reg_target, pre_condition=None,
+                                                            m=aa_dim + 1)
+        # print(Accout)
+        #
+        dxs = dxs_Acc - self.lr_chara * g_Acc
+        reg_Acc = reg_dxs_Acc - self.lr_chara * reg_g_Acc
+        reg_level = reg_Acc ** 2 / self.reg_w
+
+        # reg_target_level = (1+self.reg_level)**( iteration//int(5/self.lr_chara) ) - 1
+        # reg_level_mask = (reg_level >= reg_target_level).long()
+        # reg_level = reg_level_mask*reg_level + (1-reg_level_mask)*reg_target_level
+        # if iteration%int(5) == 0:
+        #    dxs_Anderson = []
+        #    g_Anderson = []
+        iteration_counts = iteration_counts * (1 - not_converged.long()) + iteration * not_converged.long()
+    self.ite_infos[0].append(best_res_el)
+    # print(iteration_counts[:,0,0,0].shape)
+    self.ite_infos[1].append(iteration_counts[:, 0, 0, 0])
+    self.ite_infos[2].append(reg_target_level)
+    print("Characteristic iteration happens", iteration_counts[:, 0, 0, 0] , "times")
+    final_dxs = best_dxs * (1 - not_converged.long())
+    dxs_cond_part = torch.cat( [*( [(h - 1) * final_dxs[:,None,...]]*num_x_in_cond )], axis=1 ).view( (dxs.shape[0]*num_x_in_cond, *dxs.shape[1:]) )
+    dxs_add = torch.cat([ dxs_cond_part, h * final_dxs], axis=0)
+    #dxs_add = torch.cat([ *( [(h - 1) * final_dxs,]*num_x_in_cond ), h * final_dxs], axis=0)
+    self.dxs_buffer = final_dxs
+    self.abt_buffer = abt_current
+
+    if self.radio_controlnet == "More Prompt":
+        controlnet_count = 0
+        for script in self.process_p.scripts.scripts:
+            if script.title() == "ControlNet":
+                try:
+                    for param in script.latest_network.control_params:
+                        param.weight = control_net_weights[controlnet_count]
+                        controlnet_count += 1
+                except:
+                    pass          
+    return dxs_add