431 lines
14 KiB
Python
431 lines
14 KiB
Python
from modules.sd_samplers_kdiffusion import KDiffusionSampler
|
|
from modules.shared import opts
|
|
from modules import scripts
|
|
|
|
from lib_cc.colorpicker import create_colorpicker
|
|
from lib_cc.callback import hook_callbacks
|
|
from lib_cc.style import StyleManager
|
|
from lib_cc.xyz import xyz_support
|
|
from lib_cc import const
|
|
|
|
from random import seed
|
|
import gradio as gr
|
|
|
|
|
|
VERSION = "2.3.1"
|
|
|
|
|
|
style_manager = StyleManager()
|
|
style_manager.load_styles()
|
|
hook_callbacks()
|
|
const.init()
|
|
|
|
|
|
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: str = "img" if is_img2img else "txt"
|
|
m: str = f'"{mode}"'
|
|
|
|
with gr.Accordion(
|
|
f"Vectorscope CC v{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",
|
|
value=const.Brightness.default,
|
|
minimum=const.Brightness.minimum,
|
|
maximum=const.Brightness.maximum,
|
|
step=0.05,
|
|
)
|
|
con = gr.Slider(
|
|
label="Contrast",
|
|
value=const.Contrast.default,
|
|
minimum=const.Contrast.minimum,
|
|
maximum=const.Contrast.maximum,
|
|
step=0.05,
|
|
)
|
|
sat = gr.Slider(
|
|
label="Saturation",
|
|
value=const.Saturation.default,
|
|
minimum=const.Saturation.minimum,
|
|
maximum=const.Saturation.maximum,
|
|
step=0.05,
|
|
)
|
|
|
|
with gr.Row():
|
|
with gr.Column():
|
|
r = gr.Slider(
|
|
label="R",
|
|
info="Cyan | Red",
|
|
value=const.Color.default,
|
|
minimum=const.Color.minimum,
|
|
maximum=const.Color.maximum,
|
|
step=0.05,
|
|
elem_id=f"cc-r-{mode}",
|
|
)
|
|
g = gr.Slider(
|
|
label="G",
|
|
info="Magenta | Green",
|
|
value=const.Color.default,
|
|
minimum=const.Color.minimum,
|
|
maximum=const.Color.maximum,
|
|
step=0.05,
|
|
elem_id=f"cc-g-{mode}",
|
|
)
|
|
b = gr.Slider(
|
|
label="B",
|
|
info="Yellow | Blue",
|
|
value=const.Color.default,
|
|
minimum=const.Color.minimum,
|
|
maximum=const.Color.maximum,
|
|
step=0.05,
|
|
elem_id=f"cc-b-{mode}",
|
|
)
|
|
|
|
for c in (r, g, b):
|
|
c.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(elem_classes="style-rows"):
|
|
style_choice = gr.Dropdown(
|
|
label="CC 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(elem_classes="style-rows"):
|
|
style_name = gr.Textbox(
|
|
label="Style Name", lines=1, max_lines=1, 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)
|
|
|
|
if getattr(opts, "cc_no_defaults", True):
|
|
style_choice.do_not_save_to_config = True
|
|
|
|
[
|
|
setattr(comp, "do_not_save_to_config", True)
|
|
for comp in (
|
|
apply_btn,
|
|
refresh_btn,
|
|
style_name,
|
|
save_btn,
|
|
delete_btn,
|
|
)
|
|
]
|
|
|
|
with gr.Accordion("Advanced Settings", open=False):
|
|
with gr.Row():
|
|
doHR = gr.Checkbox(
|
|
label="Process Hires. fix",
|
|
visible=(not is_img2img),
|
|
)
|
|
doAD = gr.Checkbox(label="Process Adetailer")
|
|
doRN = gr.Checkbox(label="Randomize using Seed")
|
|
|
|
method = gr.Radio(
|
|
choices=(
|
|
"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(
|
|
choices=("Flat", "Cos", "Sin", "1 - Cos", "1 - Sin"),
|
|
label="Scaling Settings",
|
|
value="Flat",
|
|
)
|
|
|
|
comps: tuple[gr.components.Component] = (
|
|
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],
|
|
show_progress="hidden",
|
|
).then(
|
|
fn=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],
|
|
show_progress="hidden",
|
|
).then(
|
|
fn=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"),
|
|
(doRN, "Vec CC Seed Randomize"),
|
|
(scaling, "Vec CC Scaling"),
|
|
]
|
|
|
|
for comp, name in self.infotext_fields:
|
|
if getattr(opts, "cc_no_defaults", True):
|
|
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],
|
|
):
|
|
|
|
enable = self.xyzCache.pop("Enable", str(enable)).lower().strip() == "true"
|
|
|
|
if not enable:
|
|
if len(self.xyzCache) > 0:
|
|
print("\n[Vec.CC] x [X/Y/Z Plot] Extension is not Enabled!\n")
|
|
self.xyzCache.clear()
|
|
|
|
setattr(KDiffusionSampler, "vec_cc", {"enable": False})
|
|
return p
|
|
|
|
method = str(self.xyzCache.pop("Method", method))
|
|
|
|
if method == "Disabled":
|
|
setattr(KDiffusionSampler, "vec_cc", {"enable": False})
|
|
return p
|
|
|
|
if "Random" in self.xyzCache.keys():
|
|
print("[X/Y/Z Plot] x [Vec.CC] Randomize is Enabled.")
|
|
if len(self.xyzCache) > 1:
|
|
print("Some parameters will be overridden!")
|
|
|
|
cc_seed = int(self.xyzCache.pop("Random"))
|
|
else:
|
|
cc_seed = int(seeds[0]) if doRN else None
|
|
|
|
latent = self.xyzCache.pop("Alt", str(latent)).lower().strip() == "true"
|
|
doHR = self.xyzCache.pop("DoHR", str(doHR)).lower().strip() == "true"
|
|
scaling = str(self.xyzCache.pop("Scaling", scaling))
|
|
|
|
bri = float(self.xyzCache.pop("Brightness", bri))
|
|
con = float(self.xyzCache.pop("Contrast", con))
|
|
sat = float(self.xyzCache.pop("Saturation", sat))
|
|
|
|
r = float(self.xyzCache.pop("R", r))
|
|
g = float(self.xyzCache.pop("G", g))
|
|
b = float(self.xyzCache.pop("B", b))
|
|
|
|
assert len(self.xyzCache) == 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: {bri}")
|
|
print(f"> Contrast: {con}")
|
|
print(f"> Saturation: {sat}")
|
|
print(f"> R: {r}")
|
|
print(f"> G: {g}")
|
|
print(f"> B: {b}\n")
|
|
|
|
if getattr(opts, "cc_metadata", True):
|
|
p.extra_generation_params.update(
|
|
{
|
|
"Vec CC Enabled": enable,
|
|
"Vec CC Alt": latent,
|
|
"Vec CC Brightness": bri,
|
|
"Vec CC Contrast": con,
|
|
"Vec CC Saturation": sat,
|
|
"Vec CC R": r,
|
|
"Vec CC G": g,
|
|
"Vec CC B": b,
|
|
"Vec CC Noise": method,
|
|
"Vec CC Proc HrF": doHR,
|
|
"Vec CC Proc Ade": doAD,
|
|
"Vec CC Seed Randomize": doRN,
|
|
"Vec CC Scaling": scaling,
|
|
"Vec CC Version": VERSION,
|
|
}
|
|
)
|
|
|
|
steps: int = getattr(p, "firstpass_steps", None) or p.steps
|
|
|
|
bri /= steps
|
|
con /= steps
|
|
sat = pow(sat, 1.0 / steps)
|
|
r /= steps
|
|
g /= steps
|
|
b /= steps
|
|
|
|
mode: str = "x" if latent else "denoised"
|
|
|
|
setattr(
|
|
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
|
|
|
|
def before_hr(self, p, enable: bool, *args, **kwargs):
|
|
|
|
if enable:
|
|
steps: int = getattr(p, "hr_second_pass_steps", None) or p.steps
|
|
KDiffusionSampler.vec_cc["step"] = steps
|
|
|
|
return p
|