initial commit

scripts/custom_code.py

@@ -0,0 +1,90 @@
+import modules.scripts as scripts
+import gradio as gr
+import ast
+import copy
+
+from modules.processing import Processed
+from modules.shared import cmd_opts
+
+
+def convertExpr2Expression(expr):
+    expr.lineno = 0
+    expr.col_offset = 0
+    result = ast.Expression(expr.value, lineno=0, col_offset = 0)
+
+    return result
+
+
+def exec_with_return(code, module):
+    """
+    like exec() but can return values
+    https://stackoverflow.com/a/52361938/5862977
+    """
+    code_ast = ast.parse(code)
+
+    init_ast = copy.deepcopy(code_ast)
+    init_ast.body = code_ast.body[:-1]
+
+    last_ast = copy.deepcopy(code_ast)
+    last_ast.body = code_ast.body[-1:]
+
+    exec(compile(init_ast, "<ast>", "exec"), module.__dict__)
+    if type(last_ast.body[0]) == ast.Expr:
+        return eval(compile(convertExpr2Expression(last_ast.body[0]), "<ast>", "eval"), module.__dict__)
+    else:
+        exec(compile(last_ast, "<ast>", "exec"), module.__dict__)
+
+
+class Script(scripts.Script):
+
+    def title(self):
+        return "Custom code"
+
+    def show(self, is_img2img):
+        return cmd_opts.allow_code
+
+    def ui(self, is_img2img):
+        example = """from modules.processing import process_images
+
+p.width = 768
+p.height = 768
+p.batch_size = 2
+p.steps = 10
+
+return process_images(p)
+"""
+
+
+        code = gr.Code(value=example, language="python", label="Python code", elem_id=self.elem_id("code"))
+        indent_level = gr.Number(label='Indent level', value=2, precision=0, elem_id=self.elem_id("indent_level"))
+
+        return [code, indent_level]
+
+    def run(self, p, code, indent_level):
+        assert cmd_opts.allow_code, '--allow-code option must be enabled'
+
+        display_result_data = [[], -1, ""]
+
+        def display(imgs, s=display_result_data[1], i=display_result_data[2]):
+            display_result_data[0] = imgs
+            display_result_data[1] = s
+            display_result_data[2] = i
+
+        from types import ModuleType
+        module = ModuleType("testmodule")
+        module.__dict__.update(globals())
+        module.p = p
+        module.display = display
+
+        indent = " " * indent_level
+        indented = code.replace('\n', f"\n{indent}")
+        body = f"""def __webuitemp__():
+{indent}{indented}
+__webuitemp__()"""
+
+        result = exec_with_return(body, module)
+
+        if isinstance(result, Processed):
+            return result
+
+        return Processed(p, *display_result_data)

scripts/img2imgalt.py

@@ -0,0 +1,218 @@
+from collections import namedtuple
+
+import numpy as np
+from tqdm import trange
+
+import modules.scripts as scripts
+import gradio as gr
+
+from modules import processing, shared, sd_samplers, sd_samplers_common
+
+import torch
+import k_diffusion as K
+
+def find_noise_for_image(p, cond, uncond, cfg_scale, steps):
+    x = p.init_latent
+
+    s_in = x.new_ones([x.shape[0]])
+    if shared.sd_model.parameterization == "v":
+        dnw = K.external.CompVisVDenoiser(shared.sd_model)
+        skip = 1
+    else:
+        dnw = K.external.CompVisDenoiser(shared.sd_model)
+        skip = 0
+    sigmas = dnw.get_sigmas(steps).flip(0)
+
+    shared.state.sampling_steps = steps
+
+    for i in trange(1, len(sigmas)):
+        shared.state.sampling_step += 1
+
+        x_in = torch.cat([x] * 2)
+        sigma_in = torch.cat([sigmas[i] * s_in] * 2)
+        cond_in = torch.cat([uncond, cond])
+
+        image_conditioning = torch.cat([p.image_conditioning] * 2)
+        cond_in = {"c_concat": [image_conditioning], "c_crossattn": [cond_in]}
+
+        c_out, c_in = [K.utils.append_dims(k, x_in.ndim) for k in dnw.get_scalings(sigma_in)[skip:]]
+        t = dnw.sigma_to_t(sigma_in)
+
+        eps = shared.sd_model.apply_model(x_in * c_in, t, cond=cond_in)
+        denoised_uncond, denoised_cond = (x_in + eps * c_out).chunk(2)
+
+        denoised = denoised_uncond + (denoised_cond - denoised_uncond) * cfg_scale
+
+        d = (x - denoised) / sigmas[i]
+        dt = sigmas[i] - sigmas[i - 1]
+
+        x = x + d * dt
+
+        sd_samplers_common.store_latent(x)
+
+        # This shouldn't be necessary, but solved some VRAM issues
+        del x_in, sigma_in, cond_in, c_out, c_in, t,
+        del eps, denoised_uncond, denoised_cond, denoised, d, dt
+
+    shared.state.nextjob()
+
+    return x / x.std()
+
+
+Cached = namedtuple("Cached", ["noise", "cfg_scale", "steps", "latent", "original_prompt", "original_negative_prompt", "sigma_adjustment"])
+
+
+# Based on changes suggested by briansemrau in https://github.com/AUTOMATIC1111/stable-diffusion-webui/issues/736
+def find_noise_for_image_sigma_adjustment(p, cond, uncond, cfg_scale, steps):
+    x = p.init_latent
+
+    s_in = x.new_ones([x.shape[0]])
+    if shared.sd_model.parameterization == "v":
+        dnw = K.external.CompVisVDenoiser(shared.sd_model)
+        skip = 1
+    else:
+        dnw = K.external.CompVisDenoiser(shared.sd_model)
+        skip = 0
+    sigmas = dnw.get_sigmas(steps).flip(0)
+
+    shared.state.sampling_steps = steps
+
+    for i in trange(1, len(sigmas)):
+        shared.state.sampling_step += 1
+
+        x_in = torch.cat([x] * 2)
+        sigma_in = torch.cat([sigmas[i - 1] * s_in] * 2)
+        cond_in = torch.cat([uncond, cond])
+
+        image_conditioning = torch.cat([p.image_conditioning] * 2)
+        cond_in = {"c_concat": [image_conditioning], "c_crossattn": [cond_in]}
+
+        c_out, c_in = [K.utils.append_dims(k, x_in.ndim) for k in dnw.get_scalings(sigma_in)[skip:]]
+
+        if i == 1:
+            t = dnw.sigma_to_t(torch.cat([sigmas[i] * s_in] * 2))
+        else:
+            t = dnw.sigma_to_t(sigma_in)
+
+        eps = shared.sd_model.apply_model(x_in * c_in, t, cond=cond_in)
+        denoised_uncond, denoised_cond = (x_in + eps * c_out).chunk(2)
+
+        denoised = denoised_uncond + (denoised_cond - denoised_uncond) * cfg_scale
+
+        if i == 1:
+            d = (x - denoised) / (2 * sigmas[i])
+        else:
+            d = (x - denoised) / sigmas[i - 1]
+
+        dt = sigmas[i] - sigmas[i - 1]
+        x = x + d * dt
+
+        sd_samplers_common.store_latent(x)
+
+        # This shouldn't be necessary, but solved some VRAM issues
+        del x_in, sigma_in, cond_in, c_out, c_in, t,
+        del eps, denoised_uncond, denoised_cond, denoised, d, dt
+
+    shared.state.nextjob()
+
+    return x / sigmas[-1]
+
+
+class Script(scripts.Script):
+    def __init__(self):
+        self.cache = None
+
+    def title(self):
+        return "img2img alternative test"
+
+    def show(self, is_img2img):
+        return is_img2img
+
+    def ui(self, is_img2img):
+        info = gr.Markdown('''
+        * `CFG Scale` should be 2 or lower.
+        ''')
+
+        override_sampler = gr.Checkbox(label="Override `Sampling method` to Euler?(this method is built for it)", value=True, elem_id=self.elem_id("override_sampler"))
+
+        override_prompt = gr.Checkbox(label="Override `prompt` to the same value as `original prompt`?(and `negative prompt`)", value=True, elem_id=self.elem_id("override_prompt"))
+        original_prompt = gr.Textbox(label="Original prompt", lines=1, elem_id=self.elem_id("original_prompt"))
+        original_negative_prompt = gr.Textbox(label="Original negative prompt", lines=1, elem_id=self.elem_id("original_negative_prompt"))
+
+        override_steps = gr.Checkbox(label="Override `Sampling Steps` to the same value as `Decode steps`?", value=True, elem_id=self.elem_id("override_steps"))
+        st = gr.Slider(label="Decode steps", minimum=1, maximum=150, step=1, value=50, elem_id=self.elem_id("st"))
+
+        override_strength = gr.Checkbox(label="Override `Denoising strength` to 1?", value=True, elem_id=self.elem_id("override_strength"))
+
+        cfg = gr.Slider(label="Decode CFG scale", minimum=0.0, maximum=15.0, step=0.1, value=1.0, elem_id=self.elem_id("cfg"))
+        randomness = gr.Slider(label="Randomness", minimum=0.0, maximum=1.0, step=0.01, value=0.0, elem_id=self.elem_id("randomness"))
+        sigma_adjustment = gr.Checkbox(label="Sigma adjustment for finding noise for image", value=False, elem_id=self.elem_id("sigma_adjustment"))
+
+        return [
+            info,
+            override_sampler,
+            override_prompt, original_prompt, original_negative_prompt,
+            override_steps, st,
+            override_strength,
+            cfg, randomness, sigma_adjustment,
+        ]
+
+    def run(self, p, _, override_sampler, override_prompt, original_prompt, original_negative_prompt, override_steps, st, override_strength, cfg, randomness, sigma_adjustment):
+        # Override
+        if override_sampler:
+            p.sampler_name = "Euler"
+        if override_prompt:
+            p.prompt = original_prompt
+            p.negative_prompt = original_negative_prompt
+        if override_steps:
+            p.steps = st
+        if override_strength:
+            p.denoising_strength = 1.0
+
+        def sample_extra(conditioning, unconditional_conditioning, seeds, subseeds, subseed_strength, prompts):
+            lat = (p.init_latent.cpu().numpy() * 10).astype(int)
+
+            same_params = self.cache is not None and self.cache.cfg_scale == cfg and self.cache.steps == st \
+                                and self.cache.original_prompt == original_prompt \
+                                and self.cache.original_negative_prompt == original_negative_prompt \
+                                and self.cache.sigma_adjustment == sigma_adjustment
+            same_everything = same_params and self.cache.latent.shape == lat.shape and np.abs(self.cache.latent-lat).sum() < 100
+
+            if same_everything:
+                rec_noise = self.cache.noise
+            else:
+                shared.state.job_count += 1
+                cond = p.sd_model.get_learned_conditioning(p.batch_size * [original_prompt])
+                uncond = p.sd_model.get_learned_conditioning(p.batch_size * [original_negative_prompt])
+                if sigma_adjustment:
+                    rec_noise = find_noise_for_image_sigma_adjustment(p, cond, uncond, cfg, st)
+                else:
+                    rec_noise = find_noise_for_image(p, cond, uncond, cfg, st)
+                self.cache = Cached(rec_noise, cfg, st, lat, original_prompt, original_negative_prompt, sigma_adjustment)
+
+            rand_noise = processing.create_random_tensors(p.init_latent.shape[1:], seeds=seeds, subseeds=subseeds, subseed_strength=p.subseed_strength, seed_resize_from_h=p.seed_resize_from_h, seed_resize_from_w=p.seed_resize_from_w, p=p)
+
+            combined_noise = ((1 - randomness) * rec_noise + randomness * rand_noise) / ((randomness**2 + (1-randomness)**2) ** 0.5)
+
+            sampler = sd_samplers.create_sampler(p.sampler_name, p.sd_model)
+
+            sigmas = sampler.model_wrap.get_sigmas(p.steps)
+
+            noise_dt = combined_noise - (p.init_latent / sigmas[0])
+
+            p.seed = p.seed + 1
+
+            return sampler.sample_img2img(p, p.init_latent, noise_dt, conditioning, unconditional_conditioning, image_conditioning=p.image_conditioning)
+
+        p.sample = sample_extra
+
+        p.extra_generation_params["Decode prompt"] = original_prompt
+        p.extra_generation_params["Decode negative prompt"] = original_negative_prompt
+        p.extra_generation_params["Decode CFG scale"] = cfg
+        p.extra_generation_params["Decode steps"] = st
+        p.extra_generation_params["Randomness"] = randomness
+        p.extra_generation_params["Sigma Adjustment"] = sigma_adjustment
+
+        processed = processing.process_images(p)
+
+        return processed

scripts/loopback.py

@@ -0,0 +1,140 @@
+import math
+
+import gradio as gr
+import modules.scripts as scripts
+from modules import deepbooru, images, processing, shared
+from modules.processing import Processed
+from modules.shared import opts, state
+
+
+class Script(scripts.Script):
+    def title(self):
+        return "Loopback"
+
+    def show(self, is_img2img):
+        return is_img2img
+
+    def ui(self, is_img2img):
+        loops = gr.Slider(minimum=1, maximum=32, step=1, label='Loops', value=4, elem_id=self.elem_id("loops"))
+        final_denoising_strength = gr.Slider(minimum=0, maximum=1, step=0.01, label='Final denoising strength', value=0.5, elem_id=self.elem_id("final_denoising_strength"))
+        denoising_curve = gr.Dropdown(label="Denoising strength curve", choices=["Aggressive", "Linear", "Lazy"], value="Linear")
+        append_interrogation = gr.Dropdown(label="Append interrogated prompt at each iteration", choices=["None", "CLIP", "DeepBooru"], value="None")
+
+        return [loops, final_denoising_strength, denoising_curve, append_interrogation]
+
+    def run(self, p, loops, final_denoising_strength, denoising_curve, append_interrogation):
+        processing.fix_seed(p)
+        batch_count = p.n_iter
+        p.extra_generation_params = {
+            "Final denoising strength": final_denoising_strength,
+            "Denoising curve": denoising_curve
+        }
+
+        p.batch_size = 1
+        p.n_iter = 1
+
+        info = None
+        initial_seed = None
+        initial_info = None
+        initial_denoising_strength = p.denoising_strength
+
+        grids = []
+        all_images = []
+        original_init_image = p.init_images
+        original_prompt = p.prompt
+        original_inpainting_fill = p.inpainting_fill
+        state.job_count = loops * batch_count
+
+        initial_color_corrections = [processing.setup_color_correction(p.init_images[0])]
+
+        def calculate_denoising_strength(loop):
+            strength = initial_denoising_strength
+
+            if loops == 1:
+                return strength
+
+            progress = loop / (loops - 1)
+            if denoising_curve == "Aggressive":
+                strength = math.sin((progress) * math.pi * 0.5)
+            elif denoising_curve == "Lazy":
+                strength = 1 - math.cos((progress) * math.pi * 0.5)
+            else:
+                strength = progress
+
+            change = (final_denoising_strength - initial_denoising_strength) * strength
+            return initial_denoising_strength + change
+
+        history = []
+
+        for n in range(batch_count):
+            # Reset to original init image at the start of each batch
+            p.init_images = original_init_image
+
+            # Reset to original denoising strength
+            p.denoising_strength = initial_denoising_strength
+
+            last_image = None
+
+            for i in range(loops):
+                p.n_iter = 1
+                p.batch_size = 1
+                p.do_not_save_grid = True
+
+                if opts.img2img_color_correction:
+                    p.color_corrections = initial_color_corrections
+
+                if append_interrogation != "None":
+                    p.prompt = f"{original_prompt}, " if original_prompt else ""
+                    if append_interrogation == "CLIP":
+                        p.prompt += shared.interrogator.interrogate(p.init_images[0])
+                    elif append_interrogation == "DeepBooru":
+                        p.prompt += deepbooru.model.tag(p.init_images[0])
+
+                state.job = f"Iteration {i + 1}/{loops}, batch {n + 1}/{batch_count}"
+
+                processed = processing.process_images(p)
+
+                # Generation cancelled.
+                if state.interrupted or state.stopping_generation:
+                    break
+
+                if initial_seed is None:
+                    initial_seed = processed.seed
+                    initial_info = processed.info
+
+                p.seed = processed.seed + 1
+                p.denoising_strength = calculate_denoising_strength(i + 1)
+
+                if state.skipped:
+                    break
+
+                last_image = processed.images[0]
+                p.init_images = [last_image]
+                p.inpainting_fill = 1 # Set "masked content" to "original" for next loop.
+
+                if batch_count == 1:
+                    history.append(last_image)
+                    all_images.append(last_image)
+
+            if batch_count > 1 and not state.skipped and not state.interrupted:
+                history.append(last_image)
+                all_images.append(last_image)
+
+            p.inpainting_fill = original_inpainting_fill
+
+            if state.interrupted or state.stopping_generation:
+                break
+
+        if len(history) > 1:
+            grid = images.image_grid(history, rows=1)
+            if opts.grid_save:
+                images.save_image(grid, p.outpath_grids, "grid", initial_seed, p.prompt, opts.grid_format, info=info, short_filename=not opts.grid_extended_filename, grid=True, p=p)
+
+            if opts.return_grid:
+                grids.append(grid)
+
+        all_images = grids + all_images
+
+        processed = Processed(p, all_images, initial_seed, initial_info)
+
+        return processed

scripts/outpainting_mk_2.py

@@ -0,0 +1,295 @@
+import math
+
+import numpy as np
+import skimage
+
+import modules.scripts as scripts
+import gradio as gr
+from PIL import Image, ImageDraw
+
+from modules import images
+from modules.processing import Processed, process_images
+from modules.shared import opts, state
+
+
+# this function is taken from https://github.com/parlance-zz/g-diffuser-bot
+def get_matched_noise(_np_src_image, np_mask_rgb, noise_q=1, color_variation=0.05):
+    # helper fft routines that keep ortho normalization and auto-shift before and after fft
+    def _fft2(data):
+        if data.ndim > 2:  # has channels
+            out_fft = np.zeros((data.shape[0], data.shape[1], data.shape[2]), dtype=np.complex128)
+            for c in range(data.shape[2]):
+                c_data = data[:, :, c]
+                out_fft[:, :, c] = np.fft.fft2(np.fft.fftshift(c_data), norm="ortho")
+                out_fft[:, :, c] = np.fft.ifftshift(out_fft[:, :, c])
+        else:  # one channel
+            out_fft = np.zeros((data.shape[0], data.shape[1]), dtype=np.complex128)
+            out_fft[:, :] = np.fft.fft2(np.fft.fftshift(data), norm="ortho")
+            out_fft[:, :] = np.fft.ifftshift(out_fft[:, :])
+
+        return out_fft
+
+    def _ifft2(data):
+        if data.ndim > 2:  # has channels
+            out_ifft = np.zeros((data.shape[0], data.shape[1], data.shape[2]), dtype=np.complex128)
+            for c in range(data.shape[2]):
+                c_data = data[:, :, c]
+                out_ifft[:, :, c] = np.fft.ifft2(np.fft.fftshift(c_data), norm="ortho")
+                out_ifft[:, :, c] = np.fft.ifftshift(out_ifft[:, :, c])
+        else:  # one channel
+            out_ifft = np.zeros((data.shape[0], data.shape[1]), dtype=np.complex128)
+            out_ifft[:, :] = np.fft.ifft2(np.fft.fftshift(data), norm="ortho")
+            out_ifft[:, :] = np.fft.ifftshift(out_ifft[:, :])
+
+        return out_ifft
+
+    def _get_gaussian_window(width, height, std=3.14, mode=0):
+        window_scale_x = float(width / min(width, height))
+        window_scale_y = float(height / min(width, height))
+
+        window = np.zeros((width, height))
+        x = (np.arange(width) / width * 2. - 1.) * window_scale_x
+        for y in range(height):
+            fy = (y / height * 2. - 1.) * window_scale_y
+            if mode == 0:
+                window[:, y] = np.exp(-(x ** 2 + fy ** 2) * std)
+            else:
+                window[:, y] = (1 / ((x ** 2 + 1.) * (fy ** 2 + 1.))) ** (std / 3.14)  # hey wait a minute that's not gaussian
+
+        return window
+
+    def _get_masked_window_rgb(np_mask_grey, hardness=1.):
+        np_mask_rgb = np.zeros((np_mask_grey.shape[0], np_mask_grey.shape[1], 3))
+        if hardness != 1.:
+            hardened = np_mask_grey[:] ** hardness
+        else:
+            hardened = np_mask_grey[:]
+        for c in range(3):
+            np_mask_rgb[:, :, c] = hardened[:]
+        return np_mask_rgb
+
+    width = _np_src_image.shape[0]
+    height = _np_src_image.shape[1]
+    num_channels = _np_src_image.shape[2]
+
+    _np_src_image[:] * (1. - np_mask_rgb)
+    np_mask_grey = (np.sum(np_mask_rgb, axis=2) / 3.)
+    img_mask = np_mask_grey > 1e-6
+    ref_mask = np_mask_grey < 1e-3
+
+    windowed_image = _np_src_image * (1. - _get_masked_window_rgb(np_mask_grey))
+    windowed_image /= np.max(windowed_image)
+    windowed_image += np.average(_np_src_image) * np_mask_rgb  # / (1.-np.average(np_mask_rgb))  # rather than leave the masked area black, we get better results from fft by filling the average unmasked color
+
+    src_fft = _fft2(windowed_image)  # get feature statistics from masked src img
+    src_dist = np.absolute(src_fft)
+    src_phase = src_fft / src_dist
+
+    # create a generator with a static seed to make outpainting deterministic / only follow global seed
+    rng = np.random.default_rng(0)
+
+    noise_window = _get_gaussian_window(width, height, mode=1)  # start with simple gaussian noise
+    noise_rgb = rng.random((width, height, num_channels))
+    noise_grey = (np.sum(noise_rgb, axis=2) / 3.)
+    noise_rgb *= color_variation  # the colorfulness of the starting noise is blended to greyscale with a parameter
+    for c in range(num_channels):
+        noise_rgb[:, :, c] += (1. - color_variation) * noise_grey
+
+    noise_fft = _fft2(noise_rgb)
+    for c in range(num_channels):
+        noise_fft[:, :, c] *= noise_window
+    noise_rgb = np.real(_ifft2(noise_fft))
+    shaped_noise_fft = _fft2(noise_rgb)
+    shaped_noise_fft[:, :, :] = np.absolute(shaped_noise_fft[:, :, :]) ** 2 * (src_dist ** noise_q) * src_phase  # perform the actual shaping
+
+    brightness_variation = 0.  # color_variation # todo: temporarily tying brightness variation to color variation for now
+    contrast_adjusted_np_src = _np_src_image[:] * (brightness_variation + 1.) - brightness_variation * 2.
+
+    # scikit-image is used for histogram matching, very convenient!
+    shaped_noise = np.real(_ifft2(shaped_noise_fft))
+    shaped_noise -= np.min(shaped_noise)
+    shaped_noise /= np.max(shaped_noise)
+    shaped_noise[img_mask, :] = skimage.exposure.match_histograms(shaped_noise[img_mask, :] ** 1., contrast_adjusted_np_src[ref_mask, :], channel_axis=1)
+    shaped_noise = _np_src_image[:] * (1. - np_mask_rgb) + shaped_noise * np_mask_rgb
+
+    matched_noise = shaped_noise[:]
+
+    return np.clip(matched_noise, 0., 1.)
+
+
+
+class Script(scripts.Script):
+    def title(self):
+        return "Outpainting mk2"
+
+    def show(self, is_img2img):
+        return is_img2img
+
+    def ui(self, is_img2img):
+        if not is_img2img:
+            return None
+
+        info = gr.HTML("<p style=\"margin-bottom:0.75em\">Recommended settings: Sampling Steps: 80-100, Sampler: Euler a, Denoising strength: 0.8</p>")
+
+        pixels = gr.Slider(label="Pixels to expand", minimum=8, maximum=256, step=8, value=128, elem_id=self.elem_id("pixels"))
+        mask_blur = gr.Slider(label='Mask blur', minimum=0, maximum=64, step=1, value=8, elem_id=self.elem_id("mask_blur"))
+        direction = gr.CheckboxGroup(label="Outpainting direction", choices=['left', 'right', 'up', 'down'], value=['left', 'right', 'up', 'down'], elem_id=self.elem_id("direction"))
+        noise_q = gr.Slider(label="Fall-off exponent (lower=higher detail)", minimum=0.0, maximum=4.0, step=0.01, value=1.0, elem_id=self.elem_id("noise_q"))
+        color_variation = gr.Slider(label="Color variation", minimum=0.0, maximum=1.0, step=0.01, value=0.05, elem_id=self.elem_id("color_variation"))
+
+        return [info, pixels, mask_blur, direction, noise_q, color_variation]
+
+    def run(self, p, _, pixels, mask_blur, direction, noise_q, color_variation):
+        initial_seed_and_info = [None, None]
+
+        process_width = p.width
+        process_height = p.height
+
+        p.inpaint_full_res = False
+        p.inpainting_fill = 1
+        p.do_not_save_samples = True
+        p.do_not_save_grid = True
+
+        left = pixels if "left" in direction else 0
+        right = pixels if "right" in direction else 0
+        up = pixels if "up" in direction else 0
+        down = pixels if "down" in direction else 0
+
+        if left > 0 or right > 0:
+            mask_blur_x = mask_blur
+        else:
+            mask_blur_x = 0
+
+        if up > 0 or down > 0:
+            mask_blur_y = mask_blur
+        else:
+            mask_blur_y = 0
+
+        p.mask_blur_x = mask_blur_x*4
+        p.mask_blur_y = mask_blur_y*4
+
+        init_img = p.init_images[0]
+        target_w = math.ceil((init_img.width + left + right) / 64) * 64
+        target_h = math.ceil((init_img.height + up + down) / 64) * 64
+
+        if left > 0:
+            left = left * (target_w - init_img.width) // (left + right)
+
+        if right > 0:
+            right = target_w - init_img.width - left
+
+        if up > 0:
+            up = up * (target_h - init_img.height) // (up + down)
+
+        if down > 0:
+            down = target_h - init_img.height - up
+
+        def expand(init, count, expand_pixels, is_left=False, is_right=False, is_top=False, is_bottom=False):
+            is_horiz = is_left or is_right
+            is_vert = is_top or is_bottom
+            pixels_horiz = expand_pixels if is_horiz else 0
+            pixels_vert = expand_pixels if is_vert else 0
+
+            images_to_process = []
+            output_images = []
+            for n in range(count):
+                res_w = init[n].width + pixels_horiz
+                res_h = init[n].height + pixels_vert
+                process_res_w = math.ceil(res_w / 64) * 64
+                process_res_h = math.ceil(res_h / 64) * 64
+
+                img = Image.new("RGB", (process_res_w, process_res_h))
+                img.paste(init[n], (pixels_horiz if is_left else 0, pixels_vert if is_top else 0))
+                mask = Image.new("RGB", (process_res_w, process_res_h), "white")
+                draw = ImageDraw.Draw(mask)
+                draw.rectangle((
+                    expand_pixels + mask_blur_x if is_left else 0,
+                    expand_pixels + mask_blur_y if is_top else 0,
+                    mask.width - expand_pixels - mask_blur_x if is_right else res_w,
+                    mask.height - expand_pixels - mask_blur_y if is_bottom else res_h,
+                ), fill="black")
+
+                np_image = (np.asarray(img) / 255.0).astype(np.float64)
+                np_mask = (np.asarray(mask) / 255.0).astype(np.float64)
+                noised = get_matched_noise(np_image, np_mask, noise_q, color_variation)
+                output_images.append(Image.fromarray(np.clip(noised * 255., 0., 255.).astype(np.uint8), mode="RGB"))
+
+                target_width = min(process_width, init[n].width + pixels_horiz) if is_horiz else img.width
+                target_height = min(process_height, init[n].height + pixels_vert) if is_vert else img.height
+                p.width = target_width if is_horiz else img.width
+                p.height = target_height if is_vert else img.height
+
+                crop_region = (
+                    0 if is_left else output_images[n].width - target_width,
+                    0 if is_top else output_images[n].height - target_height,
+                    target_width if is_left else output_images[n].width,
+                    target_height if is_top else output_images[n].height,
+                )
+                mask = mask.crop(crop_region)
+                p.image_mask = mask
+
+                image_to_process = output_images[n].crop(crop_region)
+                images_to_process.append(image_to_process)
+
+            p.init_images = images_to_process
+
+            latent_mask = Image.new("RGB", (p.width, p.height), "white")
+            draw = ImageDraw.Draw(latent_mask)
+            draw.rectangle((
+                expand_pixels + mask_blur_x * 2 if is_left else 0,
+                expand_pixels + mask_blur_y * 2 if is_top else 0,
+                mask.width - expand_pixels - mask_blur_x * 2 if is_right else res_w,
+                mask.height - expand_pixels - mask_blur_y * 2 if is_bottom else res_h,
+            ), fill="black")
+            p.latent_mask = latent_mask
+
+            proc = process_images(p)
+
+            if initial_seed_and_info[0] is None:
+                initial_seed_and_info[0] = proc.seed
+                initial_seed_and_info[1] = proc.info
+
+            for n in range(count):
+                output_images[n].paste(proc.images[n], (0 if is_left else output_images[n].width - proc.images[n].width, 0 if is_top else output_images[n].height - proc.images[n].height))
+                output_images[n] = output_images[n].crop((0, 0, res_w, res_h))
+
+            return output_images
+
+        batch_count = p.n_iter
+        batch_size = p.batch_size
+        p.n_iter = 1
+        state.job_count = batch_count * ((1 if left > 0 else 0) + (1 if right > 0 else 0) + (1 if up > 0 else 0) + (1 if down > 0 else 0))
+        all_processed_images = []
+
+        for i in range(batch_count):
+            imgs = [init_img] * batch_size
+            state.job = f"Batch {i + 1} out of {batch_count}"
+
+            if left > 0:
+                imgs = expand(imgs, batch_size, left, is_left=True)
+            if right > 0:
+                imgs = expand(imgs, batch_size, right, is_right=True)
+            if up > 0:
+                imgs = expand(imgs, batch_size, up, is_top=True)
+            if down > 0:
+                imgs = expand(imgs, batch_size, down, is_bottom=True)
+
+            all_processed_images += imgs
+
+        all_images = all_processed_images
+
+        combined_grid_image = images.image_grid(all_processed_images)
+        unwanted_grid_because_of_img_count = len(all_processed_images) < 2 and opts.grid_only_if_multiple
+        if opts.return_grid and not unwanted_grid_because_of_img_count:
+            all_images = [combined_grid_image] + all_processed_images
+
+        res = Processed(p, all_images, initial_seed_and_info[0], initial_seed_and_info[1])
+
+        if opts.samples_save:
+            for img in all_processed_images:
+                images.save_image(img, p.outpath_samples, "", res.seed, p.prompt, opts.samples_format, info=res.info, p=p)
+
+        if opts.grid_save and not unwanted_grid_because_of_img_count:
+            images.save_image(combined_grid_image, p.outpath_grids, "grid", res.seed, p.prompt, opts.grid_format, info=res.info, short_filename=not opts.grid_extended_filename, grid=True, p=p)
+
+        return res

scripts/poor_mans_outpainting.py

@@ -0,0 +1,146 @@
+import math
+
+import modules.scripts as scripts
+import gradio as gr
+from PIL import Image, ImageDraw
+
+from modules import images, devices
+from modules.processing import Processed, process_images
+from modules.shared import opts, state
+
+
+class Script(scripts.Script):
+    def title(self):
+        return "Poor man's outpainting"
+
+    def show(self, is_img2img):
+        return is_img2img
+
+    def ui(self, is_img2img):
+        if not is_img2img:
+            return None
+
+        pixels = gr.Slider(label="Pixels to expand", minimum=8, maximum=256, step=8, value=128, elem_id=self.elem_id("pixels"))
+        mask_blur = gr.Slider(label='Mask blur', minimum=0, maximum=64, step=1, value=4, elem_id=self.elem_id("mask_blur"))
+        inpainting_fill = gr.Radio(label='Masked content', choices=['fill', 'original', 'latent noise', 'latent nothing'], value='fill', type="index", elem_id=self.elem_id("inpainting_fill"))
+        direction = gr.CheckboxGroup(label="Outpainting direction", choices=['left', 'right', 'up', 'down'], value=['left', 'right', 'up', 'down'], elem_id=self.elem_id("direction"))
+
+        return [pixels, mask_blur, inpainting_fill, direction]
+
+    def run(self, p, pixels, mask_blur, inpainting_fill, direction):
+        initial_seed = None
+        initial_info = None
+
+        p.mask_blur = mask_blur * 2
+        p.inpainting_fill = inpainting_fill
+        p.inpaint_full_res = False
+
+        left = pixels if "left" in direction else 0
+        right = pixels if "right" in direction else 0
+        up = pixels if "up" in direction else 0
+        down = pixels if "down" in direction else 0
+
+        init_img = p.init_images[0]
+        target_w = math.ceil((init_img.width + left + right) / 64) * 64
+        target_h = math.ceil((init_img.height + up + down) / 64) * 64
+
+        if left > 0:
+            left = left * (target_w - init_img.width) // (left + right)
+        if right > 0:
+            right = target_w - init_img.width - left
+
+        if up > 0:
+            up = up * (target_h - init_img.height) // (up + down)
+
+        if down > 0:
+            down = target_h - init_img.height - up
+
+        img = Image.new("RGB", (target_w, target_h))
+        img.paste(init_img, (left, up))
+
+        mask = Image.new("L", (img.width, img.height), "white")
+        draw = ImageDraw.Draw(mask)
+        draw.rectangle((
+            left + (mask_blur * 2 if left > 0 else 0),
+            up + (mask_blur * 2 if up > 0 else 0),
+            mask.width - right - (mask_blur * 2 if right > 0 else 0),
+            mask.height - down - (mask_blur * 2 if down > 0 else 0)
+        ), fill="black")
+
+        latent_mask = Image.new("L", (img.width, img.height), "white")
+        latent_draw = ImageDraw.Draw(latent_mask)
+        latent_draw.rectangle((
+             left + (mask_blur//2 if left > 0 else 0),
+             up + (mask_blur//2 if up > 0 else 0),
+             mask.width - right - (mask_blur//2 if right > 0 else 0),
+             mask.height - down - (mask_blur//2 if down > 0 else 0)
+        ), fill="black")
+
+        devices.torch_gc()
+
+        grid = images.split_grid(img, tile_w=p.width, tile_h=p.height, overlap=pixels)
+        grid_mask = images.split_grid(mask, tile_w=p.width, tile_h=p.height, overlap=pixels)
+        grid_latent_mask = images.split_grid(latent_mask, tile_w=p.width, tile_h=p.height, overlap=pixels)
+
+        p.n_iter = 1
+        p.batch_size = 1
+        p.do_not_save_grid = True
+        p.do_not_save_samples = True
+
+        work = []
+        work_mask = []
+        work_latent_mask = []
+        work_results = []
+
+        for (y, h, row), (_, _, row_mask), (_, _, row_latent_mask) in zip(grid.tiles, grid_mask.tiles, grid_latent_mask.tiles):
+            for tiledata, tiledata_mask, tiledata_latent_mask in zip(row, row_mask, row_latent_mask):
+                x, w = tiledata[0:2]
+
+                if x >= left and x+w <= img.width - right and y >= up and y+h <= img.height - down:
+                    continue
+
+                work.append(tiledata[2])
+                work_mask.append(tiledata_mask[2])
+                work_latent_mask.append(tiledata_latent_mask[2])
+
+        batch_count = len(work)
+        print(f"Poor man's outpainting will process a total of {len(work)} images tiled as {len(grid.tiles[0][2])}x{len(grid.tiles)}.")
+
+        state.job_count = batch_count
+
+        for i in range(batch_count):
+            p.init_images = [work[i]]
+            p.image_mask = work_mask[i]
+            p.latent_mask = work_latent_mask[i]
+
+            state.job = f"Batch {i + 1} out of {batch_count}"
+            processed = process_images(p)
+
+            if initial_seed is None:
+                initial_seed = processed.seed
+                initial_info = processed.info
+
+            p.seed = processed.seed + 1
+            work_results += processed.images
+
+
+        image_index = 0
+        for y, h, row in grid.tiles:
+            for tiledata in row:
+                x, w = tiledata[0:2]
+
+                if x >= left and x+w <= img.width - right and y >= up and y+h <= img.height - down:
+                    continue
+
+                tiledata[2] = work_results[image_index] if image_index < len(work_results) else Image.new("RGB", (p.width, p.height))
+                image_index += 1
+
+        combined_image = images.combine_grid(grid)
+
+        if opts.samples_save:
+            images.save_image(combined_image, p.outpath_samples, "", initial_seed, p.prompt, opts.samples_format, info=initial_info, p=p)
+
+        processed = Processed(p, [combined_image], initial_seed, initial_info)
+
+        return processed
+

scripts/postprocessing_codeformer.py

@@ -0,0 +1,38 @@
+from PIL import Image
+import numpy as np
+
+from modules import scripts_postprocessing, codeformer_model, ui_components
+import gradio as gr
+
+
+class ScriptPostprocessingCodeFormer(scripts_postprocessing.ScriptPostprocessing):
+    name = "CodeFormer"
+    order = 3000
+
+    def ui(self):
+        with ui_components.InputAccordion(False, label="CodeFormer") as enable:
+            with gr.Row():
+                codeformer_visibility = gr.Slider(minimum=0.0, maximum=1.0, step=0.001, label="Visibility", value=1.0, elem_id="extras_codeformer_visibility")
+                codeformer_weight = gr.Slider(minimum=0.0, maximum=1.0, step=0.001, label="Weight (0 = maximum effect, 1 = minimum effect)", value=0, elem_id="extras_codeformer_weight")
+
+        return {
+            "enable": enable,
+            "codeformer_visibility": codeformer_visibility,
+            "codeformer_weight": codeformer_weight,
+        }
+
+    def process(self, pp: scripts_postprocessing.PostprocessedImage, enable, codeformer_visibility, codeformer_weight):
+        if codeformer_visibility == 0 or not enable:
+            return
+
+        source_img = pp.image.convert("RGB")
+
+        restored_img = codeformer_model.codeformer.restore(np.array(source_img, dtype=np.uint8), w=codeformer_weight)
+        res = Image.fromarray(restored_img)
+
+        if codeformer_visibility < 1.0:
+            res = Image.blend(source_img, res, codeformer_visibility)
+
+        pp.image = res
+        pp.info["CodeFormer visibility"] = round(codeformer_visibility, 3)
+        pp.info["CodeFormer weight"] = round(codeformer_weight, 3)

scripts/postprocessing_focal_crop.py

@@ -0,0 +1,56 @@
+
+from modules import scripts_postprocessing, ui_components, errors
+import gradio as gr
+
+from modules.textual_inversion import autocrop
+
+
+class ScriptPostprocessingFocalCrop(scripts_postprocessing.ScriptPostprocessing):
+    name = "Auto focal point crop"
+    order = 4010
+
+    def ui(self):
+        with ui_components.InputAccordion(False, label="Auto focal point crop") as enable:
+            face_weight = gr.Slider(label='Focal point face weight', value=0.9, minimum=0.0, maximum=1.0, step=0.05, elem_id="postprocess_focal_crop_face_weight")
+            entropy_weight = gr.Slider(label='Focal point entropy weight', value=0.15, minimum=0.0, maximum=1.0, step=0.05, elem_id="postprocess_focal_crop_entropy_weight")
+            edges_weight = gr.Slider(label='Focal point edges weight', value=0.5, minimum=0.0, maximum=1.0, step=0.05, elem_id="postprocess_focal_crop_edges_weight")
+            debug = gr.Checkbox(label='Create debug image', elem_id="train_process_focal_crop_debug")
+
+        return {
+            "enable": enable,
+            "face_weight": face_weight,
+            "entropy_weight": entropy_weight,
+            "edges_weight": edges_weight,
+            "debug": debug,
+        }
+
+    def process(self, pp: scripts_postprocessing.PostprocessedImage, enable, face_weight, entropy_weight, edges_weight, debug):
+        if not enable:
+            return
+
+        if not pp.shared.target_width or not pp.shared.target_height:
+            return
+
+        pp.image = pp.image.convert('RGB')
+
+        dnn_model_path = None
+        try:
+            dnn_model_path = autocrop.download_and_cache_models()
+        except Exception:
+            errors.report("Unable to load face detection model for auto crop selection. Falling back to lower quality haar method.", exc_info=True)
+
+        autocrop_settings = autocrop.Settings(
+            crop_width=pp.shared.target_width,
+            crop_height=pp.shared.target_height,
+            face_points_weight=face_weight,
+            entropy_points_weight=entropy_weight,
+            corner_points_weight=edges_weight,
+            annotate_image=debug,
+            dnn_model_path=dnn_model_path,
+        )
+
+        result, *others = autocrop.crop_image(pp.image, autocrop_settings)
+
+        pp.image = result
+        pp.extra_images = [pp.create_copy(x, nametags=["focal-crop-debug"], disable_processing=True) for x in others]
+

scripts/postprocessing_gfpgan.py

@@ -0,0 +1,34 @@
+from PIL import Image
+import numpy as np
+
+from modules import scripts_postprocessing, gfpgan_model, ui_components
+import gradio as gr
+
+
+class ScriptPostprocessingGfpGan(scripts_postprocessing.ScriptPostprocessing):
+    name = "GFPGAN"
+    order = 2000
+
+    def ui(self):
+        with ui_components.InputAccordion(False, label="GFPGAN") as enable:
+            gfpgan_visibility = gr.Slider(minimum=0.0, maximum=1.0, step=0.001, label="Visibility", value=1.0, elem_id="extras_gfpgan_visibility")
+
+        return {
+            "enable": enable,
+            "gfpgan_visibility": gfpgan_visibility,
+        }
+
+    def process(self, pp: scripts_postprocessing.PostprocessedImage, enable, gfpgan_visibility):
+        if gfpgan_visibility == 0 or not enable:
+            return
+
+        source_img = pp.image.convert("RGB")
+
+        restored_img = gfpgan_model.gfpgan_fix_faces(np.array(source_img, dtype=np.uint8))
+        res = Image.fromarray(restored_img)
+
+        if gfpgan_visibility < 1.0:
+            res = Image.blend(source_img, res, gfpgan_visibility)
+
+        pp.image = res
+        pp.info["GFPGAN visibility"] = round(gfpgan_visibility, 3)

scripts/postprocessing_upscale.py

@@ -0,0 +1,195 @@
+import re
+
+from PIL import Image
+import numpy as np
+
+from modules import scripts_postprocessing, shared
+import gradio as gr
+
+from modules.ui_components import FormRow, ToolButton, InputAccordion
+from modules.ui import switch_values_symbol
+
+upscale_cache = {}
+
+
+def limit_size_by_one_dimention(w, h, limit):
+    if h > w and h > limit:
+        w = limit * w // h
+        h = limit
+    elif w > limit:
+        h = limit * h // w
+        w = limit
+
+    return int(w), int(h)
+
+
+class ScriptPostprocessingUpscale(scripts_postprocessing.ScriptPostprocessing):
+    name = "Upscale"
+    order = 1000
+
+    def ui(self):
+        selected_tab = gr.Number(value=0, visible=False)
+
+        with InputAccordion(True, label="Upscale", elem_id="extras_upscale") as upscale_enabled:
+            with FormRow():
+                extras_upscaler_1 = gr.Dropdown(label='Upscaler 1', elem_id="extras_upscaler_1", choices=[x.name for x in shared.sd_upscalers], value=shared.sd_upscalers[0].name)
+
+            with FormRow():
+                extras_upscaler_2 = gr.Dropdown(label='Upscaler 2', elem_id="extras_upscaler_2", choices=[x.name for x in shared.sd_upscalers], value=shared.sd_upscalers[0].name)
+                extras_upscaler_2_visibility = gr.Slider(minimum=0.0, maximum=1.0, step=0.001, label="Upscaler 2 visibility", value=0.0, elem_id="extras_upscaler_2_visibility")
+
+            with FormRow():
+                with gr.Tabs(elem_id="extras_resize_mode"):
+                    with gr.TabItem('Scale by', elem_id="extras_scale_by_tab") as tab_scale_by:
+                        with gr.Row():
+                            with gr.Column(scale=4):
+                                upscaling_resize = gr.Slider(minimum=1.0, maximum=8.0, step=0.05, label="Resize", value=4, elem_id="extras_upscaling_resize")
+                            with gr.Column(scale=1, min_width=160):
+                                max_side_length = gr.Number(label="Max side length", value=0, elem_id="extras_upscale_max_side_length", tooltip="If any of two sides of the image ends up larger than specified, will downscale it to fit. 0 = no limit.", min_width=160, step=8, minimum=0)
+
+                    with gr.TabItem('Scale to', elem_id="extras_scale_to_tab") as tab_scale_to:
+                        with FormRow():
+                            with gr.Column(elem_id="upscaling_column_size", scale=4):
+                                upscaling_resize_w = gr.Slider(minimum=64, maximum=8192, step=8, label="Width", value=512, elem_id="extras_upscaling_resize_w")
+                                upscaling_resize_h = gr.Slider(minimum=64, maximum=8192, step=8, label="Height", value=512, elem_id="extras_upscaling_resize_h")
+                            with gr.Column(elem_id="upscaling_dimensions_row", scale=1, elem_classes="dimensions-tools"):
+                                upscaling_res_switch_btn = ToolButton(value=switch_values_symbol, elem_id="upscaling_res_switch_btn", tooltip="Switch width/height")
+                                upscaling_crop = gr.Checkbox(label='Crop to fit', value=True, elem_id="extras_upscaling_crop")
+
+        def on_selected_upscale_method(upscale_method):
+            if not shared.opts.set_scale_by_when_changing_upscaler:
+                return gr.update()
+
+            match = re.search(r'(\d)[xX]|[xX](\d)', upscale_method)
+            if not match:
+                return gr.update()
+
+            return gr.update(value=int(match.group(1) or match.group(2)))
+
+        upscaling_res_switch_btn.click(lambda w, h: (h, w), inputs=[upscaling_resize_w, upscaling_resize_h], outputs=[upscaling_resize_w, upscaling_resize_h], show_progress=False)
+        tab_scale_by.select(fn=lambda: 0, inputs=[], outputs=[selected_tab])
+        tab_scale_to.select(fn=lambda: 1, inputs=[], outputs=[selected_tab])
+
+        extras_upscaler_1.change(on_selected_upscale_method, inputs=[extras_upscaler_1], outputs=[upscaling_resize], show_progress="hidden")
+
+        return {
+            "upscale_enabled": upscale_enabled,
+            "upscale_mode": selected_tab,
+            "upscale_by": upscaling_resize,
+            "max_side_length": max_side_length,
+            "upscale_to_width": upscaling_resize_w,
+            "upscale_to_height": upscaling_resize_h,
+            "upscale_crop": upscaling_crop,
+            "upscaler_1_name": extras_upscaler_1,
+            "upscaler_2_name": extras_upscaler_2,
+            "upscaler_2_visibility": extras_upscaler_2_visibility,
+        }
+
+    def upscale(self, image, info, upscaler, upscale_mode, upscale_by, max_side_length, upscale_to_width, upscale_to_height, upscale_crop):
+        if upscale_mode == 1:
+            upscale_by = max(upscale_to_width/image.width, upscale_to_height/image.height)
+            info["Postprocess upscale to"] = f"{upscale_to_width}x{upscale_to_height}"
+        else:
+            info["Postprocess upscale by"] = upscale_by
+            if max_side_length != 0 and max(*image.size)*upscale_by > max_side_length:
+                upscale_mode = 1
+                upscale_crop = False
+                upscale_to_width, upscale_to_height = limit_size_by_one_dimention(image.width*upscale_by, image.height*upscale_by, max_side_length)
+                upscale_by = max(upscale_to_width/image.width, upscale_to_height/image.height)
+                info["Max side length"] = max_side_length
+
+        cache_key = (hash(np.array(image.getdata()).tobytes()), upscaler.name, upscale_mode, upscale_by,  upscale_to_width, upscale_to_height, upscale_crop)
+        cached_image = upscale_cache.pop(cache_key, None)
+
+        if cached_image is not None:
+            image = cached_image
+        else:
+            image = upscaler.scaler.upscale(image, upscale_by, upscaler.data_path)
+
+        upscale_cache[cache_key] = image
+        if len(upscale_cache) > shared.opts.upscaling_max_images_in_cache:
+            upscale_cache.pop(next(iter(upscale_cache), None), None)
+
+        if upscale_mode == 1 and upscale_crop:
+            cropped = Image.new("RGB", (upscale_to_width, upscale_to_height))
+            cropped.paste(image, box=(upscale_to_width // 2 - image.width // 2, upscale_to_height // 2 - image.height // 2))
+            image = cropped
+            info["Postprocess crop to"] = f"{image.width}x{image.height}"
+
+        return image
+
+    def process_firstpass(self, pp: scripts_postprocessing.PostprocessedImage, upscale_enabled=True, upscale_mode=1, upscale_by=2.0, max_side_length=0, upscale_to_width=None, upscale_to_height=None, upscale_crop=False, upscaler_1_name=None, upscaler_2_name=None, upscaler_2_visibility=0.0):
+        if upscale_mode == 1:
+            pp.shared.target_width = upscale_to_width
+            pp.shared.target_height = upscale_to_height
+        else:
+            pp.shared.target_width = int(pp.image.width * upscale_by)
+            pp.shared.target_height = int(pp.image.height * upscale_by)
+
+            pp.shared.target_width, pp.shared.target_height = limit_size_by_one_dimention(pp.shared.target_width, pp.shared.target_height, max_side_length)
+
+    def process(self, pp: scripts_postprocessing.PostprocessedImage, upscale_enabled=True, upscale_mode=1, upscale_by=2.0, max_side_length=0, upscale_to_width=None, upscale_to_height=None, upscale_crop=False, upscaler_1_name=None, upscaler_2_name=None, upscaler_2_visibility=0.0):
+        if not upscale_enabled:
+            return
+
+        upscaler_1_name = upscaler_1_name
+        if upscaler_1_name == "None":
+            upscaler_1_name = None
+
+        upscaler1 = next(iter([x for x in shared.sd_upscalers if x.name == upscaler_1_name]), None)
+        assert upscaler1 or (upscaler_1_name is None), f'could not find upscaler named {upscaler_1_name}'
+
+        if not upscaler1:
+            return
+
+        upscaler_2_name = upscaler_2_name
+        if upscaler_2_name == "None":
+            upscaler_2_name = None
+
+        upscaler2 = next(iter([x for x in shared.sd_upscalers if x.name == upscaler_2_name and x.name != "None"]), None)
+        assert upscaler2 or (upscaler_2_name is None), f'could not find upscaler named {upscaler_2_name}'
+
+        upscaled_image = self.upscale(pp.image, pp.info, upscaler1, upscale_mode, upscale_by, max_side_length, upscale_to_width, upscale_to_height, upscale_crop)
+        pp.info["Postprocess upscaler"] = upscaler1.name
+
+        if upscaler2 and upscaler_2_visibility > 0:
+            second_upscale = self.upscale(pp.image, pp.info, upscaler2, upscale_mode, upscale_by, max_side_length, upscale_to_width, upscale_to_height, upscale_crop)
+            if upscaled_image.mode != second_upscale.mode:
+                second_upscale = second_upscale.convert(upscaled_image.mode)
+            upscaled_image = Image.blend(upscaled_image, second_upscale, upscaler_2_visibility)
+
+            pp.info["Postprocess upscaler 2"] = upscaler2.name
+
+        pp.image = upscaled_image
+
+    def image_changed(self):
+        upscale_cache.clear()
+
+
+class ScriptPostprocessingUpscaleSimple(ScriptPostprocessingUpscale):
+    name = "Simple Upscale"
+    order = 900
+
+    def ui(self):
+        with FormRow():
+            upscaler_name = gr.Dropdown(label='Upscaler', choices=[x.name for x in shared.sd_upscalers], value=shared.sd_upscalers[0].name)
+            upscale_by = gr.Slider(minimum=0.05, maximum=8.0, step=0.05, label="Upscale by", value=2)
+
+        return {
+            "upscale_by": upscale_by,
+            "upscaler_name": upscaler_name,
+        }
+
+    def process_firstpass(self, pp: scripts_postprocessing.PostprocessedImage, upscale_by=2.0, upscaler_name=None):
+        pp.shared.target_width = int(pp.image.width * upscale_by)
+        pp.shared.target_height = int(pp.image.height * upscale_by)
+
+    def process(self, pp: scripts_postprocessing.PostprocessedImage, upscale_by=2.0, upscaler_name=None):
+        if upscaler_name is None or upscaler_name == "None":
+            return
+
+        upscaler1 = next(iter([x for x in shared.sd_upscalers if x.name == upscaler_name]), None)
+        assert upscaler1, f'could not find upscaler named {upscaler_name}'
+
+        pp.image = self.upscale(pp.image, pp.info, upscaler1, 0, upscale_by, 0, 0, 0, False)
+        pp.info["Postprocess upscaler"] = upscaler1.name

scripts/prompt_matrix.py

@@ -0,0 +1,108 @@
+import math
+
+import modules.scripts as scripts
+import gradio as gr
+
+from modules import images
+from modules.processing import process_images
+from modules.shared import opts, state
+import modules.sd_samplers
+
+
+def draw_xy_grid(xs, ys, x_label, y_label, cell):
+    res = []
+
+    ver_texts = [[images.GridAnnotation(y_label(y))] for y in ys]
+    hor_texts = [[images.GridAnnotation(x_label(x))] for x in xs]
+
+    first_processed = None
+
+    state.job_count = len(xs) * len(ys)
+
+    for iy, y in enumerate(ys):
+        for ix, x in enumerate(xs):
+            state.job = f"{ix + iy * len(xs) + 1} out of {len(xs) * len(ys)}"
+
+            processed = cell(x, y)
+            if first_processed is None:
+                first_processed = processed
+
+            res.append(processed.images[0])
+
+    grid = images.image_grid(res, rows=len(ys))
+    grid = images.draw_grid_annotations(grid, res[0].width, res[0].height, hor_texts, ver_texts)
+
+    first_processed.images = [grid]
+
+    return first_processed
+
+
+class Script(scripts.Script):
+    def title(self):
+        return "Prompt matrix"
+
+    def ui(self, is_img2img):
+        gr.HTML('<br />')
+        with gr.Row():
+            with gr.Column():
+                put_at_start = gr.Checkbox(label='Put variable parts at start of prompt', value=False, elem_id=self.elem_id("put_at_start"))
+                different_seeds = gr.Checkbox(label='Use different seed for each picture', value=False, elem_id=self.elem_id("different_seeds"))
+            with gr.Column():
+                prompt_type = gr.Radio(["positive", "negative"], label="Select prompt", elem_id=self.elem_id("prompt_type"), value="positive")
+                variations_delimiter = gr.Radio(["comma", "space"], label="Select joining char", elem_id=self.elem_id("variations_delimiter"), value="comma")
+            with gr.Column():
+                margin_size = gr.Slider(label="Grid margins (px)", minimum=0, maximum=500, value=0, step=2, elem_id=self.elem_id("margin_size"))
+
+        return [put_at_start, different_seeds, prompt_type, variations_delimiter, margin_size]
+
+    def run(self, p, put_at_start, different_seeds, prompt_type, variations_delimiter, margin_size):
+        modules.processing.fix_seed(p)
+        # Raise error if promp type is not positive or negative
+        if prompt_type not in ["positive", "negative"]:
+            raise ValueError(f"Unknown prompt type {prompt_type}")
+        # Raise error if variations delimiter is not comma or space
+        if variations_delimiter not in ["comma", "space"]:
+            raise ValueError(f"Unknown variations delimiter {variations_delimiter}")
+
+        prompt = p.prompt if prompt_type == "positive" else p.negative_prompt
+        original_prompt = prompt[0] if type(prompt) == list else prompt
+        positive_prompt = p.prompt[0] if type(p.prompt) == list else p.prompt
+
+        delimiter = ", " if variations_delimiter == "comma" else " "
+
+        all_prompts = []
+        prompt_matrix_parts = original_prompt.split("|")
+        combination_count = 2 ** (len(prompt_matrix_parts) - 1)
+        for combination_num in range(combination_count):
+            selected_prompts = [text.strip().strip(',') for n, text in enumerate(prompt_matrix_parts[1:]) if combination_num & (1 << n)]
+
+            if put_at_start:
+                selected_prompts = selected_prompts + [prompt_matrix_parts[0]]
+            else:
+                selected_prompts = [prompt_matrix_parts[0]] + selected_prompts
+
+            all_prompts.append(delimiter.join(selected_prompts))
+
+        p.n_iter = math.ceil(len(all_prompts) / p.batch_size)
+        p.do_not_save_grid = True
+
+        print(f"Prompt matrix will create {len(all_prompts)} images using a total of {p.n_iter} batches.")
+
+        if prompt_type == "positive":
+            p.prompt = all_prompts
+        else:
+            p.negative_prompt = all_prompts
+        p.seed = [p.seed + (i if different_seeds else 0) for i in range(len(all_prompts))]
+        p.prompt_for_display = positive_prompt
+        processed = process_images(p)
+
+        grid = images.image_grid(processed.images, p.batch_size, rows=1 << ((len(prompt_matrix_parts) - 1) // 2))
+        grid = images.draw_prompt_matrix(grid, processed.images[0].width, processed.images[0].height, prompt_matrix_parts, margin_size)
+        processed.images.insert(0, grid)
+        processed.index_of_first_image = 1
+        processed.infotexts.insert(0, processed.infotexts[0])
+
+        if opts.grid_save:
+            images.save_image(processed.images[0], p.outpath_grids, "prompt_matrix", extension=opts.grid_format, prompt=original_prompt, seed=processed.seed, grid=True, p=p)
+
+        return processed

scripts/prompts_from_file.py

@@ -0,0 +1,221 @@
+import copy
+import random
+import shlex
+
+import modules.scripts as scripts
+import gradio as gr
+
+from modules import sd_samplers, errors, sd_models
+from modules.processing import Processed, process_images
+from modules.shared import state
+from modules.images import image_grid, save_image
+from modules.shared import opts
+
+def process_model_tag(tag):
+    info = sd_models.get_closet_checkpoint_match(tag)
+    assert info is not None, f'Unknown checkpoint: {tag}'
+    return info.name
+
+
+def process_string_tag(tag):
+    return tag
+
+
+def process_int_tag(tag):
+    return int(tag)
+
+
+def process_float_tag(tag):
+    return float(tag)
+
+
+def process_boolean_tag(tag):
+    return True if (tag == "true") else False
+
+
+prompt_tags = {
+    "sd_model": process_model_tag,
+    "outpath_samples": process_string_tag,
+    "outpath_grids": process_string_tag,
+    "prompt_for_display": process_string_tag,
+    "prompt": process_string_tag,
+    "negative_prompt": process_string_tag,
+    "styles": process_string_tag,
+    "seed": process_int_tag,
+    "subseed_strength": process_float_tag,
+    "subseed": process_int_tag,
+    "seed_resize_from_h": process_int_tag,
+    "seed_resize_from_w": process_int_tag,
+    "sampler_index": process_int_tag,
+    "sampler_name": process_string_tag,
+    "batch_size": process_int_tag,
+    "n_iter": process_int_tag,
+    "steps": process_int_tag,
+    "cfg_scale": process_float_tag,
+    "width": process_int_tag,
+    "height": process_int_tag,
+    "restore_faces": process_boolean_tag,
+    "tiling": process_boolean_tag,
+    "do_not_save_samples": process_boolean_tag,
+    "do_not_save_grid": process_boolean_tag
+}
+
+
+def cmdargs(line):
+    args = shlex.split(line)
+    pos = 0
+    res = {}
+
+    while pos < len(args):
+        arg = args[pos]
+
+        assert arg.startswith("--"), f'must start with "--": {arg}'
+        assert pos+1 < len(args), f'missing argument for command line option {arg}'
+
+        tag = arg[2:]
+
+        if tag == "prompt" or tag == "negative_prompt":
+            pos += 1
+            prompt = args[pos]
+            pos += 1
+            while pos < len(args) and not args[pos].startswith("--"):
+                prompt += " "
+                prompt += args[pos]
+                pos += 1
+            res[tag] = prompt
+            continue
+
+
+        func = prompt_tags.get(tag, None)
+        assert func, f'unknown commandline option: {arg}'
+
+        val = args[pos+1]
+        if tag == "sampler_name":
+            val = sd_samplers.samplers_map.get(val.lower(), None)
+
+        res[tag] = func(val)
+
+        pos += 2
+
+    return res
+
+
+def load_prompt_file(file):
+    if file is None:
+        return None, gr.update()
+    else:
+        lines = [x.strip() for x in file.decode('utf8', errors='ignore').split("\n")]
+        return None, "\n".join(lines)
+
+
+class Script(scripts.Script):
+    def title(self):
+        return "Prompts from file or textbox"
+
+    def ui(self, is_img2img):
+        checkbox_iterate = gr.Checkbox(label="Iterate seed every line", value=False, elem_id=self.elem_id("checkbox_iterate"))
+        checkbox_iterate_batch = gr.Checkbox(label="Use same random seed for all lines", value=False, elem_id=self.elem_id("checkbox_iterate_batch"))
+        prompt_position = gr.Radio(["start", "end"], label="Insert prompts at the", elem_id=self.elem_id("prompt_position"), value="start")
+        make_combined = gr.Checkbox(label="Make a combined image containing all outputs (if more than one)", value=False)
+
+        prompt_txt = gr.Textbox(label="List of prompt inputs", lines=2, elem_id=self.elem_id("prompt_txt"))
+        file = gr.File(label="Upload prompt inputs", type='binary', elem_id=self.elem_id("file"))
+
+        file.upload(fn=load_prompt_file, inputs=[file], outputs=[file, prompt_txt], show_progress=False)
+
+        return [checkbox_iterate, checkbox_iterate_batch, prompt_position, prompt_txt, make_combined]
+
+    def run(self, p, checkbox_iterate, checkbox_iterate_batch, prompt_position, prompt_txt: str, make_combined):
+        lines = [x for x in (x.strip() for x in prompt_txt.splitlines()) if x]
+
+        p.do_not_save_grid = True
+
+        job_count = 0
+        jobs = []
+
+        for line in lines:
+            if "--" in line:
+                try:
+                    args = cmdargs(line)
+                except Exception:
+                    errors.report(f"Error parsing line {line} as commandline", exc_info=True)
+                    args = {"prompt": line}
+            else:
+                args = {"prompt": line}
+
+            job_count += args.get("n_iter", p.n_iter)
+
+            jobs.append(args)
+
+        print(f"Will process {len(lines)} lines in {job_count} jobs.")
+        if (checkbox_iterate or checkbox_iterate_batch) and p.seed == -1:
+            p.seed = int(random.randrange(4294967294))
+
+        state.job_count = job_count
+
+        images = []
+        all_prompts = []
+        infotexts = []
+        for args in jobs:
+            state.job = f"{state.job_no + 1} out of {state.job_count}"
+
+            copy_p = copy.copy(p)
+            for k, v in args.items():
+                if k == "sd_model":
+                    copy_p.override_settings['sd_model_checkpoint'] = v
+                else:
+                    setattr(copy_p, k, v)
+
+            if args.get("prompt") and p.prompt:
+                if prompt_position == "start":
+                    copy_p.prompt = args.get("prompt") + " " + p.prompt
+                else:
+                    copy_p.prompt = p.prompt + " " + args.get("prompt")
+
+            if args.get("negative_prompt") and p.negative_prompt:
+                if prompt_position == "start":
+                    copy_p.negative_prompt = args.get("negative_prompt") + " " + p.negative_prompt
+                else:
+                    copy_p.negative_prompt = p.negative_prompt + " " + args.get("negative_prompt")
+
+            proc = process_images(copy_p)
+            images += proc.images
+
+            if checkbox_iterate:
+                p.seed = p.seed + (p.batch_size * p.n_iter)
+            all_prompts += proc.all_prompts
+            infotexts += proc.infotexts
+
+        if make_combined and len(images) > 1:
+            combined_image = image_grid(images, batch_size=1, rows=None).convert("RGB")
+            full_infotext = "\n".join(infotexts)
+            
+            is_img2img = getattr(p, "init_images", None) is not None
+            
+            if opts.grid_save:  #   use grid specific Settings
+                save_image(
+                    combined_image,
+                    opts.outdir_grids or (opts.outdir_img2img_grids if is_img2img else opts.outdir_txt2img_grids),
+                    "",
+                    -1,
+                    prompt_txt,
+                    opts.grid_format,
+                    full_infotext,
+                    grid=True
+                )
+            else:               #   use normal output Settings
+                save_image(
+                    combined_image,
+                    opts.outdir_samples or (opts.outdir_img2img_samples if is_img2img else opts.outdir_txt2img_samples),
+                    "",
+                    -1,
+                    prompt_txt,
+                    opts.samples_format,
+                    full_infotext
+                )
+
+            images.insert(0, combined_image)
+            all_prompts.insert(0, prompt_txt)
+            infotexts.insert(0, full_infotext)
+
+        return Processed(p, images, p.seed, "", all_prompts=all_prompts, infotexts=infotexts)

scripts/sd_upscale.py

@@ -0,0 +1,101 @@
+import math
+
+import modules.scripts as scripts
+import gradio as gr
+from PIL import Image
+
+from modules import processing, shared, images, devices
+from modules.processing import Processed
+from modules.shared import opts, state
+
+
+class Script(scripts.Script):
+    def title(self):
+        return "SD upscale"
+
+    def show(self, is_img2img):
+        return is_img2img
+
+    def ui(self, is_img2img):
+        info = gr.HTML("<p style=\"margin-bottom:0.75em\">Will upscale the image by the selected scale factor; use width and height sliders to set tile size</p>")
+        overlap = gr.Slider(minimum=0, maximum=256, step=16, label='Tile overlap', value=64, elem_id=self.elem_id("overlap"))
+        scale_factor = gr.Slider(minimum=1.0, maximum=4.0, step=0.05, label='Scale Factor', value=2.0, elem_id=self.elem_id("scale_factor"))
+        upscaler_index = gr.Radio(label='Upscaler', choices=[x.name for x in shared.sd_upscalers], value=shared.sd_upscalers[0].name, type="index", elem_id=self.elem_id("upscaler_index"))
+
+        return [info, overlap, upscaler_index, scale_factor]
+
+    def run(self, p, _, overlap, upscaler_index, scale_factor):
+        if isinstance(upscaler_index, str):
+            upscaler_index = [x.name.lower() for x in shared.sd_upscalers].index(upscaler_index.lower())
+        processing.fix_seed(p)
+        upscaler = shared.sd_upscalers[upscaler_index]
+
+        p.extra_generation_params["SD upscale overlap"] = overlap
+        p.extra_generation_params["SD upscale upscaler"] = upscaler.name
+
+        initial_info = None
+        seed = p.seed
+
+        init_img = p.init_images[0]
+        init_img = images.flatten(init_img, opts.img2img_background_color)
+
+        if upscaler.name != "None":
+            img = upscaler.scaler.upscale(init_img, scale_factor, upscaler.data_path)
+        else:
+            img = init_img
+
+        devices.torch_gc()
+
+        grid = images.split_grid(img, tile_w=p.width, tile_h=p.height, overlap=overlap)
+
+        batch_size = p.batch_size
+        upscale_count = p.n_iter
+        p.n_iter = 1
+        p.do_not_save_grid = True
+        p.do_not_save_samples = True
+
+        work = []
+
+        for _y, _h, row in grid.tiles:
+            for tiledata in row:
+                work.append(tiledata[2])
+
+        batch_count = math.ceil(len(work) / batch_size)
+        state.job_count = batch_count * upscale_count
+
+        print(f"SD upscaling will process a total of {len(work)} images tiled as {len(grid.tiles[0][2])}x{len(grid.tiles)} per upscale in a total of {state.job_count} batches.")
+
+        result_images = []
+        for n in range(upscale_count):
+            start_seed = seed + n
+            p.seed = start_seed
+
+            work_results = []
+            for i in range(batch_count):
+                p.batch_size = batch_size
+                p.init_images = work[i * batch_size:(i + 1) * batch_size]
+
+                state.job = f"Batch {i + 1 + n * batch_count} out of {state.job_count}"
+                processed = processing.process_images(p)
+
+                if initial_info is None:
+                    initial_info = processed.info
+
+                p.seed = processed.seed + 1
+                work_results += processed.images
+
+            image_index = 0
+            for _y, _h, row in grid.tiles:
+                for tiledata in row:
+                    tiledata[2] = work_results[image_index] if image_index < len(work_results) else Image.new("RGB", (p.width, p.height))
+                    image_index += 1
+
+            combined_image = images.combine_grid(grid)
+            result_images.append(combined_image)
+
+            if opts.samples_save:
+                images.save_image(combined_image, p.outpath_samples, "", start_seed, p.prompt, opts.samples_format, info=initial_info, p=p)
+
+        processed = Processed(p, result_images, seed, initial_info)
+
+        return processed

scripts/xyz_grid.py

@@ -0,0 +1,844 @@
+from collections import namedtuple
+from copy import copy
+from itertools import permutations, chain
+import random
+import csv
+import os.path
+from io import StringIO
+from PIL import Image
+import numpy as np
+
+import modules.scripts as scripts
+import gradio as gr
+
+from modules import images, sd_samplers, processing, sd_models, sd_vae, sd_schedulers, errors
+from modules.processing import process_images, Processed, StableDiffusionProcessingTxt2Img
+from modules.shared import opts, state
+from modules.sd_models import model_data, select_checkpoint
+import modules.shared as shared
+import modules.sd_samplers
+import modules.sd_models
+import modules.sd_vae
+import re
+
+from modules.ui_components import ToolButton
+
+fill_values_symbol = "\U0001f4d2"  # 📒
+
+AxisInfo = namedtuple('AxisInfo', ['axis', 'values'])
+
+
+def apply_field(field):
+    def fun(p, x, xs):
+        setattr(p, field, x)
+
+    return fun
+
+
+def apply_prompt(p, x, xs):
+    if xs[0] not in p.prompt and xs[0] not in p.negative_prompt:
+        raise RuntimeError(f"Prompt S/R did not find {xs[0]} in prompt or negative prompt.")
+
+    p.prompt = p.prompt.replace(xs[0], x)
+    p.negative_prompt = p.negative_prompt.replace(xs[0], x)
+
+
+def apply_order(p, x, xs):
+    token_order = []
+
+    # Initially grab the tokens from the prompt, so they can be replaced in order of earliest seen
+    for token in x:
+        token_order.append((p.prompt.find(token), token))
+
+    token_order.sort(key=lambda t: t[0])
+
+    prompt_parts = []
+
+    # Split the prompt up, taking out the tokens
+    for _, token in token_order:
+        n = p.prompt.find(token)
+        prompt_parts.append(p.prompt[0:n])
+        p.prompt = p.prompt[n + len(token):]
+
+    # Rebuild the prompt with the tokens in the order we want
+    prompt_tmp = ""
+    for idx, part in enumerate(prompt_parts):
+        prompt_tmp += part
+        prompt_tmp += x[idx]
+    p.prompt = prompt_tmp + p.prompt
+
+
+def confirm_samplers(p, xs):
+    for x in xs:
+        if x.lower() not in sd_samplers.samplers_map:
+            raise RuntimeError(f"Unknown sampler: {x}")
+
+
+def apply_checkpoint(p, x, xs):
+    info = modules.sd_models.get_closet_checkpoint_match(x)
+    if info is None:
+        raise RuntimeError(f"Unknown checkpoint: {x}")
+    # skip if the checkpoint was last override
+    if info.name == p.override_settings.get('sd_model_checkpoint', None):
+        return
+    org_cp = getattr(opts, 'sd_model_checkpoint', None)
+    p.override_settings['sd_model_checkpoint'] = info.name
+    opts.set('sd_model_checkpoint', info.name)
+    refresh_loading_params_for_xyz_grid()
+    # This saves part of the reload
+    opts.set('sd_model_checkpoint', org_cp)
+
+def refresh_loading_params_for_xyz_grid():
+    """
+    Refreshes the loading parameters for the model, 
+    prompts a reload in sd_models.forge_model_reload()
+    """
+    checkpoint_info = select_checkpoint()
+
+    model_data.forge_loading_parameters = dict(
+        checkpoint_info=checkpoint_info,
+        additional_modules=shared.opts.forge_additional_modules,
+        #unet_storage_dtype=shared.opts.forge_unet_storage_dtype
+        unet_storage_dtype=model_data.forge_loading_parameters.get('unet_storage_dtype', None)
+    )
+
+
+def confirm_checkpoints(p, xs):
+    for x in xs:
+        if modules.sd_models.get_closet_checkpoint_match(x) is None:
+            raise RuntimeError(f"Unknown checkpoint: {x}")
+
+
+def confirm_checkpoints_or_none(p, xs):
+    for x in xs:
+        if x in (None, "", "None", "none"):
+            continue
+
+        if modules.sd_models.get_closet_checkpoint_match(x) is None:
+            raise RuntimeError(f"Unknown checkpoint: {x}")
+
+
+def confirm_range(min_val, max_val, axis_label):
+    """Generates a AxisOption.confirm() function that checks all values are within the specified range."""
+
+    def confirm_range_fun(p, xs):
+        for x in xs:
+            if not (max_val >= x >= min_val):
+                raise ValueError(f'{axis_label} value "{x}" out of range [{min_val}, {max_val}]')
+
+    return confirm_range_fun
+
+
+def apply_size(p, x: str, xs) -> None:
+    try:
+        width, _, height = x.partition('x')
+        width = int(width.strip())
+        height = int(height.strip())
+        p.width = width
+        p.height = height
+    except ValueError:
+        print(f"Invalid size in XYZ plot: {x}")
+
+
+def find_vae(name: str):
+    if (name := name.strip().lower()) in ('auto', 'automatic'):
+        return 'Automatic'
+    elif name == 'none':
+        return 'None'
+    return next((k for k in modules.sd_vae.vae_dict if k.lower() == name), print(f'No VAE found for {name}; using Automatic') or 'Automatic')
+
+
+def apply_vae(p, x, xs):
+    p.override_settings['sd_vae'] = find_vae(x)
+
+
+def apply_styles(p: StableDiffusionProcessingTxt2Img, x: str, _):
+    p.styles.extend(x.split(','))
+
+
+def apply_uni_pc_order(p, x, xs):
+    p.override_settings['uni_pc_order'] = min(x, p.steps - 1)
+
+
+def apply_face_restore(p, opt, x):
+    opt = opt.lower()
+    if opt == 'codeformer':
+        is_active = True
+        p.face_restoration_model = 'CodeFormer'
+    elif opt == 'gfpgan':
+        is_active = True
+        p.face_restoration_model = 'GFPGAN'
+    else:
+        is_active = opt in ('true', 'yes', 'y', '1')
+
+    p.restore_faces = is_active
+
+
+def apply_override(field, boolean: bool = False):
+    def fun(p, x, xs):
+        if boolean:
+            x = True if x.lower() == "true" else False
+        p.override_settings[field] = x
+
+    return fun
+
+
+def boolean_choice(reverse: bool = False):
+    def choice():
+        return ["False", "True"] if reverse else ["True", "False"]
+
+    return choice
+
+
+def format_value_add_label(p, opt, x):
+    if type(x) == float:
+        x = round(x, 8)
+
+    return f"{opt.label}: {x}"
+
+
+def format_value(p, opt, x):
+    if type(x) == float:
+        x = round(x, 8)
+    return x
+
+
+def format_value_join_list(p, opt, x):
+    return ", ".join(x)
+
+
+def do_nothing(p, x, xs):
+    pass
+
+
+def format_nothing(p, opt, x):
+    return ""
+
+
+def format_remove_path(p, opt, x):
+    return os.path.basename(x)
+
+
+def str_permutations(x):
+    """dummy function for specifying it in AxisOption's type when you want to get a list of permutations"""
+    return x
+
+
+def list_to_csv_string(data_list):
+    with StringIO() as o:
+        csv.writer(o).writerow(data_list)
+        return o.getvalue().strip()
+
+
+def csv_string_to_list_strip(data_str):
+    return list(map(str.strip, chain.from_iterable(csv.reader(StringIO(data_str), skipinitialspace=True))))
+
+
+class AxisOption:
+    def __init__(self, label, type, apply, format_value=format_value_add_label, confirm=None, cost=0.0, choices=None, prepare=None):
+        self.label = label
+        self.type = type
+        self.apply = apply
+        self.format_value = format_value
+        self.confirm = confirm
+        self.cost = cost
+        self.prepare = prepare
+        self.choices = choices
+
+
+class AxisOptionImg2Img(AxisOption):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.is_img2img = True
+
+
+class AxisOptionTxt2Img(AxisOption):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.is_img2img = False
+
+
+axis_options = [
+    AxisOption("Nothing", str, do_nothing, format_value=format_nothing),
+    AxisOption("Seed", int, apply_field("seed")),
+    AxisOption("Var. seed", int, apply_field("subseed")),
+    AxisOption("Var. strength", float, apply_field("subseed_strength")),
+    AxisOption("Steps", int, apply_field("steps")),
+    AxisOptionTxt2Img("Hires steps", int, apply_field("hr_second_pass_steps")),
+    AxisOption("CFG Scale", float, apply_field("cfg_scale")),
+    AxisOption("Distilled CFG Scale", float, apply_field("distilled_cfg_scale")),
+    AxisOptionImg2Img("Image CFG Scale", float, apply_field("image_cfg_scale")),
+    AxisOption("Prompt S/R", str, apply_prompt, format_value=format_value),
+    AxisOption("Prompt order", str_permutations, apply_order, format_value=format_value_join_list),
+    AxisOptionTxt2Img("Sampler", str, apply_field("sampler_name"), format_value=format_value, confirm=confirm_samplers, choices=lambda: [x.name for x in sd_samplers.samplers if x.name not in opts.hide_samplers]),
+    AxisOptionTxt2Img("Hires sampler", str, apply_field("hr_sampler_name"), confirm=confirm_samplers, choices=lambda: [x.name for x in sd_samplers.samplers_for_img2img if x.name not in opts.hide_samplers]),
+    AxisOptionImg2Img("Sampler", str, apply_field("sampler_name"), format_value=format_value, confirm=confirm_samplers, choices=lambda: [x.name for x in sd_samplers.samplers_for_img2img if x.name not in opts.hide_samplers]),
+    AxisOption("Checkpoint name", str, apply_checkpoint, format_value=format_remove_path, confirm=confirm_checkpoints, cost=1.0, choices=lambda: sorted(sd_models.checkpoints_list, key=str.casefold)),
+    AxisOption("Negative Guidance minimum sigma", float, apply_field("s_min_uncond")),
+    AxisOption("Sigma Churn", float, apply_field("s_churn")),
+    AxisOption("Sigma min", float, apply_field("s_tmin")),
+    AxisOption("Sigma max", float, apply_field("s_tmax")),
+    AxisOption("Sigma noise", float, apply_field("s_noise")),
+    AxisOption("Schedule type", str, apply_field("scheduler"), choices=lambda: [x.label for x in sd_schedulers.schedulers]),
+    AxisOption("Schedule min sigma", float, apply_override("sigma_min")),
+    AxisOption("Schedule max sigma", float, apply_override("sigma_max")),
+    AxisOption("Schedule rho", float, apply_override("rho")),
+    AxisOption("Beta schedule alpha", float, apply_override("beta_dist_alpha")),
+    AxisOption("Beta schedule beta", float, apply_override("beta_dist_beta")),
+    AxisOption("Eta", float, apply_field("eta")),
+    AxisOption("Clip skip", int, apply_override('CLIP_stop_at_last_layers')),
+    AxisOption("Denoising", float, apply_field("denoising_strength")),
+    AxisOption("Initial noise multiplier", float, apply_field("initial_noise_multiplier")),
+    AxisOption("Extra noise", float, apply_override("img2img_extra_noise")),
+    AxisOptionTxt2Img("Hires upscaler", str, apply_field("hr_upscaler"), choices=lambda: [*shared.latent_upscale_modes, *[x.name for x in shared.sd_upscalers]]),
+    AxisOptionImg2Img("Cond. Image Mask Weight", float, apply_field("inpainting_mask_weight")),
+    AxisOption("VAE", str, apply_vae, cost=0.7, choices=lambda: ['Automatic', 'None'] + list(sd_vae.vae_dict)),
+    AxisOption("Styles", str, apply_styles, choices=lambda: list(shared.prompt_styles.styles)),
+    AxisOption("UniPC Order", int, apply_uni_pc_order, cost=0.5),
+    AxisOption("Face restore", str, apply_face_restore, format_value=format_value),
+    AxisOption("Token merging ratio", float, apply_override('token_merging_ratio')),
+    AxisOption("Token merging ratio high-res", float, apply_override('token_merging_ratio_hr')),
+    AxisOption("Always discard next-to-last sigma", str, apply_override('always_discard_next_to_last_sigma', boolean=True), choices=boolean_choice(reverse=True)),
+    AxisOption("SGM noise multiplier", str, apply_override('sgm_noise_multiplier', boolean=True), choices=boolean_choice(reverse=True)),
+    AxisOption("Refiner checkpoint", str, apply_field('refiner_checkpoint'), format_value=format_remove_path, confirm=confirm_checkpoints_or_none, cost=1.0, choices=lambda: ['None'] + sorted(sd_models.checkpoints_list, key=str.casefold)),
+    AxisOption("Refiner switch at", float, apply_field('refiner_switch_at')),
+    AxisOption("RNG source", str, apply_override("randn_source"), choices=lambda: ["GPU", "CPU", "NV"]),
+    AxisOption("FP8 mode", str, apply_override("fp8_storage"), cost=0.9, choices=lambda: ["Disable", "Enable for SDXL", "Enable"]),
+    AxisOption("Size", str, apply_size),
+]
+
+
+def draw_xyz_grid(p, xs, ys, zs, x_labels, y_labels, z_labels, cell, draw_legend, include_lone_images, include_sub_grids, first_axes_processed, second_axes_processed, margin_size):
+    hor_texts = [[images.GridAnnotation(x)] for x in x_labels]
+    ver_texts = [[images.GridAnnotation(y)] for y in y_labels]
+    title_texts = [[images.GridAnnotation(z)] for z in z_labels]
+
+    list_size = (len(xs) * len(ys) * len(zs))
+
+    processed_result = None
+
+    state.job_count = list_size * p.n_iter
+
+    def process_cell(x, y, z, ix, iy, iz):
+        nonlocal processed_result
+
+        def index(ix, iy, iz):
+            return ix + iy * len(xs) + iz * len(xs) * len(ys)
+
+        state.job = f"{index(ix, iy, iz) + 1} out of {list_size}"
+
+        processed: Processed = cell(x, y, z, ix, iy, iz)
+
+        if processed_result is None:
+            # Use our first processed result object as a template container to hold our full results
+            processed_result = copy(processed)
+            processed_result.images = [None] * list_size
+            processed_result.all_prompts = [None] * list_size
+            processed_result.all_seeds = [None] * list_size
+            processed_result.infotexts = [None] * list_size
+            processed_result.index_of_first_image = 1
+
+        idx = index(ix, iy, iz)
+        if processed.images:
+            # Non-empty list indicates some degree of success.
+            processed_result.images[idx] = processed.images[0]
+            processed_result.all_prompts[idx] = processed.prompt
+            processed_result.all_seeds[idx] = processed.seed
+            processed_result.infotexts[idx] = processed.infotexts[0]
+        else:
+            cell_mode = "P"
+            cell_size = (processed_result.width, processed_result.height)
+            if processed_result.images[0] is not None:
+                cell_mode = processed_result.images[0].mode
+                # This corrects size in case of batches:
+                cell_size = processed_result.images[0].size
+            processed_result.images[idx] = Image.new(cell_mode, cell_size)
+
+    if first_axes_processed == 'x':
+        for ix, x in enumerate(xs):
+            if second_axes_processed == 'y':
+                for iy, y in enumerate(ys):
+                    for iz, z in enumerate(zs):
+                        process_cell(x, y, z, ix, iy, iz)
+            else:
+                for iz, z in enumerate(zs):
+                    for iy, y in enumerate(ys):
+                        process_cell(x, y, z, ix, iy, iz)
+    elif first_axes_processed == 'y':
+        for iy, y in enumerate(ys):
+            if second_axes_processed == 'x':
+                for ix, x in enumerate(xs):
+                    for iz, z in enumerate(zs):
+                        process_cell(x, y, z, ix, iy, iz)
+            else:
+                for iz, z in enumerate(zs):
+                    for ix, x in enumerate(xs):
+                        process_cell(x, y, z, ix, iy, iz)
+    elif first_axes_processed == 'z':
+        for iz, z in enumerate(zs):
+            if second_axes_processed == 'x':
+                for ix, x in enumerate(xs):
+                    for iy, y in enumerate(ys):
+                        process_cell(x, y, z, ix, iy, iz)
+            else:
+                for iy, y in enumerate(ys):
+                    for ix, x in enumerate(xs):
+                        process_cell(x, y, z, ix, iy, iz)
+
+    if not processed_result:
+        # Should never happen, I've only seen it on one of four open tabs and it needed to refresh.
+        print("Unexpected error: Processing could not begin, you may need to refresh the tab or restart the service.")
+        return Processed(p, [])
+    elif not any(processed_result.images):
+        print("Unexpected error: draw_xyz_grid failed to return even a single processed image")
+        return Processed(p, [])
+
+    z_count = len(zs)
+
+    for i in range(z_count):
+        start_index = (i * len(xs) * len(ys)) + i
+        end_index = start_index + len(xs) * len(ys)
+        grid = images.image_grid(processed_result.images[start_index:end_index], rows=len(ys))
+        if draw_legend:
+            grid_max_w, grid_max_h = map(max, zip(*(img.size for img in processed_result.images[start_index:end_index])))
+            grid = images.draw_grid_annotations(grid, grid_max_w, grid_max_h, hor_texts, ver_texts, margin_size)
+        processed_result.images.insert(i, grid)
+        processed_result.all_prompts.insert(i, processed_result.all_prompts[start_index])
+        processed_result.all_seeds.insert(i, processed_result.all_seeds[start_index])
+        processed_result.infotexts.insert(i, processed_result.infotexts[start_index])
+
+    z_grid = images.image_grid(processed_result.images[:z_count], rows=1)
+    z_sub_grid_max_w, z_sub_grid_max_h = map(max, zip(*(img.size for img in processed_result.images[:z_count])))
+    if draw_legend:
+        z_grid = images.draw_grid_annotations(z_grid, z_sub_grid_max_w, z_sub_grid_max_h, title_texts, [[images.GridAnnotation()]])
+    processed_result.images.insert(0, z_grid)
+    # TODO: Deeper aspects of the program rely on grid info being misaligned between metadata arrays, which is not ideal.
+    # processed_result.all_prompts.insert(0, processed_result.all_prompts[0])
+    # processed_result.all_seeds.insert(0, processed_result.all_seeds[0])
+    processed_result.infotexts.insert(0, processed_result.infotexts[0])
+
+    return processed_result
+
+
+class SharedSettingsStackHelper(object):
+    def __enter__(self):
+        pass
+
+    def __exit__(self, exc_type, exc_value, tb):
+        modules.sd_models.reload_model_weights()
+        modules.sd_vae.reload_vae_weights()
+
+
+re_range = re.compile(r"\s*([+-]?\s*\d+)\s*-\s*([+-]?\s*\d+)(?:\s*\(([+-]\d+)\s*\))?\s*")
+re_range_float = re.compile(r"\s*([+-]?\s*\d+(?:.\d*)?)\s*-\s*([+-]?\s*\d+(?:.\d*)?)(?:\s*\(([+-]\d+(?:.\d*)?)\s*\))?\s*")
+
+re_range_count = re.compile(r"\s*([+-]?\s*\d+)\s*-\s*([+-]?\s*\d+)(?:\s*\[(\d+)\s*])?\s*")
+re_range_count_float = re.compile(r"\s*([+-]?\s*\d+(?:.\d*)?)\s*-\s*([+-]?\s*\d+(?:.\d*)?)(?:\s*\[(\d+(?:.\d*)?)\s*])?\s*")
+
+
+class Script(scripts.Script):
+    def title(self):
+        return "X/Y/Z plot"
+
+    def ui(self, is_img2img):
+        self.current_axis_options = [x for x in axis_options if type(x) == AxisOption or x.is_img2img == is_img2img]
+
+        with gr.Row():
+            with gr.Column(scale=19):
+                with gr.Row():
+                    x_type = gr.Dropdown(label="X type", choices=[x.label for x in self.current_axis_options], value=self.current_axis_options[1].label, type="index", elem_id=self.elem_id("x_type"))
+                    x_values = gr.Textbox(label="X values", lines=1, elem_id=self.elem_id("x_values"))
+                    x_values_dropdown = gr.Dropdown(label="X values", visible=False, multiselect=True, interactive=True)
+                    fill_x_button = ToolButton(value=fill_values_symbol, elem_id="xyz_grid_fill_x_tool_button", visible=False)
+
+                with gr.Row():
+                    y_type = gr.Dropdown(label="Y type", choices=[x.label for x in self.current_axis_options], value=self.current_axis_options[0].label, type="index", elem_id=self.elem_id("y_type"))
+                    y_values = gr.Textbox(label="Y values", lines=1, elem_id=self.elem_id("y_values"))
+                    y_values_dropdown = gr.Dropdown(label="Y values", visible=False, multiselect=True, interactive=True)
+                    fill_y_button = ToolButton(value=fill_values_symbol, elem_id="xyz_grid_fill_y_tool_button", visible=False)
+
+                with gr.Row():
+                    z_type = gr.Dropdown(label="Z type", choices=[x.label for x in self.current_axis_options], value=self.current_axis_options[0].label, type="index", elem_id=self.elem_id("z_type"))
+                    z_values = gr.Textbox(label="Z values", lines=1, elem_id=self.elem_id("z_values"))
+                    z_values_dropdown = gr.Dropdown(label="Z values", visible=False, multiselect=True, interactive=True)
+                    fill_z_button = ToolButton(value=fill_values_symbol, elem_id="xyz_grid_fill_z_tool_button", visible=False)
+
+        with gr.Row(variant="compact", elem_id="axis_options"):
+            with gr.Column():
+                draw_legend = gr.Checkbox(label='Draw legend', value=True, elem_id=self.elem_id("draw_legend"))
+                no_fixed_seeds = gr.Checkbox(label='Keep -1 for seeds', value=False, elem_id=self.elem_id("no_fixed_seeds"))
+                with gr.Row():
+                    vary_seeds_x = gr.Checkbox(label='Vary seeds for X', value=False, min_width=80, elem_id=self.elem_id("vary_seeds_x"), tooltip="Use different seeds for images along X axis.")
+                    vary_seeds_y = gr.Checkbox(label='Vary seeds for Y', value=False, min_width=80, elem_id=self.elem_id("vary_seeds_y"), tooltip="Use different seeds for images along Y axis.")
+                    vary_seeds_z = gr.Checkbox(label='Vary seeds for Z', value=False, min_width=80, elem_id=self.elem_id("vary_seeds_z"), tooltip="Use different seeds for images along Z axis.")
+            with gr.Column():
+                include_lone_images = gr.Checkbox(label='Include Sub Images', value=False, elem_id=self.elem_id("include_lone_images"))
+                include_sub_grids = gr.Checkbox(label='Include Sub Grids', value=False, elem_id=self.elem_id("include_sub_grids"))
+                csv_mode = gr.Checkbox(label='Use text inputs instead of dropdowns', value=False, elem_id=self.elem_id("csv_mode"))
+            with gr.Column():
+                margin_size = gr.Slider(label="Grid margins (px)", minimum=0, maximum=500, value=0, step=2, elem_id=self.elem_id("margin_size"))
+
+        with gr.Row(variant="compact", elem_id="swap_axes"):
+            swap_xy_axes_button = gr.Button(value="Swap X/Y axes", elem_id="xy_grid_swap_axes_button")
+            swap_yz_axes_button = gr.Button(value="Swap Y/Z axes", elem_id="yz_grid_swap_axes_button")
+            swap_xz_axes_button = gr.Button(value="Swap X/Z axes", elem_id="xz_grid_swap_axes_button")
+
+        def swap_axes(axis1_type, axis1_values, axis1_values_dropdown, axis2_type, axis2_values, axis2_values_dropdown):
+            return self.current_axis_options[axis2_type].label, axis2_values, axis2_values_dropdown, self.current_axis_options[axis1_type].label, axis1_values, axis1_values_dropdown
+
+        xy_swap_args = [x_type, x_values, x_values_dropdown, y_type, y_values, y_values_dropdown]
+        swap_xy_axes_button.click(swap_axes, inputs=xy_swap_args, outputs=xy_swap_args)
+        yz_swap_args = [y_type, y_values, y_values_dropdown, z_type, z_values, z_values_dropdown]
+        swap_yz_axes_button.click(swap_axes, inputs=yz_swap_args, outputs=yz_swap_args)
+        xz_swap_args = [x_type, x_values, x_values_dropdown, z_type, z_values, z_values_dropdown]
+        swap_xz_axes_button.click(swap_axes, inputs=xz_swap_args, outputs=xz_swap_args)
+
+        def fill(axis_type, csv_mode):
+            axis = self.current_axis_options[axis_type]
+            if axis.choices:
+                if csv_mode:
+                    return list_to_csv_string(axis.choices()), gr.update()
+                else:
+                    return gr.update(), axis.choices()
+            else:
+                return gr.update(), gr.update()
+
+        fill_x_button.click(fn=fill, inputs=[x_type, csv_mode], outputs=[x_values, x_values_dropdown])
+        fill_y_button.click(fn=fill, inputs=[y_type, csv_mode], outputs=[y_values, y_values_dropdown])
+        fill_z_button.click(fn=fill, inputs=[z_type, csv_mode], outputs=[z_values, z_values_dropdown])
+
+        def select_axis(axis_type, axis_values, axis_values_dropdown, csv_mode):
+            axis_type = axis_type or 0  # if axle type is None set to 0
+
+            choices = self.current_axis_options[axis_type].choices
+            has_choices = choices is not None
+
+            if has_choices:
+                choices = choices()
+                if csv_mode:
+                    if axis_values_dropdown:
+                        axis_values = list_to_csv_string(list(filter(lambda x: x in choices, axis_values_dropdown)))
+                        axis_values_dropdown = []
+                else:
+                    if axis_values:
+                        axis_values_dropdown = list(filter(lambda x: x in choices, csv_string_to_list_strip(axis_values)))
+                        axis_values = ""
+
+            return (gr.Button.update(visible=has_choices), gr.Textbox.update(visible=not has_choices or csv_mode, value=axis_values),
+                    gr.update(choices=choices if has_choices else None, visible=has_choices and not csv_mode, value=axis_values_dropdown))
+
+        x_type.change(fn=select_axis, inputs=[x_type, x_values, x_values_dropdown, csv_mode], outputs=[fill_x_button, x_values, x_values_dropdown])
+        y_type.change(fn=select_axis, inputs=[y_type, y_values, y_values_dropdown, csv_mode], outputs=[fill_y_button, y_values, y_values_dropdown])
+        z_type.change(fn=select_axis, inputs=[z_type, z_values, z_values_dropdown, csv_mode], outputs=[fill_z_button, z_values, z_values_dropdown])
+
+        def change_choice_mode(csv_mode, x_type, x_values, x_values_dropdown, y_type, y_values, y_values_dropdown, z_type, z_values, z_values_dropdown):
+            _fill_x_button, _x_values, _x_values_dropdown = select_axis(x_type, x_values, x_values_dropdown, csv_mode)
+            _fill_y_button, _y_values, _y_values_dropdown = select_axis(y_type, y_values, y_values_dropdown, csv_mode)
+            _fill_z_button, _z_values, _z_values_dropdown = select_axis(z_type, z_values, z_values_dropdown, csv_mode)
+            return _fill_x_button, _x_values, _x_values_dropdown, _fill_y_button, _y_values, _y_values_dropdown, _fill_z_button, _z_values, _z_values_dropdown
+
+        csv_mode.change(fn=change_choice_mode, inputs=[csv_mode, x_type, x_values, x_values_dropdown, y_type, y_values, y_values_dropdown, z_type, z_values, z_values_dropdown], outputs=[fill_x_button, x_values, x_values_dropdown, fill_y_button, y_values, y_values_dropdown, fill_z_button, z_values, z_values_dropdown])
+
+        def get_dropdown_update_from_params(axis, params):
+            val_key = f"{axis} Values"
+            vals = params.get(val_key, "")
+            valslist = csv_string_to_list_strip(vals)
+            return gr.update(value=valslist)
+
+        self.infotext_fields = (
+            (x_type, "X Type"),
+            (x_values, "X Values"),
+            (x_values_dropdown, lambda params: get_dropdown_update_from_params("X", params)),
+            (y_type, "Y Type"),
+            (y_values, "Y Values"),
+            (y_values_dropdown, lambda params: get_dropdown_update_from_params("Y", params)),
+            (z_type, "Z Type"),
+            (z_values, "Z Values"),
+            (z_values_dropdown, lambda params: get_dropdown_update_from_params("Z", params)),
+        )
+
+        return [x_type, x_values, x_values_dropdown, y_type, y_values, y_values_dropdown, z_type, z_values, z_values_dropdown, draw_legend, include_lone_images, include_sub_grids, no_fixed_seeds, vary_seeds_x, vary_seeds_y, vary_seeds_z, margin_size, csv_mode]
+
+    def run(self, p, x_type, x_values, x_values_dropdown, y_type, y_values, y_values_dropdown, z_type, z_values, z_values_dropdown, draw_legend, include_lone_images, include_sub_grids, no_fixed_seeds, vary_seeds_x, vary_seeds_y, vary_seeds_z, margin_size, csv_mode):
+        x_type, y_type, z_type = x_type or 0, y_type or 0, z_type or 0  # if axle type is None set to 0
+
+        if not no_fixed_seeds:
+            modules.processing.fix_seed(p)
+
+        if not opts.return_grid:
+            p.batch_size = 1
+
+        def process_axis(opt, vals, vals_dropdown):
+            if opt.label == 'Nothing':
+                return [0]
+
+            if opt.choices is not None and not csv_mode:
+                valslist = vals_dropdown
+            elif opt.prepare is not None:
+                valslist = opt.prepare(vals)
+            else:
+                valslist = csv_string_to_list_strip(vals)
+
+            if opt.type == int:
+                valslist_ext = []
+
+                for val in valslist:
+                    if val.strip() == '':
+                        continue
+                    m = re_range.fullmatch(val)
+                    mc = re_range_count.fullmatch(val)
+                    if m is not None:
+                        start = int(m.group(1))
+                        end = int(m.group(2)) + 1
+                        step = int(m.group(3)) if m.group(3) is not None else 1
+
+                        valslist_ext += list(range(start, end, step))
+                    elif mc is not None:
+                        start = int(mc.group(1))
+                        end = int(mc.group(2))
+                        num = int(mc.group(3)) if mc.group(3) is not None else 1
+
+                        valslist_ext += [int(x) for x in np.linspace(start=start, stop=end, num=num).tolist()]
+                    else:
+                        valslist_ext.append(val)
+
+                valslist = valslist_ext
+            elif opt.type == float:
+                valslist_ext = []
+
+                for val in valslist:
+                    if val.strip() == '':
+                        continue
+                    m = re_range_float.fullmatch(val)
+                    mc = re_range_count_float.fullmatch(val)
+                    if m is not None:
+                        start = float(m.group(1))
+                        end = float(m.group(2))
+                        step = float(m.group(3)) if m.group(3) is not None else 1
+
+                        valslist_ext += np.arange(start, end + step, step).tolist()
+                    elif mc is not None:
+                        start = float(mc.group(1))
+                        end = float(mc.group(2))
+                        num = int(mc.group(3)) if mc.group(3) is not None else 1
+
+                        valslist_ext += np.linspace(start=start, stop=end, num=num).tolist()
+                    else:
+                        valslist_ext.append(val)
+
+                valslist = valslist_ext
+            elif opt.type == str_permutations:
+                valslist = list(permutations(valslist))
+
+            valslist = [opt.type(x) for x in valslist]
+
+            # Confirm options are valid before starting
+            if opt.confirm:
+                opt.confirm(p, valslist)
+
+            return valslist
+
+        x_opt = self.current_axis_options[x_type]
+        if x_opt.choices is not None and not csv_mode:
+            x_values = list_to_csv_string(x_values_dropdown)
+        xs = process_axis(x_opt, x_values, x_values_dropdown)
+
+        y_opt = self.current_axis_options[y_type]
+        if y_opt.choices is not None and not csv_mode:
+            y_values = list_to_csv_string(y_values_dropdown)
+        ys = process_axis(y_opt, y_values, y_values_dropdown)
+
+        z_opt = self.current_axis_options[z_type]
+        if z_opt.choices is not None and not csv_mode:
+            z_values = list_to_csv_string(z_values_dropdown)
+        zs = process_axis(z_opt, z_values, z_values_dropdown)
+
+        # this could be moved to common code, but unlikely to be ever triggered anywhere else
+        Image.MAX_IMAGE_PIXELS = None  # disable check in Pillow and rely on check below to allow large custom image sizes
+        grid_mp = round(len(xs) * len(ys) * len(zs) * p.width * p.height / 1000000)
+        assert grid_mp < opts.img_max_size_mp, f'Error: Resulting grid would be too large ({grid_mp} MPixels) (max configured size is {opts.img_max_size_mp} MPixels)'
+
+        def fix_axis_seeds(axis_opt, axis_list):
+            if axis_opt.label in ['Seed', 'Var. seed']:
+                return [int(random.randrange(4294967294)) if val is None or val == '' or val == -1 else val for val in axis_list]
+            else:
+                return axis_list
+
+        if not no_fixed_seeds:
+            xs = fix_axis_seeds(x_opt, xs)
+            ys = fix_axis_seeds(y_opt, ys)
+            zs = fix_axis_seeds(z_opt, zs)
+
+        if x_opt.label == 'Steps':
+            total_steps = sum(xs) * len(ys) * len(zs)
+        elif y_opt.label == 'Steps':
+            total_steps = sum(ys) * len(xs) * len(zs)
+        elif z_opt.label == 'Steps':
+            total_steps = sum(zs) * len(xs) * len(ys)
+        else:
+            total_steps = p.steps * len(xs) * len(ys) * len(zs)
+
+        if isinstance(p, StableDiffusionProcessingTxt2Img) and p.enable_hr:
+            if x_opt.label == "Hires steps":
+                total_steps += sum(xs) * len(ys) * len(zs)
+            elif y_opt.label == "Hires steps":
+                total_steps += sum(ys) * len(xs) * len(zs)
+            elif z_opt.label == "Hires steps":
+                total_steps += sum(zs) * len(xs) * len(ys)
+            elif p.hr_second_pass_steps:
+                total_steps += p.hr_second_pass_steps * len(xs) * len(ys) * len(zs)
+            else:
+                total_steps *= 2
+
+        total_steps *= p.n_iter
+
+        image_cell_count = p.n_iter * p.batch_size
+        cell_console_text = f"; {image_cell_count} images per cell" if image_cell_count > 1 else ""
+        plural_s = 's' if len(zs) > 1 else ''
+        print(f"X/Y/Z plot will create {len(xs) * len(ys) * len(zs) * image_cell_count} images on {len(zs)} {len(xs)}x{len(ys)} grid{plural_s}{cell_console_text}. (Total steps to process: {total_steps})")
+        shared.total_tqdm.updateTotal(total_steps)
+
+        state.xyz_plot_x = AxisInfo(x_opt, xs)
+        state.xyz_plot_y = AxisInfo(y_opt, ys)
+        state.xyz_plot_z = AxisInfo(z_opt, zs)
+
+        # If one of the axes is very slow to change between (like SD model
+        # checkpoint), then make sure it is in the outer iteration of the nested
+        # `for` loop.
+        first_axes_processed = 'z'
+        second_axes_processed = 'y'
+        if x_opt.cost > y_opt.cost and x_opt.cost > z_opt.cost:
+            first_axes_processed = 'x'
+            if y_opt.cost > z_opt.cost:
+                second_axes_processed = 'y'
+            else:
+                second_axes_processed = 'z'
+        elif y_opt.cost > x_opt.cost and y_opt.cost > z_opt.cost:
+            first_axes_processed = 'y'
+            if x_opt.cost > z_opt.cost:
+                second_axes_processed = 'x'
+            else:
+                second_axes_processed = 'z'
+        elif z_opt.cost > x_opt.cost and z_opt.cost > y_opt.cost:
+            first_axes_processed = 'z'
+            if x_opt.cost > y_opt.cost:
+                second_axes_processed = 'x'
+            else:
+                second_axes_processed = 'y'
+
+        grid_infotext = [None] * (1 + len(zs))
+
+        def cell(x, y, z, ix, iy, iz):
+            if shared.state.interrupted or state.stopping_generation:
+                return Processed(p, [], p.seed, "")
+
+            pc = copy(p)
+            pc.styles = pc.styles[:]
+            x_opt.apply(pc, x, xs)
+            y_opt.apply(pc, y, ys)
+            z_opt.apply(pc, z, zs)
+
+            xdim = len(xs) if vary_seeds_x else 1
+            ydim = len(ys) if vary_seeds_y else 1
+
+            if vary_seeds_x:
+                pc.seed += ix
+            if vary_seeds_y:
+                pc.seed += iy * xdim
+            if vary_seeds_z:
+                pc.seed += iz * xdim * ydim
+
+            try:
+                res = process_images(pc)
+            except Exception as e:
+                errors.display(e, "generating image for xyz plot")
+
+                res = Processed(p, [], p.seed, "")
+
+            # Sets subgrid infotexts
+            subgrid_index = 1 + iz
+            if grid_infotext[subgrid_index] is None and ix == 0 and iy == 0:
+                pc.extra_generation_params = copy(pc.extra_generation_params)
+                pc.extra_generation_params['Script'] = self.title()
+
+                if x_opt.label != 'Nothing':
+                    pc.extra_generation_params["X Type"] = x_opt.label
+                    pc.extra_generation_params["X Values"] = x_values
+                    if x_opt.label in ["Seed", "Var. seed"] and not no_fixed_seeds:
+                        pc.extra_generation_params["Fixed X Values"] = ", ".join([str(x) for x in xs])
+
+                if y_opt.label != 'Nothing':
+                    pc.extra_generation_params["Y Type"] = y_opt.label
+                    pc.extra_generation_params["Y Values"] = y_values
+                    if y_opt.label in ["Seed", "Var. seed"] and not no_fixed_seeds:
+                        pc.extra_generation_params["Fixed Y Values"] = ", ".join([str(y) for y in ys])
+
+                grid_infotext[subgrid_index] = processing.create_infotext(pc, pc.all_prompts, pc.all_seeds, pc.all_subseeds)
+
+            # Sets main grid infotext
+            if grid_infotext[0] is None and ix == 0 and iy == 0 and iz == 0:
+                pc.extra_generation_params = copy(pc.extra_generation_params)
+
+                if z_opt.label != 'Nothing':
+                    pc.extra_generation_params["Z Type"] = z_opt.label
+                    pc.extra_generation_params["Z Values"] = z_values
+                    if z_opt.label in ["Seed", "Var. seed"] and not no_fixed_seeds:
+                        pc.extra_generation_params["Fixed Z Values"] = ", ".join([str(z) for z in zs])
+
+                grid_infotext[0] = processing.create_infotext(pc, pc.all_prompts, pc.all_seeds, pc.all_subseeds)
+
+            return res
+
+        with SharedSettingsStackHelper():
+            processed = draw_xyz_grid(
+                p,
+                xs=xs,
+                ys=ys,
+                zs=zs,
+                x_labels=[x_opt.format_value(p, x_opt, x) for x in xs],
+                y_labels=[y_opt.format_value(p, y_opt, y) for y in ys],
+                z_labels=[z_opt.format_value(p, z_opt, z) for z in zs],
+                cell=cell,
+                draw_legend=draw_legend,
+                include_lone_images=include_lone_images,
+                include_sub_grids=include_sub_grids,
+                first_axes_processed=first_axes_processed,
+                second_axes_processed=second_axes_processed,
+                margin_size=margin_size
+            )
+        
+        # reset loading params to previous state
+        refresh_loading_params_for_xyz_grid()
+
+        if not processed.images:
+            # It broke, no further handling needed.
+            return processed
+
+        z_count = len(zs)
+
+        # Set the grid infotexts to the real ones with extra_generation_params (1 main grid + z_count sub-grids)
+        processed.infotexts[:1 + z_count] = grid_infotext[:1 + z_count]
+
+        if not include_lone_images:
+            # Don't need sub-images anymore, drop from list:
+            processed.images = processed.images[:z_count + 1]
+
+        if opts.grid_save:
+            # Auto-save main and sub-grids:
+            grid_count = z_count + 1 if z_count > 1 else 1
+            for g in range(grid_count):
+                # TODO: See previous comment about intentional data misalignment.
+                adj_g = g - 1 if g > 0 else g
+                images.save_image(processed.images[g], p.outpath_grids, "xyz_grid", info=processed.infotexts[g], extension=opts.grid_format, prompt=processed.all_prompts[adj_g], seed=processed.all_seeds[adj_g], grid=True, p=processed)
+                if not include_sub_grids:  # if not include_sub_grids then skip saving after the first grid
+                    break
+
+        if not include_sub_grids:
+            # Done with sub-grids, drop all related information:
+            for _ in range(z_count):
+                del processed.images[1]
+                del processed.all_prompts[1]
+                del processed.all_seeds[1]
+                del processed.infotexts[1]
+
+        return processed