Upload outpaint_region.py

outpaint_region.py

@@ -0,0 +1,290 @@
+import math
+
+import numpy as np
+import skimage
+
+import modules.scripts as scripts
+import gradio as gr
+from PIL import Image, ImageDraw
+
+from modules import images, processing, devices
+from modules.processing import Processed, process_images
+from modules.shared import opts, cmd_opts, state
+
+# this function is taken from https://github.com/parlance-zz/g-diffuser-bot
+def get_matched_noise(_np_src_image, np_mask_rgb, noise_q=1, color_variation=0.05):
+    # helper fft routines that keep ortho normalization and auto-shift before and after fft
+    def _fft2(data):
+        if data.ndim > 2:  # has channels
+            out_fft = np.zeros((data.shape[0], data.shape[1], data.shape[2]), dtype=np.complex128)
+            for c in range(data.shape[2]):
+                c_data = data[:, :, c]
+                out_fft[:, :, c] = np.fft.fft2(np.fft.fftshift(c_data), norm="ortho")
+                out_fft[:, :, c] = np.fft.ifftshift(out_fft[:, :, c])
+        else:  # one channel
+            out_fft = np.zeros((data.shape[0], data.shape[1]), dtype=np.complex128)
+            out_fft[:, :] = np.fft.fft2(np.fft.fftshift(data), norm="ortho")
+            out_fft[:, :] = np.fft.ifftshift(out_fft[:, :])
+
+        return out_fft
+
+    def _ifft2(data):
+        if data.ndim > 2:  # has channels
+            out_ifft = np.zeros((data.shape[0], data.shape[1], data.shape[2]), dtype=np.complex128)
+            for c in range(data.shape[2]):
+                c_data = data[:, :, c]
+                out_ifft[:, :, c] = np.fft.ifft2(np.fft.fftshift(c_data), norm="ortho")
+                out_ifft[:, :, c] = np.fft.ifftshift(out_ifft[:, :, c])
+        else:  # one channel
+            out_ifft = np.zeros((data.shape[0], data.shape[1]), dtype=np.complex128)
+            out_ifft[:, :] = np.fft.ifft2(np.fft.fftshift(data), norm="ortho")
+            out_ifft[:, :] = np.fft.ifftshift(out_ifft[:, :])
+
+        return out_ifft
+
+    def _get_gaussian_window(width, height, std=3.14, mode=0):
+        window_scale_x = float(width / min(width, height))
+        window_scale_y = float(height / min(width, height))
+
+        window = np.zeros((width, height))
+        x = (np.arange(width) / width * 2. - 1.) * window_scale_x
+        for y in range(height):
+            fy = (y / height * 2. - 1.) * window_scale_y
+            if mode == 0:
+                window[:, y] = np.exp(-(x ** 2 + fy ** 2) * std)
+            else:
+                window[:, y] = (1 / ((x ** 2 + 1.) * (fy ** 2 + 1.))) ** (std / 3.14)  # hey wait a minute that's not gaussian
+
+        return window
+
+    def _get_masked_window_rgb(np_mask_grey, hardness=1.):
+        np_mask_rgb = np.zeros((np_mask_grey.shape[0], np_mask_grey.shape[1], 3))
+        if hardness != 1.:
+            hardened = np_mask_grey[:] ** hardness
+        else:
+            hardened = np_mask_grey[:]
+        for c in range(3):
+            np_mask_rgb[:, :, c] = hardened[:]
+        return np_mask_rgb
+
+    width = _np_src_image.shape[0]
+    height = _np_src_image.shape[1]
+    num_channels = _np_src_image.shape[2]
+
+    np_src_image = _np_src_image[:] * (1. - np_mask_rgb)
+    np_mask_grey = (np.sum(np_mask_rgb, axis=2) / 3.)
+    img_mask = np_mask_grey > 1e-6
+    ref_mask = np_mask_grey < 1e-3
+
+    windowed_image = _np_src_image * (1. - _get_masked_window_rgb(np_mask_grey))
+    windowed_image /= np.max(windowed_image)
+    windowed_image += np.average(_np_src_image) * np_mask_rgb  # / (1.-np.average(np_mask_rgb))  # rather than leave the masked area black, we get better results from fft by filling the average unmasked color
+
+    src_fft = _fft2(windowed_image)  # get feature statistics from masked src img
+    src_dist = np.absolute(src_fft)
+    src_phase = src_fft / src_dist
+
+    # create a generator with a static seed to make outpainting deterministic / only follow global seed
+    rng = np.random.default_rng(0)
+
+    noise_window = _get_gaussian_window(width, height, mode=1)  # start with simple gaussian noise
+    noise_rgb = rng.random((width, height, num_channels))
+    noise_grey = (np.sum(noise_rgb, axis=2) / 3.)
+    noise_rgb *= color_variation  # the colorfulness of the starting noise is blended to greyscale with a parameter
+    for c in range(num_channels):
+        noise_rgb[:, :, c] += (1. - color_variation) * noise_grey
+
+    noise_fft = _fft2(noise_rgb)
+    for c in range(num_channels):
+        noise_fft[:, :, c] *= noise_window
+    noise_rgb = np.real(_ifft2(noise_fft))
+    shaped_noise_fft = _fft2(noise_rgb)
+    shaped_noise_fft[:, :, :] = np.absolute(shaped_noise_fft[:, :, :]) ** 2 * (src_dist ** noise_q) * src_phase  # perform the actual shaping
+
+    brightness_variation = 0.  # color_variation # todo: temporarily tieing brightness variation to color variation for now
+    contrast_adjusted_np_src = _np_src_image[:] * (brightness_variation + 1.) - brightness_variation * 2.
+
+    # scikit-image is used for histogram matching, very convenient!
+    shaped_noise = np.real(_ifft2(shaped_noise_fft))
+    shaped_noise -= np.min(shaped_noise)
+    shaped_noise /= np.max(shaped_noise)
+    shaped_noise[img_mask, :] = skimage.exposure.match_histograms(shaped_noise[img_mask, :] ** 1., contrast_adjusted_np_src[ref_mask, :], channel_axis=1)
+    shaped_noise = _np_src_image[:] * (1. - np_mask_rgb) + shaped_noise * np_mask_rgb
+
+    matched_noise = shaped_noise[:]
+
+    return np.clip(matched_noise, 0., 1.)
+
+class Script(scripts.Script):
+    def title(self):
+        return "Outpaint Canvas Region"
+
+    def show(self, is_img2img):
+        return is_img2img
+
+    def ui(self, is_img2img):
+        if not is_img2img:
+            return None
+
+        canvasButton = gr.Button("Show/Hide Canvas")
+        leftcoord = gr.Slider(label="Left start coord", minimum=-400, maximum=2048, step=1, value=0, elem_id="leftCoord")
+        topcoord = gr.Slider(label="top start coord", minimum=-400, maximum=2048, step=1, value=0, elem_id="topCoord")
+        dummy = gr.Slider(label="unused", minimum=-1, maximum=1, step=1, value=0)
+        
+        canvasButton.click(None, [], dummy, _js="(x) => {   let grap = document.body.children[0];\
+                                                            let tabDiv = grap.shadowRoot.getElementById('tab_img2img');\
+                                                            let img2imgDiv = grap.shadowRoot.getElementById('img2img_image');\
+                                                            let imgB64 = img2imgDiv.children[2].children[0].children[1].src;\
+                                                            let canvDiv = grap.shadowRoot.getElementById('outDrawCanvasDiv');\
+                                                            let canv = grap.shadowRoot.getElementById('outDrawCanvas');\
+                                                            console.info('run',canvDiv);\
+                                                            if (!canvDiv) {\
+                                                              canvDiv = document.createElement('div');\
+                                                              canvDiv.id = 'outDrawCanvasDiv';\
+                                                              canv = document.createElement('canvas');\
+                                                              canv.id = 'outDrawCanvas';\
+                                                              canvDiv.append(canv);\
+                                                              tabDiv.append(canvDiv);\
+                                                              canvDiv.style.display = 'none';\
+                                                              canvDiv.style.position = 'absolute';\
+                                                              canvDiv.style.left = '50px';\
+                                                              canvDiv.style.right = '50px';\
+                                                              canvDiv.style.top = '50px';\
+                                                              canvDiv.style.bottom = '50px';\
+                                                              canvDiv.style.zIndex = '1000';\
+                                                              canvDiv.style.background = '#d0d0d0';\
+                                                              canvDiv.style.overflow = 'auto';\
+                                                              canv.onclick = function(event) {\
+                                                                event.stopPropagation();\
+                                                                let rect = canv.getBoundingClientRect();\
+                                                                let x = event.clientX - rect.left;\
+                                                                let y = event.clientY - rect.top;\
+                                                                if (x>canv.width-512 || y>canv.height-512) return;\
+                                                                let ctx = canv.getContext('2d');\
+                                                                ctx.fillStyle = 'black';\
+                                                                ctx.fillRect(0, 0, canv.width, canv.height);\
+                                                                ctx.drawImage(canv.storeImage, 400, 400, canv.width-800, canv.height-800);\
+                                                                ctx.beginPath();\
+                                                                ctx.lineWidth = '2';\
+                                                                ctx.strokeStyle = 'white';\
+                                                                ctx.rect(x, y, 512, 512);\
+                                                                ctx.stroke();\
+                                                                grap.shadowRoot.getElementById('leftCoord').getElementsByTagName('input')[0].value = x - 400;\
+                                                                grap.shadowRoot.getElementById('leftCoord').getElementsByTagName('input')[1].value = x - 400;\
+                                                                grap.shadowRoot.getElementById('topCoord').getElementsByTagName('input')[0].value = y -400;\
+                                                                grap.shadowRoot.getElementById('topCoord').getElementsByTagName('input')[1].value = y - 400;\
+                                                                grap.shadowRoot.getElementById('leftCoord').getElementsByTagName('input')[0].dispatchEvent(new Event('input'));\
+                                                                grap.shadowRoot.getElementById('topCoord').getElementsByTagName('input')[0].dispatchEvent(new Event('input'));\
+                                                              }\
+                                                            }\
+                                                            console.info(canvDiv.style.display);\
+                                                            if (canvDiv.style.display!=='none') {\
+                                                              canvDiv.style.display = 'none';\
+                                                              return 0;\
+                                                            }\
+                                                            if (canv && imgB64) {\
+                                                              let ctx = canv.getContext('2d');\
+                                                              let image = new Image();\
+                                                              image.onload = function() {\
+                                                                console.info('onLoad');\
+                                                                canv.width = this.width;\
+                                                                canv.height = this.height;\
+                                                                ctx.drawImage(this, 0, 0);\
+                                                                let pixelData = ctx.getImageData(0, 0, canv.width, canv.height).data;\
+                                                                let firstX = 9999;\
+                                                                let firstY = 9999;\
+                                                                let lastX = 0;\
+                                                                let lastY = 0;\
+                                                                for (let y=0;y<this.height;y=y+10) {\
+                                                                  for (let x=0;x<this.width;x++) {\
+                                                                    if (pixelData[y*this.width*3+x*3] || pixelData[y*this.width*3+x*3+1] || pixelData[y*this.width*3+x*3+2]) {\
+                                                                      if (x<firstX) firstX = x;\
+                                                                      if (x>lastX) lastX = x;\
+                                                                    }\
+                                                                  }\
+                                                                }\
+                                                                for (let x=0;x<this.width;x=x+10) {\
+                                                                  for (let y=0;y<this.height;y++) {\
+                                                                    if (pixelData[y*this.width*3+x*3] || pixelData[y*this.width*3+x*3+1] || pixelData[y*this.width*3+x*3+2]) {\
+                                                                      if (y<firstY) firstY = y;\
+                                                                      if (y>lastY) lastY = y;\
+                                                                    }\
+                                                                  }\
+                                                                }\
+                                                                if (lastX<firstX || lastY < firstY) return 0;\
+                                                                canv.width = (lastX - firstX) + 800;\
+                                                                canv.style.width = canv.width + 'px';\
+                                                                canv.height = (lastY - firstY) + 800;\
+                                                                canv.style.height = canv.height + 'px';\
+                                                                ctx.fillStyle = 'black';\
+                                                                ctx.fillRect(0, 0, canv.width, canv.height);\
+                                                                ctx.drawImage(image, 400, 400, (lastX - firstX), (lastY - firstY));\
+                                                                canvDiv.style.display = 'block';\
+                                                                canvDiv.style.position = 'fixed';\
+                                                                canvDiv.style.left = '400px';\
+                                                                canvDiv.style.width = 'calc(100% - 400px)';\
+                                                                canvDiv.style.top = '0px';\
+                                                                canvDiv.style.height = '100%';\
+                                                                canv.storeImage = this; \
+                                                              };\
+                                                              console.info('loading image');\
+                                                              image.src = imgB64;\
+                                                            };\
+                                                            return 0}")
+        return [leftcoord, topcoord,canvasButton,dummy]
+
+    def run(self, p, leftcoord, topcoord,canvasButton,dummy):
+        initial_seed = None
+        initial_info = None
+        p.mask_blur = 0
+        p.inpaint_full_res = False
+        p.do_not_save_samples = True
+        p.do_not_save_grid = True
+        origInBaseLeft = 0
+        origInBaseTop = 0
+        workItemLeft = leftcoord
+        workItemTop = topcoord
+        newwidth = p.init_images[0].width
+        newheight = p.init_images[0].height
+        if leftcoord<0: 
+          newwidth = newwidth - leftcoord
+          origInBaseLeft = -leftcoord
+          workItemLeft = 0          
+        if topcoord<0:
+          newheight = newheight - topcoord
+          origInBaseTop = -topcoord
+          workItemTop = 0
+        if leftcoord + p.width > newwidth:
+          newwidth = leftcoord + p.width
+        if topcoord + p.height > newheight:
+          newheight = topcoord + p.height
+        newBase = Image.new("RGB", (newwidth, newheight), "black")
+        newBase.paste(p.init_images[0], (origInBaseLeft, origInBaseTop))
+        workItem = Image.new("RGB", (p.width, p.height))
+        region = newBase.crop((workItemLeft, workItemTop, workItemLeft+p.width, workItemTop + p.height))
+        workItem.paste(region, (0,0))
+        workData = np.array(workItem).astype(np.float32) / 255.0
+        mask = Image.new("L", (p.width, p.height),color=255)
+        maskData = np.array(mask)
+        for y in range(p.height):
+          for x in range(p.width):
+            if workData[y][x][0] + workData[y][x][1] + workData[y][x][2] > 0.001:
+              maskData[y][x] = 0
+        p.image_mask = Image.fromarray(maskData, mode="L")
+        np_image = (np.asarray(workItem) / 255.0).astype(np.float64)
+        np_mask = (np.asarray(p.image_mask.convert('RGB')) / 255.0).astype(np.float64)
+        noised = get_matched_noise(np_image, np_mask)
+        workItem = Image.fromarray(np.clip(noised * 255., 0., 255.).astype(np.uint8), mode="RGB")
+        workImages = []
+        for n in range(p.batch_size):
+          workImages.append(workItem)
+        p.init_images = workImages
+        p.latent_mask = None
+        proc = process_images(p)
+        results = []
+        for n in range(p.batch_size):
+          proc_img = proc.images[n]
+          final_image = newBase.copy()
+          final_image.paste(proc_img,(workItemLeft,workItemTop))
+          proc.images[n] = final_image
+        return proc