import spaces
import os
from stablepy.diffusers_vanilla.style_prompt_config import STYLE_NAMES
import re
from stablepy import (
CONTROLNET_MODEL_IDS,
VALID_TASKS,
T2I_PREPROCESSOR_NAME,
FLASH_LORA,
SCHEDULER_CONFIG_MAP,
scheduler_names,
IP_ADAPTER_MODELS,
IP_ADAPTERS_SD,
IP_ADAPTERS_SDXL,
REPO_IMAGE_ENCODER,
ALL_PROMPT_WEIGHT_OPTIONS,
SD15_TASKS,
SDXL_TASKS,
)
from config import (
DEFAULT_STEPS,
DEFAULT_CFG,
MINIMUM_IMAGE_NUMBER,
MAXIMUM_IMAGE_NUMBER,
DEFAULT_NEGATIVE_PROMPT,
DEFAULT_POSITIVE_PROMPT,
task_stablepy
)
from models.vae import VAE_LIST as download_vae
from models.checkpoints import CHECKPOINT_LIST as download_model
from models.loras import LORA_LIST as download_lora
from models.format_models import FORMAT_MODELS as load_diffusers_format_model
from models.upscaler import upscaler_dict_gui
from models.controlnet import preprocessor_controlnet
from models.embeds import download_embeds
from examples.examples import example_prompts
from utils.download_utils import download_things
from utils.model_utils import get_model_list
import gradio as gr
import logging
from utils.string_utils import extract_parameters
from stablepy import logger
import diffusers
import warnings
from gui import GuiSD
# LOAD ALL ENV TOKEN
CIVITAI_API_KEY: str = os.environ.get("CIVITAI_API_KEY")
hf_token: str = os.environ.get("HF_TOKEN")
task_model_list = list(task_stablepy.keys())
# [Create directories]
directory_models: str = 'models'
os.makedirs(
directory_models,
exist_ok=True
)
directory_loras: str = 'loras'
os.makedirs(
directory_loras,
exist_ok=True
)
directory_vaes: str = 'vaes'
os.makedirs(
directory_vaes,
exist_ok=True
)
directory_embeds: str = 'embedings'
os.makedirs(
directory_embeds,
exist_ok=True
)
# Download stuffs
for url in [url.strip() for url in download_model.split(',')]:
if not os.path.exists(f"./models/{url.split('/')[-1]}"):
download_things(
directory_models,
url,
hf_token,
CIVITAI_API_KEY
)
for url in [url.strip() for url in download_vae.split(',')]:
if not os.path.exists(f"./vaes/{url.split('/')[-1]}"):
download_things(
directory_vaes,
url,
hf_token,
CIVITAI_API_KEY
)
for url in [url.strip() for url in download_lora.split(',')]:
if not os.path.exists(f"./loras/{url.split('/')[-1]}"):
download_things(
directory_loras,
url,
hf_token,
CIVITAI_API_KEY
)
for url_embed in download_embeds:
if not os.path.exists(f"./embedings/{url_embed.split('/')[-1]}"):
download_things(
directory_embeds,
url_embed,
hf_token,
CIVITAI_API_KEY
)
# Build list models
embed_list: list = get_model_list(directory_embeds)
model_list: list = get_model_list(directory_models)
model_list: list = load_diffusers_format_model + model_list
lora_model_list: list = get_model_list(directory_loras)
lora_model_list.insert(0, "None")
vae_model_list: list = get_model_list(directory_vaes)
vae_model_list.insert(0, "None")
def get_my_lora(link_url) -> tuple:
for __url in [_url.strip() for _url in link_url.split(',')]:
if not os.path.exists(f"./loras/{__url.split('/')[-1]}"):
download_things(
directory_loras,
__url,
hf_token,
CIVITAI_API_KEY
)
new_lora_model_list: list = get_model_list(directory_loras)
new_lora_model_list.insert(0, "None")
return gr.update(
choices=new_lora_model_list
), gr.update(
choices=new_lora_model_list
), gr.update(
choices=new_lora_model_list
), gr.update(
choices=new_lora_model_list
), gr.update(
choices=new_lora_model_list
)
print('\033[33m🏁 Download and listing of valid models completed.\033[0m')
#######################
# GUI
#######################
logging.getLogger("diffusers").setLevel(logging.ERROR)
diffusers.utils.logging.set_verbosity(40)
warnings.filterwarnings(
action="ignore",
category=FutureWarning,
module="diffusers"
)
warnings.filterwarnings(
action="ignore",
category=UserWarning,
module="diffusers"
)
warnings.filterwarnings(
action="ignore",
category=FutureWarning,
module="transformers"
)
logger.setLevel(logging.DEBUG)
# init GuiSD
SD_GEN: GuiSD = GuiSD(
model_list=model_list,
task_stablepy=task_stablepy,
lora_model_list=lora_model_list,
embed_list=embed_list,
)
with open("app.css", "r") as f:
CSS: str = f.read()
sdxl_task = [k for k, v in task_stablepy.items() if v in SDXL_TASKS]
sd_task = [k for k, v in task_stablepy.items() if v in SD15_TASKS]
def update_task_options(
model_name: str,
task_name: str):
"""
:param model_name:
:param task_name:
:return:
"""
if model_name in model_list:
if "xl" in model_name.lower():
new_choices = sdxl_task
else:
new_choices = sd_task
if task_name not in new_choices:
task_name = "txt2img"
return gr.update(
value=task_name,
choices=new_choices
)
else:
return gr.update(
value=task_name,
choices=task_model_list
)
# APP
with gr.Blocks(css=CSS) as app:
gr.Markdown("# 🧩 (Ivan) DiffuseCraft")
with gr.Tab("Generation"):
with gr.Row():
with gr.Column(scale=2):
task_gui = gr.Dropdown(
label="Task",
choices=sdxl_task,
value=task_model_list[0],
)
model_name_gui = gr.Dropdown(
label="Model",
choices=model_list,
value="models/animaPencilXL_v500.safetensors" or model_list[0],
allow_custom_value=True
)
prompt_gui = gr.Textbox(
lines=5,
placeholder="Enter Positive prompt",
label="Positive Prompt",
value=DEFAULT_POSITIVE_PROMPT
)
neg_prompt_gui = gr.Textbox(
lines=3,
placeholder="Enter Negative prompt",
label="Negative prompt",
value=DEFAULT_NEGATIVE_PROMPT
)
with gr.Row(equal_height=False):
set_params_gui = gr.Button(value="↙️")
clear_prompt_gui = gr.Button(value="🗑️")
set_random_seed = gr.Button(value="🎲")
generate_button = gr.Button(
value="GENERATE",
variant="primary"
)
model_name_gui.change(
update_task_options,
[model_name_gui, task_gui],
[task_gui],
)
load_model_gui = gr.HTML()
result_images = gr.Gallery(
label="Generated images",
show_label=False,
elem_id="gallery",
columns=[2],
rows=[2],
object_fit="contain",
# height="auto",
interactive=False,
preview=False,
selected_index=50,
)
actual_task_info = gr.HTML()
with gr.Column(scale=1):
steps_gui = gr.Slider(
minimum=1,
maximum=100,
step=1,
value=DEFAULT_STEPS,
label="Steps"
)
cfg_gui = gr.Slider(
minimum=0,
maximum=30,
step=0.5,
value=DEFAULT_CFG,
label="CFG"
)
sampler_gui = gr.Dropdown(
label="Sampler",
choices=scheduler_names,
value="DPM++ 2M Karras"
)
img_width_gui = gr.Slider(
minimum=64,
maximum=4096,
step=8,
value=1024,
label="Img Width"
)
img_height_gui = gr.Slider(
minimum=64,
maximum=4096,
step=8,
value=1024,
label="Img Height"
)
seed_gui = gr.Number(
minimum=-1,
maximum=9999999999,
value=-1,
label="Seed"
)
with gr.Row():
clip_skip_gui = gr.Checkbox(
value=False,
label="Layer 2 Clip Skip"
)
free_u_gui = gr.Checkbox(
value=True,
label="FreeU"
)
with gr.Row(equal_height=False):
def run_set_params_gui(base_prompt):
valid_receptors: dict = { # default values
"prompt": gr.update(value=base_prompt),
"neg_prompt": gr.update(value=""),
"Steps": gr.update(value=30),
"width": gr.update(value=1024),
"height": gr.update(value=1024),
"Seed": gr.update(value=-1),
"Sampler": gr.update(value="Euler a"),
"scale": gr.update(value=7.5), # cfg
"skip": gr.update(value=True),
}
valid_keys = list(valid_receptors.keys())
parameters: dict = extract_parameters(base_prompt)
for key, val in parameters.items():
if key in valid_keys:
if key == "Sampler":
if val not in scheduler_names:
continue
elif key == "skip":
if int(val) >= 2:
val = True
if key == "prompt":
if ">" in val and "<" in val:
val = re.sub(r'<[^>]+>', '', val)
print("Removed LoRA written in the prompt")
if key in ["prompt", "neg_prompt"]:
val = val.strip()
if key in ["Steps", "width", "height", "Seed"]:
val = int(val)
if key == "scale":
val = float(val)
if key == "Seed":
continue
valid_receptors[key] = gr.update(value=val)
return [value for value in valid_receptors.values()]
set_params_gui.click(
run_set_params_gui, [prompt_gui], [
prompt_gui,
neg_prompt_gui,
steps_gui,
img_width_gui,
img_height_gui,
seed_gui,
sampler_gui,
cfg_gui,
clip_skip_gui,
],
)
def run_clear_prompt_gui():
return gr.update(value=""), gr.update(value="")
clear_prompt_gui.click(
run_clear_prompt_gui, [], [prompt_gui, neg_prompt_gui]
)
def run_set_random_seed():
return -1
set_random_seed.click(
run_set_random_seed, [], seed_gui
)
num_images_gui = gr.Slider(
minimum=MINIMUM_IMAGE_NUMBER,
maximum=MAXIMUM_IMAGE_NUMBER,
step=1,
value=1,
label="Images"
)
prompt_s_options = [
("Classic format: (word:weight)", "Classic"),
("Compel format: (word)weight", "Compel"),
("Classic-original format: (word:weight)", "Classic-original"),
("Classic-no_norm format: (word:weight)", "Classic-no_norm"),
("Classic-ignore", "Classic-ignore"),
("None", "None"),
]
prompt_syntax_gui = gr.Dropdown(
label="Prompt Syntax",
choices=prompt_s_options,
value=prompt_s_options[0][1]
)
vae_model_gui = gr.Dropdown(
label="VAE Model",
choices=vae_model_list,
value=vae_model_list[1]
)
with gr.Accordion(
"Hires fix",
open=False,
visible=True):
upscaler_keys = list(upscaler_dict_gui.keys())
upscaler_model_path_gui = gr.Dropdown(
label="Upscaler",
choices=upscaler_keys,
value=upscaler_keys[0]
)
upscaler_increases_size_gui = gr.Slider(
minimum=1.1,
maximum=6.,
step=0.1,
value=1.4,
label="Upscale by"
)
esrgan_tile_gui = gr.Slider(
minimum=0,
value=100,
maximum=500,
step=1,
label="ESRGAN Tile"
)
esrgan_tile_overlap_gui = gr.Slider(
minimum=1,
maximum=200,
step=1,
value=10,
label="ESRGAN Tile Overlap"
)
hires_steps_gui = gr.Slider(
minimum=0,
value=30,
maximum=100,
step=1,
label="Hires Steps"
)
hires_denoising_strength_gui = gr.Slider(
minimum=0.1,
maximum=1.0,
step=0.01,
value=0.55,
label="Hires Denoising Strength"
)
hires_sampler_gui = gr.Dropdown(
label="Hires Sampler",
choices=["Use same sampler"] + scheduler_names[:-1],
value="Use same sampler"
)
hires_prompt_gui = gr.Textbox(
label="Hires Prompt",
placeholder="Main prompt will be use",
lines=3
)
hires_negative_prompt_gui = gr.Textbox(
label="Hires Negative Prompt",
placeholder="Main negative prompt will be use",
lines=3
)
with gr.Accordion("LoRA", open=False, visible=True):
lora1_gui = gr.Dropdown(
label="Lora1",
choices=lora_model_list
)
lora_scale_1_gui = gr.Slider(
minimum=-2,
maximum=2,
step=0.01,
value=0.33,
label="Lora Scale 1"
)
lora2_gui = gr.Dropdown(
label="Lora2",
choices=lora_model_list
)
lora_scale_2_gui = gr.Slider(
minimum=-2,
maximum=2,
step=0.01,
value=0.33,
label="Lora Scale 2"
)
lora3_gui = gr.Dropdown(
label="Lora3",
choices=lora_model_list
)
lora_scale_3_gui = gr.Slider(
minimum=-2,
maximum=2,
step=0.01,
value=0.33,
label="Lora Scale 3"
)
lora4_gui = gr.Dropdown(
label="Lora4",
choices=lora_model_list
)
lora_scale_4_gui = gr.Slider(
minimum=-2,
maximum=2,
step=0.01,
value=0.33,
label="Lora Scale 4"
)
lora5_gui = gr.Dropdown(
label="Lora5",
choices=lora_model_list
)
lora_scale_5_gui = gr.Slider(
minimum=-2,
maximum=2,
step=0.01,
value=0.33,
label="Lora Scale 5"
)
with gr.Accordion(
"From URL",
open=False,
visible=True):
text_lora = gr.Textbox(
label="URL",
placeholder="http://...my_lora_url.safetensors",
lines=1
)
button_lora = gr.Button("Get and update lists of LoRAs")
button_lora.click(
get_my_lora,
[text_lora],
[
lora1_gui,
lora2_gui,
lora3_gui,
lora4_gui,
lora5_gui
]
)
with gr.Accordion(
"IP-Adapter",
open=False,
visible=True): # IP-Adapter
IP_MODELS = sorted(
list(
set(
IP_ADAPTERS_SD + IP_ADAPTERS_SDXL
)
)
)
MODE_IP_OPTIONS = [
"original",
"style",
"layout",
"style+layout"
]
with gr.Accordion("IP-Adapter 1", open=False, visible=True):
image_ip1 = gr.Image(
label="IP Image",
type="filepath"
)
mask_ip1 = gr.Image(
label="IP Mask",
type="filepath"
)
model_ip1 = gr.Dropdown(
value="plus_face",
label="Model",
choices=IP_MODELS
)
mode_ip1 = gr.Dropdown(
value="original",
label="Mode",
choices=MODE_IP_OPTIONS
)
scale_ip1 = gr.Slider(
minimum=0.,
maximum=2.,
step=0.01,
value=0.7,
label="Scale"
)
with gr.Accordion("IP-Adapter 2", open=False, visible=True):
image_ip2 = gr.Image(
label="IP Image",
type="filepath"
)
mask_ip2 = gr.Image(
label="IP Mask (optional)",
type="filepath"
)
model_ip2 = gr.Dropdown(
value="base",
label="Model",
choices=IP_MODELS
)
mode_ip2 = gr.Dropdown(
value="style",
label="Mode",
choices=MODE_IP_OPTIONS
)
scale_ip2 = gr.Slider(
minimum=0.,
maximum=2.,
step=0.01,
value=0.7,
label="Scale"
)
with gr.Accordion(
"ControlNet / Img2img / Inpaint",
open=False,
visible=True):
image_control = gr.Image(
label="Image ControlNet/Inpaint/Img2img",
type="filepath"
)
image_mask_gui = gr.Image(
label="Image Mask",
type="filepath"
)
strength_gui = gr.Slider(
minimum=0.01,
maximum=1.0,
step=0.01,
value=0.55,
label="Strength",
info="This option adjusts the level of changes for img2img and inpainting."
)
image_resolution_gui = gr.Slider(
minimum=64,
maximum=2048,
step=64, value=1024,
label="Image Resolution"
)
preprocessor_name_gui = gr.Dropdown(
label="Preprocessor Name",
choices=preprocessor_controlnet["canny"]
)
def change_preprocessor_choices(task):
task = task_stablepy[task]
if task in preprocessor_controlnet.keys():
choices_task = preprocessor_controlnet[task]
else:
choices_task = preprocessor_controlnet["canny"]
return gr.update(
choices=choices_task,
value=choices_task[0]
)
task_gui.change(
change_preprocessor_choices,
[task_gui],
[preprocessor_name_gui],
)
preprocess_resolution_gui = gr.Slider(
minimum=64,
maximum=2048,
step=64,
value=512,
label="Preprocess Resolution"
)
low_threshold_gui = gr.Slider(
minimum=1,
maximum=255,
step=1,
value=100,
label="Canny low threshold"
)
high_threshold_gui = gr.Slider(
minimum=1,
maximum=255,
step=1,
value=200,
label="Canny high threshold"
)
value_threshold_gui = gr.Slider(
minimum=1,
maximum=2.0,
step=0.01, value=0.1,
label="Hough value threshold (MLSD)"
)
distance_threshold_gui = gr.Slider(
minimum=1,
maximum=20.0,
step=0.01,
value=0.1,
label="Hough distance threshold (MLSD)"
)
control_net_output_scaling_gui = gr.Slider(
minimum=0,
maximum=5.0,
step=0.1,
value=1,
label="ControlNet Output Scaling in UNet"
)
control_net_start_threshold_gui = gr.Slider(
minimum=0,
maximum=1,
step=0.01,
value=0,
label="ControlNet Start Threshold (%)"
)
control_net_stop_threshold_gui = gr.Slider(
minimum=0,
maximum=1,
step=0.01,
value=1,
label="ControlNet Stop Threshold (%)"
)
with gr.Accordion(
"T2I adapter",
open=False,
visible=True):
t2i_adapter_preprocessor_gui = gr.Checkbox(
value=True,
label="T2i Adapter Preprocessor"
)
adapter_conditioning_scale_gui = gr.Slider(
minimum=0,
maximum=5.,
step=0.1,
value=1,
label="Adapter Conditioning Scale"
)
adapter_conditioning_factor_gui = gr.Slider(
minimum=0,
maximum=1.,
step=0.01,
value=0.55,
label="Adapter Conditioning Factor (%)"
)
with gr.Accordion(
"Styles",
open=False,
visible=True):
# noinspection PyBroadException
try:
style_names_found = SD_GEN.model.STYLE_NAMES
except Exception as e:
style_names_found = STYLE_NAMES
style_prompt_gui = gr.Dropdown(
style_names_found,
multiselect=True,
value=None,
label="Style Prompt",
interactive=True,
)
style_json_gui = gr.File(label="Style JSON File")
style_button = gr.Button("Load styles")
def load_json_style_file(json):
if not SD_GEN.model:
gr.Info("First load the model")
return gr.update(
value=None,
choices=STYLE_NAMES
)
SD_GEN.model.load_style_file(json)
gr.Info(f"{len(SD_GEN.model.STYLE_NAMES)} styles loaded")
return gr.update(
value=None,
choices=SD_GEN.model.STYLE_NAMES
)
style_button.click(
load_json_style_file,
[style_json_gui],
[style_prompt_gui]
)
with gr.Accordion(
"Textual inversion",
open=False,
visible=False):
active_textual_inversion_gui = gr.Checkbox(
value=False,
label="Active Textual Inversion in prompt"
)
with gr.Accordion(
"Detailfix",
open=False,
visible=True):
# Adetailer Inpaint Only
adetailer_inpaint_only_gui = gr.Checkbox(
label="Inpaint only",
value=True
)
# Adetailer Verbose
adetailer_verbose_gui = gr.Checkbox(
label="Verbose",
value=False
)
# Adetailer Sampler
adetailer_sampler_options = ["Use same sampler"] + scheduler_names[:-1]
adetailer_sampler_gui = gr.Dropdown(
label="Adetailer sampler:",
choices=adetailer_sampler_options,
value="Use same sampler"
)
with gr.Accordion(
"Detailfix A",
open=False,
visible=True):
# Adetailer A
adetailer_active_a_gui = gr.Checkbox(
label="Enable Adetailer A",
value=False
)
prompt_ad_a_gui = gr.Textbox(
label="Main prompt",
placeholder="Main prompt will be use",
lines=3
)
negative_prompt_ad_a_gui = gr.Textbox(
label="Negative prompt",
placeholder="Main negative prompt will be use",
lines=3
)
strength_ad_a_gui = gr.Number(
label="Strength:",
value=0.35, step=0.01,
minimum=0.01,
maximum=1.0
)
face_detector_ad_a_gui = gr.Checkbox(
label="Face detector",
value=True
)
person_detector_ad_a_gui = gr.Checkbox(
label="Person detector",
value=True
)
hand_detector_ad_a_gui = gr.Checkbox(
label="Hand detector",
value=False
)
mask_dilation_a_gui = gr.Number(
label="Mask dilation:",
value=4,
minimum=1
)
mask_blur_a_gui = gr.Number(
label="Mask blur:",
value=4,
minimum=1
)
mask_padding_a_gui = gr.Number(
label="Mask padding:",
value=32,
minimum=1
)
with gr.Accordion(
"Detailfix B",
open=False,
visible=True):
# Adetailer B
adetailer_active_b_gui = gr.Checkbox(
label="Enable Adetailer B",
value=False
)
prompt_ad_b_gui = gr.Textbox(
label="Main prompt",
placeholder="Main prompt will be use",
lines=3
)
negative_prompt_ad_b_gui = gr.Textbox(
label="Negative prompt",
placeholder="Main negative prompt will be use",
lines=3
)
strength_ad_b_gui = gr.Number(
label="Strength:",
value=0.35,
step=0.01,
minimum=0.01,
maximum=1.0
)
face_detector_ad_b_gui = gr.Checkbox(
label="Face detector",
value=True
)
person_detector_ad_b_gui = gr.Checkbox(
label="Person detector",
value=True
)
hand_detector_ad_b_gui = gr.Checkbox(
label="Hand detector",
value=False
)
mask_dilation_b_gui = gr.Number(
label="Mask dilation:",
value=4,
minimum=1
)
mask_blur_b_gui = gr.Number(
label="Mask blur:",
value=4,
minimum=1
)
mask_padding_b_gui = gr.Number(
label="Mask padding:",
value=32,
minimum=1
)
with gr.Accordion(
"Other settings",
open=False,
visible=True):
image_previews_gui = gr.Checkbox(
value=True,
label="Image Previews"
)
hires_before_adetailer_gui = gr.Checkbox(
value=False,
label="Hires Before Adetailer"
)
hires_after_adetailer_gui = gr.Checkbox(
value=True,
label="Hires After Adetailer"
)
generator_in_cpu_gui = gr.Checkbox(
value=False,
label="Generator in CPU"
)
with gr.Accordion(
"More settings",
open=False,
visible=False):
loop_generation_gui = gr.Slider(
minimum=1,
value=1,
label="Loop Generation"
)
retain_task_cache_gui = gr.Checkbox(
value=False,
label="Retain task model in cache"
)
leave_progress_bar_gui = gr.Checkbox(
value=True,
label="Leave Progress Bar"
)
disable_progress_bar_gui = gr.Checkbox(
value=False,
label="Disable Progress Bar"
)
display_images_gui = gr.Checkbox(
value=True,
label="Display Images"
)
save_generated_images_gui = gr.Checkbox(
value=False,
label="Save Generated Images"
)
image_storage_location_gui = gr.Textbox(
value="./images",
label="Image Storage Location"
)
retain_compel_previous_load_gui = gr.Checkbox(
value=False,
label="Retain Compel Previous Load"
)
retain_detail_fix_model_previous_load_gui = gr.Checkbox(
value=False,
label="Retain Detail fix Model Previous Load"
)
retain_hires_model_previous_load_gui = gr.Checkbox(
value=False,
label="Retain Hires Model Previous Load"
)
xformers_memory_efficient_attention_gui = gr.Checkbox(
value=False,
label="Xformers Memory Efficient Attention"
)
# example and Help Section
with gr.Accordion(
"Examples and help",
open=False,
visible=True):
gr.Markdown(
"""### Help:
- The current space runs on a ZERO GPU which is assigned for approximately 60 seconds; Therefore, \
if you submit expensive tasks, the operation may be canceled upon reaching the \
maximum allowed time with 'GPU TASK ABORTED'.
- Distorted or strange images often result from high prompt weights, \
so it's best to use low weights and scales, and consider using Classic variants like 'Classic-original'.
- For better results with Pony Diffusion, \
try using sampler DPM++ 1s or DPM2 with Compel or Classic prompt weights.
"""
)
gr.Markdown(
"""### The following examples perform specific tasks:
1. Generation with SDXL and upscale
2. Generation with SDXL
3. ControlNet Canny SDXL
4. Optical pattern (Optical illusion) SDXL
5. Convert an image to a coloring drawing
6. ControlNet OpenPose SD 1.5
- Different tasks can be performed, such as img2img or using the IP adapter, \
to preserve a person's appearance or a specific style based on an image.
"""
)
gr.Examples(
examples=example_prompts,
fn=SD_GEN.generate_pipeline,
inputs=[
prompt_gui,
neg_prompt_gui,
num_images_gui,
steps_gui,
cfg_gui,
clip_skip_gui,
seed_gui,
lora1_gui,
lora_scale_1_gui,
lora2_gui,
lora_scale_2_gui,
lora3_gui,
lora_scale_3_gui,
lora4_gui,
lora_scale_4_gui,
lora5_gui,
lora_scale_5_gui,
sampler_gui,
img_height_gui,
img_width_gui,
model_name_gui,
vae_model_gui,
task_gui,
image_control,
preprocessor_name_gui,
preprocess_resolution_gui,
image_resolution_gui,
style_prompt_gui,
style_json_gui,
image_mask_gui,
strength_gui,
low_threshold_gui,
high_threshold_gui,
value_threshold_gui,
distance_threshold_gui,
control_net_output_scaling_gui,
control_net_start_threshold_gui,
control_net_stop_threshold_gui,
active_textual_inversion_gui,
prompt_syntax_gui,
upscaler_model_path_gui,
],
outputs=[result_images],
cache_examples=False,
)
with gr.Tab("Inpaint mask maker", render=True):
def create_mask_now(img, invert):
import numpy as np
import time
time.sleep(0.5)
transparent_image = img["layers"][0]
# Extract the alpha channel
alpha_channel = np.array(transparent_image)[:, :, 3]
# Create a binary mask by thresholding the alpha channel
binary_mask = alpha_channel > 1
if invert:
print("Invert")
# Invert the binary mask so that the drawn shape is white and the rest is black
binary_mask = np.invert(binary_mask)
# Convert the binary mask to a 3-channel RGB mask
rgb_mask = np.stack((binary_mask,) * 3, axis=-1)
# Convert the mask to uint8
rgb_mask = rgb_mask.astype(np.uint8) * 255
return img["background"], rgb_mask
with gr.Row():
with gr.Column(scale=2):
# image_base = gr.ImageEditor(label="Base image", show_label=True, brush=gr.Brush(colors=["#000000"]))
image_base = gr.ImageEditor(
sources=[
"upload",
"clipboard"
],
# crop_size="1:1",
# enable crop (or disable it)
# transforms=["crop"],
brush=gr.Brush(
default_size="16", # or leave it as 'auto'
color_mode="fixed", # 'fixed' hides the user swatches and colorpicker, 'defaults' shows it
# default_color="black", # html names are supported
colors=[
"rgba(0, 0, 0, 1)", # rgb(a)
"rgba(0, 0, 0, 0.1)",
"rgba(255, 255, 255, 0.1)",
# "hsl(360, 120, 120)" # in fact any valid colorstring
]
),
eraser=gr.Eraser(default_size="16")
)
invert_mask = gr.Checkbox(
value=False,
label="Invert mask"
)
btn = gr.Button("Create mask")
with gr.Column(scale=1):
img_source = gr.Image(interactive=False)
img_result = gr.Image(
label="Mask image",
show_label=True,
interactive=False
)
btn_send = gr.Button("Send to the first tab")
btn.click(
create_mask_now,
[image_base, invert_mask],
[img_source, img_result]
)
def send_img(img_source, img_result) -> tuple:
return img_source, img_result
btn_send.click(
send_img,
[img_source, img_result],
[image_control, image_mask_gui]
)
generate_button.click(
fn=SD_GEN.load_new_model,
inputs=[
model_name_gui,
vae_model_gui,
task_gui
],
outputs=[load_model_gui],
queue=True,
show_progress="minimal",
).success(
fn=SD_GEN.generate_pipeline,
inputs=[
prompt_gui,
neg_prompt_gui,
num_images_gui,
steps_gui,
cfg_gui,
clip_skip_gui,
seed_gui,
lora1_gui,
lora_scale_1_gui,
lora2_gui,
lora_scale_2_gui,
lora3_gui,
lora_scale_3_gui,
lora4_gui,
lora_scale_4_gui,
lora5_gui,
lora_scale_5_gui,
sampler_gui,
img_height_gui,
img_width_gui,
model_name_gui,
vae_model_gui,
task_gui,
image_control,
preprocessor_name_gui,
preprocess_resolution_gui,
image_resolution_gui,
style_prompt_gui,
style_json_gui,
image_mask_gui,
strength_gui,
low_threshold_gui,
high_threshold_gui,
value_threshold_gui,
distance_threshold_gui,
control_net_output_scaling_gui,
control_net_start_threshold_gui,
control_net_stop_threshold_gui,
active_textual_inversion_gui,
prompt_syntax_gui,
upscaler_model_path_gui,
upscaler_increases_size_gui,
esrgan_tile_gui,
esrgan_tile_overlap_gui,
hires_steps_gui,
hires_denoising_strength_gui,
hires_sampler_gui,
hires_prompt_gui,
hires_negative_prompt_gui,
hires_before_adetailer_gui,
hires_after_adetailer_gui,
loop_generation_gui,
leave_progress_bar_gui,
disable_progress_bar_gui,
image_previews_gui,
display_images_gui,
save_generated_images_gui,
image_storage_location_gui,
retain_compel_previous_load_gui,
retain_detail_fix_model_previous_load_gui,
retain_hires_model_previous_load_gui,
t2i_adapter_preprocessor_gui,
adapter_conditioning_scale_gui,
adapter_conditioning_factor_gui,
xformers_memory_efficient_attention_gui,
free_u_gui,
generator_in_cpu_gui,
adetailer_inpaint_only_gui,
adetailer_verbose_gui,
adetailer_sampler_gui,
adetailer_active_a_gui,
prompt_ad_a_gui,
negative_prompt_ad_a_gui,
strength_ad_a_gui,
face_detector_ad_a_gui,
person_detector_ad_a_gui,
hand_detector_ad_a_gui,
mask_dilation_a_gui,
mask_blur_a_gui,
mask_padding_a_gui,
adetailer_active_b_gui,
prompt_ad_b_gui,
negative_prompt_ad_b_gui,
strength_ad_b_gui,
face_detector_ad_b_gui,
person_detector_ad_b_gui,
hand_detector_ad_b_gui,
mask_dilation_b_gui,
mask_blur_b_gui,
mask_padding_b_gui,
retain_task_cache_gui,
image_ip1,
mask_ip1,
model_ip1,
mode_ip1,
scale_ip1,
image_ip2,
mask_ip2,
model_ip2,
mode_ip2,
scale_ip2,
],
outputs=[
result_images,
actual_task_info
],
queue=True,
show_progress="minimal",
)
app.queue()
app.launch(
show_error=True,
debug=True,
)