Upload 43 files

.gitattributes

@@ -33,3 +33,10 @@ 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
+sd-webui-vectorscope-cc/samples/Bright.jpg filter=lfs diff=lfs merge=lfs -text
+sd-webui-vectorscope-cc/samples/Dark.jpg filter=lfs diff=lfs merge=lfs -text
+sd-webui-vectorscope-cc/samples/Random.jpg filter=lfs diff=lfs merge=lfs -text
+sd-webui-vectorscope-cc/samples/Scaling_alt.jpg filter=lfs diff=lfs merge=lfs -text
+sd-webui-vectorscope-cc/samples/Scaling.jpg filter=lfs diff=lfs merge=lfs -text
+sd-webui-vectorscope-cc/samples/Skip.jpg filter=lfs diff=lfs merge=lfs -text
+sd-webui-vectorscope-cc/samples/XYZ.jpg filter=lfs diff=lfs merge=lfs -text

sd-webui-vectorscope-cc/.gitattributes

@@ -0,0 +1,2 @@
+*.png filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text

sd-webui-vectorscope-cc/.github/FUNDING.yml

@@ -0,0 +1 @@
+ko_fi: haoming

sd-webui-vectorscope-cc/CHANGELOG.md

@@ -0,0 +1,76 @@
+### v1.4.10 - 2023 Nov.01
+- Better **Hires. fix** logic
+
+### v1.4.9 - 2023 Nov.01
+- Improve Sliders values refresh 
+
+### v1.4.8 - 2023 Nov.01
+- Removed "**magic numbers**"
+
+### v1.4.7 - 2023 Nov.01
+- Removed **Skip** parameter
+
+### v1.4.6 - 2023 Sep.19
+- Add **HDR** Script
+
+### v1.4.5 - 2023 Sep.13
+- Bug Fix for Color Wheel in `img2img`
+- Minor Formatting
+
+### v1.4.4 - 2023 Sep.13
+- Add **Infotext** Support by. **catboxanon**
+
+### v1.4.3 - 2023 Sep.13
+- Improve **Color Wheel** Functionality by. **catboxanon**
+
+### v1.4.2 - 2023 Sep.11
+- Fix the Reset and Randomize buttons for the new Contrast algorithm
+
+### v1.4.1 - 2023 Sep.11
+- New **Contrast** algorithm
+
+### v1.4.0 - 2023 Jul.11
+- Implement **Scaling** algorithm
+
+### v1.3.5 - 2023 Jul.11
+- Implement **Color Picker**
+
+### v1.3.4 - 2023 Jul.08
+- Implement **Metadata**
+
+### v1.3.3 - 2023 Jul.07
+- Color Wheel now works at (0, 0, 0)
+- Style/Randomize/Reset now updates Color Wheel
+
+### v1.3.2 - 2023 Jul.07
+- Implement **Color Wheel**
+- Finally added `changelog`
+
+### v1.3.1 - 2023 Jul.06
+- Bug Fix
+
+### v1.3.0 - 2023 Jul.06
+- Implement **Style Presets**
+- Separate logics into different scripts
+
+### v1.2.1 - 2023 Jul.05
+- Add **Randomize** function
+- Add **Reset** function
+
+### v1.2.0 - 2023 Jul.03
+- Implement multiple **Noise** algorithms
+
+### v1.1.3 - 2023 Jun.26
+- Automatically refresh outdated Sliders values
+
+### v1.1.2 - 2023 Jun.23
+- Bug Fix
+
+### v1.1.1 - 2023 Jun.22
+- **Batch** Support
+
+### v1.1.0 - 2023 Jun.21
+- **X/Y/Z Plot** Support
+
+### v1.0.0 - 2023 Jun.20
+- Extension **Released**!

sd-webui-vectorscope-cc/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Haoming
+
+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.

sd-webui-vectorscope-cc/README.md

@@ -0,0 +1,250 @@
+# SD Webui Vectorscope CC
+This is an Extension for the [Automatic1111 Webui](https://github.com/AUTOMATIC1111/stable-diffusion-webui), which performs a kind of **Offset Noise**[*](#offset-noise-tldr) natively,
+allowing you to adjust the brightness, contrast, and color of the generations.
+
+> [Sample Images](#sample-images)
+
+## How to Use
+After installing this Extension, you will see a new section in both **txt2img** and **img2img** tabs. 
+Refer to the parameters and sample images below and play around with the values.
+
+**Note:** Since this modifies the underlying latent noise, the composition may change drastically. Using the **Ones** scaling seems to reduce the variations.
+
+#### Parameters
+- **Enable:** Turn on/off this Extension
+- **Alt:** Modify an alternative Tensor instead, causing the effects to be significantly stronger
+- **Brightness:** Adjust the overall brightness of the image
+- **Contrast:** Adjust the overall contrast of the image
+- **Saturation:** Adjust the overall saturation of the image
+
+#### Color Channels
+- Comes with a Color Wheel for visualization
+- You can also click and drag on the Color Wheel to select a color directly
+
+<table>
+    <thead align="center">
+        <tr>
+            <td><b>Channel</b></td>
+            <td><b>Lower</b></td>
+            <td><b>Higher</b></td>
+        </tr>
+    </thead>
+    <tbody align="center">
+        <tr>
+            <td><b>R</b></td>
+            <td>Cyan</td>
+            <td>Red</td>
+        </tr>
+        <tr>
+            <td><b>G</b></td>
+            <td>Magenta</td>
+            <td>Green</td>
+        </tr>
+        <tr>
+            <td><b>B</b></td>
+            <td>Yellow</td>
+            <td>Blue</td>
+        </tr>
+    </tbody>
+</table>
+
+#### Buttons
+- **Reset:** Reset all settings to the default values
+- **Randomize:** Randomize `Brightness`, `Contrast`, `Saturation`, `R`, `G`, `B`
+
+#### Style Presets
+- Use the `Dropdown` to select a Style then click **Apply Style** to apply
+- To save a Style, enter a name in the `Textbox` then click **Save Style**
+- To delete a Style, enter the name in the `Textbox` then click **Delete Style**
+    - *Deleted Style is still in the `styles.json` in case you wish to retrieve it*
+- Click **Refresh Style** to update the `Dropdown` if you edited the `styles.json` directly
+
+#### Advanced Settings
+- **Process Hires. fix:** By default, this Extension only functions during the **txt2img** phase, so that **Hires. fix** may "fix" the artifacts introduced during **txt2img**. Enable this to process **Hires. fix** phase too.
+  - This option does not affect **img2img**
+
+##### Noise Settings
+> let `x` denote the Tensor ; let `y` denote the operations
+
+<!-- "Straight", "Straight Abs.", "Cross", "Cross Abs.", "Ones", "N.Random", "U.Random", "Multi-Res", "Multi-Res Abs." -->
+
+- **Straight:** All operations are calculated on the same Tensor
+  - `x += x * y`
+- **Cross:** All operations are calculated on the Tensor opposite of the `Alt.` setting
+  - `x += x' * y`
+- **Ones:** All operations are calculated on a Tensor filled with ones 
+  - `x += 1 * y` 
+- **N.Random:** All operations are calculated on a Tensor filled with random values from normal distribution 
+  - `x += randn() * y`
+- **U.Random:** All operations are calculated on a Tensor filled with random values from uniform distribution
+  - `x += rand() * y`
+- **Multi-Res:** All operations are calculated on a Tensor generated with multi-res noise algorithm
+  - `x += multires() * y`
+- **Abs:** Calculate using the absolute values of the chosen Tensors instead
+  - `x += abs(F) * y`
+
+<p align="center"><img src="samples/Bright.jpg" width=768></p>
+<p align="center"><img src="samples/Dark.jpg" width=768></p>
+
+##### Scaling Settings
+Previously, this Extension offsets the noise by the same amount each step. 
+But due to the denoising process, this may produce undesired outcomes such as blurriness at high **Brightness** or noises at low **Brightness**.
+Thus, I added a scaling option to modify the offset amount.
+
+> Essentially, the "magnitude" of the default Tensor gets smaller every step, so offsetting by the same amount will have stronger effects at later steps. This is reversed on the `Alt.` Tensor however.
+
+- **Flat:** Default behavior. Same amount each step.
+- **Cos:** Cosine scaling. *(High -> Low)*
+- **Sin:** Sine scaling. *(Low -> High)*
+- **1 - Cos:** *(Low -> High)*
+- **1 - Sin:** *(High -> Low)*
+
+> In my experience, **`1 - Sin`** works better for the **default** Tensor while **`1 - Cos`** works better for the **Alt.** Tensor
+
+<p align="center">
+<code>Alt. Disabled</code><br>
+<img src="samples/Scaling.jpg" width=768>
+</p>
+
+<p align="center">
+<code>Alt. Enabled</code><br>
+<img src="samples/Scaling_alt.jpg" width=768>
+</p>
+
+<p align="center"><i>Notice the blurriness and the noises on <code>Flat</code> scaling</i></p>
+
+## Sample Images
+- **Checkpoint:** [UHD-23](https://civitai.com/models/22371/uhd-23)
+- **Pos. Prompt:** `(masterpiece, best quality), 1girl, solo, night, street, city, neon_lights`
+- **Neg. Prompt:** `(low quality, worst quality:1.2)`, [`EasyNegative`](https://huggingface.co/datasets/gsdf/EasyNegative/tree/main), [`EasyNegativeV2`](https://huggingface.co/gsdf/Counterfeit-V3.0/tree/main/embedding)
+- `Euler a`; `20 steps`; `7.5 CFG`; `Hires. fix`; `Latent (nearest)`; `16 H.steps`; `0.6 D.Str.`; `Seed:`**`3814649974`**
+- `Straight Abs.`
+
+<p align="center">
+<b>Base</b><br>
+<code>Extension Disabled</code><br>
+<img src="samples/00.jpg" width=512>
+</p>
+
+<p align="center">
+<b>Dark</b><br>
+<code><b>Brightness:</b> -3; <b>Contrast:</b> 1.5</code><br>
+<img src="samples/01.jpg" width=512>
+</p>
+
+<p align="center">
+<b>Bright</b><br>
+<code><b>Brightness:</b> 2.5; <b>Contrast:</b> 0.5; <b>Alt:</b> Enabled</code><br>
+<img src="samples/02.jpg" width=512>
+</p>
+
+<p align="center">
+<b>Chill</b><br>
+<code><b>Brightness:</b> -2.5; <b>Contrast:</b> 1.25</code><br>
+<code><b>R:</b> -1.5; <b>B:</b> 2.5</code><br>
+<img src="samples/03.jpg" width=512>
+</p>
+
+<p align="center">
+<b><s>Mexican Movie</s></b><br>
+<code><b>Brightness:</b> 3; <b>Saturation:</b> 1.5</code><br>
+<code><b>R:</b> 2; <b>G:</b> 1; <b>B:</b> -2</code><br>
+<img src="samples/04.jpg" width=512>
+</p>
+
+<p align="center"><i>Notice the significant differences even when using the same seed</i></p>
+
+## Roadmap
+- [X] Extension Released
+- [X] Add Support for **X/Y/Z Plot**
+- [X] Implement different **Noise** functions
+- [X] Add **Randomize** functions
+- [X] Append Parameters onto Metadata
+  - You can enable this in the **Infotext** section of the **Settings** tab
+- [X] **Style** Presets
+- [X] Implement **Color Wheel** & **Color Picker**
+- [X] Implement better scaling algorithms
+  - [X] Fix the **Brightness** issues *~~kinda~~*
+- [X] Add API Docs
+- [X] Add Infotext Support *(by. [catboxanon](https://github.com/catboxanon))*
+- [X] ADD **HDR** Script
+- [ ] Add Gradient features
+
+<p align="center"><code>X/Y/Z Plot Support</code><br><i>(Outdated Contrast Value)</i></p>
+<p align="center"><img src="samples/XYZ.jpg" width=768></p>
+
+<p align="center"><code>X/Y/Z Plot w/ Randomize</code></p>
+<p align="center"><img src="samples/Random.jpg" width=768></p>
+<p align="center">The value is used as the random seed<br>You can refer to the console to see the randomized values</p>
+
+## API
+You can use this Extension via [API](https://github.com/AUTOMATIC1111/stable-diffusion-webui/wiki/API) by adding an entry in the `alwayson_scripts` of your payload. 
+An [example](samples/api_example.json) is provided.
+The `args` are sent in the following order:
+
+- **[Enable, Alt, Brightness, Contrast, Saturation, R, G, B, Process Hires. Fix, Noise Settings, Scaling Settings]**
+> `bool`, `bool`, `float`, `float`, `float`, `float`, `float`, `float`, `bool`, `str`, `str`
+
+## Known Issues
+- Does not work with `DDIM`, `UniPC` samplers
+- Has little effect when used with certain **LoRA**s
+
+## HDR
+<p align="right"><i><b>BETA</b></i></p>
+
+> [Discussion Thread](https://github.com/Haoming02/sd-webui-vectorscope-cc/issues/16)
+
+- In the **Script** `Dropdown` at the bottom, there is now a new option: **`High Dynamic Range`**
+- This script will generate multiple images *("Brackets")* of varying brightness, then merge them into 1 HDR image
+- *Do provide feedback in the thread!*
+- **Highly Recommended** to use a deterministic sampler and high enough steps. `Euler` *(**not** `Euler a`)* worked the best in my experience.
+
+#### Settings
+- **Brackets:** The numer of images to generate
+- **Gaps:** The brightness difference between each image
+- **Automatically Merge:** When enabled, this will merge the images using a `OpenCV` algorithm and save to the `HDR` folder in the `outputs` folder; When disabled, this will return all images to the result section, for when you have a more advanced program such as Photoshop to do the merging.
+  - All the images are still saved to the `outputs` folder regardless
+
+<hr>
+
+### Offset Noise TL;DR
+The most common *version* of **Offset Noise** you may have heard of is from this [blog post](https://www.crosslabs.org/blog/diffusion-with-offset-noise), 
+where it was discovered that the noise functions used during **training** were flawed, causing `Stable Diffusion` to always generate images with an average of `0.5`.
+
+> **ie.** Even if you prompt for dark/night or bright/snow, the overall image still looks "grey"
+
+> [Technical Explanations](https://youtu.be/cVxQmbf3q7Q)
+
+However, this Extension instead tries to offset the latent noise during the **inference** phase. 
+Therefore, you do not need to use models that were specially trained, as this can work on any model.
+Though, the results may not be as good as using properly trained models.
+
+<hr>
+
+### What is Under the Hood
+After reading through and messing around with the code, 
+I found out that it is possible to directly modify the Tensors 
+representing the latent noise used by the Stable Diffusion process.
+
+The dimensions of the Tensors is `(X, 4, H / 8, W / 8)`, which can be thought of like this:
+
+> **X** batch of noise images, with **4** channels, each with **(W / 8) x (H / 8)** values
+
+> **eg.** Generating a single 512x768 image will create a Tensor of size (1, 4, 96, 64)
+
+Then, I tried to play around with the values of each channel and ended up discovering these relationships.
+Essentially, the 4 channels correspond to the **CMYK** color format, 
+hence why you can control the brightness as well as the colors.
+
+<hr>
+
+### Vectorscope?
+The Extension is named this way because the color interactions remind me of the `Vectorscope` found in **Premiere Pro**'s **Lumetri Color**.
+Those who are experienced in Color Correction should be rather familiar with this Extension.
+
+<p align="center"><img src="scripts/Vectorscope.png" width=256></p>
+
+<hr>
+
+<sup>~~Yes. I'm aware that it's just how digital colors work in general.~~<br>
+~~We've come full **circle** *(\*ba dum tss)* now that a Color Wheel is actually added.~~</sup>

sd-webui-vectorscope-cc/javascript/vec_cc.js

@@ -0,0 +1,136 @@
+function registerPicker(wheel, sliders, mode) {
+    for (const event of ['mousemove', 'click']) {
+        wheel.addEventListener(event, (e) => {
+            e.preventDefault();
+
+            const rect = e.target.getBoundingClientRect();
+
+            if (e.type != 'click') {
+                if (e.buttons != 1) {
+                    return;
+                }
+
+                const dot = e.target.parentElement.querySelector('#cc-dot-' + mode);
+                dot.style.position = 'fixed';
+                dot.style.left = e.x - (dot.width / 2) + 'px';
+                dot.style.top = e.y - (dot.height / 2) + 'px';
+            }
+
+            x = ((e.clientX - rect.left) - 100.0) / 25;
+            y = ((e.clientY - rect.top) - 100.0) / 25;
+
+            const zeta = Math.atan(y / x)
+            var degree = 0
+
+            if (x >= 0) {
+                if (y >= 0)
+                    degree = zeta * 180 / Math.PI
+                else
+                    degree = 360 + zeta * 180 / Math.PI
+            }
+            else if (x < 0) {
+                degree = 180 + zeta * 180 / Math.PI
+            }
+
+            // -0.5r - 0.5g + b = x
+            // -0.866r + 0.866g = y
+            // 240r + 120g = z * rgb
+
+            // g = (1 / 0.866)y + r
+            // -0.5r - 0.5((1 / 0.866)y + r) + b = x
+            // b = x + 0.5r + 0.5((1 / 0.866)y + r)
+
+            // 240r + 120(1 / 0.866)y + r = z * r((1 / 0.866)y + r)(x + 0.5r + 0.5((1 / 0.866)y + r))
+
+            var r = -(0.00077 * (433 * x * degree + 750 * y * degree) / degree)
+            var g = y / 0.866 + r
+            var b = x + 0.5 * r + 0.5 * g
+
+            const mag = Math.sqrt(r * r + g * g + b * b)
+            const len = Math.abs(r) + Math.abs(g) + Math.abs(b)
+
+            r = r / mag * len
+            g = g / mag * len
+            b = b / mag * len
+
+            sliders[0].value = r.toFixed(2)
+            sliders[0].closest('.gradio-slider').querySelector('input[type=range]').value = r.toFixed(2)
+            sliders[1].value = g.toFixed(2)
+            sliders[1].closest('.gradio-slider').querySelector('input[type=range]').value = g.toFixed(2)
+            sliders[2].value = b.toFixed(2)
+            sliders[2].closest('.gradio-slider').querySelector('input[type=range]').value = b.toFixed(2)
+
+            if (e.type == 'click') {
+                updateInput(sliders[0])
+                updateInput(sliders[1])
+                updateInput(sliders[2])
+            }
+        })
+    }
+
+    wheel.addEventListener('mouseup', (e) => {
+        const dot = e.target.parentElement.querySelector('#cc-dot-' + mode);
+        dot.style.position = 'absolute';
+        updateInput(sliders[0])
+        updateInput(sliders[1])
+        updateInput(sliders[2])
+    })
+}
+
+onUiLoaded(async () => {
+
+    ['txt', 'img'].forEach((mode) => {
+
+        const container = document.getElementById('cc-colorwheel-' + mode)
+        container.style.height = '200px'
+        container.style.width = 'auto'
+
+        container.querySelector('.float')?.remove()
+        container.querySelector('.download')?.remove()
+        for (const downloadButton of container.querySelectorAll('[download]')) {
+            downloadButton.parentElement.remove()
+        }
+
+        const wheel = container.getElementsByTagName('img')[0]
+        wheel.style.height = '100%'
+        wheel.style.width = 'auto'
+        wheel.style.margin = 'auto'
+        wheel.id = 'cc-img-' + mode
+
+        wheel.ondragstart = (e) => { e.preventDefault(); }
+
+        sliders = [
+            document.getElementById('cc-r-' + mode).querySelector('input'),
+            document.getElementById('cc-g-' + mode).querySelector('input'),
+            document.getElementById('cc-b-' + mode).querySelector('input')
+        ]
+
+        registerPicker(wheel, sliders, mode)
+
+        const temp = document.getElementById('cc-temp-' + mode)
+
+        const dot = temp.getElementsByTagName('img')[0]
+        dot.id = 'cc-dot-' + mode
+
+        container.appendChild(dot)
+        dot.style.left = 'calc(50% - 12px)'
+        dot.style.top = 'calc(50% - 12px)'
+
+        temp.remove()
+
+        const row1 = document.getElementById('cc-apply-' + mode).parentNode
+        const row2 = document.getElementById('cc-save-' + mode).parentNode
+
+        row1.style.alignItems = 'end'
+        row1.style.gap = '1em'
+        row2.style.alignItems = 'end'
+        row2.style.gap = '1em'
+
+        // ----- HDR UIs -----
+        const hdr_settings = document.getElementById('vec-hdr-' + mode)
+        const buttons = hdr_settings.getElementsByTagName('label')
+
+        for (let i = 0; i < buttons.length; i++)
+            buttons[i].style.borderRadius = '0.5em'
+    })
+})

sd-webui-vectorscope-cc/samples/api_example.json

@@ -0,0 +1,29 @@
+{
+	"prompt": "(masterpiece, best quality), 1girl, solo, night",
+	"negative_prompt": "(low quality, worst quality:1.2)",
+	"seed": -1,
+	"sampler_name": "Euler a",
+	"sampler_index": "euler",
+	"batch_size": 1,
+	"steps": 24,
+	"cfg_scale": 8.5,
+	"width": 512,
+	"height": 512,
+	"alwayson_scripts": {
+		"Vectorscope CC": {
+			"args": [
+				true,
+				true,
+				-2.5,
+				0.5,
+				1.25,
+				0.0,
+				0.0,
+				0.0,
+				false,
+				"Straight Abs.",
+				"Flat"
+			]
+		}
+	}
+}

sd-webui-vectorscope-cc/scripts/cc.py

@@ -0,0 +1,294 @@
+from modules.sd_samplers_kdiffusion import KDiffusionSampler
+import modules.scripts as scripts
+import scripts.cc_const as const
+from modules import shared
+import gradio as gr
+import random
+
+from scripts.cc_noise import *
+
+from scripts.cc_xyz import xyz_support
+
+from scripts.cc_scaling import apply_scaling
+
+from scripts.cc_version import VERSION
+
+from scripts.cc_colorpicker import create_colorpicker
+from scripts.cc_colorpicker import horizontal_js
+from scripts.cc_colorpicker import vertical_js
+
+from scripts.cc_style import StyleManager
+style_manager = StyleManager()
+style_manager.load_styles()
+
+og_callback = KDiffusionSampler.callback_state
+
+class VectorscopeCC(scripts.Script):
+    def __init__(self):
+        self.xyzCache = {}
+        xyz_support(self.xyzCache)
+
+    def title(self):
+        return "Vectorscope CC"
+
+    def show(self, is_img2img):
+        return scripts.AlwaysVisible
+
+    def ui(self, is_img2img):
+
+        with gr.Accordion(f"Vectorscope CC {VERSION}", elem_id='vec-cc-' + ('img' if is_img2img else 'txt'), open=False):
+
+            with gr.Row():
+                enable = gr.Checkbox(label="Enable")
+                latent = gr.Checkbox(label="Alt. (Stronger Effects)")
+
+            with gr.Row():
+                bri = gr.Slider(label="Brightness", minimum=const.Brightness.minimum, maximum=const.Brightness.maximum, step=0.1, value=const.Brightness.default)
+                con = gr.Slider(label="Contrast", minimum=const.Contrast.minimum, maximum=const.Contrast.maximum, step=0.05, value=const.Contrast.default)
+                sat = gr.Slider(label="Saturation", minimum=const.Saturation.minimum, maximum=const.Saturation.maximum, step=0.05, value=const.Saturation.default)
+
+            with gr.Row():
+                with gr.Column():
+                    r = gr.Slider(label="R", info='Cyan | Red', minimum=const.R.minimum, maximum=const.R.maximum, step=0.05, value=const.R.default, elem_id='cc-r-' + ('img' if is_img2img else 'txt'))
+                    g = gr.Slider(label="G", info='Magenta | Green',minimum=const.G.minimum, maximum=const.G.maximum, step=0.05, value=const.G.default, elem_id='cc-g-' + ('img' if is_img2img else 'txt'))
+                    b = gr.Slider(label="B", info='Yellow | Blue',minimum=const.B.minimum, maximum=const.B.maximum, step=0.05, value=const.B.default, elem_id='cc-b-' + ('img' if is_img2img else 'txt'))
+
+                create_colorpicker(is_img2img)
+
+                for component in [r, g, b]:
+                    component.change(None, inputs=[r, g, b], outputs=[], _js=horizontal_js(is_img2img))
+                    component.change(None, inputs=[r, g, b], outputs=[], _js=vertical_js(is_img2img))
+
+            with gr.Accordion("Styles", open=False):
+
+                with gr.Row():
+                    style_choice = gr.Dropdown(label="Styles", choices=style_manager.list_style(), scale = 3)
+                    apply_btn = gr.Button(value="Apply Style", elem_id='cc-apply-' + ('img' if is_img2img else 'txt'), scale = 2)
+                    refresh_btn = gr.Button(value="Refresh Style", scale = 2)
+                with gr.Row():
+                    style_name = gr.Textbox(label="Style Name", scale = 3)
+                    save_btn = gr.Button(value="Save Style", elem_id='cc-save-' + ('img' if is_img2img else 'txt'), scale = 2)
+                    delete_btn = gr.Button(value="Delete Style", scale = 2)
+
+                apply_btn.click(fn=style_manager.get_style, inputs=style_choice, outputs=[latent, bri, con, sat, r, g, b])
+                save_btn.click(fn=lambda *args: gr.update(choices=style_manager.save_style(*args)), inputs=[style_name, latent, bri, con, sat, r, g, b], outputs=style_choice)
+                delete_btn.click(fn=lambda name: gr.update(choices=style_manager.delete_style(name)), inputs=style_name, outputs=style_choice)
+                refresh_btn.click(fn=lambda _: gr.update(choices=style_manager.list_style()), outputs=style_choice)
+
+            with gr.Accordion("Advanced Settings", open=False):
+                doHR = gr.Checkbox(label="Process Hires. fix")
+                method = gr.Radio(["Straight", "Straight Abs.", "Cross", "Cross Abs.", "Ones", "N.Random", "U.Random", "Multi-Res", "Multi-Res Abs."], label="Noise Settings", value="Straight Abs.")
+                scaling = gr.Radio(["Flat", "Cos", "Sin", "1 - Cos", "1 - Sin"], label="Scaling Settings", value="Flat")
+
+            with gr.Row():
+                reset_btn = gr.Button(value="Reset")
+                self.register_reset(reset_btn, enable, latent, bri, con, sat, r, g, b, doHR, method, scaling)
+
+                random_btn = gr.Button(value="Randomize")
+                self.register_random(random_btn, bri, con, sat, r, g, b)
+
+        self.infotext_fields = []
+        self.paste_field_names = []
+        self.infotext_fields = [
+            (enable, lambda d: enable.update(value=("Vec CC Enabled" in d))),
+            (latent, "Vec CC Alt"),
+            (bri, "Vec CC Brightness"),
+            (con, "Vec CC Contrast"),
+            (sat, "Vec CC Saturation"),
+            (r, "Vec CC R"),
+            (g, "Vec CC G"),
+            (b, "Vec CC B"),
+            (method, "Vec CC Noise"),
+            (doHR, "Vec CC Proc HrF"),
+            (scaling, "Vec CC Scaling"),
+        ]
+
+        for _, name in self.infotext_fields:
+            self.paste_field_names.append(name)
+
+        return [enable, latent, bri, con, sat, r, g, b, doHR, method, scaling]
+
+    def register_reset(self, reset_btn, enable, latent, bri, con, sat, r, g, b, doHR, method, scaling):
+        for component in [enable, latent, doHR]:
+            reset_btn.click(fn=lambda _: gr.update(value=False), outputs=component)
+        for component in [bri, con, r, g, b]:
+            reset_btn.click(fn=lambda _: gr.update(value=0.0), outputs=component)
+        for component in [sat]:
+            reset_btn.click(fn=lambda _: gr.update(value=const.Saturation.default), outputs=component)
+
+        reset_btn.click(fn=lambda _: gr.update(value='Straight Abs.'), outputs=method)
+        reset_btn.click(fn=lambda _: gr.update(value='Flat'), outputs=scaling)
+
+    def register_random(self, random_btn, bri, con, sat, r, g, b):
+        for component in [bri, con, r, g, b]:
+            random_btn.click(fn=lambda _: gr.update(value=round(random.uniform(const.R.minimum, const.R.maximum), 2)), outputs=component)
+        for component in [sat]:
+            random_btn.click(fn=lambda _: gr.update(value=round(random.uniform(const.Saturation.minimum, const.Saturation.maximum), 2)), outputs=component)
+
+    def parse_bool(self, string:str):
+        if string.lower() == "true":
+            return True
+        if string.lower() == "false":
+            return False
+
+        raise ValueError(f"Invalid Value: {string}")
+
+    def process(self, p, enable:bool, latent:bool, bri:float, con:float, sat:float, r:float, g:float, b:float, doHR:bool, method:str, scaling:str):
+        KDiffusionSampler.isHR_Pass = False
+        if 'Enable' in self.xyzCache.keys():
+            enable = self.parse_bool(self.xyzCache['Enable'])
+
+        if not enable:
+            if 'Enable' not in self.xyzCache.keys():
+                if len(self.xyzCache) > 0:
+                    print('\n[X/Y/Z Plot] x [Vec.CC] Extension is not Enabled!\n')
+                self.xyzCache.clear()
+
+            KDiffusionSampler.callback_state = og_callback
+            return p
+
+        if 'Random' in self.xyzCache.keys():
+            if len(self.xyzCache) > 1:
+                print('\n[X/Y/Z Plot] x [Vec.CC] Randomize is Enabled!\nSome settings will not apply!\n')
+            else:
+                print('\n[X/Y/Z Plot] x [Vec.CC] Randomize is Enabled!\n')
+
+        cc_seed = None
+
+        for k, v in self.xyzCache.items():
+            match k:
+                case 'Alt':
+                    latent = self.parse_bool(v)
+                case 'Brightness':
+                    bri = v
+                case 'Contrast':
+                    con = v
+                case 'Saturation':
+                    sat = v
+                case 'R':
+                    r = v
+                case 'G':
+                    g = v
+                case 'B':
+                    b = v
+                case 'DoHR':
+                    doHR = self.parse_bool(v)
+                case 'Method':
+                    method = v
+                case 'Scaling':
+                    scaling = v
+                case 'Random':
+                    cc_seed = v
+
+        self.xyzCache.clear()
+
+        if method == 'Disabled':
+            KDiffusionSampler.callback_state = og_callback
+            return p
+
+        steps = p.steps
+        if not hasattr(p, 'enable_hr') and hasattr(p, 'denoising_strength') and not shared.opts.img2img_fix_steps:
+            steps = int(steps * p.denoising_strength)
+
+        if cc_seed is not None:
+            random.seed(cc_seed)
+
+            bri = round(random.uniform(const.Contrast.minimum, const.Contrast.maximum), 2)
+            con = round(random.uniform(const.Contrast.minimum, const.Contrast.maximum), 2)
+            r = round(random.uniform(const.R.minimum, const.R.maximum), 2)
+            g = round(random.uniform(const.G.minimum, const.G.maximum), 2)
+            b = round(random.uniform(const.B.minimum, const.B.maximum), 2)
+
+            sat = round(random.uniform(const.Saturation.minimum, const.Saturation.maximum), 2)
+
+            print(f'-> Seed: {cc_seed}')
+            print(f'Brightness:\t{bri}')
+            print(f'Contrast:\t{con}')
+            print(f'Saturation:\t{sat}')
+            print(f'R:\t\t{r}')
+            print(f'G:\t\t{g}')
+            print(f'B:\t\t{b}\n')
+
+        if hasattr(shared.opts, 'cc_metadata') and shared.opts.cc_metadata is True:
+            p.extra_generation_params['Vec CC Enabled'] = enable
+            p.extra_generation_params['Vec CC Alt'] = latent
+            p.extra_generation_params['Vec CC Brightness'] = bri
+            p.extra_generation_params['Vec CC Contrast'] = con
+            p.extra_generation_params['Vec CC Saturation'] = sat
+            p.extra_generation_params['Vec CC R'] = r
+            p.extra_generation_params['Vec CC G'] = g
+            p.extra_generation_params['Vec CC B'] = b
+            p.extra_generation_params['Vec CC Noise'] = method
+            p.extra_generation_params['Vec CC Proc HrF'] = doHR
+            p.extra_generation_params['Vec CC Scaling'] = scaling
+            p.extra_generation_params['Vec CC Version'] = VERSION
+
+        bri /= steps
+        con /= steps
+        sat = pow(sat, 1.0 / steps)
+        r /= steps
+        g /= steps
+        b /= steps
+
+        mode = 'x' if latent else 'denoised'
+
+        # Channel 0:    Dark    |   Bright
+        # Channel 1:    Purple  |   Green
+        # Channel 2:    Red     |   Cyan
+        # Channel 2:    Violet  |   Yellow
+
+        def callback_state(self, d):
+            if not doHR and self.isHR_Pass is True:
+                return og_callback(self, d)
+
+            source = d[mode]
+
+            # "Straight", "Straight Abs.", "Cross", "Cross Abs.", "Ones", "N.Random", "U.Random", "Multi-Res", "Multi-Res Abs."
+            if 'Straight' in method:
+                target = d[mode]
+            elif 'Cross' in method:
+                cross = 'x' if mode == 'denoised' else 'denoised'
+                target = d[cross]
+            elif 'Multi-Res' in method:
+                target = multires_noise(d[mode], 'Abs' in method)
+            elif method == 'Ones':
+                target = ones(d[mode])
+            elif method == 'N.Random':
+                target = normal_noise(d[mode])
+            elif method ==  'U.Random':
+                target = gaussian_noise(d[mode])
+
+            if 'Abs' in method:
+                target = to_abs(target)
+
+            batchSize = d[mode].size(0)
+
+            mods = apply_scaling(scaling, d["i"], steps, bri, con, sat, r, g, b)
+
+            for i in range(batchSize):
+                BRIGHTNESS = [source[i, 0], target[i, 0]]
+                R = [source[i, 2], target[i, 2]]
+                G = [source[i, 1], target[i, 1]]
+                B = [source[i, 3], target[i, 3]]
+
+                BRIGHTNESS[0] += BRIGHTNESS[1] * mods[0]
+                BRIGHTNESS[0] += get_delta(BRIGHTNESS[0]) * mods[1]
+
+                R[0] -= R[1] * mods[3]
+                G[0] += G[1] * mods[4]
+                B[0] -= B[1] * mods[5]
+
+                R[0] *= mods[2]
+                G[0] *= mods[2]
+                B[0] *= mods[2]
+
+            return og_callback(self, d)
+
+        KDiffusionSampler.callback_state = callback_state
+        return p
+
+    def before_hr(self, p, *args):
+        KDiffusionSampler.isHR_Pass = True
+
+    def postprocess(self, p, processed, *args):
+        KDiffusionSampler.callback_state = og_callback

sd-webui-vectorscope-cc/scripts/cc_colorpicker.py

@@ -0,0 +1,23 @@
+import modules.scripts as scripts
+import gradio as gr
+
+WHEEL = scripts.basedir() + '/scripts/Vectorscope.png'
+DOT = scripts.basedir() + '/scripts/dot.png'
+
+def create_colorpicker(is_img):
+	gr.Image(WHEEL, type='filepath', interactive=False, container=False, elem_id='cc-colorwheel-' + ('img' if is_img else 'txt'))
+	gr.Image(DOT, type='filepath', interactive=False, container=False, elem_id='cc-temp-' + ('img' if is_img else 'txt'))
+
+def horizontal_js(is_img):
+	mag = '(Math.abs(r) + Math.abs(g) + Math.abs(b))'
+	calc = '25 * Math.sqrt(r*r+g*g+b*b) * (r * -0.5 + g * -0.5 + b * 1.0) / ' + mag
+	cond = '(' + mag + ' === 0 ? 0 : ' + calc + ')'
+
+	return "(r, g, b) => {document.getElementById('cc-dot-" + ('img' if is_img else 'txt') + "').style.left = 'calc(50% + ' +(" + cond + "- 12) + 'px)'}"
+
+def vertical_js(is_img):
+	mag = '(Math.abs(r) + Math.abs(g) + Math.abs(b))'
+	calc = '25 * Math.sqrt(r*r+g*g+b*b) * (r * -0.866 + g * 0.866 + b * 0.0) / ' + mag
+	cond = '(' + mag + ' === 0 ? 0 : ' + calc + ')'
+
+	return "(r, g, b) => {document.getElementById('cc-dot-" + ('img' if is_img else 'txt') + "').style.top = 'calc(50% + ' +(" + cond + "- 12) + 'px)'}"

sd-webui-vectorscope-cc/scripts/cc_const.py

@@ -0,0 +1,12 @@
+class Param():
+    def __init__(self, minimum, maximum, default):
+        self.minimum = minimum
+        self.maximum = maximum
+        self.default = default
+
+Brightness = Param(-7.5, 7.5, 0.0)
+Contrast = Param(-5.0, 5.0, 0.0)
+Saturation = Param(0.15, 1.85, 1.0)
+R = Param(-4.0, 4.0, 0.0)
+G = Param(-4.0, 4.0, 0.0)
+B = Param(-4.0, 4.0, 0.0)

sd-webui-vectorscope-cc/scripts/cc_hdr.py

@@ -0,0 +1,107 @@
+import modules.scripts as scripts
+import gradio as gr
+import numpy as np
+import cv2 as cv
+
+from modules.processing import process_images, get_fixed_seed
+from copy import copy
+
+# https://docs.opencv.org/4.8.0/d2/df0/tutorial_py_hdr.html
+def merge_HDR(imgs:list, path:str, depth:str, fmt:str, gamma:float):
+    import datetime
+    import math
+    import os
+
+    output_folder = os.path.join(path, 'hdr')
+    if not os.path.exists(output_folder):
+        os.makedirs(output_folder)
+
+    imgs_np = [np.array(img, dtype=np.uint8) for img in imgs]
+
+    merge = cv.createMergeMertens()
+    hdr = merge.process(imgs_np)
+    hdr += math.ceil(0 - np.min(hdr) * 1000) / 1000
+
+    #print(f'{np.min(hdr)}, {np.max(hdr)}')
+
+    target = (65535 if depth == '16bpc' else 255)
+    precision = ('uint16' if depth == '16bpc' else 'uint8')
+
+    hdr = np.power(hdr, (1 / gamma))
+
+    ldr = np.clip(hdr * target, 0, target).astype(precision)
+    rgb = cv.cvtColor(ldr, cv.COLOR_BGR2RGB)
+
+    cv.imwrite(os.path.join(output_folder, f'{datetime.datetime.now().strftime("%H-%M-%S")}{fmt}'), rgb)
+
+class VectorHDR(scripts.Script):
+
+    def title(self):
+        return "High Dynamic Range"
+
+    def show(self, is_img2img):
+        return True
+
+    def ui(self, is_img2img):
+        with gr.Row():
+            count = gr.Slider(label="Brackets", minimum=3, maximum=9, step=2, value=7)
+            gap = gr.Slider(label="Gaps", minimum=0.50, maximum=2.50, step=0.25, value=1.50)
+
+        with gr.Accordion("Merge Options", elem_id='vec-hdr-' + ('img' if is_img2img else 'txt'), open=False):
+            auto = gr.Checkbox(label="Automatically Merge", value=True)
+
+            with gr.Row():
+                depth = gr.Radio(['16bpc', '8bpc'], label="Bit Depth", value="16bpc")
+                fmt = gr.Radio(['.tiff', '.png'], label="Image Format", value=".tiff")
+
+            gamma = gr.Slider(label="Gamma", info='Lower: Darker | Higher: Brighter',minimum=0.2, maximum=2.2, step=0.2, value=1.2)
+
+        return [count, gap, auto, depth, fmt, gamma]
+
+    def run(self, p, count:int, gap:float, auto:bool, depth:str, fmt:str, gamma:float):
+        center = count // 2
+
+        p.seed = get_fixed_seed(p.seed)
+        p.scripts.script('vectorscope cc').xyzCache.update({
+            'Enable':'True',
+            'Alt':'True',
+            'Brightness': 0,
+            'DoHR': 'False',
+            'Method': 'Ones',
+            'Scaling': '1 - Cos'
+        })
+
+        baseline = process_images(p)
+        pc = copy(p)
+
+        imgs = [None] * count
+        imgs[center] = baseline.images[0]
+
+        brackets = brightness_brackets(count, gap)
+
+        for it in range(count):
+            if it == center:
+                continue
+
+            pc.scripts.script('vectorscope cc').xyzCache.update({
+                'Enable':'True',
+                'Alt':'True',
+                'Brightness': brackets[it],
+                'DoHR': 'False',
+                'Method': 'Ones',
+                'Scaling': '1 - Cos'
+            })
+
+            proc = process_images(pc)
+            imgs[it] = proc.images[0]
+
+        if not auto:
+            baseline.images = imgs
+            return baseline
+        else:
+            merge_HDR(imgs, p.outpath_samples, depth, fmt, gamma)
+            return baseline
+
+def brightness_brackets(count, gap):
+    half = count // 2
+    return [gap * (i - half) for i in range(count)]

sd-webui-vectorscope-cc/scripts/cc_noise.py

@@ -0,0 +1,50 @@
+from modules import devices
+import torch
+
+def get_delta(latent):
+    mean = torch.mean(latent)
+    return torch.sub(latent, mean)
+
+def to_abs(latent):
+    return torch.abs(latent)
+
+def zeros(latent):
+    return torch.zeros_like(latent)
+
+def ones(latent):
+    return torch.ones_like(latent)
+
+def gaussian_noise(latent):
+    return torch.rand_like(latent)
+
+def normal_noise(latent):
+    return torch.randn_like(latent)
+
+def multires_noise(latent, use_zero:bool, iterations=8, discount=0.4):
+    """
+    Reference: https://wandb.ai/johnowhitaker/multires_noise/reports/Multi-Resolution-Noise-for-Diffusion-Model-Training--VmlldzozNjYyOTU2
+    Credit: Kohya_SS
+    """
+    noise = zeros(latent) if use_zero else ones(latent)
+
+    batchSize = noise.size(0)
+    height = noise.size(2)
+    width = noise.size(3)
+
+    device = devices.get_optimal_device()
+    upsampler = torch.nn.Upsample(size=(height, width), mode="bilinear").to(device)
+
+    for b in range(batchSize):
+        for i in range(iterations):
+            r = torch.rand(1).item() * 2 + 2
+
+            wn = max(1, int(width / (r**i)))
+            hn = max(1, int(height / (r**i)))
+
+            for c in range(4):
+                noise[b, c] += upsampler(torch.randn(1, 1, hn, wn).to(device))[0, 0] * discount**i
+
+            if wn == 1 or hn == 1:
+                break
+
+    return noise / noise.std()

sd-webui-vectorscope-cc/scripts/cc_scaling.py

@@ -0,0 +1,28 @@
+from math import cos
+from math import sin
+from math import pi
+
+def apply_scaling(alg:str, current_step:int, total_steps:int, bri:float, con:float, sat:float, r:float, g:float, b:float):
+    ratio = float(current_step / total_steps)
+    rad = ratio * pi / 2
+
+    mod = 1.0
+
+    match alg:
+        case "Cos":
+            mod = cos(rad)
+        case "Sin":
+            mod = sin(rad)
+        case "1 - Cos":
+            mod = (1 - cos(rad))
+        case "1 - Sin":
+            mod = (1 - sin(rad))
+
+    return [
+        bri * mod,
+        con * mod,
+        (sat - 1) * mod + 1,
+        r * mod,
+        g * mod,
+        b * mod
+    ]

sd-webui-vectorscope-cc/scripts/cc_settings.py

@@ -0,0 +1,6 @@
+from modules import script_callbacks, shared
+
+def on_ui_settings():
+    shared.opts.add_option("cc_metadata", shared.OptionInfo(False, "Add Vectorscope CC parameters to generation information", section=("infotext", "Infotext")))
+
+script_callbacks.on_ui_settings(on_ui_settings)

sd-webui-vectorscope-cc/scripts/cc_style.py

@@ -0,0 +1,76 @@
+import modules.scripts as scripts
+import scripts.cc_const as const
+import json
+
+STYLE_FILE = scripts.basedir() + '/' + 'styles.json'
+
+EMPTY_STYLE = {
+	'styles' : {},
+	'deleted' : {}
+}
+
+class StyleManager():
+	def __init__(self):
+		self.STYLE_SHEET = None
+
+	def load_styles(self):
+		if self.STYLE_SHEET is not None:
+			return
+
+		try:
+			with open(STYLE_FILE, 'r') as json_file:
+				self.STYLE_SHEET = json.loads(json_file.read())
+				print('[Vec. CC] Style Sheet Loaded...')
+		except IOError:
+			with open(STYLE_FILE, 'w+') as json_file:
+				self.STYLE_SHEET = EMPTY_STYLE
+				json_file.write(json.dumps(self.STYLE_SHEET))
+				print('[Vec. CC] Creating Empty Style Sheet...')
+
+	def list_style(self):
+		return list(self.STYLE_SHEET['styles'].keys())
+
+	def get_style(self, style_name):
+		try:
+			style = self.STYLE_SHEET['styles'][style_name]
+			return style['alt'], style['brightness'], style['contrast'], style['saturation'], style['rgb'][0], style['rgb'][1], style['rgb'][2]
+		except KeyError:
+			print(f'\n[Warning] No Style of Name "{style_name}" Found!\n')
+			return False, const.Brightness.default, const.Contrast.default, const.Saturation.default, const.R.default, const.G.default, const.B.default
+
+	def save_style(self, style_name, latent, bri, con, sat, r, g, b):
+		if style_name in self.STYLE_SHEET['styles'].keys():
+			print(f'\n[Warning] Duplicated Style Name "{style_name}" Detected! Values are not saved!\n')
+			return self.list_style()
+
+		style = {
+			'alt' : latent,
+			'brightness' : bri,
+			'contrast' : con,
+			'saturation' : sat,
+			'rgb' : [r, g, b]
+		}
+
+		self.STYLE_SHEET['styles'].update({style_name:style})
+
+		with open(STYLE_FILE, 'w+') as json_file:
+			json_file.write(json.dumps(self.STYLE_SHEET))
+
+		print(f'\nStyle of Name "{style_name}" Saved!\n')
+		return self.list_style()
+
+	def delete_style(self, style_name):
+		try:
+			style = self.STYLE_SHEET['styles'][style_name]
+			del self.STYLE_SHEET['styles'][style_name]
+		except KeyError:
+			print(f'\n[Warning] No Style of Name "{style_name}" Found!\n')
+			return self.list_style()
+
+		self.STYLE_SHEET['deleted'].update({style_name:style})
+
+		with open(STYLE_FILE, 'w+') as json_file:
+			json_file.write(json.dumps(self.STYLE_SHEET))
+
+		print(f'\nStyle of Name "{style_name}" Deleted!\n')
+		return self.list_style()

sd-webui-vectorscope-cc/scripts/cc_version.py

@@ -0,0 +1,20 @@
+from modules import script_callbacks
+import modules.scripts as scripts
+import json
+
+VERSION = 'v1.4.10'
+
+def clean_outdated(EXT_NAME:str):
+    with open(scripts.basedir() + '/' + 'ui-config.json', 'r') as json_file:
+        configs = json.loads(json_file.read())
+
+    cleaned_configs = {key: value for key, value in configs.items() if EXT_NAME not in key}
+
+    with open(scripts.basedir() + '/' + 'ui-config.json', 'w') as json_file:
+        json.dump(cleaned_configs, json_file)
+
+def refresh_sliders():
+    clean_outdated('cc.py')
+    clean_outdated('cc_hdr.py')
+
+script_callbacks.on_before_ui(refresh_sliders)

sd-webui-vectorscope-cc/scripts/cc_xyz.py

@@ -0,0 +1,40 @@
+import modules.scripts as scripts
+
+def grid_reference():
+    for data in scripts.scripts_data:
+        if data.script_class.__module__ == 'xyz_grid.py' and hasattr(data, "module"):
+            return data.module
+
+def xyz_support(cache):
+    def apply_field(field):
+        def _(p, x, xs):
+            cache.update({field : x})
+        return _
+
+    def choices_bool():
+        return ["False", "True"]
+
+    def choices_method():
+        return ["Disabled", "Straight", "Straight Abs.", "Cross", "Cross Abs.", "Ones", "N.Random", "U.Random", "Multi-Res", "Multi-Res Abs."]
+
+    def choices_scaling():
+        return ["Flat", "Cos", "Sin", "1 - Cos", "1 - Sin"]
+
+    xyz_grid = grid_reference()
+
+    extra_axis_options = [
+        xyz_grid.AxisOption("[Vec.CC] Enable", str, apply_field("Enable"), choices=choices_bool),
+        xyz_grid.AxisOption("[Vec.CC] Alt.", str, apply_field("Alt"), choices=choices_bool),
+        xyz_grid.AxisOption("[Vec.CC] Brightness", float, apply_field("Brightness")),
+        xyz_grid.AxisOption("[Vec.CC] Contrast", float, apply_field("Contrast")),
+        xyz_grid.AxisOption("[Vec.CC] Saturation", float, apply_field("Saturation")),
+        xyz_grid.AxisOption("[Vec.CC] R", float, apply_field("R")),
+        xyz_grid.AxisOption("[Vec.CC] G", float, apply_field("G")),
+        xyz_grid.AxisOption("[Vec.CC] B", float, apply_field("B")),
+        xyz_grid.AxisOption("[Adv.CC] Proc. H.Fix", str, apply_field("DoHR"), choices=choices_bool),
+        xyz_grid.AxisOption("[Adv.CC] Method", str, apply_field("Method"), choices=choices_method),
+        xyz_grid.AxisOption("[Adv.CC] Scaling", str, apply_field("Scaling"), choices=choices_scaling),
+        xyz_grid.AxisOption("[Adv.CC] Randomize", int, apply_field("Random"))
+    ]
+
+    xyz_grid.axis_options.extend(extra_axis_options)

sd-webui-vectorscope-cc/style.css

@@ -0,0 +1,37 @@
+#cc-dot-txt {
+    position: absolute;
+    width: 24px;
+    height: 24px;
+    pointer-events: none;
+}
+
+#cc-dot-img {
+    position: absolute;
+    width: 24px;
+    height: 24px;
+    pointer-events: none;
+}
+
+#cc-img-txt {
+    cursor: pointer;
+}
+
+#cc-img-img {
+    cursor: pointer;
+}
+
+#vec-cc-txt button {
+    border-radius: 0.5em;
+}
+
+#vec-cc-txt label {
+    border-radius: 0.5em;
+}
+
+#vec-cc-img button {
+    border-radius: 0.5em;
+}
+
+#vec-cc-img label {
+    border-radius: 0.5em;
+}

sd-webui-vectorscope-cc/styles.json

@@ -0,0 +1 @@
+{"styles": {}, "deleted": {}}