From debf836fcc8d9becc3da8b1a29e33f40b0d9ef3e Mon Sep 17 00:00:00 2001
From: CodeHatchling <steve@codehatch.com>
Date: Tue, 28 Nov 2023 16:15:36 -0700
Subject: Added UI elements to control blending parameters.

---
 scripts/outpainting_mk_2.py      | 10 ++++++++--
 scripts/poor_mans_outpainting.py | 11 +++++++++--
 2 files changed, 17 insertions(+), 4 deletions(-)

(limited to 'scripts')

diff --git a/scripts/outpainting_mk_2.py b/scripts/outpainting_mk_2.py
index c98ab480..6aa97edf 100644
--- a/scripts/outpainting_mk_2.py
+++ b/scripts/outpainting_mk_2.py
@@ -133,13 +133,16 @@ class Script(scripts.Script):
 
         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"))
+        mask_blend_power = gr.Slider(label='Mask blend power', minimum=0, maximum=8, step=0.1, value=1, elem_id=self.elem_id("mask_blend_power"))
+        mask_blend_scale = gr.Slider(label='Mask blend scale', minimum=0, maximum=8, step=0.1, value=1, elem_id=self.elem_id("mask_blend_scale"))
+        mask_blend_offset = gr.Slider(label='Mask blend scale', minimum=-4, maximum=4, step=0.1, value=1, elem_id=self.elem_id("mask_blend_offset"))
         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]
+        return [info, pixels, mask_blur, mask_blend_power, mask_blend_scale, mask_blend_offset, direction, noise_q, color_variation]
 
-    def run(self, p, _, pixels, mask_blur, direction, noise_q, color_variation):
+    def run(self, p, _, pixels, mask_blur, mask_blend_power, mask_blend_scale, mask_blend_offset, direction, noise_q, color_variation):
         initial_seed_and_info = [None, None]
 
         process_width = p.width
@@ -167,6 +170,9 @@ class Script(scripts.Script):
 
         p.mask_blur_x = mask_blur_x*4
         p.mask_blur_y = mask_blur_y*4
+        p.mask_blend_power = mask_blend_power
+        p.mask_blend_scale = mask_blend_scale
+        p.mask_blend_offset = mask_blend_offset
 
         init_img = p.init_images[0]
         target_w = math.ceil((init_img.width + left + right) / 64) * 64
diff --git a/scripts/poor_mans_outpainting.py b/scripts/poor_mans_outpainting.py
index ea0632b6..b10140f1 100644
--- a/scripts/poor_mans_outpainting.py
+++ b/scripts/poor_mans_outpainting.py
@@ -22,16 +22,23 @@ class Script(scripts.Script):
 
         pixels = gr.Slider(label="Pixels to expand", minimum=8, maximum=256, step=8, value=128, elem_id=self.elem_id("pixels"))
         mask_blur = gr.Slider(label='Mask blur', minimum=0, maximum=64, step=1, value=4, elem_id=self.elem_id("mask_blur"))
+        mask_blend_power = gr.Slider(label='Mask blend power', minimum=0, maximum=8, step=0.1, value=1, elem_id=self.elem_id("mask_blend_power"))
+        mask_blend_scale = gr.Slider(label='Mask blend scale', minimum=0, maximum=8, step=0.1, value=1, elem_id=self.elem_id("mask_blend_scale"))
+        mask_blend_offset = gr.Slider(label='Mask blend offset', minimum=-4, maximum=4, step=0.1, value=0, elem_id=self.elem_id("mask_blend_offset"))
         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]
+        return [pixels, mask_blur, mask_blend_power, mask_blend_scale, mask_blend_offset, inpainting_fill, direction]
 
-    def run(self, p, pixels, mask_blur, inpainting_fill, direction):
+    def run(self, p, pixels, mask_blur, mask_blend_power, mask_blend_scale, mask_blend_offset, inpainting_fill, direction):
         initial_seed = None
         initial_info = None
 
         p.mask_blur = mask_blur * 2
+        p.mask_blend_power = mask_blend_power
+        p.mask_blend_scale = mask_blend_scale
+        p.mask_blend_offset = mask_blend_offset
+
         p.inpainting_fill = inpainting_fill
         p.inpaint_full_res = False
 
-- 
cgit v1.2.3


From c5c7fa06aae1ae9f8b6d29ae2da3874921d4729b Mon Sep 17 00:00:00 2001
From: CodeHatchling <steve@codehatch.com>
Date: Tue, 28 Nov 2023 22:35:07 -0700
Subject: Added slider for detail preservation strength, removed largely
 needless offset parameter, changed labels in UI and for saving to/pasting
 data from PNG files.

---
 scripts/outpainting_mk_2.py      | 12 ++++++------
 scripts/poor_mans_outpainting.py | 12 ++++++------
 2 files changed, 12 insertions(+), 12 deletions(-)

(limited to 'scripts')

diff --git a/scripts/outpainting_mk_2.py b/scripts/outpainting_mk_2.py
index 6aa97edf..54d95825 100644
--- a/scripts/outpainting_mk_2.py
+++ b/scripts/outpainting_mk_2.py
@@ -133,16 +133,16 @@ class Script(scripts.Script):
 
         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"))
-        mask_blend_power = gr.Slider(label='Mask blend power', minimum=0, maximum=8, step=0.1, value=1, elem_id=self.elem_id("mask_blend_power"))
-        mask_blend_scale = gr.Slider(label='Mask blend scale', minimum=0, maximum=8, step=0.1, value=1, elem_id=self.elem_id("mask_blend_scale"))
-        mask_blend_offset = gr.Slider(label='Mask blend scale', minimum=-4, maximum=4, step=0.1, value=1, elem_id=self.elem_id("mask_blend_offset"))
+        mask_blend_power = gr.Slider(label='Blending bias', minimum=0, maximum=8, step=0.1, value=1, elem_id=self.elem_id("mask_blend_power"))
+        mask_blend_scale = gr.Slider(label='Blending preservation', minimum=0, maximum=8, step=0.1, value=1, elem_id=self.elem_id("mask_blend_scale"))
+        inpaint_detail_preservation = gr.Slider(label='Blending detail boost', minimum=1, maximum=32, step=0.5, value=16, elem_id=self.elem_id("inpaint_detail_preservation"))
         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, mask_blend_power, mask_blend_scale, mask_blend_offset, direction, noise_q, color_variation]
+        return [info, pixels, mask_blur, mask_blend_power, mask_blend_scale, inpaint_detail_preservation, direction, noise_q, color_variation]
 
-    def run(self, p, _, pixels, mask_blur, mask_blend_power, mask_blend_scale, mask_blend_offset, direction, noise_q, color_variation):
+    def run(self, p, _, pixels, mask_blur, mask_blend_power, mask_blend_scale, inpaint_detail_preservation, direction, noise_q, color_variation):
         initial_seed_and_info = [None, None]
 
         process_width = p.width
@@ -172,7 +172,7 @@ class Script(scripts.Script):
         p.mask_blur_y = mask_blur_y*4
         p.mask_blend_power = mask_blend_power
         p.mask_blend_scale = mask_blend_scale
-        p.mask_blend_offset = mask_blend_offset
+        p.inpaint_detail_preservation = inpaint_detail_preservation
 
         init_img = p.init_images[0]
         target_w = math.ceil((init_img.width + left + right) / 64) * 64
diff --git a/scripts/poor_mans_outpainting.py b/scripts/poor_mans_outpainting.py
index b10140f1..e3acb3d4 100644
--- a/scripts/poor_mans_outpainting.py
+++ b/scripts/poor_mans_outpainting.py
@@ -22,22 +22,22 @@ class Script(scripts.Script):
 
         pixels = gr.Slider(label="Pixels to expand", minimum=8, maximum=256, step=8, value=128, elem_id=self.elem_id("pixels"))
         mask_blur = gr.Slider(label='Mask blur', minimum=0, maximum=64, step=1, value=4, elem_id=self.elem_id("mask_blur"))
-        mask_blend_power = gr.Slider(label='Mask blend power', minimum=0, maximum=8, step=0.1, value=1, elem_id=self.elem_id("mask_blend_power"))
-        mask_blend_scale = gr.Slider(label='Mask blend scale', minimum=0, maximum=8, step=0.1, value=1, elem_id=self.elem_id("mask_blend_scale"))
-        mask_blend_offset = gr.Slider(label='Mask blend offset', minimum=-4, maximum=4, step=0.1, value=0, elem_id=self.elem_id("mask_blend_offset"))
+        mask_blend_power = gr.Slider(label='Blending bias', minimum=0, maximum=8, step=0.1, value=1, elem_id=self.elem_id("mask_blend_power"))
+        mask_blend_scale = gr.Slider(label='Blending preservation', minimum=0, maximum=8, step=0.1, value=1, elem_id=self.elem_id("mask_blend_scale"))
+        inpaint_detail_preservation = gr.Slider(label='Blending detail boost', minimum=1, maximum=32, step=0.5, value=16, elem_id=self.elem_id("inpaint_detail_preservation"))
         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, mask_blend_power, mask_blend_scale, mask_blend_offset, inpainting_fill, direction]
+        return [pixels, mask_blur, mask_blend_power, mask_blend_scale, inpaint_detail_preservation, inpainting_fill, direction]
 
-    def run(self, p, pixels, mask_blur, mask_blend_power, mask_blend_scale, mask_blend_offset, inpainting_fill, direction):
+    def run(self, p, pixels, mask_blur, mask_blend_power, mask_blend_scale, inpaint_detail_preservation, inpainting_fill, direction):
         initial_seed = None
         initial_info = None
 
         p.mask_blur = mask_blur * 2
         p.mask_blend_power = mask_blend_power
         p.mask_blend_scale = mask_blend_scale
-        p.mask_blend_offset = mask_blend_offset
+        p.inpaint_detail_preservation = inpaint_detail_preservation
 
         p.inpainting_fill = inpainting_fill
         p.inpaint_full_res = False
-- 
cgit v1.2.3


From 284fd8f415ec70e14ae5de0b7f5ce738007a6b7f Mon Sep 17 00:00:00 2001
From: CodeHatchling <steve@codehatch.com>
Date: Tue, 28 Nov 2023 23:03:50 -0700
Subject: Tweaked UI sliders and labels.

---
 scripts/outpainting_mk_2.py      | 4 ++--
 scripts/poor_mans_outpainting.py | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

(limited to 'scripts')

diff --git a/scripts/outpainting_mk_2.py b/scripts/outpainting_mk_2.py
index 54d95825..bd9cb61b 100644
--- a/scripts/outpainting_mk_2.py
+++ b/scripts/outpainting_mk_2.py
@@ -134,8 +134,8 @@ class Script(scripts.Script):
         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"))
         mask_blend_power = gr.Slider(label='Blending bias', minimum=0, maximum=8, step=0.1, value=1, elem_id=self.elem_id("mask_blend_power"))
-        mask_blend_scale = gr.Slider(label='Blending preservation', minimum=0, maximum=8, step=0.1, value=1, elem_id=self.elem_id("mask_blend_scale"))
-        inpaint_detail_preservation = gr.Slider(label='Blending detail boost', minimum=1, maximum=32, step=0.5, value=16, elem_id=self.elem_id("inpaint_detail_preservation"))
+        mask_blend_scale = gr.Slider(label='Blending preservation', minimum=0, maximum=8, step=0.05, value=0.5, elem_id=self.elem_id("mask_blend_scale"))
+        inpaint_detail_preservation = gr.Slider(label='Blending contrast boost', minimum=1, maximum=32, step=0.5, value=4, elem_id=self.elem_id("inpaint_detail_preservation"))
         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"))
diff --git a/scripts/poor_mans_outpainting.py b/scripts/poor_mans_outpainting.py
index e3acb3d4..5388f5db 100644
--- a/scripts/poor_mans_outpainting.py
+++ b/scripts/poor_mans_outpainting.py
@@ -23,8 +23,8 @@ class Script(scripts.Script):
         pixels = gr.Slider(label="Pixels to expand", minimum=8, maximum=256, step=8, value=128, elem_id=self.elem_id("pixels"))
         mask_blur = gr.Slider(label='Mask blur', minimum=0, maximum=64, step=1, value=4, elem_id=self.elem_id("mask_blur"))
         mask_blend_power = gr.Slider(label='Blending bias', minimum=0, maximum=8, step=0.1, value=1, elem_id=self.elem_id("mask_blend_power"))
-        mask_blend_scale = gr.Slider(label='Blending preservation', minimum=0, maximum=8, step=0.1, value=1, elem_id=self.elem_id("mask_blend_scale"))
-        inpaint_detail_preservation = gr.Slider(label='Blending detail boost', minimum=1, maximum=32, step=0.5, value=16, elem_id=self.elem_id("inpaint_detail_preservation"))
+        mask_blend_scale = gr.Slider(label='Blending preservation', minimum=0, maximum=8, step=0.05, value=0.5, elem_id=self.elem_id("mask_blend_scale"))
+        inpaint_detail_preservation = gr.Slider(label='Blending contrast boost', minimum=1, maximum=32, step=0.5, value=4, elem_id=self.elem_id("inpaint_detail_preservation"))
         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"))
 
-- 
cgit v1.2.3


From aaacf4823241450d88315af9d465d6815119fe0d Mon Sep 17 00:00:00 2001
From: CodeHatchling <steve@codehatch.com>
Date: Mon, 4 Dec 2023 01:27:22 -0700
Subject: Organized the settings and UI of soft inpainting to allow for
 toggling the feature, and centralizes default values to reduce the amount of
 copy-pasta.

---
 scripts/outpainting_mk_2.py      | 15 +++++++--------
 scripts/poor_mans_outpainting.py | 15 ++++++---------
 2 files changed, 13 insertions(+), 17 deletions(-)

(limited to 'scripts')

diff --git a/scripts/outpainting_mk_2.py b/scripts/outpainting_mk_2.py
index bd9cb61b..f7888688 100644
--- a/scripts/outpainting_mk_2.py
+++ b/scripts/outpainting_mk_2.py
@@ -10,6 +10,7 @@ from PIL import Image, ImageDraw
 from modules import images
 from modules.processing import Processed, process_images
 from modules.shared import opts, state
+import modules.soft_inpainting as si
 
 
 # this function is taken from https://github.com/parlance-zz/g-diffuser-bot
@@ -133,16 +134,14 @@ class Script(scripts.Script):
 
         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"))
-        mask_blend_power = gr.Slider(label='Blending bias', minimum=0, maximum=8, step=0.1, value=1, elem_id=self.elem_id("mask_blend_power"))
-        mask_blend_scale = gr.Slider(label='Blending preservation', minimum=0, maximum=8, step=0.05, value=0.5, elem_id=self.elem_id("mask_blend_scale"))
-        inpaint_detail_preservation = gr.Slider(label='Blending contrast boost', minimum=1, maximum=32, step=0.5, value=4, elem_id=self.elem_id("inpaint_detail_preservation"))
+        soft_inpainting = si.gradio_ui()[0]
         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, mask_blend_power, mask_blend_scale, inpaint_detail_preservation, direction, noise_q, color_variation]
+        return [info, pixels, mask_blur, *soft_inpainting, direction, noise_q, color_variation]
 
-    def run(self, p, _, pixels, mask_blur, mask_blend_power, mask_blend_scale, inpaint_detail_preservation, direction, noise_q, color_variation):
+    def run(self, p, _, pixels, mask_blur, mask_blend_enabled, mask_blend_power, mask_blend_scale, inpaint_detail_preservation, direction, noise_q, color_variation):
         initial_seed_and_info = [None, None]
 
         process_width = p.width
@@ -170,9 +169,9 @@ class Script(scripts.Script):
 
         p.mask_blur_x = mask_blur_x*4
         p.mask_blur_y = mask_blur_y*4
-        p.mask_blend_power = mask_blend_power
-        p.mask_blend_scale = mask_blend_scale
-        p.inpaint_detail_preservation = inpaint_detail_preservation
+
+        p.soft_inpainting = si.SoftInpaintingSettings(mask_blend_power, mask_blend_scale, inpaint_detail_preservation) \
+            if mask_blend_enabled else None
 
         init_img = p.init_images[0]
         target_w = math.ceil((init_img.width + left + right) / 64) * 64
diff --git a/scripts/poor_mans_outpainting.py b/scripts/poor_mans_outpainting.py
index 5388f5db..11f7f74a 100644
--- a/scripts/poor_mans_outpainting.py
+++ b/scripts/poor_mans_outpainting.py
@@ -7,6 +7,7 @@ from PIL import Image, ImageDraw
 from modules import images, devices
 from modules.processing import Processed, process_images
 from modules.shared import opts, state
+import modules.soft_inpainting as si
 
 
 class Script(scripts.Script):
@@ -22,23 +23,19 @@ class Script(scripts.Script):
 
         pixels = gr.Slider(label="Pixels to expand", minimum=8, maximum=256, step=8, value=128, elem_id=self.elem_id("pixels"))
         mask_blur = gr.Slider(label='Mask blur', minimum=0, maximum=64, step=1, value=4, elem_id=self.elem_id("mask_blur"))
-        mask_blend_power = gr.Slider(label='Blending bias', minimum=0, maximum=8, step=0.1, value=1, elem_id=self.elem_id("mask_blend_power"))
-        mask_blend_scale = gr.Slider(label='Blending preservation', minimum=0, maximum=8, step=0.05, value=0.5, elem_id=self.elem_id("mask_blend_scale"))
-        inpaint_detail_preservation = gr.Slider(label='Blending contrast boost', minimum=1, maximum=32, step=0.5, value=4, elem_id=self.elem_id("inpaint_detail_preservation"))
+        soft_inpainting = si.gradio_ui()[0]
         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, mask_blend_power, mask_blend_scale, inpaint_detail_preservation, inpainting_fill, direction]
+        return [pixels, mask_blur, *soft_inpainting, inpainting_fill, direction]
 
-    def run(self, p, pixels, mask_blur, mask_blend_power, mask_blend_scale, inpaint_detail_preservation, inpainting_fill, direction):
+    def run(self, p, pixels, mask_blur, mask_blend_enabled, mask_blend_power, mask_blend_scale, inpaint_detail_preservation, inpainting_fill, direction):
         initial_seed = None
         initial_info = None
 
         p.mask_blur = mask_blur * 2
-        p.mask_blend_power = mask_blend_power
-        p.mask_blend_scale = mask_blend_scale
-        p.inpaint_detail_preservation = inpaint_detail_preservation
-
+        p.soft_inpainting = si.SoftInpaintingSettings(mask_blend_power, mask_blend_scale, inpaint_detail_preservation) \
+            if mask_blend_enabled else None
         p.inpainting_fill = inpainting_fill
         p.inpaint_full_res = False
 
-- 
cgit v1.2.3


From 4608f6236fc24d937f89500b2c9bf48484537cf9 Mon Sep 17 00:00:00 2001
From: CodeHatchling <steve@codehatch.com>
Date: Wed, 6 Dec 2023 18:11:17 -0700
Subject: Removed changes in some scripts since the arguments for soft painting
 are no longer passed through the same path as "mask_blur".

---
 scripts/outpainting_mk_2.py      | 9 ++-------
 scripts/poor_mans_outpainting.py | 8 ++------
 2 files changed, 4 insertions(+), 13 deletions(-)

(limited to 'scripts')

diff --git a/scripts/outpainting_mk_2.py b/scripts/outpainting_mk_2.py
index f7888688..c98ab480 100644
--- a/scripts/outpainting_mk_2.py
+++ b/scripts/outpainting_mk_2.py
@@ -10,7 +10,6 @@ from PIL import Image, ImageDraw
 from modules import images
 from modules.processing import Processed, process_images
 from modules.shared import opts, state
-import modules.soft_inpainting as si
 
 
 # this function is taken from https://github.com/parlance-zz/g-diffuser-bot
@@ -134,14 +133,13 @@ class Script(scripts.Script):
 
         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"))
-        soft_inpainting = si.gradio_ui()[0]
         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, *soft_inpainting, direction, noise_q, color_variation]
+        return [info, pixels, mask_blur, direction, noise_q, color_variation]
 
-    def run(self, p, _, pixels, mask_blur, mask_blend_enabled, mask_blend_power, mask_blend_scale, inpaint_detail_preservation, 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
@@ -170,9 +168,6 @@ class Script(scripts.Script):
         p.mask_blur_x = mask_blur_x*4
         p.mask_blur_y = mask_blur_y*4
 
-        p.soft_inpainting = si.SoftInpaintingSettings(mask_blend_power, mask_blend_scale, inpaint_detail_preservation) \
-            if mask_blend_enabled else None
-
         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
diff --git a/scripts/poor_mans_outpainting.py b/scripts/poor_mans_outpainting.py
index 11f7f74a..ea0632b6 100644
--- a/scripts/poor_mans_outpainting.py
+++ b/scripts/poor_mans_outpainting.py
@@ -7,7 +7,6 @@ from PIL import Image, ImageDraw
 from modules import images, devices
 from modules.processing import Processed, process_images
 from modules.shared import opts, state
-import modules.soft_inpainting as si
 
 
 class Script(scripts.Script):
@@ -23,19 +22,16 @@ class Script(scripts.Script):
 
         pixels = gr.Slider(label="Pixels to expand", minimum=8, maximum=256, step=8, value=128, elem_id=self.elem_id("pixels"))
         mask_blur = gr.Slider(label='Mask blur', minimum=0, maximum=64, step=1, value=4, elem_id=self.elem_id("mask_blur"))
-        soft_inpainting = si.gradio_ui()[0]
         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, *soft_inpainting, inpainting_fill, direction]
+        return [pixels, mask_blur, inpainting_fill, direction]
 
-    def run(self, p, pixels, mask_blur, mask_blend_enabled, mask_blend_power, mask_blend_scale, inpaint_detail_preservation, 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.soft_inpainting = si.SoftInpaintingSettings(mask_blend_power, mask_blend_scale, inpaint_detail_preservation) \
-            if mask_blend_enabled else None
         p.inpainting_fill = inpainting_fill
         p.inpaint_full_res = False
 
-- 
cgit v1.2.3


From 2abc417834d752e43a283f8603bfddfb1c80b30f Mon Sep 17 00:00:00 2001
From: CodeHatchling <steve@codehatch.com>
Date: Wed, 6 Dec 2023 22:25:53 -0700
Subject: Re-implemented soft inpainting via a script. Also fixed some mistakes
 with the previous hooks, removed unnecessary formatting changes, removed code
 that I had forgotten to.

---
 scripts/soft_inpainting.py | 401 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 401 insertions(+)
 create mode 100644 scripts/soft_inpainting.py

(limited to 'scripts')

diff --git a/scripts/soft_inpainting.py b/scripts/soft_inpainting.py
new file mode 100644
index 00000000..47e0269b
--- /dev/null
+++ b/scripts/soft_inpainting.py
@@ -0,0 +1,401 @@
+import gradio as gr
+from modules.ui_components import InputAccordion
+import modules.scripts as scripts
+
+
+class SoftInpaintingSettings:
+    def __init__(self, mask_blend_power, mask_blend_scale, inpaint_detail_preservation):
+        self.mask_blend_power = mask_blend_power
+        self.mask_blend_scale = mask_blend_scale
+        self.inpaint_detail_preservation = inpaint_detail_preservation
+
+    def add_generation_params(self, dest):
+        dest[enabled_gen_param_label] = True
+        dest[gen_param_labels.mask_blend_power] = self.mask_blend_power
+        dest[gen_param_labels.mask_blend_scale] = self.mask_blend_scale
+        dest[gen_param_labels.inpaint_detail_preservation] = self.inpaint_detail_preservation
+
+
+# ------------------- Methods -------------------
+
+
+def latent_blend(soft_inpainting, a, b, t):
+    """
+    Interpolates two latent image representations according to the parameter t,
+    where the interpolated vectors' magnitudes are also interpolated separately.
+    The "detail_preservation" factor biases the magnitude interpolation towards
+    the larger of the two magnitudes.
+    """
+    import torch
+
+    # NOTE: We use inplace operations wherever possible.
+
+    # [4][w][h] to [1][4][w][h]
+    t2 = t.unsqueeze(0)
+    # [4][w][h] to [1][1][w][h] - the [4] seem redundant.
+    t3 = t[0].unsqueeze(0).unsqueeze(0)
+
+    one_minus_t2 = 1 - t2
+    one_minus_t3 = 1 - t3
+
+    # Linearly interpolate the image vectors.
+    a_scaled = a * one_minus_t2
+    b_scaled = b * t2
+    image_interp = a_scaled
+    image_interp.add_(b_scaled)
+    result_type = image_interp.dtype
+    del a_scaled, b_scaled, t2, one_minus_t2
+
+    # Calculate the magnitude of the interpolated vectors. (We will remove this magnitude.)
+    # 64-bit operations are used here to allow large exponents.
+    current_magnitude = torch.norm(image_interp, p=2, dim=1, keepdim=True).to(torch.float64).add_(0.00001)
+
+    # Interpolate the powered magnitudes, then un-power them (bring them back to a power of 1).
+    a_magnitude = torch.norm(a, p=2, dim=1, keepdim=True).to(torch.float64).pow_(
+        soft_inpainting.inpaint_detail_preservation) * one_minus_t3
+    b_magnitude = torch.norm(b, p=2, dim=1, keepdim=True).to(torch.float64).pow_(
+        soft_inpainting.inpaint_detail_preservation) * t3
+    desired_magnitude = a_magnitude
+    desired_magnitude.add_(b_magnitude).pow_(1 / soft_inpainting.inpaint_detail_preservation)
+    del a_magnitude, b_magnitude, t3, one_minus_t3
+
+    # Change the linearly interpolated image vectors' magnitudes to the value we want.
+    # This is the last 64-bit operation.
+    image_interp_scaling_factor = desired_magnitude
+    image_interp_scaling_factor.div_(current_magnitude)
+    image_interp_scaling_factor = image_interp_scaling_factor.to(result_type)
+    image_interp_scaled = image_interp
+    image_interp_scaled.mul_(image_interp_scaling_factor)
+    del current_magnitude
+    del desired_magnitude
+    del image_interp
+    del image_interp_scaling_factor
+    del result_type
+
+    return image_interp_scaled
+
+
+def get_modified_nmask(soft_inpainting, nmask, sigma):
+    """
+    Converts a negative mask representing the transparency of the original latent vectors being overlayed
+    to a mask that is scaled according to the denoising strength for this step.
+
+    Where:
+        0 = fully opaque, infinite density, fully masked
+        1 = fully transparent, zero density, fully unmasked
+
+    We bring this transparency to a power, as this allows one to simulate N number of blending operations
+    where N can be any positive real value. Using this one can control the balance of influence between
+    the denoiser and the original latents according to the sigma value.
+
+    NOTE: "mask" is not used
+    """
+    import torch
+    return torch.pow(nmask, (sigma ** soft_inpainting.mask_blend_power) * soft_inpainting.mask_blend_scale)
+
+
+def apply_adaptive_masks(
+        latent_orig,
+        latent_processed,
+        overlay_images,
+        width, height,
+        paste_to):
+    import torch
+    import numpy as np
+    import modules.processing as proc
+    import modules.images as images
+    from PIL import Image, ImageOps, ImageFilter
+
+    # TODO: Bias the blending according to the latent mask, add adjustable parameter for bias control.
+    # latent_mask = p.nmask[0].float().cpu()
+    # convert the original mask into a form we use to scale distances for thresholding
+    # mask_scalar = 1-(torch.clamp(latent_mask, min=0, max=1) ** (p.mask_blend_scale / 2))
+    # mask_scalar = mask_scalar / (1.00001-mask_scalar)
+    # mask_scalar = mask_scalar.numpy()
+
+    latent_distance = torch.norm(latent_processed - latent_orig, p=2, dim=1)
+
+    kernel, kernel_center = images.get_gaussian_kernel(stddev_radius=1.5, max_radius=2)
+
+    masks_for_overlay = []
+
+    for i, (distance_map, overlay_image) in enumerate(zip(latent_distance, overlay_images)):
+        converted_mask = distance_map.float().cpu().numpy()
+        converted_mask = images.weighted_histogram_filter(converted_mask, kernel, kernel_center,
+                                                          percentile_min=0.9, percentile_max=1, min_width=1)
+        converted_mask = images.weighted_histogram_filter(converted_mask, kernel, kernel_center,
+                                                          percentile_min=0.25, percentile_max=0.75, min_width=1)
+
+        # The distance at which opacity of original decreases to 50%
+        # half_weighted_distance = 1  # * mask_scalar
+        # converted_mask = converted_mask / half_weighted_distance
+
+        converted_mask = 1 / (1 + converted_mask ** 2)
+        converted_mask = images.smootherstep(converted_mask)
+        converted_mask = 1 - converted_mask
+        converted_mask = 255. * converted_mask
+        converted_mask = converted_mask.astype(np.uint8)
+        converted_mask = Image.fromarray(converted_mask)
+        converted_mask = images.resize_image(2, converted_mask, width, height)
+        converted_mask = proc.create_binary_mask(converted_mask, round=False)
+
+        # Remove aliasing artifacts using a gaussian blur.
+        converted_mask = converted_mask.filter(ImageFilter.GaussianBlur(radius=4))
+
+        # Expand the mask to fit the whole image if needed.
+        if paste_to is not None:
+            converted_mask = proc.uncrop(converted_mask,
+                                         (overlay_image.width, overlay_image.height),
+                                         paste_to)
+
+        masks_for_overlay.append(converted_mask)
+
+        image_masked = Image.new('RGBa', (overlay_image.width, overlay_image.height))
+        image_masked.paste(overlay_image.convert("RGBA").convert("RGBa"),
+                           mask=ImageOps.invert(converted_mask.convert('L')))
+
+        overlay_images[i] = image_masked.convert('RGBA')
+
+    return masks_for_overlay
+
+
+def apply_masks(
+        soft_inpainting,
+        nmask,
+        overlay_images,
+        width, height,
+        paste_to):
+    import torch
+    import numpy as np
+    import modules.processing as proc
+    import modules.images as images
+    from PIL import Image, ImageOps, ImageFilter
+
+    converted_mask = nmask[0].float()
+    converted_mask = torch.clamp(converted_mask, min=0, max=1).pow_(soft_inpainting.mask_blend_scale / 2)
+    converted_mask = 255. * converted_mask
+    converted_mask = converted_mask.cpu().numpy().astype(np.uint8)
+    converted_mask = Image.fromarray(converted_mask)
+    converted_mask = images.resize_image(2, converted_mask, width, height)
+    converted_mask = proc.create_binary_mask(converted_mask, round=False)
+
+    # Remove aliasing artifacts using a gaussian blur.
+    converted_mask = converted_mask.filter(ImageFilter.GaussianBlur(radius=4))
+
+    # Expand the mask to fit the whole image if needed.
+    if paste_to is not None:
+        converted_mask = proc.uncrop(converted_mask,
+                                     (width, height),
+                                     paste_to)
+
+    masks_for_overlay = []
+
+    for i, overlay_image in enumerate(overlay_images):
+        masks_for_overlay[i] = converted_mask
+
+        image_masked = Image.new('RGBa', (overlay_image.width, overlay_image.height))
+        image_masked.paste(overlay_image.convert("RGBA").convert("RGBa"),
+                           mask=ImageOps.invert(converted_mask.convert('L')))
+
+        overlay_images[i] = image_masked.convert('RGBA')
+
+    return masks_for_overlay
+
+
+# ------------------- Constants -------------------
+
+
+default = SoftInpaintingSettings(1, 0.5, 4)
+
+enabled_ui_label = "Soft inpainting"
+enabled_gen_param_label = "Soft inpainting enabled"
+enabled_el_id = "soft_inpainting_enabled"
+
+ui_labels = SoftInpaintingSettings(
+    "Schedule bias",
+    "Preservation strength",
+    "Transition contrast boost")
+
+ui_info = SoftInpaintingSettings(
+    "Shifts when preservation of original content occurs during denoising.",
+    "How strongly partially masked content should be preserved.",
+    "Amplifies the contrast that may be lost in partially masked regions.")
+
+gen_param_labels = SoftInpaintingSettings(
+    "Soft inpainting schedule bias",
+    "Soft inpainting preservation strength",
+    "Soft inpainting transition contrast boost")
+
+el_ids = SoftInpaintingSettings(
+    "mask_blend_power",
+    "mask_blend_scale",
+    "inpaint_detail_preservation")
+
+
+class Script(scripts.Script):
+
+    def __init__(self):
+        self.masks_for_overlay = None
+        self.overlay_images = None
+
+    def title(self):
+        return "Soft Inpainting"
+
+    def show(self, is_img2img):
+        return scripts.AlwaysVisible if is_img2img else False
+
+    def ui(self, is_img2img):
+        if not is_img2img:
+            return
+
+        with InputAccordion(False, label=enabled_ui_label, elem_id=enabled_el_id) as soft_inpainting_enabled:
+            with gr.Group():
+                gr.Markdown(
+                    """
+                    Soft inpainting allows you to **seamlessly blend original content with inpainted content** according to the mask opacity.
+                    **High _Mask blur_** values are recommended!
+                    """)
+
+                result = SoftInpaintingSettings(
+                    gr.Slider(label=ui_labels.mask_blend_power,
+                              info=ui_info.mask_blend_power,
+                              minimum=0,
+                              maximum=8,
+                              step=0.1,
+                              value=default.mask_blend_power,
+                              elem_id=el_ids.mask_blend_power),
+                    gr.Slider(label=ui_labels.mask_blend_scale,
+                              info=ui_info.mask_blend_scale,
+                              minimum=0,
+                              maximum=8,
+                              step=0.05,
+                              value=default.mask_blend_scale,
+                              elem_id=el_ids.mask_blend_scale),
+                    gr.Slider(label=ui_labels.inpaint_detail_preservation,
+                              info=ui_info.inpaint_detail_preservation,
+                              minimum=1,
+                              maximum=32,
+                              step=0.5,
+                              value=default.inpaint_detail_preservation,
+                              elem_id=el_ids.inpaint_detail_preservation))
+
+                with gr.Accordion("Help", open=False):
+                    gr.Markdown(
+                        f"""
+                        ### {ui_labels.mask_blend_power}
+
+                        The blending strength of original content is scaled proportionally with the decreasing noise level values at each step (sigmas).
+                        This ensures that the influence of the denoiser and original content preservation is roughly balanced at each step.
+                        This balance can be shifted using this parameter, controlling whether earlier or later steps have stronger preservation.
+
+                        - **Below 1**: Stronger preservation near the end (with low sigma)
+                        - **1**: Balanced (proportional to sigma)
+                        - **Above 1**: Stronger preservation in the beginning (with high sigma)
+                        """)
+                    gr.Markdown(
+                        f"""
+                        ### {ui_labels.mask_blend_scale}
+
+                        Skews whether partially masked image regions should be more likely to preserve the original content or favor inpainted content.
+                        This may need to be adjusted depending on the {ui_labels.mask_blend_power}, CFG Scale, prompt and Denoising strength.
+
+                        - **Low values**: Favors generated content.
+                        - **High values**: Favors original content.
+                        """)
+                    gr.Markdown(
+                        f"""
+                        ### {ui_labels.inpaint_detail_preservation}
+
+                        This parameter controls how the original latent vectors and denoised latent vectors are interpolated.
+                        With higher values, the magnitude of the resulting blended vector will be closer to the maximum of the two interpolated vectors.
+                        This can prevent the loss of contrast that occurs with linear interpolation.
+
+                        - **Low values**: Softer blending, details may fade.
+                        - **High values**: Stronger contrast, may over-saturate colors.
+                        """)
+
+        self.infotext_fields = [(soft_inpainting_enabled, enabled_gen_param_label),
+                                (result.mask_blend_power, gen_param_labels.mask_blend_power),
+                                (result.mask_blend_scale, gen_param_labels.mask_blend_scale),
+                                (result.inpaint_detail_preservation, gen_param_labels.inpaint_detail_preservation)]
+
+        self.paste_field_names = []
+        for _, field_name in self.infotext_fields:
+            self.paste_field_names.append(field_name)
+
+        return [soft_inpainting_enabled,
+                result.mask_blend_power,
+                result.mask_blend_scale,
+                result.inpaint_detail_preservation]
+
+    def process(self, p, enabled, power, scale, detail_preservation):
+        if not enabled:
+            return
+
+        # Shut off the rounding it normally does.
+        p.mask_round = False
+
+        settings = SoftInpaintingSettings(power, scale, detail_preservation)
+
+        # p.extra_generation_params["Mask rounding"] = False
+        settings.add_generation_params(p.extra_generation_params)
+
+    def on_mask_blend(self, p, mba: scripts.MaskBlendArgs, enabled, power, scale, detail_preservation):
+        if not enabled:
+            return
+
+        if mba.sigma is None:
+            mba.blended_latent = mba.current_latent
+            return
+
+        settings = SoftInpaintingSettings(power, scale, detail_preservation)
+
+        # todo: Why is sigma 2D? Both values are the same.
+        mba.blended_latent = latent_blend(settings,
+                                          mba.init_latent,
+                                          mba.current_latent,
+                                          get_modified_nmask(settings, mba.nmask, mba.sigma[0]))
+
+    def post_sample(self, p, ps: scripts.PostSampleArgs, enabled, power, scale, detail_preservation):
+        if not enabled:
+            return
+
+        settings = SoftInpaintingSettings(power, scale, detail_preservation)
+
+        from modules import images
+        from modules.shared import opts
+
+        # since the original code puts holes in the existing overlay images,
+        # we have to rebuild them.
+        self.overlay_images = []
+        for img in p.init_images:
+
+            image = images.flatten(img, opts.img2img_background_color)
+
+            if p.paste_to is None and p.resize_mode != 3:
+                image = images.resize_image(p.resize_mode, image, p.width, p.height)
+
+            self.overlay_images.append(image.convert('RGBA'))
+
+        if getattr(ps.samples, 'already_decoded', False):
+            self.masks_for_overlay = apply_masks(soft_inpainting=settings,
+                                                 nmask=p.nmask,
+                                                 overlay_images=self.overlay_images,
+                                                 width=p.width,
+                                                 height=p.height,
+                                                 paste_to=p.paste_to)
+        else:
+            self.masks_for_overlay = apply_adaptive_masks(latent_orig=p.init_latent,
+                                                          latent_processed=ps.samples,
+                                                          overlay_images=self.overlay_images,
+                                                          width=p.width,
+                                                          height=p.height,
+                                                          paste_to=p.paste_to)
+
+
+    def postprocess_maskoverlay(self, p, ppmo: scripts.PostProcessMaskOverlayArgs, enabled, power, scale, detail_preservation):
+        if not enabled:
+            return
+
+        ppmo.mask_for_overlay = self.masks_for_overlay[ppmo.index]
+        ppmo.overlay_image = self.overlay_images[ppmo.index]
\ No newline at end of file
-- 
cgit v1.2.3


From 8dbacc7d018774a3bc801cc57617795274a15087 Mon Sep 17 00:00:00 2001
From: CodeHatchling <steve@codehatch.com>
Date: Thu, 7 Dec 2023 14:30:30 -0700
Subject: Fixed "No newline at end of file".

---
 scripts/soft_inpainting.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'scripts')

diff --git a/scripts/soft_inpainting.py b/scripts/soft_inpainting.py
index 47e0269b..6d0cf847 100644
--- a/scripts/soft_inpainting.py
+++ b/scripts/soft_inpainting.py
@@ -398,4 +398,4 @@ class Script(scripts.Script):
             return
 
         ppmo.mask_for_overlay = self.masks_for_overlay[ppmo.index]
-        ppmo.overlay_image = self.overlay_images[ppmo.index]
\ No newline at end of file
+        ppmo.overlay_image = self.overlay_images[ppmo.index]
-- 
cgit v1.2.3


From 56604f08a18588e8e6b57d7c3f9c61d6624846f8 Mon Sep 17 00:00:00 2001
From: CodeHatchling <steve@codehatch.com>
Date: Thu, 7 Dec 2023 14:53:44 -0700
Subject: Moved image filters used by soft inpainting into soft_inpainting.py
 from images.py

---
 scripts/soft_inpainting.py | 205 +++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 199 insertions(+), 6 deletions(-)

(limited to 'scripts')

diff --git a/scripts/soft_inpainting.py b/scripts/soft_inpainting.py
index 6d0cf847..1f451b55 100644
--- a/scripts/soft_inpainting.py
+++ b/scripts/soft_inpainting.py
@@ -1,4 +1,6 @@
+import numpy as np
 import gradio as gr
+import math
 from modules.ui_components import InputAccordion
 import modules.scripts as scripts
 
@@ -101,7 +103,6 @@ def apply_adaptive_masks(
         width, height,
         paste_to):
     import torch
-    import numpy as np
     import modules.processing as proc
     import modules.images as images
     from PIL import Image, ImageOps, ImageFilter
@@ -115,15 +116,15 @@ def apply_adaptive_masks(
 
     latent_distance = torch.norm(latent_processed - latent_orig, p=2, dim=1)
 
-    kernel, kernel_center = images.get_gaussian_kernel(stddev_radius=1.5, max_radius=2)
+    kernel, kernel_center = get_gaussian_kernel(stddev_radius=1.5, max_radius=2)
 
     masks_for_overlay = []
 
     for i, (distance_map, overlay_image) in enumerate(zip(latent_distance, overlay_images)):
         converted_mask = distance_map.float().cpu().numpy()
-        converted_mask = images.weighted_histogram_filter(converted_mask, kernel, kernel_center,
+        converted_mask = weighted_histogram_filter(converted_mask, kernel, kernel_center,
                                                           percentile_min=0.9, percentile_max=1, min_width=1)
-        converted_mask = images.weighted_histogram_filter(converted_mask, kernel, kernel_center,
+        converted_mask = weighted_histogram_filter(converted_mask, kernel, kernel_center,
                                                           percentile_min=0.25, percentile_max=0.75, min_width=1)
 
         # The distance at which opacity of original decreases to 50%
@@ -131,7 +132,7 @@ def apply_adaptive_masks(
         # converted_mask = converted_mask / half_weighted_distance
 
         converted_mask = 1 / (1 + converted_mask ** 2)
-        converted_mask = images.smootherstep(converted_mask)
+        converted_mask = smootherstep(converted_mask)
         converted_mask = 1 - converted_mask
         converted_mask = 255. * converted_mask
         converted_mask = converted_mask.astype(np.uint8)
@@ -166,7 +167,6 @@ def apply_masks(
         width, height,
         paste_to):
     import torch
-    import numpy as np
     import modules.processing as proc
     import modules.images as images
     from PIL import Image, ImageOps, ImageFilter
@@ -202,6 +202,196 @@ def apply_masks(
     return masks_for_overlay
 
 
+def weighted_histogram_filter(img, kernel, kernel_center, percentile_min=0.0, percentile_max=1.0, min_width=1.0):
+    """
+    Generalization convolution filter capable of applying
+    weighted mean, median, maximum, and minimum filters
+    parametrically using an arbitrary kernel.
+
+    Args:
+        img (nparray):
+            The image, a 2-D array of floats, to which the filter is being applied.
+        kernel (nparray):
+            The kernel, a 2-D array of floats.
+        kernel_center (nparray):
+            The kernel center coordinate, a 1-D array with two elements.
+        percentile_min (float):
+            The lower bound of the histogram window used by the filter,
+            from 0 to 1.
+        percentile_max (float):
+            The upper bound of the histogram window used by the filter,
+            from 0 to 1.
+        min_width (float):
+            The minimum size of the histogram window bounds, in weight units.
+            Must be greater than 0.
+
+    Returns:
+        (nparray): A filtered copy of the input image "img", a 2-D array of floats.
+    """
+
+    # Converts an index tuple into a vector.
+    def vec(x):
+        return np.array(x)
+
+    kernel_min = -kernel_center
+    kernel_max = vec(kernel.shape) - kernel_center
+
+    def weighted_histogram_filter_single(idx):
+        idx = vec(idx)
+        min_index = np.maximum(0, idx + kernel_min)
+        max_index = np.minimum(vec(img.shape), idx + kernel_max)
+        window_shape = max_index - min_index
+
+        class WeightedElement:
+            """
+            An element of the histogram, its weight
+            and bounds.
+            """
+            def __init__(self, value, weight):
+                self.value: float = value
+                self.weight: float = weight
+                self.window_min: float = 0.0
+                self.window_max: float = 1.0
+
+        # Collect the values in the image as WeightedElements,
+        # weighted by their corresponding kernel values.
+        values = []
+        for window_tup in np.ndindex(tuple(window_shape)):
+            window_index = vec(window_tup)
+            image_index = window_index + min_index
+            centered_kernel_index = image_index - idx
+            kernel_index = centered_kernel_index + kernel_center
+            element = WeightedElement(img[tuple(image_index)], kernel[tuple(kernel_index)])
+            values.append(element)
+
+        def sort_key(x: WeightedElement):
+            return x.value
+
+        values.sort(key=sort_key)
+
+        # Calculate the height of the stack (sum)
+        # and each sample's range they occupy in the stack
+        sum = 0
+        for i in range(len(values)):
+            values[i].window_min = sum
+            sum += values[i].weight
+            values[i].window_max = sum
+
+        # Calculate what range of this stack ("window")
+        # we want to get the weighted average across.
+        window_min = sum * percentile_min
+        window_max = sum * percentile_max
+        window_width = window_max - window_min
+
+        # Ensure the window is within the stack and at least a certain size.
+        if window_width < min_width:
+            window_center = (window_min + window_max) / 2
+            window_min = window_center - min_width / 2
+            window_max = window_center + min_width / 2
+
+            if window_max > sum:
+                window_max = sum
+                window_min = sum - min_width
+
+            if window_min < 0:
+                window_min = 0
+                window_max = min_width
+
+        value = 0
+        value_weight = 0
+
+        # Get the weighted average of all the samples
+        # that overlap with the window, weighted
+        # by the size of their overlap.
+        for i in range(len(values)):
+            if window_min >= values[i].window_max:
+                continue
+            if window_max <= values[i].window_min:
+                break
+
+            s = max(window_min, values[i].window_min)
+            e = min(window_max, values[i].window_max)
+            w = e - s
+
+            value += values[i].value * w
+            value_weight += w
+
+        return value / value_weight if value_weight != 0 else 0
+
+    img_out = img.copy()
+
+    # Apply the kernel operation over each pixel.
+    for index in np.ndindex(img.shape):
+        img_out[index] = weighted_histogram_filter_single(index)
+
+    return img_out
+
+def smoothstep(x):
+    """
+    The smoothstep function, input should be clamped to 0-1 range.
+    Turns a diagonal line (f(x) = x) into a sigmoid-like curve.
+    """
+    return x * x * (3 - 2 * x)
+
+def smootherstep(x):
+    """
+    The smootherstep function, input should be clamped to 0-1 range.
+    Turns a diagonal line (f(x) = x) into a sigmoid-like curve.
+    """
+    return x * x * x * (x * (6 * x - 15) + 10)
+
+
+def get_gaussian_kernel(stddev_radius=1.0, max_radius=2):
+    """
+    Creates a Gaussian kernel with thresholded edges.
+
+    Args:
+        stddev_radius (float):
+            Standard deviation of the gaussian kernel, in pixels.
+        max_radius (int):
+            The size of the filter kernel. The number of pixels is (max_radius*2+1) ** 2.
+            The kernel is thresholded so that any values one pixel beyond this radius
+            is weighted at 0.
+
+    Returns:
+        (nparray, nparray): A kernel array (shape: (N, N)), its center coordinate (shape: (2))
+    """
+    # Evaluates a 0-1 normalized gaussian function for a given square distance from the mean.
+    def gaussian(sqr_mag):
+        return math.exp(-sqr_mag / (stddev_radius * stddev_radius))
+
+    # Helper function for converting a tuple to an array.
+    def vec(x):
+        return np.array(x)
+
+    """
+    Since a gaussian is unbounded, we need to limit ourselves
+    to a finite range.
+    We taper the ends off at the end of that range so they equal zero
+    while preserving the maximum value of 1 at the mean.
+    """
+    zero_radius = max_radius + 1.0
+    gauss_zero = gaussian(zero_radius * zero_radius)
+    gauss_kernel_scale = 1 / (1 - gauss_zero)
+
+    def gaussian_kernel_func(coordinate):
+        x = coordinate[0] ** 2.0 + coordinate[1] ** 2.0
+        x = gaussian(x)
+        x -= gauss_zero
+        x *= gauss_kernel_scale
+        x = max(0.0, x)
+        return x
+
+    size = max_radius * 2 + 1
+    kernel_center = max_radius
+    kernel = np.zeros((size, size))
+
+    for index in np.ndindex(kernel.shape):
+        kernel[index] = gaussian_kernel_func(vec(index) - kernel_center)
+
+    return kernel, kernel_center
+
+
 # ------------------- Constants -------------------
 
 
@@ -232,6 +422,9 @@ el_ids = SoftInpaintingSettings(
     "inpaint_detail_preservation")
 
 
+# -----
+
+
 class Script(scripts.Script):
 
     def __init__(self):
-- 
cgit v1.2.3


From f284ae23bcdfa212cf4763659c06e124ec5b1456 Mon Sep 17 00:00:00 2001
From: CodeHatchling <steve@codehatch.com>
Date: Thu, 7 Dec 2023 20:19:35 -0700
Subject: Added parameters for the composite stage, fixed batched generation.

---
 scripts/soft_inpainting.py | 198 +++++++++++++++++++++++++++++++++++----------
 1 file changed, 155 insertions(+), 43 deletions(-)

(limited to 'scripts')

diff --git a/scripts/soft_inpainting.py b/scripts/soft_inpainting.py
index 1f451b55..1b21aee9 100644
--- a/scripts/soft_inpainting.py
+++ b/scripts/soft_inpainting.py
@@ -6,22 +6,34 @@ import modules.scripts as scripts
 
 
 class SoftInpaintingSettings:
-    def __init__(self, mask_blend_power, mask_blend_scale, inpaint_detail_preservation):
+    def __init__(self,
+                 mask_blend_power,
+                 mask_blend_scale,
+                 inpaint_detail_preservation,
+                 composite_mask_influence,
+                 composite_difference_threshold,
+                 composite_difference_contrast):
         self.mask_blend_power = mask_blend_power
         self.mask_blend_scale = mask_blend_scale
         self.inpaint_detail_preservation = inpaint_detail_preservation
+        self.composite_mask_influence = composite_mask_influence
+        self.composite_difference_threshold = composite_difference_threshold
+        self.composite_difference_contrast = composite_difference_contrast
 
     def add_generation_params(self, dest):
         dest[enabled_gen_param_label] = True
         dest[gen_param_labels.mask_blend_power] = self.mask_blend_power
         dest[gen_param_labels.mask_blend_scale] = self.mask_blend_scale
         dest[gen_param_labels.inpaint_detail_preservation] = self.inpaint_detail_preservation
+        dest[gen_param_labels.composite_mask_influence] = self.composite_mask_influence
+        dest[gen_param_labels.composite_difference_threshold] = self.composite_difference_threshold
+        dest[gen_param_labels.composite_difference_contrast] = self.composite_difference_contrast
 
 
 # ------------------- Methods -------------------
 
 
-def latent_blend(soft_inpainting, a, b, t):
+def latent_blend(settings, a, b, t):
     """
     Interpolates two latent image representations according to the parameter t,
     where the interpolated vectors' magnitudes are also interpolated separately.
@@ -54,11 +66,11 @@ def latent_blend(soft_inpainting, a, b, t):
 
     # Interpolate the powered magnitudes, then un-power them (bring them back to a power of 1).
     a_magnitude = torch.norm(a, p=2, dim=1, keepdim=True).to(torch.float64).pow_(
-        soft_inpainting.inpaint_detail_preservation) * one_minus_t3
+        settings.inpaint_detail_preservation) * one_minus_t3
     b_magnitude = torch.norm(b, p=2, dim=1, keepdim=True).to(torch.float64).pow_(
-        soft_inpainting.inpaint_detail_preservation) * t3
+        settings.inpaint_detail_preservation) * t3
     desired_magnitude = a_magnitude
-    desired_magnitude.add_(b_magnitude).pow_(1 / soft_inpainting.inpaint_detail_preservation)
+    desired_magnitude.add_(b_magnitude).pow_(1 / settings.inpaint_detail_preservation)
     del a_magnitude, b_magnitude, t3, one_minus_t3
 
     # Change the linearly interpolated image vectors' magnitudes to the value we want.
@@ -77,7 +89,7 @@ def latent_blend(soft_inpainting, a, b, t):
     return image_interp_scaled
 
 
-def get_modified_nmask(soft_inpainting, nmask, sigma):
+def get_modified_nmask(settings, nmask, sigma):
     """
     Converts a negative mask representing the transparency of the original latent vectors being overlayed
     to a mask that is scaled according to the denoising strength for this step.
@@ -93,10 +105,12 @@ def get_modified_nmask(soft_inpainting, nmask, sigma):
     NOTE: "mask" is not used
     """
     import torch
-    return torch.pow(nmask, (sigma ** soft_inpainting.mask_blend_power) * soft_inpainting.mask_blend_scale)
+    return torch.pow(nmask, (sigma ** settings.mask_blend_power) * settings.mask_blend_scale)
 
 
 def apply_adaptive_masks(
+        settings:SoftInpaintingSettings,
+        nmask,
         latent_orig,
         latent_processed,
         overlay_images,
@@ -108,11 +122,13 @@ def apply_adaptive_masks(
     from PIL import Image, ImageOps, ImageFilter
 
     # TODO: Bias the blending according to the latent mask, add adjustable parameter for bias control.
-    # latent_mask = p.nmask[0].float().cpu()
+    latent_mask = nmask[0].float()
     # convert the original mask into a form we use to scale distances for thresholding
-    # mask_scalar = 1-(torch.clamp(latent_mask, min=0, max=1) ** (p.mask_blend_scale / 2))
-    # mask_scalar = mask_scalar / (1.00001-mask_scalar)
-    # mask_scalar = mask_scalar.numpy()
+    mask_scalar = 1-(torch.clamp(latent_mask, min=0, max=1) ** (settings.mask_blend_scale / 2))
+    mask_scalar = (0.5 * (1-settings.composite_mask_influence)
+                   + mask_scalar * settings.composite_mask_influence)
+    mask_scalar = mask_scalar / (1.00001-mask_scalar)
+    mask_scalar = mask_scalar.cpu().numpy()
 
     latent_distance = torch.norm(latent_processed - latent_orig, p=2, dim=1)
 
@@ -128,10 +144,10 @@ def apply_adaptive_masks(
                                                           percentile_min=0.25, percentile_max=0.75, min_width=1)
 
         # The distance at which opacity of original decreases to 50%
-        # half_weighted_distance = 1  # * mask_scalar
-        # converted_mask = converted_mask / half_weighted_distance
+        half_weighted_distance = settings.composite_difference_threshold * mask_scalar
+        converted_mask = converted_mask / half_weighted_distance
 
-        converted_mask = 1 / (1 + converted_mask ** 2)
+        converted_mask = 1 / (1 + converted_mask ** settings.composite_difference_contrast)
         converted_mask = smootherstep(converted_mask)
         converted_mask = 1 - converted_mask
         converted_mask = 255. * converted_mask
@@ -161,7 +177,7 @@ def apply_adaptive_masks(
 
 
 def apply_masks(
-        soft_inpainting,
+        settings,
         nmask,
         overlay_images,
         width, height,
@@ -172,7 +188,7 @@ def apply_masks(
     from PIL import Image, ImageOps, ImageFilter
 
     converted_mask = nmask[0].float()
-    converted_mask = torch.clamp(converted_mask, min=0, max=1).pow_(soft_inpainting.mask_blend_scale / 2)
+    converted_mask = torch.clamp(converted_mask, min=0, max=1).pow_(settings.mask_blend_scale / 2)
     converted_mask = 255. * converted_mask
     converted_mask = converted_mask.cpu().numpy().astype(np.uint8)
     converted_mask = Image.fromarray(converted_mask)
@@ -395,7 +411,7 @@ def get_gaussian_kernel(stddev_radius=1.0, max_radius=2):
 # ------------------- Constants -------------------
 
 
-default = SoftInpaintingSettings(1, 0.5, 4)
+default = SoftInpaintingSettings(1, 0.5, 4, 0, 0.5, 2)
 
 enabled_ui_label = "Soft inpainting"
 enabled_gen_param_label = "Soft inpainting enabled"
@@ -404,25 +420,37 @@ enabled_el_id = "soft_inpainting_enabled"
 ui_labels = SoftInpaintingSettings(
     "Schedule bias",
     "Preservation strength",
-    "Transition contrast boost")
+    "Transition contrast boost",
+    "Mask influence",
+    "Difference threshold",
+    "Difference contrast")
 
 ui_info = SoftInpaintingSettings(
     "Shifts when preservation of original content occurs during denoising.",
     "How strongly partially masked content should be preserved.",
-    "Amplifies the contrast that may be lost in partially masked regions.")
+    "Amplifies the contrast that may be lost in partially masked regions.",
+    "How strongly the original mask should bias the difference threshold.",
+    "How much an image region can change before the original pixels are not blended in anymore.",
+    "How sharp the transition should be between blended and not blended.")
 
 gen_param_labels = SoftInpaintingSettings(
     "Soft inpainting schedule bias",
     "Soft inpainting preservation strength",
-    "Soft inpainting transition contrast boost")
+    "Soft inpainting transition contrast boost",
+    "Soft inpainting mask influence",
+    "Soft inpainting difference threshold",
+    "Soft inpainting difference contrast")
 
 el_ids = SoftInpaintingSettings(
     "mask_blend_power",
     "mask_blend_scale",
-    "inpaint_detail_preservation")
+    "inpaint_detail_preservation",
+    "composite_mask_influence",
+    "composite_difference_threshold",
+    "composite_difference_contrast")
 
 
-# -----
+# ------------------- Script -------------------
 
 
 class Script(scripts.Script):
@@ -449,28 +477,62 @@ class Script(scripts.Script):
                     **High _Mask blur_** values are recommended!
                     """)
 
-                result = SoftInpaintingSettings(
+                power = \
                     gr.Slider(label=ui_labels.mask_blend_power,
                               info=ui_info.mask_blend_power,
                               minimum=0,
                               maximum=8,
                               step=0.1,
                               value=default.mask_blend_power,
-                              elem_id=el_ids.mask_blend_power),
+                              elem_id=el_ids.mask_blend_power)
+                scale = \
                     gr.Slider(label=ui_labels.mask_blend_scale,
                               info=ui_info.mask_blend_scale,
                               minimum=0,
                               maximum=8,
                               step=0.05,
                               value=default.mask_blend_scale,
-                              elem_id=el_ids.mask_blend_scale),
+                              elem_id=el_ids.mask_blend_scale)
+                detail = \
                     gr.Slider(label=ui_labels.inpaint_detail_preservation,
                               info=ui_info.inpaint_detail_preservation,
                               minimum=1,
                               maximum=32,
                               step=0.5,
                               value=default.inpaint_detail_preservation,
-                              elem_id=el_ids.inpaint_detail_preservation))
+                              elem_id=el_ids.inpaint_detail_preservation)
+
+                gr.Markdown(
+                    """
+                    ### Pixel Composite Settings
+                    """)
+
+                mask_inf = \
+                    gr.Slider(label=ui_labels.composite_mask_influence,
+                              info=ui_info.composite_mask_influence,
+                              minimum=0,
+                              maximum=1,
+                              step=0.05,
+                              value=default.composite_mask_influence,
+                              elem_id=el_ids.composite_mask_influence)
+
+                dif_thresh = \
+                    gr.Slider(label=ui_labels.composite_difference_threshold,
+                              info=ui_info.composite_difference_threshold,
+                              minimum=0,
+                              maximum=8,
+                              step=0.25,
+                              value=default.composite_difference_threshold,
+                              elem_id=el_ids.composite_difference_threshold)
+
+                dif_contr = \
+                    gr.Slider(label=ui_labels.composite_difference_contrast,
+                              info=ui_info.composite_difference_contrast,
+                              minimum=0,
+                              maximum=8,
+                              step=0.25,
+                              value=default.composite_difference_contrast,
+                              elem_id=el_ids.composite_difference_contrast)
 
                 with gr.Accordion("Help", open=False):
                     gr.Markdown(
@@ -507,41 +569,86 @@ class Script(scripts.Script):
                         - **High values**: Stronger contrast, may over-saturate colors.
                         """)
 
+                    gr.Markdown(
+                        """
+                        ## Pixel Composite Settings
+                        
+                        Masks are generated based on how much a part of the image changed after denoising.
+                        These masks are used to blend the original and final images together.
+                        If the difference is low, the original pixels are used instead of the pixels returned by the inpainting process.
+                        """)
+
+                    gr.Markdown(
+                        f"""
+                        ### {ui_labels.composite_mask_influence}
+
+                        This parameter controls how much the mask should bias this sensitivity to difference.
+
+                        - **0**: Ignore the mask, only consider differences in image content.
+                        - **1**: Follow the mask closely despite image content changes.
+                        """)
+
+                    gr.Markdown(
+                        f"""
+                        ### {ui_labels.composite_difference_threshold}
+
+                        This value represents the difference at which the opacity of the original pixels will have less than 50% opacity.
+
+                        - **Low values**: Two images patches must be almost the same in order to retain original pixels.
+                        - **High values**: Two images patches can be very different and still retain original pixels.
+                        """)
+
+                    gr.Markdown(
+                        f"""
+                        ### {ui_labels.composite_difference_contrast}
+
+                        This value represents the difference at which the opacity of the original pixels will have less than 50% opacity.
+
+                        - **Low values**: Two images patches must be almost the same in order to retain original pixels.
+                        - **High values**: Two images patches can be very different and still retain original pixels.
+                        """)
+
         self.infotext_fields = [(soft_inpainting_enabled, enabled_gen_param_label),
-                                (result.mask_blend_power, gen_param_labels.mask_blend_power),
-                                (result.mask_blend_scale, gen_param_labels.mask_blend_scale),
-                                (result.inpaint_detail_preservation, gen_param_labels.inpaint_detail_preservation)]
+                                (power, gen_param_labels.mask_blend_power),
+                                (scale, gen_param_labels.mask_blend_scale),
+                                (detail, gen_param_labels.inpaint_detail_preservation),
+                                (mask_inf, gen_param_labels.composite_mask_influence),
+                                (dif_thresh, gen_param_labels.composite_difference_threshold),
+                                (dif_contr, gen_param_labels.composite_difference_contrast)]
 
         self.paste_field_names = []
         for _, field_name in self.infotext_fields:
             self.paste_field_names.append(field_name)
 
         return [soft_inpainting_enabled,
-                result.mask_blend_power,
-                result.mask_blend_scale,
-                result.inpaint_detail_preservation]
-
-    def process(self, p, enabled, power, scale, detail_preservation):
+                power,
+                scale,
+                detail,
+                mask_inf,
+                dif_thresh,
+                dif_contr]
+
+    def process(self, p, enabled, power, scale, detail_preservation, mask_inf, dif_thresh, dif_contr):
         if not enabled:
             return
 
         # Shut off the rounding it normally does.
         p.mask_round = False
 
-        settings = SoftInpaintingSettings(power, scale, detail_preservation)
+        settings = SoftInpaintingSettings(power, scale, detail_preservation, mask_inf, dif_thresh, dif_contr)
 
         # p.extra_generation_params["Mask rounding"] = False
         settings.add_generation_params(p.extra_generation_params)
 
-    def on_mask_blend(self, p, mba: scripts.MaskBlendArgs, enabled, power, scale, detail_preservation):
+    def on_mask_blend(self, p, mba: scripts.MaskBlendArgs, enabled, power, scale, detail_preservation, mask_inf, dif_thresh, dif_contr):
         if not enabled:
             return
 
-        if mba.sigma is None:
+        if mba.is_final_blend:
             mba.blended_latent = mba.current_latent
             return
 
-        settings = SoftInpaintingSettings(power, scale, detail_preservation)
+        settings = SoftInpaintingSettings(power, scale, detail_preservation, mask_inf, dif_thresh, dif_contr)
 
         # todo: Why is sigma 2D? Both values are the same.
         mba.blended_latent = latent_blend(settings,
@@ -549,11 +656,11 @@ class Script(scripts.Script):
                                           mba.current_latent,
                                           get_modified_nmask(settings, mba.nmask, mba.sigma[0]))
 
-    def post_sample(self, p, ps: scripts.PostSampleArgs, enabled, power, scale, detail_preservation):
+    def post_sample(self, p, ps: scripts.PostSampleArgs, enabled, power, scale, detail_preservation, mask_inf, dif_thresh, dif_contr):
         if not enabled:
             return
 
-        settings = SoftInpaintingSettings(power, scale, detail_preservation)
+        settings = SoftInpaintingSettings(power, scale, detail_preservation, mask_inf, dif_thresh, dif_contr)
 
         from modules import images
         from modules.shared import opts
@@ -570,15 +677,20 @@ class Script(scripts.Script):
 
             self.overlay_images.append(image.convert('RGBA'))
 
+        if len(p.init_images) == 1:
+            self.overlay_images = self.overlay_images * p.batch_size
+
         if getattr(ps.samples, 'already_decoded', False):
-            self.masks_for_overlay = apply_masks(soft_inpainting=settings,
+            self.masks_for_overlay = apply_masks(settings=settings,
                                                  nmask=p.nmask,
                                                  overlay_images=self.overlay_images,
                                                  width=p.width,
                                                  height=p.height,
                                                  paste_to=p.paste_to)
         else:
-            self.masks_for_overlay = apply_adaptive_masks(latent_orig=p.init_latent,
+            self.masks_for_overlay = apply_adaptive_masks(settings=settings,
+                                                          nmask=p.nmask,
+                                                          latent_orig=p.init_latent,
                                                           latent_processed=ps.samples,
                                                           overlay_images=self.overlay_images,
                                                           width=p.width,
@@ -586,7 +698,7 @@ class Script(scripts.Script):
                                                           paste_to=p.paste_to)
 
 
-    def postprocess_maskoverlay(self, p, ppmo: scripts.PostProcessMaskOverlayArgs, enabled, power, scale, detail_preservation):
+    def postprocess_maskoverlay(self, p, ppmo: scripts.PostProcessMaskOverlayArgs, enabled, power, scale, detail_preservation, mask_inf, dif_thresh, dif_contr):
         if not enabled:
             return
 
-- 
cgit v1.2.3


From fc3e246c0f4f292c33b181a902cd934629ff0d7a Mon Sep 17 00:00:00 2001
From: CodeHatchling <steve@codehatch.com>
Date: Thu, 7 Dec 2023 20:28:38 -0700
Subject: Fixed complaint about whitespace, updated help section for a
 parameter.

---
 scripts/soft_inpainting.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'scripts')

diff --git a/scripts/soft_inpainting.py b/scripts/soft_inpainting.py
index 1b21aee9..6fb5cfbd 100644
--- a/scripts/soft_inpainting.py
+++ b/scripts/soft_inpainting.py
@@ -572,7 +572,7 @@ class Script(scripts.Script):
                     gr.Markdown(
                         """
                         ## Pixel Composite Settings
-                        
+
                         Masks are generated based on how much a part of the image changed after denoising.
                         These masks are used to blend the original and final images together.
                         If the difference is low, the original pixels are used instead of the pixels returned by the inpainting process.
@@ -602,10 +602,10 @@ class Script(scripts.Script):
                         f"""
                         ### {ui_labels.composite_difference_contrast}
 
-                        This value represents the difference at which the opacity of the original pixels will have less than 50% opacity.
+                        This value represents the contrast between the opacity of the original and inpainted content.
 
-                        - **Low values**: Two images patches must be almost the same in order to retain original pixels.
-                        - **High values**: Two images patches can be very different and still retain original pixels.
+                        - **Low values**: The blend will be more gradual and have longer transitions, but may cause ghosting.
+                        - **High values**: Ghosting will be less common, but transitions may be very sudden.
                         """)
 
         self.infotext_fields = [(soft_inpainting_enabled, enabled_gen_param_label),
-- 
cgit v1.2.3


From 659f62e120b210e3043712ff928e8b7b6cd6cf61 Mon Sep 17 00:00:00 2001
From: CodeHatchling <steve@codehatch.com>
Date: Thu, 7 Dec 2023 21:39:54 -0700
Subject: Fixed grammar error.

---
 scripts/soft_inpainting.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'scripts')

diff --git a/scripts/soft_inpainting.py b/scripts/soft_inpainting.py
index 6fb5cfbd..51f9ca2f 100644
--- a/scripts/soft_inpainting.py
+++ b/scripts/soft_inpainting.py
@@ -592,7 +592,7 @@ class Script(scripts.Script):
                         f"""
                         ### {ui_labels.composite_difference_threshold}
 
-                        This value represents the difference at which the opacity of the original pixels will have less than 50% opacity.
+                        This value represents the difference at which the original pixels will have less than 50% opacity.
 
                         - **Low values**: Two images patches must be almost the same in order to retain original pixels.
                         - **High values**: Two images patches can be very different and still retain original pixels.
-- 
cgit v1.2.3


From b2414476ef164ba55cff2508c58b73d23bbc3000 Mon Sep 17 00:00:00 2001
From: CodeHatchling <steve@codehatch.com>
Date: Fri, 8 Dec 2023 17:32:41 -0700
Subject: soft_inpainting now appears in the "inpaint" section, and will not
 activate unless inpainting is activated.

---
 scripts/soft_inpainting.py | 43 +++++++++++++++++++++++++++++++++++++++----
 1 file changed, 39 insertions(+), 4 deletions(-)

(limited to 'scripts')

diff --git a/scripts/soft_inpainting.py b/scripts/soft_inpainting.py
index 51f9ca2f..f10a1e56 100644
--- a/scripts/soft_inpainting.py
+++ b/scripts/soft_inpainting.py
@@ -32,6 +32,19 @@ class SoftInpaintingSettings:
 
 # ------------------- Methods -------------------
 
+def processing_uses_inpainting(p):
+    # TODO: Figure out a better way to determine if inpainting is being used by p
+    if getattr(p, "image_mask", None) is not None:
+        return True
+
+    if getattr(p, "mask", None) is not None:
+        return True
+
+    if getattr(p, "nmask", None) is not None:
+        return True
+
+    return False
+
 
 def latent_blend(settings, a, b, t):
     """
@@ -454,8 +467,8 @@ el_ids = SoftInpaintingSettings(
 
 
 class Script(scripts.Script):
-
     def __init__(self):
+        self.section = "inpaint"
         self.masks_for_overlay = None
         self.overlay_images = None
 
@@ -632,6 +645,9 @@ class Script(scripts.Script):
         if not enabled:
             return
 
+        if not processing_uses_inpainting(p):
+            return
+
         # Shut off the rounding it normally does.
         p.mask_round = False
 
@@ -644,6 +660,9 @@ class Script(scripts.Script):
         if not enabled:
             return
 
+        if not processing_uses_inpainting(p):
+            return
+
         if mba.is_final_blend:
             mba.blended_latent = mba.current_latent
             return
@@ -660,11 +679,18 @@ class Script(scripts.Script):
         if not enabled:
             return
 
-        settings = SoftInpaintingSettings(power, scale, detail_preservation, mask_inf, dif_thresh, dif_contr)
+        if not processing_uses_inpainting(p):
+            return
+
+        nmask = getattr(p, "nmask", None)
+        if nmask is None:
+            return
 
         from modules import images
         from modules.shared import opts
 
+        settings = SoftInpaintingSettings(power, scale, detail_preservation, mask_inf, dif_thresh, dif_contr)
+
         # since the original code puts holes in the existing overlay images,
         # we have to rebuild them.
         self.overlay_images = []
@@ -682,14 +708,14 @@ class Script(scripts.Script):
 
         if getattr(ps.samples, 'already_decoded', False):
             self.masks_for_overlay = apply_masks(settings=settings,
-                                                 nmask=p.nmask,
+                                                 nmask=nmask,
                                                  overlay_images=self.overlay_images,
                                                  width=p.width,
                                                  height=p.height,
                                                  paste_to=p.paste_to)
         else:
             self.masks_for_overlay = apply_adaptive_masks(settings=settings,
-                                                          nmask=p.nmask,
+                                                          nmask=nmask,
                                                           latent_orig=p.init_latent,
                                                           latent_processed=ps.samples,
                                                           overlay_images=self.overlay_images,
@@ -702,5 +728,14 @@ class Script(scripts.Script):
         if not enabled:
             return
 
+        if not processing_uses_inpainting(p):
+            return
+
+        if self.masks_for_overlay is None:
+            return
+
+        if self.overlay_images is None:
+            return
+
         ppmo.mask_for_overlay = self.masks_for_overlay[ppmo.index]
         ppmo.overlay_image = self.overlay_images[ppmo.index]
-- 
cgit v1.2.3


From f1ff932cafa2bf34fa35f41072f21a8ea5474d84 Mon Sep 17 00:00:00 2001
From: CodeHatchling <steve@codehatch.com>
Date: Fri, 8 Dec 2023 17:33:11 -0700
Subject: Formatted soft_inpainting.

---
 scripts/soft_inpainting.py | 26 ++++++++++++++++----------
 1 file changed, 16 insertions(+), 10 deletions(-)

(limited to 'scripts')

diff --git a/scripts/soft_inpainting.py b/scripts/soft_inpainting.py
index f10a1e56..d9024344 100644
--- a/scripts/soft_inpainting.py
+++ b/scripts/soft_inpainting.py
@@ -122,7 +122,7 @@ def get_modified_nmask(settings, nmask, sigma):
 
 
 def apply_adaptive_masks(
-        settings:SoftInpaintingSettings,
+        settings: SoftInpaintingSettings,
         nmask,
         latent_orig,
         latent_processed,
@@ -137,10 +137,10 @@ def apply_adaptive_masks(
     # TODO: Bias the blending according to the latent mask, add adjustable parameter for bias control.
     latent_mask = nmask[0].float()
     # convert the original mask into a form we use to scale distances for thresholding
-    mask_scalar = 1-(torch.clamp(latent_mask, min=0, max=1) ** (settings.mask_blend_scale / 2))
-    mask_scalar = (0.5 * (1-settings.composite_mask_influence)
+    mask_scalar = 1 - (torch.clamp(latent_mask, min=0, max=1) ** (settings.mask_blend_scale / 2))
+    mask_scalar = (0.5 * (1 - settings.composite_mask_influence)
                    + mask_scalar * settings.composite_mask_influence)
-    mask_scalar = mask_scalar / (1.00001-mask_scalar)
+    mask_scalar = mask_scalar / (1.00001 - mask_scalar)
     mask_scalar = mask_scalar.cpu().numpy()
 
     latent_distance = torch.norm(latent_processed - latent_orig, p=2, dim=1)
@@ -152,9 +152,9 @@ def apply_adaptive_masks(
     for i, (distance_map, overlay_image) in enumerate(zip(latent_distance, overlay_images)):
         converted_mask = distance_map.float().cpu().numpy()
         converted_mask = weighted_histogram_filter(converted_mask, kernel, kernel_center,
-                                                          percentile_min=0.9, percentile_max=1, min_width=1)
+                                                   percentile_min=0.9, percentile_max=1, min_width=1)
         converted_mask = weighted_histogram_filter(converted_mask, kernel, kernel_center,
-                                                          percentile_min=0.25, percentile_max=0.75, min_width=1)
+                                                   percentile_min=0.25, percentile_max=0.75, min_width=1)
 
         # The distance at which opacity of original decreases to 50%
         half_weighted_distance = settings.composite_difference_threshold * mask_scalar
@@ -276,6 +276,7 @@ def weighted_histogram_filter(img, kernel, kernel_center, percentile_min=0.0, pe
             An element of the histogram, its weight
             and bounds.
             """
+
             def __init__(self, value, weight):
                 self.value: float = value
                 self.weight: float = weight
@@ -355,6 +356,7 @@ def weighted_histogram_filter(img, kernel, kernel_center, percentile_min=0.0, pe
 
     return img_out
 
+
 def smoothstep(x):
     """
     The smoothstep function, input should be clamped to 0-1 range.
@@ -362,6 +364,7 @@ def smoothstep(x):
     """
     return x * x * (3 - 2 * x)
 
+
 def smootherstep(x):
     """
     The smootherstep function, input should be clamped to 0-1 range.
@@ -385,6 +388,7 @@ def get_gaussian_kernel(stddev_radius=1.0, max_radius=2):
     Returns:
         (nparray, nparray): A kernel array (shape: (N, N)), its center coordinate (shape: (2))
     """
+
     # Evaluates a 0-1 normalized gaussian function for a given square distance from the mean.
     def gaussian(sqr_mag):
         return math.exp(-sqr_mag / (stddev_radius * stddev_radius))
@@ -656,7 +660,8 @@ class Script(scripts.Script):
         # p.extra_generation_params["Mask rounding"] = False
         settings.add_generation_params(p.extra_generation_params)
 
-    def on_mask_blend(self, p, mba: scripts.MaskBlendArgs, enabled, power, scale, detail_preservation, mask_inf, dif_thresh, dif_contr):
+    def on_mask_blend(self, p, mba: scripts.MaskBlendArgs, enabled, power, scale, detail_preservation, mask_inf,
+                      dif_thresh, dif_contr):
         if not enabled:
             return
 
@@ -675,7 +680,8 @@ class Script(scripts.Script):
                                           mba.current_latent,
                                           get_modified_nmask(settings, mba.nmask, mba.sigma[0]))
 
-    def post_sample(self, p, ps: scripts.PostSampleArgs, enabled, power, scale, detail_preservation, mask_inf, dif_thresh, dif_contr):
+    def post_sample(self, p, ps: scripts.PostSampleArgs, enabled, power, scale, detail_preservation, mask_inf,
+                    dif_thresh, dif_contr):
         if not enabled:
             return
 
@@ -723,8 +729,8 @@ class Script(scripts.Script):
                                                           height=p.height,
                                                           paste_to=p.paste_to)
 
-
-    def postprocess_maskoverlay(self, p, ppmo: scripts.PostProcessMaskOverlayArgs, enabled, power, scale, detail_preservation, mask_inf, dif_thresh, dif_contr):
+    def postprocess_maskoverlay(self, p, ppmo: scripts.PostProcessMaskOverlayArgs, enabled, power, scale,
+                                detail_preservation, mask_inf, dif_thresh, dif_contr):
         if not enabled:
             return
 
-- 
cgit v1.2.3