410 lines
14 KiB
Python
410 lines
14 KiB
Python
from modules.sd_samplers_kdiffusion import KDiffusionSampler
|
|
from modules import shared, scripts
|
|
|
|
from scripts.cc_colorpicker import create_colorpicker
|
|
from scripts.cc_style import StyleManager
|
|
from scripts.cc_xyz import xyz_support
|
|
import scripts.cc_const as const
|
|
|
|
from random import seed
|
|
import gradio as gr
|
|
|
|
|
|
VERSION = "v2.2.0"
|
|
|
|
|
|
style_manager = StyleManager()
|
|
style_manager.load_styles()
|
|
|
|
|
|
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):
|
|
mode = "img" if is_img2img else "txt"
|
|
m = f'"{mode}"'
|
|
|
|
with gr.Accordion(
|
|
f"Vectorscope CC {VERSION}", elem_id=f"vec-cc-{mode}", 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.05,
|
|
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.Color.minimum,
|
|
maximum=const.Color.maximum,
|
|
step=0.05,
|
|
value=const.Color.default,
|
|
elem_id=f"cc-r-{mode}",
|
|
)
|
|
g = gr.Slider(
|
|
label="G",
|
|
info="Magenta | Green",
|
|
minimum=const.Color.minimum,
|
|
maximum=const.Color.maximum,
|
|
step=0.05,
|
|
value=const.Color.default,
|
|
elem_id=f"cc-g-{mode}",
|
|
)
|
|
b = gr.Slider(
|
|
label="B",
|
|
info="Yellow | Blue",
|
|
minimum=const.Color.minimum,
|
|
maximum=const.Color.maximum,
|
|
step=0.05,
|
|
value=const.Color.default,
|
|
elem_id=f"cc-b-{mode}",
|
|
)
|
|
|
|
r.input(
|
|
None,
|
|
inputs=[r, g, b],
|
|
_js=f"(r, g, b) => {{ VectorscopeCC.updateCursor(r, g, b, {m}); }}",
|
|
)
|
|
g.input(
|
|
None,
|
|
inputs=[r, g, b],
|
|
_js=f"(r, g, b) => {{ VectorscopeCC.updateCursor(r, g, b, {m}); }}",
|
|
)
|
|
b.input(
|
|
None,
|
|
inputs=[r, g, b],
|
|
_js=f"(r, g, b) => {{ VectorscopeCC.updateCursor(r, g, b, {m}); }}",
|
|
)
|
|
|
|
create_colorpicker(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=f"cc-apply-{mode}", 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=f"cc-save-{mode}", scale=2
|
|
)
|
|
delete_btn = gr.Button(value="Delete Style", scale=2)
|
|
|
|
with gr.Accordion("Advanced Settings", open=False):
|
|
with gr.Row():
|
|
doHR = gr.Checkbox(label="Process Hires. fix")
|
|
doAD = gr.Checkbox(label="Process Adetailer")
|
|
|
|
doRN = gr.Checkbox(label="Randomize using Seed")
|
|
doRN.do_not_save_to_config = True
|
|
|
|
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",
|
|
)
|
|
|
|
comps = (
|
|
latent,
|
|
bri,
|
|
con,
|
|
sat,
|
|
r,
|
|
g,
|
|
b,
|
|
doHR,
|
|
doAD,
|
|
doRN,
|
|
method,
|
|
scaling,
|
|
)
|
|
|
|
apply_btn.click(
|
|
fn=style_manager.get_style,
|
|
inputs=style_choice,
|
|
outputs=[*comps],
|
|
).then(
|
|
None,
|
|
inputs=[r, g, b],
|
|
_js=f"(r, g, b) => {{ VectorscopeCC.updateCursor(r, g, b, {m}); }}",
|
|
)
|
|
|
|
save_btn.click(
|
|
fn=lambda *args: gr.update(choices=style_manager.save_style(*args)),
|
|
inputs=[style_name, *comps],
|
|
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.load_styles()),
|
|
outputs=style_choice,
|
|
)
|
|
|
|
with gr.Row():
|
|
reset_btn = gr.Button(value="Reset")
|
|
random_btn = gr.Button(value="Randomize")
|
|
|
|
def on_reset():
|
|
return [
|
|
gr.update(value=False),
|
|
gr.update(value=const.Brightness.default),
|
|
gr.update(value=const.Contrast.default),
|
|
gr.update(value=const.Saturation.default),
|
|
gr.update(value=const.Color.default),
|
|
gr.update(value=const.Color.default),
|
|
gr.update(value=const.Color.default),
|
|
gr.update(value=False),
|
|
gr.update(value=False),
|
|
gr.update(value=False),
|
|
gr.update(value="Straight Abs."),
|
|
gr.update(value="Flat"),
|
|
]
|
|
|
|
def on_random():
|
|
return [
|
|
gr.update(value=const.Brightness.rand()),
|
|
gr.update(value=const.Contrast.rand()),
|
|
gr.update(value=const.Saturation.rand()),
|
|
gr.update(value=const.Color.rand()),
|
|
gr.update(value=const.Color.rand()),
|
|
gr.update(value=const.Color.rand()),
|
|
]
|
|
|
|
reset_btn.click(
|
|
fn=on_reset,
|
|
outputs=[*comps],
|
|
).then(
|
|
None,
|
|
inputs=[r, g, b],
|
|
_js=f"(r, g, b) => {{ VectorscopeCC.updateCursor(r, g, b, {m}); }}",
|
|
)
|
|
random_btn.click(fn=on_random, outputs=[bri, con, sat, r, g, b]).then(
|
|
None,
|
|
inputs=[r, g, b],
|
|
_js=f"(r, g, b) => {{ VectorscopeCC.updateCursor(r, g, b, {m}); }}",
|
|
)
|
|
|
|
self.paste_field_names = []
|
|
self.infotext_fields = [
|
|
(enable, "Vec CC Enabled"),
|
|
(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"),
|
|
(doAD, "Vec CC Proc Ade"),
|
|
(scaling, "Vec CC Scaling"),
|
|
]
|
|
|
|
for comp, name in self.infotext_fields:
|
|
comp.do_not_save_to_config = True
|
|
self.paste_field_names.append(name)
|
|
|
|
return [enable, *comps]
|
|
|
|
def process_batch(
|
|
self,
|
|
p,
|
|
enable: bool,
|
|
latent: bool,
|
|
bri: float,
|
|
con: float,
|
|
sat: float,
|
|
r: float,
|
|
g: float,
|
|
b: float,
|
|
doHR: bool,
|
|
doAD: bool,
|
|
doRN: bool,
|
|
method: str,
|
|
scaling: str,
|
|
batch_number: int,
|
|
prompts: list[str],
|
|
seeds: list[int],
|
|
subseeds: list[int],
|
|
):
|
|
if "Enable" in self.xyzCache.keys():
|
|
enable = self.xyzCache["Enable"].lower().strip() == "true"
|
|
|
|
if not enable:
|
|
if "Enable" not in self.xyzCache.keys():
|
|
if len(self.xyzCache) > 0:
|
|
print("\n[Vec.CC] x [X/Y/Z Plot] Extension is not Enabled!\n")
|
|
|
|
self.xyzCache.clear()
|
|
|
|
KDiffusionSampler.vec_cc = {"enable": False}
|
|
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 = int(seeds[0]) if doRN else None
|
|
|
|
for k, v in self.xyzCache.items():
|
|
match k:
|
|
case "Alt":
|
|
latent = self.xyzCache["Alt"].lower().strip() == "true"
|
|
case "Brightness":
|
|
bri = float(v)
|
|
case "Contrast":
|
|
con = float(v)
|
|
case "Saturation":
|
|
sat = float(v)
|
|
case "R":
|
|
r = float(v)
|
|
case "G":
|
|
g = float(v)
|
|
case "B":
|
|
b = float(v)
|
|
case "DoHR":
|
|
doHR = self.xyzCache["DoHR"].lower().strip() == "true"
|
|
case "Method":
|
|
method = str(v)
|
|
case "Scaling":
|
|
scaling = str(v)
|
|
case "Random":
|
|
cc_seed = int(v)
|
|
|
|
self.xyzCache.clear()
|
|
|
|
if method == "Disabled":
|
|
KDiffusionSampler.vec_cc = {"enable": False}
|
|
return p
|
|
|
|
steps: int = p.steps
|
|
# is img2img & do full steps
|
|
if not hasattr(p, "enable_hr") and not shared.opts.img2img_fix_steps:
|
|
if getattr(p, "denoising_strength", 1.0) < 1.0:
|
|
steps = int(steps * getattr(p, "denoising_strength", 1.0) + 1.0)
|
|
|
|
if cc_seed:
|
|
seed(cc_seed)
|
|
|
|
bri = const.Brightness.rand()
|
|
con = const.Contrast.rand()
|
|
sat = const.Saturation.rand()
|
|
|
|
r = const.Color.rand()
|
|
g = const.Color.rand()
|
|
b = const.Color.rand()
|
|
|
|
print(f"\n-> 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 getattr(shared.opts, "cc_metadata", 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 Proc Ade"] = doAD
|
|
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"
|
|
|
|
KDiffusionSampler.vec_cc = {
|
|
"enable": True,
|
|
"mode": mode,
|
|
"bri": bri,
|
|
"con": con,
|
|
"sat": sat,
|
|
"r": r,
|
|
"g": g,
|
|
"b": b,
|
|
"method": method,
|
|
"doHR": doHR,
|
|
"doAD": doAD,
|
|
"scaling": scaling,
|
|
"step": steps,
|
|
}
|
|
|
|
return p
|