Upload 9 files

scripts/custom_code.py

@@ -0,0 +1,42 @@
+import modules.scripts as scripts
+import gradio as gr
+
+from modules.processing import Processed
+from modules.shared import opts, cmd_opts, state
+
+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):
+        code = gr.Textbox(label="Python code", visible=False, lines=1)
+
+        return [code]
+
+
+    def run(self, p, code):
+        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
+        compiled = compile(code, '', 'exec')
+        module = ModuleType("testmodule")
+        module.__dict__.update(globals())
+        module.p = p
+        module.display = display
+        exec(compiled, module.__dict__)
+
+        return Processed(p, *display_result_data)
+    
+    

scripts/img2imgalt.py

@@ -0,0 +1,183 @@
+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, prompt_parser
+from modules.processing import Processed
+from modules.shared import opts, cmd_opts, state
+
+import torch
+import k_diffusion as K
+
+from PIL import Image
+from torch import autocast
+from einops import rearrange, repeat
+
+
+def find_noise_for_image(p, cond, uncond, cfg_scale, steps):
+    x = p.init_latent
+
+    s_in = x.new_ones([x.shape[0]])
+    dnw = K.external.CompVisDenoiser(shared.sd_model)
+    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])
+
+        c_out, c_in = [K.utils.append_dims(k, x_in.ndim) for k in dnw.get_scalings(sigma_in)]
+        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.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]])
+    dnw = K.external.CompVisDenoiser(shared.sd_model)
+    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])
+
+        c_out, c_in = [K.utils.append_dims(k, x_in.ndim) for k in dnw.get_scalings(sigma_in)]
+
+        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.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):
+        original_prompt = gr.Textbox(label="Original prompt", lines=1)
+        original_negative_prompt = gr.Textbox(label="Original negative prompt", lines=1)
+        cfg = gr.Slider(label="Decode CFG scale", minimum=0.0, maximum=15.0, step=0.1, value=1.0)
+        st = gr.Slider(label="Decode steps", minimum=1, maximum=150, step=1, value=50)
+        randomness = gr.Slider(label="Randomness", minimum=0.0, maximum=1.0, step=0.01, value=0.0)
+        sigma_adjustment = gr.Checkbox(label="Sigma adjustment for finding noise for image", value=False)
+        return [original_prompt, original_negative_prompt, cfg, st, randomness, sigma_adjustment]
+
+    def run(self, p, original_prompt, original_negative_prompt, cfg, st, randomness, sigma_adjustment):
+        p.batch_size = 1
+        p.batch_count = 1
+
+
+        def sample_extra(conditioning, unconditional_conditioning, seeds, subseeds, subseed_strength):
+            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:], [p.seed + x + 1 for x in range(p.init_latent.shape[0])])
+            
+            combined_noise = ((1 - randomness) * rec_noise + randomness * rand_noise) / ((randomness**2 + (1-randomness)**2) ** 0.5)
+            
+            sampler = sd_samplers.create_sampler_with_index(sd_samplers.samplers, p.sampler_index, 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)
+
+        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,83 @@
+import numpy as np
+from tqdm import trange
+
+import modules.scripts as scripts
+import gradio as gr
+
+from modules import processing, shared, sd_samplers, images
+from modules.processing import Processed
+from modules.sd_samplers import samplers
+from modules.shared import opts, cmd_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)
+        denoising_strength_change_factor = gr.Slider(minimum=0.9, maximum=1.1, step=0.01, label='Denoising strength change factor', value=1)
+
+        return [loops, denoising_strength_change_factor]
+
+    def run(self, p, loops, denoising_strength_change_factor):
+        processing.fix_seed(p)
+        batch_count = p.n_iter
+        p.extra_generation_params = {
+            "Denoising strength change factor": denoising_strength_change_factor,
+        }
+
+        p.batch_size = 1
+        p.n_iter = 1
+
+        output_images, info = None, None
+        initial_seed = None
+        initial_info = None
+
+        grids = []
+        all_images = []
+        state.job_count = loops * batch_count
+
+        initial_color_corrections = [processing.setup_color_correction(p.init_images[0])]
+
+        for n in range(batch_count):
+            history = []
+
+            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
+
+                state.job = f"Iteration {i + 1}/{loops}, batch {n + 1}/{batch_count}"
+
+                processed = processing.process_images(p)
+
+                if initial_seed is None:
+                    initial_seed = processed.seed
+                    initial_info = processed.info
+
+                init_img = processed.images[0]
+
+                p.init_images = [init_img]
+                p.seed = processed.seed + 1
+                p.denoising_strength = min(max(p.denoising_strength * denoising_strength_change_factor, 0.1), 1)
+                history.append(processed.images[0])
+
+            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)
+
+            grids.append(grid)
+            all_images += history
+
+        if opts.return_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,262 @@
+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, processing, devices
+from modules.processing import Processed, process_images
+from modules.shared import opts, cmd_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 = _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 tieing 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)
+        mask_blur = gr.Slider(label='Mask blur', minimum=0, maximum=64, step=1, value=8, visible=False)
+        direction = gr.CheckboxGroup(label="Outpainting direction", choices=['left', 'right', 'up', 'down'], value=['left', 'right', 'up', 'down'])
+        noise_q = gr.Slider(label="Fall-off exponent (lower=higher detail)", minimum=0.0, maximum=4.0, step=0.01, value=1.0)
+        color_variation = gr.Slider(label="Color variation", minimum=0.0, maximum=1.0, step=0.01, value=0.05)
+
+        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.mask_blur = mask_blur*4
+        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
+
+        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
+
+        init_image = p.init_images[0]
+
+        state.job_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)
+
+        def expand(init, 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
+
+            res_w = init.width + pixels_horiz
+            res_h = init.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, (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 if is_left else 0,
+                expand_pixels + mask_blur if is_top else 0,
+                mask.width - expand_pixels - mask_blur if is_right else res_w,
+                mask.height - expand_pixels - mask_blur 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)
+            out = Image.fromarray(np.clip(noised * 255., 0., 255.).astype(np.uint8), mode="RGB")
+
+            target_width = min(process_width, init.width + pixels_horiz) if is_horiz else img.width
+            target_height = min(process_height, init.height + pixels_vert) if is_vert else img.height
+
+            crop_region = (
+                0 if is_left else out.width - target_width,
+                0 if is_top else out.height - target_height,
+                target_width if is_left else out.width,
+                target_height if is_top else out.height,
+            )
+
+            image_to_process = out.crop(crop_region)
+            mask = mask.crop(crop_region)
+
+            p.width = target_width if is_horiz else img.width
+            p.height = target_height if is_vert else img.height
+            p.init_images = [image_to_process]
+            p.image_mask = mask
+
+            latent_mask = Image.new("RGB", (p.width, p.height), "white")
+            draw = ImageDraw.Draw(latent_mask)
+            draw.rectangle((
+                expand_pixels + mask_blur * 2 if is_left else 0,
+                expand_pixels + mask_blur * 2 if is_top else 0,
+                mask.width - expand_pixels - mask_blur * 2 if is_right else res_w,
+                mask.height - expand_pixels - mask_blur * 2 if is_bottom else res_h,
+            ), fill="black")
+            p.latent_mask = latent_mask
+
+            proc = process_images(p)
+            proc_img = proc.images[0]
+
+            if initial_seed_and_info[0] is None:
+                initial_seed_and_info[0] = proc.seed
+                initial_seed_and_info[1] = proc.info
+
+            out.paste(proc_img, (0 if is_left else out.width - proc_img.width, 0 if is_top else out.height - proc_img.height))
+            out = out.crop((0, 0, res_w, res_h))
+            return out
+
+        img = init_image
+
+        if left > 0:
+            img = expand(img, left, is_left=True)
+        if right > 0:
+            img = expand(img, right, is_right=True)
+        if up > 0:
+            img = expand(img, up, is_top=True)
+        if down > 0:
+            img = expand(img, down, is_bottom=True)
+
+        res = Processed(p, [img], initial_seed_and_info[0], initial_seed_and_info[1])
+
+        if opts.samples_save:
+            images.save_image(img, p.outpath_samples, "", res.seed, p.prompt, opts.grid_format, info=res.info, p=p)
+
+        return res
+

scripts/poor_mans_outpainting.py

@@ -0,0 +1,147 @@
+import math
+
+import modules.scripts as scripts
+import gradio as gr
+from PIL import Image, ImageDraw
+
+from modules import images, processing, devices
+from modules.processing import Processed, process_images
+from modules.shared import opts, cmd_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)
+        mask_blur = gr.Slider(label='Mask blur', minimum=0, maximum=64, step=1, value=4, visible=False)
+        inpainting_fill = gr.Radio(label='Masked content', choices=['fill', 'original', 'latent noise', 'latent nothing'], value='fill', type="index", visible=False)
+        direction = gr.CheckboxGroup(label="Outpainting direction", choices=['left', 'right', 'up', 'down'], value=['left', 'right', 'up', 'down'])
+
+        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.grid_format, info=initial_info, p=p)
+
+        processed = Processed(p, [combined_image], initial_seed, initial_info)
+
+        return processed
+

scripts/prompt_matrix.py

@@ -0,0 +1,87 @@
+import math
+from collections import namedtuple
+from copy import copy
+import random
+
+import modules.scripts as scripts
+import gradio as gr
+
+from modules import images
+from modules.processing import process_images, Processed
+from modules.shared import opts, cmd_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_pocessed = 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_pocessed is None:
+                first_pocessed = 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_pocessed.images = [grid]
+
+    return first_pocessed
+
+
+class Script(scripts.Script):
+    def title(self):
+        return "Prompt matrix"
+
+    def ui(self, is_img2img):
+        put_at_start = gr.Checkbox(label='Put variable parts at start of prompt', value=False)
+
+        return [put_at_start]
+
+    def run(self, p, put_at_start):
+        modules.processing.fix_seed(p)
+
+        original_prompt = p.prompt[0] if type(p.prompt) == list else p.prompt
+
+        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(", ".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.")
+
+        p.prompt = all_prompts
+        p.seed = [p.seed for _ in all_prompts]
+        p.prompt_for_display = original_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, p.width, p.height, prompt_matrix_parts)
+        processed.images.insert(0, grid)
+
+        if opts.grid_save:
+            images.save_image(processed.images[0], p.outpath_grids, "prompt_matrix", prompt=original_prompt, seed=processed.seed, grid=True, p=p)
+
+        return processed

scripts/prompts_from_file.py

@@ -0,0 +1,55 @@
+import math
+import os
+import sys
+import traceback
+
+import modules.scripts as scripts
+import gradio as gr
+
+from modules.processing import Processed, process_images
+from PIL import Image
+from modules.shared import opts, cmd_opts, state
+
+
+class Script(scripts.Script):
+    def title(self):
+        return "Prompts from file or textbox"
+
+    def ui(self, is_img2img):
+        # This checkbox would look nicer as two tabs, but there are two problems:
+        # 1) There is a bug in Gradio 3.3 that prevents visibility from working on Tabs
+        # 2) Even with Gradio 3.3.1, returning a control (like Tabs) that can't be used as input
+        #    causes a AttributeError: 'Tabs' object has no attribute 'preprocess' assert,
+        #    due to the way Script assumes all controls returned can be used as inputs.
+        # Therefore, there's no good way to use grouping components right now,
+        # so we will use a checkbox! :)
+        checkbox_txt = gr.Checkbox(label="Show Textbox", value=False)
+        file = gr.File(label="File with inputs", type='bytes')
+        prompt_txt = gr.TextArea(label="Prompts")
+        checkbox_txt.change(fn=lambda x: [gr.File.update(visible = not x), gr.TextArea.update(visible = x)], inputs=[checkbox_txt], outputs=[file, prompt_txt])
+        return [checkbox_txt, file, prompt_txt]
+
+    def run(self, p, checkbox_txt, data: bytes, prompt_txt: str):
+        if (checkbox_txt):
+            lines = [x.strip() for x in prompt_txt.splitlines()]
+        else:
+            lines = [x.strip() for x in data.decode('utf8', errors='ignore').split("\n")]
+        lines = [x for x in lines if len(x) > 0]
+
+        img_count = len(lines) * p.n_iter
+        batch_count = math.ceil(img_count / p.batch_size)
+        loop_count = math.ceil(batch_count / p.n_iter)
+        print(f"Will process {img_count} images in {batch_count} batches.")
+
+        p.do_not_save_grid = True
+
+        state.job_count = batch_count
+
+        images = []
+        for loop_no in range(loop_count):
+            state.job = f"{loop_no + 1} out of {loop_count}"
+            p.prompt = lines[loop_no*p.batch_size:(loop_no+1)*p.batch_size] * p.n_iter
+            proc = process_images(p)
+            images += proc.images
+
+        return Processed(p, images, p.seed, "")

scripts/sd_upscale.py

@@ -0,0 +1,97 @@
+import math
+
+import modules.scripts as scripts
+import gradio as gr
+from PIL import Image
+
+from modules import processing, shared, sd_samplers, images, devices
+from modules.processing import Processed
+from modules.shared import opts, cmd_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 to twice the dimensions; use width and height sliders to set tile size</p>")
+        overlap = gr.Slider(minimum=0, maximum=256, step=16, label='Tile overlap', value=64, visible=False)
+        upscaler_index = gr.Radio(label='Upscaler', choices=[x.name for x in shared.sd_upscalers], value=shared.sd_upscalers[0].name, type="index", visible=False)
+
+        return [info, overlap, upscaler_index]
+
+    def run(self, p, _, overlap, upscaler_index):
+        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]
+        
+        if(upscaler.name != "None"): 
+            img = upscaler.scaler.upscale(init_img, 2, 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/xy_grid.py

@@ -0,0 +1,313 @@
+from collections import namedtuple
+from copy import copy
+from itertools import permutations, chain
+import random
+import csv
+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
+from modules.processing import process_images, Processed
+from modules.shared import opts, cmd_opts, state
+import modules.shared as shared
+import modules.sd_samplers
+import modules.sd_models
+import re
+
+
+def apply_field(field):
+    def fun(p, x, xs):
+        setattr(p, field, x)
+
+    return fun
+
+
+def apply_prompt(p, x, xs):
+    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 = []
+
+    # Initally 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
+    
+
+samplers_dict = {}
+for i, sampler in enumerate(modules.sd_samplers.samplers):
+    samplers_dict[sampler.name.lower()] = i
+    for alias in sampler.aliases:
+        samplers_dict[alias.lower()] = i
+
+
+def apply_sampler(p, x, xs):
+    sampler_index = samplers_dict.get(x.lower(), None)
+    if sampler_index is None:
+        raise RuntimeError(f"Unknown sampler: {x}")
+
+    p.sampler_index = sampler_index
+
+
+def apply_checkpoint(p, x, xs):
+    info = modules.sd_models.get_closet_checkpoint_match(x)
+    assert info is not None, f'Checkpoint for {x} not found'
+    modules.sd_models.reload_model_weights(shared.sd_model, info)
+
+
+def apply_hypernetwork(p, x, xs):
+    hn = shared.hypernetworks.get(x, None)
+    opts.data["sd_hypernetwork"] = hn.name if hn is not None else 'None'
+
+
+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 str_permutations(x):
+    """dummy function for specifying it in AxisOption's type when you want to get a list of permutations"""
+    return x
+
+
+AxisOption = namedtuple("AxisOption", ["label", "type", "apply", "format_value"])
+AxisOptionImg2Img = namedtuple("AxisOptionImg2Img", ["label", "type", "apply", "format_value"])
+
+
+axis_options = [
+    AxisOption("Nothing", str, do_nothing, format_nothing),
+    AxisOption("Seed", int, apply_field("seed"), format_value_add_label),
+    AxisOption("Var. seed", int, apply_field("subseed"), format_value_add_label),
+    AxisOption("Var. strength", float, apply_field("subseed_strength"), format_value_add_label),
+    AxisOption("Steps", int, apply_field("steps"), format_value_add_label),
+    AxisOption("CFG Scale", float, apply_field("cfg_scale"), format_value_add_label),
+    AxisOption("Prompt S/R", str, apply_prompt, format_value),
+    AxisOption("Prompt order", str_permutations, apply_order, format_value_join_list),
+    AxisOption("Sampler", str, apply_sampler, format_value),
+    AxisOption("Checkpoint name", str, apply_checkpoint, format_value),
+    AxisOption("Hypernetwork", str, apply_hypernetwork, format_value),
+    AxisOption("Sigma Churn", float, apply_field("s_churn"), format_value_add_label),
+    AxisOption("Sigma min", float, apply_field("s_tmin"), format_value_add_label),
+    AxisOption("Sigma max", float, apply_field("s_tmax"), format_value_add_label),
+    AxisOption("Sigma noise", float, apply_field("s_noise"), format_value_add_label),
+    AxisOption("Eta", float, apply_field("eta"), format_value_add_label),
+    AxisOptionImg2Img("Denoising", float, apply_field("denoising_strength"), format_value_add_label),  # as it is now all AxisOptionImg2Img items must go after AxisOption ones
+]
+
+
+def draw_xy_grid(p, xs, ys, x_labels, y_labels, cell, draw_legend):
+    res = []
+
+    ver_texts = [[images.GridAnnotation(y)] for y in y_labels]
+    hor_texts = [[images.GridAnnotation(x)] for x in x_labels]
+
+    first_pocessed = None
+
+    state.job_count = len(xs) * len(ys) * p.n_iter
+
+    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_pocessed is None:
+                first_pocessed = processed
+
+            try:
+              res.append(processed.images[0])
+            except:
+              res.append(Image.new(res[0].mode, res[0].size))
+
+    grid = images.image_grid(res, rows=len(ys))
+    if draw_legend:
+        grid = images.draw_grid_annotations(grid, res[0].width, res[0].height, hor_texts, ver_texts)
+
+    first_pocessed.images = [grid]
+
+    return first_pocessed
+
+
+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 plot"
+
+    def ui(self, is_img2img):
+        current_axis_options = [x for x in axis_options if type(x) == AxisOption or type(x) == AxisOptionImg2Img and is_img2img]
+
+        with gr.Row():
+            x_type = gr.Dropdown(label="X type", choices=[x.label for x in current_axis_options], value=current_axis_options[1].label, visible=False, type="index", elem_id="x_type")
+            x_values = gr.Textbox(label="X values", visible=False, lines=1)
+
+        with gr.Row():
+            y_type = gr.Dropdown(label="Y type", choices=[x.label for x in current_axis_options], value=current_axis_options[4].label, visible=False, type="index", elem_id="y_type")
+            y_values = gr.Textbox(label="Y values", visible=False, lines=1)
+        
+        draw_legend = gr.Checkbox(label='Draw legend', value=True)
+        no_fixed_seeds = gr.Checkbox(label='Keep -1 for seeds', value=False)
+
+        return [x_type, x_values, y_type, y_values, draw_legend, no_fixed_seeds]
+
+    def run(self, p, x_type, x_values, y_type, y_values, draw_legend, no_fixed_seeds):
+        modules.processing.fix_seed(p)
+        p.batch_size = 1
+
+        initial_hn = opts.sd_hypernetwork
+
+        def process_axis(opt, vals):
+            if opt.label == 'Nothing':
+                return [0]
+
+            valslist = [x.strip() for x in chain.from_iterable(csv.reader(StringIO(vals)))]
+
+            if opt.type == int:
+                valslist_ext = []
+
+                for val in valslist:
+                    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:
+                    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]
+
+            return valslist
+
+        x_opt = axis_options[x_type]
+        xs = process_axis(x_opt, x_values)
+
+        y_opt = axis_options[y_type]
+        ys = process_axis(y_opt, y_values)
+
+        def fix_axis_seeds(axis_opt, axis_list):
+            if axis_opt.label == '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)
+
+        if x_opt.label == 'Steps':
+            total_steps = sum(xs) * len(ys)
+        elif y_opt.label == 'Steps':
+            total_steps = sum(ys) * len(xs)
+        else:
+            total_steps = p.steps * len(xs) * len(ys)
+
+        print(f"X/Y plot will create {len(xs) * len(ys) * p.n_iter} images on a {len(xs)}x{len(ys)} grid. (Total steps to process: {total_steps * p.n_iter})")
+        shared.total_tqdm.updateTotal(total_steps * p.n_iter)
+
+        def cell(x, y):
+            pc = copy(p)
+            x_opt.apply(pc, x, xs)
+            y_opt.apply(pc, y, ys)
+
+            return process_images(pc)
+
+        processed = draw_xy_grid(
+            p,
+            xs=xs,
+            ys=ys,
+            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],
+            cell=cell,
+            draw_legend=draw_legend
+        )
+
+        if opts.grid_save:
+            images.save_image(processed.images[0], p.outpath_grids, "xy_grid", prompt=p.prompt, seed=processed.seed, grid=True, p=p)
+
+        # restore checkpoint in case it was changed by axes
+        modules.sd_models.reload_model_weights(shared.sd_model)
+
+        opts.data["sd_hypernetwork"] = initial_hn
+
+        return processed