Merge branch 'dev' into Branch_AddNewFilenameGen

5 files changed, 234 insertions, 94 deletions

diff --git a/scripts/custom_code.py b/scripts/custom_code.py
index d29113e6..4071d86d 100644
--- a/scripts/custom_code.py
+++ b/scripts/custom_code.py
@@ -1,9 +1,40 @@
 import modules.scripts as scripts

 import gradio as gr

+import ast

+import copy

 

 from modules.processing import Processed

 from modules.shared import opts, cmd_opts, state

 

+

+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):

@@ -13,12 +44,23 @@ class Script(scripts.Script):
         return cmd_opts.allow_code

 

     def ui(self, is_img2img):

-        code = gr.Textbox(label="Python code", lines=1, elem_id=self.elem_id("code"))

+        example = """from modules.processing import process_images

+

+p.width = 768

+p.height = 768

+p.batch_size = 2

+p.steps = 10

+

+return process_images(p)

+"""

+

 

-        return [code]

+        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):

+    def run(self, p, code, indent_level):

         assert cmd_opts.allow_code, '--allow-code option must be enabled'

 

         display_result_data = [[], -1, ""]

@@ -29,13 +71,20 @@ class Script(scripts.Script):
             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__)

+

+        indent = " " * indent_level

+        indented = code.replace('\n', '\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)

-    

-    
\ No newline at end of file
diff --git a/scripts/img2imgalt.py b/scripts/img2imgalt.py
index 2572443f..bb00fb3f 100644
--- a/scripts/img2imgalt.py
+++ b/scripts/img2imgalt.py
@@ -6,23 +6,21 @@ from tqdm import trange
 import modules.scripts as scripts

 import gradio as gr

 

-from modules import processing, shared, sd_samplers, prompt_parser, sd_samplers_common

-from modules.processing import Processed

-from modules.shared import opts, cmd_opts, state

+from modules import processing, shared, sd_samplers, sd_samplers_common

 

 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)

+    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

@@ -37,7 +35,7 @@ def find_noise_for_image(p, cond, uncond, cfg_scale, steps):
         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)]

+        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)

@@ -69,7 +67,12 @@ 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)

+    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

@@ -84,7 +87,7 @@ def find_noise_for_image_sigma_adjustment(p, cond, uncond, cfg_scale, steps):
         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)]

+        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))

@@ -125,7 +128,7 @@ class Script(scripts.Script):
     def show(self, is_img2img):

         return is_img2img

 

-    def ui(self, is_img2img):     

+    def ui(self, is_img2img):

         info = gr.Markdown('''

         * `CFG Scale` should be 2 or lower.

         ''')

@@ -213,4 +216,3 @@ class Script(scripts.Script):
         processed = processing.process_images(p)

 

         return processed

-

diff --git a/scripts/loopback.py b/scripts/loopback.py
index ec1f85e5..d3065fe6 100644
--- a/scripts/loopback.py
+++ b/scripts/loopback.py
@@ -1,14 +1,10 @@
-import numpy as np

-from tqdm import trange

+import math

 

-import modules.scripts as scripts

 import gradio as gr

-

-from modules import processing, shared, sd_samplers, images

+import modules.scripts as scripts

+from modules import deepbooru, images, processing, shared

 from modules.processing import Processed

-from modules.sd_samplers import samplers

-from modules.shared import opts, cmd_opts, state

-from modules import deepbooru

+from modules.shared import opts, state

 

 

 class Script(scripts.Script):

@@ -20,39 +16,65 @@ class Script(scripts.Script):
 

     def ui(self, is_img2img):        

         loops = gr.Slider(minimum=1, maximum=32, step=1, label='Loops', value=4, elem_id=self.elem_id("loops"))

-        denoising_strength_change_factor = gr.Slider(minimum=0.9, maximum=1.1, step=0.01, label='Denoising strength change factor', value=1, elem_id=self.elem_id("denoising_strength_change_factor"))

+        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, denoising_strength_change_factor, append_interrogation]

+        return [loops, final_denoising_strength, denoising_curve, append_interrogation]

 

-    def run(self, p, loops, denoising_strength_change_factor, 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 = {

-            "Denoising strength change factor": denoising_strength_change_factor,

+            "Final denoising strength": final_denoising_strength,

+            "Denoising curve": denoising_curve

         }

 

         p.batch_size = 1

         p.n_iter = 1

 

-        output_images, info = None, None

+        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])]

 

-        for n in range(batch_count):

-            history = []

+        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

@@ -72,26 +94,46 @@ class Script(scripts.Script):
 

                 processed = processing.process_images(p)

 

+                # Generation cancelled.

+                if state.interrupted:

+                    break

+

                 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])

+                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:

+                    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)

 

-            grids.append(grid)

-            all_images += history

-

-        if opts.return_grid:

-            all_images = grids + all_images

+            if opts.return_grid:

+                grids.append(grid)

+                

+        all_images = grids + all_images

 

         processed = Processed(p, all_images, initial_seed, initial_info)

 

diff --git a/scripts/postprocessing_upscale.py b/scripts/postprocessing_upscale.py
index 8842bd91..ef1186ac 100644
--- a/scripts/postprocessing_upscale.py
+++ b/scripts/postprocessing_upscale.py
@@ -4,8 +4,8 @@ import numpy as np
 from modules import scripts_postprocessing, shared

 import gradio as gr

 

-from modules.ui_components import FormRow

-

+from modules.ui_components import FormRow, ToolButton

+from modules.ui import switch_values_symbol

 

 upscale_cache = {}

 

@@ -17,23 +17,29 @@ class ScriptPostprocessingUpscale(scripts_postprocessing.ScriptPostprocessing):
     def ui(self):

         selected_tab = gr.State(value=0)

 

-        with gr.Tabs(elem_id="extras_resize_mode"):

-            with gr.TabItem('Scale by', elem_id="extras_scale_by_tab") as tab_scale_by:

-                upscaling_resize = gr.Slider(minimum=1.0, maximum=8.0, step=0.05, label="Resize", value=4, elem_id="extras_upscaling_resize")

-

-            with gr.TabItem('Scale to', elem_id="extras_scale_to_tab") as tab_scale_to:

-                with FormRow():

-                    upscaling_resize_w = gr.Number(label="Width", value=512, precision=0, elem_id="extras_upscaling_resize_w")

-                    upscaling_resize_h = gr.Number(label="Height", value=512, precision=0, elem_id="extras_upscaling_resize_h")

-                    upscaling_crop = gr.Checkbox(label='Crop to fit', value=True, elem_id="extras_upscaling_crop")

-

-        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 gr.Column():

+            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:

+                        upscaling_resize = gr.Slider(minimum=1.0, maximum=8.0, step=0.05, label="Resize", value=4, elem_id="extras_upscaling_resize")

+

+                    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=2048, step=8, label="Width", value=512, elem_id="extras_upscaling_resize_w")

+                                upscaling_resize_h = gr.Slider(minimum=64, maximum=2048, 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")

+                                upscaling_crop = gr.Checkbox(label='Crop to fit', value=True, elem_id="extras_upscaling_crop")

+

+            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")

+

+        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])

 

diff --git a/scripts/xyz_grid.py b/scripts/xyz_grid.py
index ce584981..52ae1c6e 100644
--- a/scripts/xyz_grid.py
+++ b/scripts/xyz_grid.py
@@ -247,7 +247,7 @@ def draw_xyz_grid(p, xs, ys, zs, x_labels, y_labels, z_labels, cell, draw_legend
 

         state.job = f"{index(ix, iy, iz) + 1} out of {list_size}"

 

-        processed: Processed = cell(x, y, z)

+        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

@@ -374,16 +374,19 @@ class Script(scripts.Script):
                 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"):

@@ -401,54 +404,74 @@ class Script(scripts.Script):
             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, axis2_type, axis2_values):

-            return self.current_axis_options[axis2_type].label, axis2_values, self.current_axis_options[axis1_type].label, axis1_values

+        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, y_type, y_values]

+        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, z_type, z_values]

+        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, z_type, z_values]

+        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(x_type):

             axis = self.current_axis_options[x_type]

-            return ", ".join(axis.choices()) if axis.choices else gr.update()

-

-        fill_x_button.click(fn=fill, inputs=[x_type], outputs=[x_values])

-        fill_y_button.click(fn=fill, inputs=[y_type], outputs=[y_values])

-        fill_z_button.click(fn=fill, inputs=[z_type], outputs=[z_values])

-

-        def select_axis(x_type):

-            return gr.Button.update(visible=self.current_axis_options[x_type].choices is not None)

-

-        x_type.change(fn=select_axis, inputs=[x_type], outputs=[fill_x_button])

-        y_type.change(fn=select_axis, inputs=[y_type], outputs=[fill_y_button])

-        z_type.change(fn=select_axis, inputs=[z_type], outputs=[fill_z_button])

+            return axis.choices() if axis.choices else gr.update()

+

+        fill_x_button.click(fn=fill, inputs=[x_type], outputs=[x_values_dropdown])

+        fill_y_button.click(fn=fill, inputs=[y_type], outputs=[y_values_dropdown])

+        fill_z_button.click(fn=fill, inputs=[z_type], outputs=[z_values_dropdown])

+

+        def select_axis(axis_type,axis_values_dropdown):

+            choices = self.current_axis_options[axis_type].choices

+            has_choices = choices is not None

+            current_values = axis_values_dropdown

+            if has_choices:

+                choices = choices()

+                if isinstance(current_values,str):

+                    current_values = current_values.split(",")

+                current_values = list(filter(lambda x: x in choices, current_values))

+            return gr.Button.update(visible=has_choices),gr.Textbox.update(visible=not has_choices),gr.update(choices=choices if has_choices else None,visible=has_choices,value=current_values)

+

+        x_type.change(fn=select_axis, inputs=[x_type,x_values_dropdown], outputs=[fill_x_button,x_values,x_values_dropdown])

+        y_type.change(fn=select_axis, inputs=[y_type,y_values_dropdown], outputs=[fill_y_button,y_values,y_values_dropdown])

+        z_type.change(fn=select_axis, inputs=[z_type,z_values_dropdown], outputs=[fill_z_button,z_values,z_values_dropdown])

+

+        def get_dropdown_update_from_params(axis,params):

+            val_key = axis + " Values"

+            vals = params.get(val_key,"")

+            valslist = [x.strip() for x in chain.from_iterable(csv.reader(StringIO(vals))) if x]

+            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, y_type, y_values, z_type, z_values, draw_legend, include_lone_images, include_sub_grids, no_fixed_seeds, margin_size]

+        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, margin_size]

 

-    def run(self, p, x_type, x_values, y_type, y_values, z_type, z_values, draw_legend, include_lone_images, include_sub_grids, no_fixed_seeds, margin_size):

+    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, margin_size):

         if not no_fixed_seeds:

             modules.processing.fix_seed(p)

 

         if not opts.return_grid:

             p.batch_size = 1

 

-        def process_axis(opt, vals):

+        def process_axis(opt, vals, vals_dropdown):

             if opt.label == 'Nothing':

                 return [0]

 

-            valslist = [x.strip() for x in chain.from_iterable(csv.reader(StringIO(vals))) if x]

+            if opt.choices is not None:

+                valslist = vals_dropdown

+            else:

+                valslist = [x.strip() for x in chain.from_iterable(csv.reader(StringIO(vals))) if x]

 

             if opt.type == int:

                 valslist_ext = []

@@ -506,15 +529,22 @@ class Script(scripts.Script):
             return valslist

 

         x_opt = self.current_axis_options[x_type]

-        xs = process_axis(x_opt, x_values)

+        if x_opt.choices is not None:

+            x_values = ",".join(x_values_dropdown)

+        xs = process_axis(x_opt, x_values, x_values_dropdown)

 

         y_opt = self.current_axis_options[y_type]

-        ys = process_axis(y_opt, y_values)

+        if y_opt.choices is not None:

+            y_values = ",".join(y_values_dropdown)

+        ys = process_axis(y_opt, y_values, y_values_dropdown)

 

         z_opt = self.current_axis_options[z_type]

-        zs = process_axis(z_opt, z_values)

+        if z_opt.choices is not None:

+            z_values = ",".join(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)'

 

@@ -558,8 +588,6 @@ class Script(scripts.Script):
         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)

 

-        grid_infotext = [None]

-

         state.xyz_plot_x = AxisInfo(x_opt, xs)

         state.xyz_plot_y = AxisInfo(y_opt, ys)

         state.xyz_plot_z = AxisInfo(z_opt, zs)

@@ -588,7 +616,9 @@ class Script(scripts.Script):
             else:

                 second_axes_processed = 'y'

 

-        def cell(x, y, z):

+        grid_infotext = [None] * (1 + len(zs))

+

+        def cell(x, y, z, ix, iy, iz):

             if shared.state.interrupted:

                 return Processed(p, [], p.seed, "")

 

@@ -600,7 +630,9 @@ class Script(scripts.Script):
 

             res = process_images(pc)

 

-            if grid_infotext[0] is None:

+            # 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()

 

@@ -616,6 +648,12 @@ class Script(scripts.Script):
                     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

@@ -650,6 +688,9 @@ class Script(scripts.Script):
 

         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]