Upload png_model_grid.py

png_model_grid.py

@@ -0,0 +1,156 @@
+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 os
+
+import modules.scripts as scripts
+import gradio as gr
+from modules import images, sd_samplers
+from modules.paths import models_path
+from modules.hypernetworks import hypernetwork
+from modules.processing import process_images, Processed, StableDiffusionProcessingTxt2Img
+from modules.shared import opts, cmd_opts, state
+import modules.shared as shared
+import modules.sd_samplers
+import modules.sd_models
+import modules.generation_parameters_copypaste as parameters_copypaste
+
+
+def edit_prompt(p,x):
+    img = Image.open(x)
+    params={}
+    params["Prompt"] = ""
+    params["Negative prompt"] = ""
+    params["Seed"] = ""
+    if img.text['parameters']:
+        params = parameters_copypaste.parse_generation_parameters(img.text['parameters'])
+
+
+
+    p.prompt = params["Prompt"]
+    p.negative_prompt = params["Negative prompt"]
+    p.seed = params["Seed"]
+    
+    
+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}")
+    modules.sd_models.reload_model_weights(shared.sd_model, info)
+
+def confirm_checkpoints(p, xs):
+    for x in xs:
+        print(f'confirm_checkpoint {x}')
+        if modules.sd_models.get_closet_checkpoint_match(x) is None:
+            raise RuntimeError(f"Unknown checkpoint: {x}")
+
+
+
+def draw_xy_grid(p, input_dir, ms, cell):
+    ps = os.listdir(input_dir)
+
+    ver_texts = [[images.GridAnnotation(y)] for y in ms]
+    hor_texts = [[images.GridAnnotation(x)] for x in ps]
+
+    # Temporary list of all the images that are generated to be populated into the grid.
+    # Will be filled with empty images for any individual step that fails to process properly
+    image_cache = []
+
+    processed_result = None
+    cell_mode = "P"
+    cell_size = (1,1)
+
+    state.job_count = len(ms) * len(ps) * p.n_iter
+
+    for iy, y in enumerate(ms):
+        for ix, x in enumerate(ps):
+            state.job = f"{ix + iy * len(ps) + 1} out of {len(ps) * len(ms)}"
+            processed:Processed = cell(os.path.join(input_dir,x), y)
+            try:
+                # this dereference will throw an exception if the image was not processed
+                # (this happens in cases such as if the user stops the process from the UI)
+                processed_image = processed.images[0]
+                
+                if processed_result is None:
+                    # Use our first valid processed result as a template container to hold our full results
+                    processed_result = copy(processed)
+                    cell_mode = processed_image.mode
+                    cell_size = processed_image.size
+                    processed_result.images = [Image.new(cell_mode, cell_size)]
+
+                image_cache.append(processed_image)
+
+            except:
+                image_cache.append(Image.new(cell_mode, cell_size))
+
+    if not processed_result:
+        print("Unexpected error: draw_xy_grid failed to return even a single processed image")
+        return Processed()
+
+    grid = images.image_grid(image_cache, rows=len(ms))
+    grid = images.draw_grid_annotations(grid, cell_size[0], cell_size[1], hor_texts, ver_texts)
+
+    processed_result.images[0] = grid
+
+    return processed_result
+
+
+
+class SharedSettingsStackHelper(object):
+    def __enter__(self):
+        self.CLIP_stop_at_last_layers = opts.CLIP_stop_at_last_layers
+        self.vae = opts.sd_vae
+  
+    def __exit__(self, exc_type, exc_value, tb):
+        opts.data["sd_vae"] = self.vae
+        modules.sd_models.reload_model_weights()
+        modules.sd_vae.reload_vae_weights()
+
+        opts.data["CLIP_stop_at_last_layers"] = self.CLIP_stop_at_last_layers
+        
+
+class Script(scripts.Script):
+    def title(self):
+        return "PNG/Model Grid"
+
+    def ui(self, is_img2img):
+
+        with gr.Row():
+            input_dir = gr.Textbox(label="PNG input dir", lines=1)
+        with gr.Row():
+            models = gr.Textbox(label="Checkpoint names", lines=1)
+
+        return [input_dir ,models]
+
+    def run(self, p, input_dir ,models):
+
+        p.batch_count = 1
+        p.batch_size = 1
+
+        ms = [x.strip() for x in chain.from_iterable(csv.reader(StringIO(models)))]
+
+        confirm_checkpoints(p,ms)
+        
+        def cell(x, y):
+            pc = copy(p)
+            edit_prompt(pc, x)
+            apply_checkpoint(pc, y, ms)
+            return process_images(pc)
+
+        with SharedSettingsStackHelper():
+            processed = draw_xy_grid(
+                p,
+                input_dir=input_dir,
+                ms=ms,
+                cell=cell
+            )
+
+        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)
+
+        return processed