Revert "Merge branch 'dev' into master"

This reverts commit 4b91ee0044, reversing
changes made to fc7e3c5721.

scripts/loopback.py

@@ -90,7 +90,7 @@ class Script(scripts.Script):
                     elif append_interrogation == "DeepBooru":
                         p.prompt += deepbooru.model.tag(p.init_images[0])
 
-                state.job = f"loopback iteration {i+1}/{loops} batch {n+1}/{batch_count}"
+                state.job = f"Iteration {i + 1}/{loops}, batch {n + 1}/{batch_count}"
 
                 processed = processing.process_images(p)
 

scripts/outpainting_mk_2.py

@@ -23,6 +23,7 @@ def get_matched_noise(_np_src_image, np_mask_rgb, noise_q=1, color_variation=0.0
             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):
@@ -36,11 +37,13 @@ def get_matched_noise(_np_src_image, np_mask_rgb, noise_q=1, color_variation=0.0
             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):
@@ -49,6 +52,7 @@ def get_matched_noise(_np_src_image, np_mask_rgb, noise_q=1, color_variation=0.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.):
@@ -60,45 +64,57 @@ def get_matched_noise(_np_src_image, np_mask_rgb, noise_q=1, color_variation=0.0
         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) # pylint: disable=pointless-statement
     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
     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"
@@ -109,43 +125,56 @@ class Script(scripts.Script):
     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): # pylint: disable=arguments-differ
         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
+
         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):
@@ -153,6 +182,7 @@ class Script(scripts.Script):
                 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")
@@ -163,14 +193,17 @@ class Script(scripts.Script):
                     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)
-                output_images.append(Image.fromarray(np.clip(255.0 * noised, 0.0, 255.0).astype(np.uint8), mode="RGB"))
+                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,
@@ -179,9 +212,12 @@ class Script(scripts.Script):
                 )
                 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((
@@ -191,22 +227,29 @@ class Script(scripts.Script):
                 mask.height - expand_pixels - mask_blur * 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"outpainting batch {i+1}/{batch_count}"
+            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:
@@ -215,15 +258,22 @@ class Script(scripts.Script):
                 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)
         if opts.return_grid and len(all_processed_images) > 1:
             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 len(all_processed_images) > 1:
             images.save_image(combined_grid_image, p.outpath_grids, "grid", res.seed, p.prompt, opts.samples_format, info=res.info, grid=True, p=p)
+
         return res

scripts/poor_mans_outpainting.py

@@ -22,31 +22,40 @@ class Script(scripts.Script):
         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((
@@ -55,6 +64,7 @@ class Script(scripts.Script):
             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((
@@ -63,50 +73,71 @@ class Script(scripts.Script):
              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)
         log.info(f"Poor-man-outpainting: images={len(work)} tiles={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"outpainting batch {i+1}/{batch_count}"
+
+            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

@@ -14,15 +14,22 @@ class ScriptPostprocessingCodeFormer(scripts_postprocessing.ScriptPostprocessing
         with FormRow():
             codeformer_visibility = gr.Slider(minimum=0.0, maximum=1.0, step=0.01, label="Strength", value=0.0, elem_id="extras_codeformer_visibility")
             codeformer_weight = gr.Slider(minimum=0.0, maximum=1.0, step=0.01, label="Weight", value=0.2, elem_id="extras_codeformer_weight")
-        return { "codeformer_visibility": codeformer_visibility, "codeformer_weight": codeformer_weight }
+
+        return {
+            "codeformer_visibility": codeformer_visibility,
+            "codeformer_weight": codeformer_weight,
+        }
 
     def process(self, pp: scripts_postprocessing.PostprocessedImage, codeformer_visibility, codeformer_weight): # pylint: disable=arguments-differ
         if codeformer_visibility == 0:
             return
+
         restored_img = codeformer_model.codeformer.restore(np.array(pp.image, dtype=np.uint8), w=codeformer_weight)
         res = Image.fromarray(restored_img)
+
         if codeformer_visibility < 1.0:
             res = Image.blend(pp.image, res, codeformer_visibility)
+
         pp.image = res
         pp.info["CodeFormer visibility"] = round(codeformer_visibility, 3)
         pp.info["CodeFormer weight"] = round(codeformer_weight, 3)

scripts/postprocessing_gfpgan.py

@@ -13,14 +13,20 @@ class ScriptPostprocessingGfpGan(scripts_postprocessing.ScriptPostprocessing):
     def ui(self):
         with FormRow():
             gfpgan_visibility = gr.Slider(minimum=0.0, maximum=1.0, step=0.001, label="Strength", value=0, elem_id="extras_gfpgan_visibility")
-        return { "gfpgan_visibility": gfpgan_visibility }
 
-    def process(self, pp: scripts_postprocessing.PostprocessedImage, gfpgan_visibility): # pylint: disable=arguments-differ
+        return {
+            "gfpgan_visibility": gfpgan_visibility,
+        }
+
+    def process(self, pp: scripts_postprocessing.PostprocessedImage, gfpgan_visibility):
         if gfpgan_visibility == 0:
             return
+
         restored_img = gfpgan_model.gfpgan_fix_faces(np.array(pp.image, dtype=np.uint8))
         res = Image.fromarray(restored_img)
+
         if gfpgan_visibility < 1.0:
             res = Image.blend(pp.image, res, gfpgan_visibility)
+
         pp.image = res
         pp.info["GFPGAN visibility"] = round(gfpgan_visibility, 3)

scripts/prompt_matrix.py

@@ -45,17 +45,17 @@ class Script(scripts.Script):
         gr.HTML('<br />')
         with gr.Row():
             with gr.Column():
-                put_at_start = gr.Checkbox(label='Set at prompt start', value=False, elem_id=self.elem_id("put_at_start"))
-                different_seeds = gr.Checkbox(label='Random seeds', value=False, elem_id=self.elem_id("different_seeds"))
+                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="Prompt type", elem_id=self.elem_id("prompt_type"), value="positive")
-                variations_delimiter = gr.Radio(["comma", "space"], label="Joining char", elem_id=self.elem_id("variations_delimiter"), value="comma")
+                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", 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): # pylint: disable=arguments-differ
+    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"]:

scripts/sd_upscale.py

@@ -72,7 +72,8 @@ class Script(scripts.Script):
             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"upscale batch {i+1+n*batch_count}/{state.job_count}"
+
+                state.job = f"Batch {i + 1 + n * batch_count} out of {state.job_count}"
                 processed = processing.process_images(p)
 
                 if initial_info is None:

scripts/xyz_grid.py

@@ -268,7 +268,7 @@ def draw_xyz_grid(p, xs, ys, zs, x_labels, y_labels, z_labels, cell, draw_legend
         def index(ix, iy, iz):
             return ix + iy * len(xs) + iz * len(xs) * len(ys)
 
-        shared.state.job = 'grid'
+        shared.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:
             processed_result = copy(processed)