Upload 2 files

Revision by XpucT.py

@@ -5,11 +5,14 @@ import modules.scripts as scripts
 import gradio as gr
 import numpy as np
 import cv2
+import math
+import random
+import modules.images as images
 
-from PIL import Image
-from modules.processing import process_images, Processed
-from PIL import ImageEnhance, Image, ImageDraw, ImageFilter, ImageChops, ImageOps
+from modules.processing import Processed
+from PIL import ImageEnhance, Image, ImageDraw, ImageFilter, ImageChops, ImageOps, ImageFont
 from blendmodes.blend import blendLayers, BlendType
+from typing import List
 
 
 def resetValues(saturationSlider, temperatureSlider, brightnessSlider, contrastSlider, sharpnessSlider, blurSlider, noiseSlider, vignetteSlider, exposureOffsetSlider, hdrSlider):
@@ -40,124 +43,575 @@ def bestChoiceValues(saturationSlider, temperatureSlider, brightnessSlider, cont
     return [saturationSlider, temperatureSlider, brightnessSlider, contrastSlider, sharpnessSlider, blurSlider, noiseSlider, vignetteSlider, exposureOffsetSlider, hdrSlider]
 
 
+def add_chromatic(im, strength: float = 1, no_blur: bool = False):
+
+    if (im.size[0] % 2 == 0 or im.size[1] % 2 == 0):
+        if (im.size[0] % 2 == 0):
+            im = im.crop((0, 0, im.size[0] - 1, im.size[1]))
+            im.load()
+        if (im.size[1] % 2 == 0):
+            im = im.crop((0, 0, im.size[0], im.size[1] - 1))
+            im.load()
+
+    def cartesian_to_polar(data: np.ndarray) -> np.ndarray:
+        width = data.shape[1]
+        height = data.shape[0]
+        assert (width > 2)
+        assert (height > 2)
+        assert (width % 2 == 1)
+        assert (height % 2 == 1)
+        perimeter = 2 * (width + height - 2)
+        halfdiag = math.ceil(((width ** 2 + height ** 2) ** 0.5) / 2)
+        halfw = width // 2
+        halfh = height // 2
+        ret = np.zeros((halfdiag, perimeter, 3))
+
+        ret[0:(halfw + 1), halfh] = data[halfh, halfw::-1]
+        ret[0:(halfw + 1), height + width - 2 +
+            halfh] = data[halfh, halfw:(halfw * 2 + 1)]
+        ret[0:(halfh + 1), height - 1 +
+            halfw] = data[halfh:(halfh * 2 + 1), halfw]
+        ret[0:(halfh + 1), perimeter - halfw] = data[halfh::-1, halfw]
+
+        for i in range(0, halfh):
+            slope = (halfh - i) / (halfw)
+            diagx = ((halfdiag ** 2) / (slope ** 2 + 1)) ** 0.5
+            unit_xstep = diagx / (halfdiag - 1)
+            unit_ystep = diagx * slope / (halfdiag - 1)
+            for row in range(halfdiag):
+                ystep = round(row * unit_ystep)
+                xstep = round(row * unit_xstep)
+                if ((halfh >= ystep) and halfw >= xstep):
+                    ret[row, i] = data[halfh - ystep, halfw - xstep]
+                    ret[row, height - 1 - i] = data[halfh + ystep, halfw - xstep]
+                    ret[row, height + width - 2 +
+                        i] = data[halfh + ystep, halfw + xstep]
+                    ret[row, height + width + height - 3 -
+                        i] = data[halfh - ystep, halfw + xstep]
+                else:
+                    break
+
+        for j in range(1, halfw):
+            slope = (halfh) / (halfw - j)
+            diagx = ((halfdiag ** 2) / (slope ** 2 + 1)) ** 0.5
+            unit_xstep = diagx / (halfdiag - 1)
+            unit_ystep = diagx * slope / (halfdiag - 1)
+            for row in range(halfdiag):
+                ystep = round(row * unit_ystep)
+                xstep = round(row * unit_xstep)
+                if (halfw >= xstep and halfh >= ystep):
+                    ret[row, height - 1 + j] = data[halfh + ystep, halfw - xstep]
+                    ret[row, height + width - 2 -
+                        j] = data[halfh + ystep, halfw + xstep]
+                    ret[row, height + width + height - 3 +
+                        j] = data[halfh - ystep, halfw + xstep]
+                    ret[row, perimeter - j] = data[halfh - ystep, halfw - xstep]
+                else:
+                    break
+        return ret
+
+    def polar_to_cartesian(data: np.ndarray, width: int, height: int) -> np.ndarray:
+        assert (width > 2)
+        assert (height > 2)
+        assert (width % 2 == 1)
+        assert (height % 2 == 1)
+        perimeter = 2 * (width + height - 2)
+        halfdiag = math.ceil(((width ** 2 + height ** 2) ** 0.5) / 2)
+        halfw = width // 2
+        halfh = height // 2
+        ret = np.zeros((height, width, 3))
+
+        def div0():
+            ret[halfh, halfw::-1] = data[0:(halfw + 1), halfh]
+            ret[halfh, halfw:(halfw * 2 + 1)] = data[0:(halfw + 1),
+                                                     height + width - 2 + halfh]
+            ret[halfh:(halfh * 2 + 1), halfw] = data[0:(halfh + 1),
+                                                     height - 1 + halfw]
+            ret[halfh::-1, halfw] = data[0:(halfh + 1), perimeter - halfw]
+
+        div0()
+
+        def part1():
+            for i in range(0, halfh):
+                slope = (halfh - i) / (halfw)
+                diagx = ((halfdiag ** 2) / (slope ** 2 + 1)) ** 0.5
+                unit_xstep = diagx / (halfdiag - 1)
+                unit_ystep = diagx * slope / (halfdiag - 1)
+                for row in range(halfdiag):
+                    ystep = round(row * unit_ystep)
+                    xstep = round(row * unit_xstep)
+                    if ((halfh >= ystep) and halfw >= xstep):
+                        ret[halfh - ystep, halfw - xstep] = \
+                            data[row, i]
+                        ret[halfh + ystep, halfw - xstep] = \
+                            data[row, height - 1 - i]
+                        ret[halfh + ystep, halfw + xstep] = \
+                            data[row, height + width - 2 + i]
+                        ret[halfh - ystep, halfw + xstep] = \
+                            data[row, height + width + height - 3 - i]
+                    else:
+                        break
+
+        part1()
+
+        def part2():
+            for j in range(1, halfw):
+                slope = (halfh) / (halfw - j)
+                diagx = ((halfdiag ** 2) / (slope ** 2 + 1)) ** 0.5
+                unit_xstep = diagx / (halfdiag - 1)
+                unit_ystep = diagx * slope / (halfdiag - 1)
+                for row in range(halfdiag):
+                    ystep = round(row * unit_ystep)
+                    xstep = round(row * unit_xstep)
+                    if (halfw >= xstep and halfh >= ystep):
+                        ret[halfh + ystep, halfw - xstep] = \
+                            data[row, height - 1 + j]
+                        ret[halfh + ystep, halfw + xstep] = \
+                            data[row, height + width - 2 - j]
+                        ret[halfh - ystep, halfw + xstep] = \
+                            data[row, height + width + height - 3 + j]
+                        ret[halfh - ystep, halfw - xstep] = \
+                            data[row, perimeter - j]
+                    else:
+                        break
+
+        part2()
+
+        def set_zeros():
+            zero_mask = ret[1:-1, 1:-1] == 0
+            ret[1:-1, 1:-1] = np.where(zero_mask, (ret[:-2,
+                                                       1:-1] + ret[2:, 1:-1]) / 2, ret[1:-1, 1:-1])
+
+        set_zeros()
+
+        return ret
+
+    def get_gauss(n: int) -> List[float]:
+        sigma = 0.3 * (n / 2 - 1) + 0.8
+        r = range(-int(n / 2), int(n / 2) + 1)
+        new_sum = sum([1 / (sigma * math.sqrt(2 * math.pi)) *
+                       math.exp(-float(x) ** 2 / (2 * sigma ** 2)) for x in r])
+        return [(1 / (sigma * math.sqrt(2 * math.pi)) *
+                math.exp(-float(x) ** 2 / (2 * sigma ** 2))) / new_sum for x in r]
+
+    def vertical_gaussian(data: np.ndarray, n: int) -> np.ndarray:
+        padding = n - 1
+        width = data.shape[1]
+        height = data.shape[0]
+        padded_data = np.zeros((height + padding * 2, width))
+        padded_data[padding: -padding, :] = data
+        ret = np.zeros((height, width))
+        kernel = None
+        old_radius = - 1
+        for i in range(height):
+            radius = round(i * padding / (height - 1)) + 1
+            if (radius != old_radius):
+                old_radius = radius
+                kernel = np.tile(get_gauss(1 + 2 * (radius - 1)),
+                                 (width, 1)).transpose()
+            ret[i, :] = np.sum(np.multiply(
+                padded_data[padding + i - radius + 1:padding + i + radius, :], kernel), axis=0)
+        return ret
+
+    r, g, b = im.split()
+    rdata = np.asarray(r)
+    gdata = np.asarray(g)
+    bdata = np.asarray(b)
+    if no_blur:
+        rfinal = r
+        gfinal = g
+        bfinal = b
+    else:
+        poles = cartesian_to_polar(np.stack([rdata, gdata, bdata], axis=-1))
+        rpolar, gpolar, bpolar = poles[:, :,
+                                       0], poles[:, :, 1], poles[:, :, 2],
+
+        bluramount = (im.size[0] + im.size[1] - 2) / 100 * strength
+        if round(bluramount) > 0:
+            rpolar = vertical_gaussian(rpolar, round(bluramount))
+            gpolar = vertical_gaussian(gpolar, round(bluramount * 1.2))
+            bpolar = vertical_gaussian(bpolar, round(bluramount * 1.4))
+
+        rgbpolar = np.stack([rpolar, gpolar, bpolar], axis=-1)
+        cartes = polar_to_cartesian(
+            rgbpolar, width=rdata.shape[1], height=rdata.shape[0])
+        rcartes, gcartes, bcartes = cartes[:, :,
+                                           0], cartes[:, :, 1], cartes[:, :, 2],
+
+        rfinal = Image.fromarray(np.uint8(rcartes), 'L')
+        gfinal = Image.fromarray(np.uint8(gcartes), 'L')
+        bfinal = Image.fromarray(np.uint8(bcartes), 'L')
+
+    gfinal = gfinal.resize((round((1 + 0.018 * strength) * rdata.shape[1]),
+                            round((1 + 0.018 * strength) * rdata.shape[0])), Image.ANTIALIAS)
+    bfinal = bfinal.resize((round((1 + 0.044 * strength) * rdata.shape[1]),
+                            round((1 + 0.044 * strength) * rdata.shape[0])), Image.ANTIALIAS)
+
+    rwidth, rheight = rfinal.size
+    gwidth, gheight = gfinal.size
+    bwidth, bheight = bfinal.size
+    rhdiff = (bheight - rheight) // 2
+    rwdiff = (bwidth - rwidth) // 2
+    ghdiff = (bheight - gheight) // 2
+    gwdiff = (bwidth - gwidth) // 2
+
+    im = Image.merge("RGB", (
+        rfinal.crop((-rwdiff, -rhdiff, bwidth - rwdiff, bheight - rhdiff)),
+        gfinal.crop((-gwdiff, -ghdiff, bwidth - gwdiff, bheight - ghdiff)),
+        bfinal))
+
+    return im.crop((rwdiff, rhdiff, rwidth + rwdiff, rheight + rhdiff))
+
+
+def tilt_shift(im, dof=60, focus_height=None):
+    above_focus, below_focus = im[:focus_height, :], im[focus_height:, :]
+    above_focus = increasing_blur(above_focus[::-1, ...], dof)[::-1, ...]
+    below_focus = increasing_blur(below_focus, dof)
+    out = np.vstack((above_focus, below_focus))
+    return out
+
+def increasing_blur(im, dof=60):
+    blur_region = cv2.GaussianBlur(im[dof:, :], ksize=(15, 15), sigmaX=0)
+    if blur_region.shape[0] > dof:
+        blur_region = increasing_blur(blur_region, dof)
+    blend_col = np.linspace(1.0, 0, num=dof)
+    blend_mask = np.tile(blend_col, (im.shape[1], 1)).T
+    res = np.zeros_like(im)
+    res[:dof, :] = im[:dof, :]
+    dof_actual = min(dof, im.shape[0] - dof, blur_region.shape[0])
+    blend_mask = blend_mask[:dof_actual, :]
+    res[dof:dof + dof_actual, :] = im[dof:dof + dof_actual, :] * blend_mask[:, :, None] + blur_region[:dof_actual, :] * (1 - blend_mask[:, :, None])
+    if dof + dof < im.shape[0]:
+        res[dof + dof_actual:, :] = blur_region[dof_actual:]
+    return res
+
 class Script(scripts.Script):
     def title(self):
         return 'Revision'
 
+    def show(self, is_img2img):
+        return scripts.AlwaysVisible
+
     def ui(self, is_img2img):
-        saturationSlider = gr.Slider(0, 2, 1, label='Saturation')
-        temperatureSlider = gr.Slider(0, 2, 1, label='Temperature')
-        brightnessSlider = gr.Slider(0, 2, 1, label='Brightness')
-        contrastSlider = gr.Slider(0, 2, 1, label='Contrast')
-        sharpnessSlider = gr.Slider(0, 1, 0, label='Sharpness')
-        blurSlider = gr.Slider(0, 1, 0, label='Blur')
-        noiseSlider = gr.Slider(0, 1, 0, label='Noise')
-        vignetteSlider = gr.Slider(0, 1, 0, step=.05, label='Vignette')
-        exposureOffsetSlider = gr.Slider(
-            0, 1, 0, step=.05, label='Exposure offset')
-        hdrSlider = gr.Slider(0, 1, 0, label='HDR')
-
-        bestChoiceButton = gr.Button(value="Best Choice")
-        bestChoiceButton.click(bestChoiceValues, inputs=[saturationSlider, temperatureSlider, brightnessSlider, contrastSlider, sharpnessSlider, blurSlider, noiseSlider, vignetteSlider, exposureOffsetSlider, hdrSlider],
-                               outputs=[saturationSlider, temperatureSlider, brightnessSlider, contrastSlider, sharpnessSlider, blurSlider, noiseSlider, vignetteSlider, exposureOffsetSlider, hdrSlider])
-
-        resetSlidersButton = gr.Button(value="Reset Sliders")
-        resetSlidersButton.click(resetValues, inputs=[saturationSlider, temperatureSlider, brightnessSlider, contrastSlider, sharpnessSlider, blurSlider, noiseSlider, vignetteSlider, exposureOffsetSlider, hdrSlider],
-                                 outputs=[saturationSlider, temperatureSlider, brightnessSlider, contrastSlider, sharpnessSlider, blurSlider, noiseSlider, vignetteSlider, exposureOffsetSlider, hdrSlider])
-
-        clearEXIFCheckbox = gr.Checkbox(label="Clear EXIF (all metadata)")
-        flipImageCheckbox = gr.Checkbox(label="Flip image")
-        dontShowOriginalCheckbox = gr.Checkbox(
-            label="Don't show original image")
-
-        return [saturationSlider, temperatureSlider, brightnessSlider, contrastSlider, sharpnessSlider, blurSlider, noiseSlider, vignetteSlider, exposureOffsetSlider, hdrSlider,
-                clearEXIFCheckbox, flipImageCheckbox, dontShowOriginalCheckbox]
-
-    def run(self, p, saturationSlider, temperatureSlider, brightnessSlider, contrastSlider, sharpnessSlider, blurSlider, noiseSlider, vignetteSlider, exposureOffsetSlider, hdrSlider,
-            clearEXIFCheckbox, flipImageCheckbox, dontShowOriginalCheckbox):
-        proc = process_images(p)
-        image = proc.images[0]
-        img = ImageEnhance.Color(image).enhance(saturationSlider)
-        img = ImageEnhance.Brightness(img).enhance(brightnessSlider)
-        img = ImageEnhance.Contrast(img).enhance(contrastSlider)
-
-        if vignetteSlider > 0:
-            width, height = img.size
-            mask = Image.new("L", (width, height), 0)
-            draw = ImageDraw.Draw(mask)
-            padding = 100 - vignetteSlider * 100
-            draw.ellipse((-padding, -padding, width +
-                         padding, height + padding), fill=255)
-            mask = mask.filter(ImageFilter.GaussianBlur(radius=100))
-            img = Image.composite(img, Image.new(
-                "RGB", img.size, "black"), mask)
-
-        if hdrSlider > 0:
-            blurred = img.filter(ImageFilter.GaussianBlur(radius=2.8))
-            difference = ImageChops.difference(img, blurred)
-            sharpEdges = Image.blend(img, difference, 1)
-
-            convertedOriginalImage = np.array(
-                image)[:, :, ::-1].copy().astype('float32') / 255.0
-            convertedSharped = np.array(
-                sharpEdges)[:, :, ::-1].copy().astype('float32') / 255.0
-
-            colorDodge = convertedOriginalImage / (1 - convertedSharped)
-            convertedColorDodge = (
-                255 * colorDodge).clip(0, 255).astype(np.uint8)
-
-            tempImage = Image.fromarray(cv2.cvtColor(
-                convertedColorDodge, cv2.COLOR_BGR2RGB))
-            invertedColorDodge = ImageOps.invert(tempImage)
-            blackWhiteColorDodge = ImageEnhance.Color(
-                invertedColorDodge).enhance(0)
-            hue = blendLayers(tempImage, blackWhiteColorDodge, BlendType.HUE)
-            hdrImage = blendLayers(hue, tempImage, BlendType.NORMAL, .7)
-
-            img = blendLayers(img, hdrImage, BlendType.NORMAL,
-                              hdrSlider * 2).convert("RGB")
-
-        if sharpnessSlider > 0:
-            img = ImageEnhance.Sharpness(img).enhance(
-                (sharpnessSlider + 1) * 1.5)
-
-        if blurSlider > 0:
-            img = img.filter(ImageFilter.BoxBlur(blurSlider * 10))
-
-        if temperatureSlider != 1:
-            pixels = img.load()
-            for i in range(img.width):
-                for j in range(img.height):
-                    (r, g, b) = pixels[i, j]
-                    if temperatureSlider > 1:
-                        r *= 1 + ((temperatureSlider - 1) / 4)
-                        b *= 1 - (((temperatureSlider - 1) / 4))
+        with gr.Accordion('Revision', open=False):
+            with gr.Tab(label='Options', id=1):
+                enabled = gr.Checkbox(label="Enable")
+                clearEXIFCheckbox = gr.Checkbox(label="Clear EXIF (all metadata)")
+                flipImageCheckbox = gr.Checkbox(label="Flip image")
+                dontShowOriginalCheckbox = gr.Checkbox(label="Don't show original image")
+
+            with gr.Tab(label='Adjustments', id=2):
+                saturationSlider = gr.Slider(0, 2, 1, label='Saturation')
+                temperatureSlider = gr.Slider(0, 2, 1, label='Temperature')
+                brightnessSlider = gr.Slider(0, 2, 1, label='Brightness')
+                contrastSlider = gr.Slider(0, 2, 1, label='Contrast')
+                sharpnessSlider = gr.Slider(0, 1, 0, label='Sharpness')
+                blurSlider = gr.Slider(0, 1, 0, label='Blur')
+                noiseSlider = gr.Slider(0, 1, 0, label='Noise')
+                vignetteSlider = gr.Slider(0, 1, 0, step=.05, label='Vignette')
+                exposureOffsetSlider = gr.Slider(0, 1, 0, step=.05, label='Exposure offset')
+                hdrSlider = gr.Slider(0, 1, 0, label='HDR')
+
+                bestChoiceButton = gr.Button(value="Best Choice")
+                bestChoiceButton.click(bestChoiceValues, inputs=[saturationSlider, temperatureSlider, brightnessSlider, contrastSlider, sharpnessSlider, blurSlider, noiseSlider, vignetteSlider, exposureOffsetSlider, hdrSlider],
+                                       outputs=[saturationSlider, temperatureSlider, brightnessSlider, contrastSlider, sharpnessSlider, blurSlider, noiseSlider, vignetteSlider, exposureOffsetSlider, hdrSlider])
+
+                resetSlidersButton = gr.Button(value="Reset Sliders")
+                resetSlidersButton.click(resetValues, inputs=[saturationSlider, temperatureSlider, brightnessSlider, contrastSlider, sharpnessSlider, blurSlider, noiseSlider, vignetteSlider, exposureOffsetSlider, hdrSlider],
+                                         outputs=[saturationSlider, temperatureSlider, brightnessSlider, contrastSlider, sharpnessSlider, blurSlider, noiseSlider, vignetteSlider, exposureOffsetSlider, hdrSlider])
+
+            with gr.Tab(label='Effects', id=3):
+                lensDistortionRadioButton = gr.Radio(["None", "Lens Distortion", "Fish Eye"], label="Lens effect", value="None")
+                chromaticAberrationSlider = gr.Slider(0, 1, 0, label='Chromatic aberration')
+                snowfallSlider = gr.Slider(0, 3000, 0, step=1, label='Snowfall')
+                asciiSlider = gr.Slider(0, 20, 0, step=1, label='ASCII')
+                tiltShiftRadioButton = gr.Radio(["None", "Top", "Center", "Bottom"], label="Tilt Shift", value="None")
+                glitchCheckbox = gr.Checkbox(label="Glitch")
+                vhsCheckbox = gr.Checkbox(label="VHS")
+                watermark = gr.Textbox(label="Watermark text")
+
+            with gr.Tab(label='Custom EXIF', id=4):
+                customEXIF = gr.TextArea(
+                    label="Here you can fill in your custom EXIF")
+
+            return [enabled, saturationSlider, temperatureSlider, brightnessSlider, contrastSlider, sharpnessSlider, blurSlider, noiseSlider, vignetteSlider, exposureOffsetSlider, hdrSlider,
+                    clearEXIFCheckbox, flipImageCheckbox, dontShowOriginalCheckbox, lensDistortionRadioButton, chromaticAberrationSlider, customEXIF, tiltShiftRadioButton,
+                    glitchCheckbox, vhsCheckbox, snowfallSlider, asciiSlider, watermark]
+
+    def postprocess(self, p, processed, enabled, saturationSlider, temperatureSlider, brightnessSlider, contrastSlider, sharpnessSlider, blurSlider, noiseSlider, vignetteSlider, exposureOffsetSlider, hdrSlider,
+                    clearEXIFCheckbox, flipImageCheckbox, dontShowOriginalCheckbox, lensDistortionRadioButton, chromaticAberrationSlider, customEXIF, tiltShiftRadioButton,
+                    glitchCheckbox, vhsCheckbox, snowfallSlider, asciiSlider, watermark):
+
+        if not enabled:
+            return
+
+        proc = processed
+        result = []
+
+        for i in range(len(proc.images)):
+            image = proc.images[i]
+            img = ImageEnhance.Color(image).enhance(saturationSlider)
+            img = ImageEnhance.Brightness(img).enhance(brightnessSlider)
+            img = ImageEnhance.Contrast(img).enhance(contrastSlider)
+
+            if vignetteSlider > 0:
+                width, height = img.size
+                mask = Image.new("L", (width, height), 0)
+                draw = ImageDraw.Draw(mask)
+                padding = 100 - vignetteSlider * 100
+                draw.ellipse((-padding, -padding, width +
+                            padding, height + padding), fill=255)
+                mask = mask.filter(ImageFilter.GaussianBlur(radius=100))
+                img = Image.composite(img, Image.new(
+                    "RGB", img.size, "black"), mask)
+
+            if hdrSlider > 0:
+                blurred = img.filter(ImageFilter.GaussianBlur(radius=2.8))
+                difference = ImageChops.difference(img, blurred)
+                sharpEdges = Image.blend(img, difference, 1)
+
+                convertedOriginalImage = np.array(
+                    image)[:, :, ::-1].copy().astype('float32') / 255.0
+                convertedSharped = np.array(
+                    sharpEdges)[:, :, ::-1].copy().astype('float32') / 255.0
+
+                colorDodge = convertedOriginalImage / (1 - convertedSharped)
+                convertedColorDodge = (
+                    255 * colorDodge).clip(0, 255).astype(np.uint8)
+
+                tempImage = Image.fromarray(cv2.cvtColor(
+                    convertedColorDodge, cv2.COLOR_BGR2RGB))
+                invertedColorDodge = ImageOps.invert(tempImage)
+                blackWhiteColorDodge = ImageEnhance.Color(
+                    invertedColorDodge).enhance(0)
+                hue = blendLayers(tempImage, blackWhiteColorDodge, BlendType.HUE)
+                hdrImage = blendLayers(hue, tempImage, BlendType.NORMAL, .7)
+
+                img = blendLayers(img, hdrImage, BlendType.NORMAL,
+                                hdrSlider * 2).convert("RGB")
+
+            if sharpnessSlider > 0:
+                img = ImageEnhance.Sharpness(img).enhance(
+                    (sharpnessSlider + 1) * 1.5)
+
+            if blurSlider > 0:
+                img = img.filter(ImageFilter.BoxBlur(blurSlider * 10))
+
+            if temperatureSlider != 1:
+                pixels = img.load()
+                for i in range(img.width):
+                    for j in range(img.height):
+                        (r, g, b) = pixels[i, j]
+                        if temperatureSlider > 1:
+                            r *= 1 + ((temperatureSlider - 1) / 4)
+                            b *= 1 - (((temperatureSlider - 1) / 4))
+                        else:
+                            r *= 1 - (1 - temperatureSlider) / 4
+                            b *= 1 + (((1 - temperatureSlider) / 4))
+                        pixels[i, j] = (int(r), int(g), int(b))
+
+            if noiseSlider > 0:
+                noise = np.random.randint(0, noiseSlider * 100, img.size, np.uint8)
+                noise_img = Image.fromarray(noise, 'L').resize(
+                    img.size).convert(img.mode)
+                img = ImageChops.add(img, noise_img)
+
+            if exposureOffsetSlider > 0:
+                np_img = np.array(img).astype(float) + exposureOffsetSlider * 75
+                np_img = np.clip(np_img, 0, 255).astype(np.uint8)
+                img = Image.fromarray(np_img)
+                img = ImageEnhance.Brightness(img).enhance(
+                    brightnessSlider - exposureOffsetSlider / 4)
+
+            if flipImageCheckbox:
+                img = Image.fromarray(np.fliplr(np.array(img)))
+
+            if lensDistortionRadioButton != "None":
+                def add_lens_distortion(img, k1, k2):
+                    img = np.array(img)[:, :, ::-1].copy()
+                    rows, cols = img.shape[:2]
+                    map_x, map_y = np.zeros((rows, cols), np.float32), np.zeros(
+                        (rows, cols), np.float32)
+                    for i in range(rows):
+                        for j in range(cols):
+                            r = np.sqrt((i - rows/2)**2 + (j - cols/2)**2)
+                            x = j + (j - cols/2) * (k1 * r**2 + k2 * r**4)
+                            y = i + (i - rows/2) * (k1 * r**2 + k2 * r**4)
+                            if x >= 0 and x < cols and y >= 0 and y < rows:
+                                map_x[i, j] = x
+                                map_y[i, j] = y
+                    return cv2.remap(img, map_x, map_y, cv2.INTER_LINEAR)
+
+                if lensDistortionRadioButton == "Lens Distortion":
+                    img = add_lens_distortion(img, 1e-12, -1e-12)
+                else:
+                    img = add_lens_distortion(img, 1e-12, 1e-12)
+                img = Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
+
+            if chromaticAberrationSlider > 0:
+                img = add_chromatic(img, chromaticAberrationSlider + .12, True)
+
+            if tiltShiftRadioButton != "None":
+                width, height = img.size
+                ratio = 1/5 if tiltShiftRadioButton == "Top" else 1 / \
+                    2 if tiltShiftRadioButton == "Center" else 4/5
+                img = Image.fromarray(cv2.cvtColor(tilt_shift(np.array(
+                    img)[:, :, ::-1].copy(), 60, round(height * ratio)), cv2.COLOR_BGR2RGB))
+
+            if glitchCheckbox:
+                img = np.array(img)[:, :, ::-1].copy()
+                num_glitches = 5
+                height, width = img.shape[:2]
+
+                for _ in range(num_glitches):
+                    y = np.random.randint(height)
+                    h = np.random.randint(10, 50)
+                    y1 = np.clip(y - h // 2, 0, height)
+                    y2 = np.clip(y + h // 2, 0, height)
+                    w = np.random.randint(20, width // 4)
+                    channel = np.random.randint(0, 3)
+                    img[y1:y2, w:, channel] = img[y1:y2, :-w, channel]
+                    img[y1:y2, :w, channel] = np.random.randint(0, 256, (y2 - y1, w), dtype=np.uint8)
+
+                img = Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
+
+            if vhsCheckbox:
+                # Коррекция насыщености, яркости и контрастности
+                img = ImageEnhance.Color(img).enhance(0.88)
+                img = ImageEnhance.Brightness(img).enhance(1.06)
+                img = ImageEnhance.Contrast(img).enhance(0.88)
+
+                # Цветной шум
+                noise = np.random.normal(loc=128, scale=128, size=img.size[::-1] + (3,)).clip(0, 255).astype(np.uint8)
+                dust_and_scratches = Image.fromarray(noise, 'RGB').filter(ImageFilter.GaussianBlur(1))
+                img = Image.blend(img, dust_and_scratches, alpha=0.02)
+
+                # Размытие в движении
+                img = np.array(img)[:, :, ::-1].copy()
+                size = 4
+                kernel = np.zeros((size, size))
+                kernel[int((size-1)/2), :] = np.ones(size)
+                kernel = kernel / size
+                img = cv2.filter2D(img, -1, kernel)
+                img = Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
+
+                # Резкость
+                img = ImageEnhance.Sharpness(img).enhance((1.2))
+
+                # Тиснение
+                img = blendLayers(img, img.filter(ImageFilter.EMBOSS()), BlendType.HARDLIGHT, 1.8)
+
+                # Glitch от плёнки
+                img = np.array(img)[:, :, ::-1].copy()
+                num_glitches = 5
+                height, width = img.shape[:2]
+                for _ in range(num_glitches):
+                    y = np.random.randint(height)
+                    h = np.random.randint(1, 3)
+                    y1 = np.clip(y - h // 2, 0, height)
+                    y2 = np.clip(y + h // 2, 0, height)
+                    w = np.random.randint(20, width // 4)
+                    channel = np.random.randint(0, 3)
+                    img[y1:y2, w:, channel] = img[y1:y2, :-w, channel]
+                    img[y1:y2, :w, channel] = np.random.randint(100, 156, (y2 - y1, w), dtype=np.uint8)
+
+                img = Image.fromarray(img[:, :, ::-1])
+
+            if snowfallSlider > 0:
+                img = np.array(img)[:, :, ::-1].copy()
+                height, width = img.shape[:2]
+                num_snowflakes = snowfallSlider
+
+                first_snow_layer = np.zeros_like(img)
+                second_snow_layer = np.zeros_like(img)
+
+                for _ in range(num_snowflakes):
+                    center_x, center_y = random.randint(0, width - 1), random.randint(0, height - 1)
+                    num_vertices = random.randint(3, 6)
+                    radius = random.randint(1, 3)
+
+                    polygon = np.array([[
+                        center_x + random.randint(-radius, radius),
+                        center_y + random.randint(-radius, radius)
+                    ] for _ in range(num_vertices)], np.int32)
+                    polygon = polygon.reshape((-1, 1, 2))
+                    blur = random.choice([True, False])
+
+                    if blur:
+                        cv2.fillPoly(second_snow_layer, [polygon], (255, 255, 255))
                     else:
-                        r *= 1 - (1 - temperatureSlider) / 4
-                        b *= 1 + (((1 - temperatureSlider) / 4))
-                    pixels[i, j] = (int(r), int(g), int(b))
-
-        if noiseSlider > 0:
-            noise = np.random.randint(0, noiseSlider * 100, img.size, np.uint8)
-            noise_img = Image.fromarray(noise, 'L').resize(
-                img.size).convert(img.mode)
-            img = ImageChops.add(img, noise_img)
-
-        if exposureOffsetSlider > 0:
-            np_img = np.array(img).astype(float) + exposureOffsetSlider * 75
-            np_img = np.clip(np_img, 0, 255).astype(np.uint8)
-            img = Image.fromarray(np_img)
-            img = ImageEnhance.Brightness(img).enhance(
-                brightnessSlider - exposureOffsetSlider / 4)
-
-        if flipImageCheckbox:
-            img = Image.fromarray(np.fliplr(np.array(img)))
+                        cv2.fillPoly(first_snow_layer, [polygon], (255, 255, 255))
+
+                first_snow_layer = cv2.GaussianBlur(first_snow_layer, (5, 5), 0)
+                second_snow_layer = cv2.GaussianBlur(second_snow_layer, (15, 15), 0)
+
+                snowy_img = cv2.addWeighted(img, 1, first_snow_layer, 1, 0)
+                img = cv2.addWeighted(snowy_img, 1, second_snow_layer, 1, 0)
+                img = Image.fromarray(img[:, :, ::-1])
+
+            if asciiSlider > 0:
+                chars = " .'`^\",:;I1!i><-+_-?][}{1)(|\/tfjrxnuvczXYUCLQ0OZmwqpbdkhao*#MW&8%B@$"
+                small_image = img.resize((img.width // asciiSlider, img.height // asciiSlider), Image.Resampling.NEAREST)
+                ascii_image = Image.new('RGB', img.size, 'black')
+                font = ImageFont.truetype("arial.ttf", asciiSlider)
+                draw = ImageDraw.Draw(ascii_image)
+
+                for i in range(small_image.height):
+                    for j in range(small_image.width):
+                        pixel = small_image.getpixel((j, i))
+                        gray = sum(pixel) // 3
+                        char = chars[gray * len(chars) // 256]
+                        draw.text((j * asciiSlider, i * asciiSlider), char, font=font, fill=pixel)
+
+                img = ascii_image
+
+            if len(watermark) > 0:
+                tempImg = Image.new('RGBA', (img.width, img.height), (0, 0, 0, 0))
+                draw = ImageDraw.Draw(tempImg)
+
+                userText = watermark.upper()
+                textSize = round(img.width / 5)
+                font = ImageFont.truetype('impact.ttf', textSize)
+                text_width, text_height = draw.textsize(userText, font)
+                right = (img.width - text_width) - 35
+                bottom = (img.height - text_height) - img.height / 3
+
+                shadowcolor = (111, 0, 0)
+                draw.text((right + (textSize / 48), bottom + (textSize / 48)), userText,
+                        font=font, fill=shadowcolor)
+
+                textcolor = (20, 25, 30)
+                draw.text((right, bottom), userText, font=font, fill=textcolor)
+
+                tempImg = tempImg.transform(tempImg.size, Image.AFFINE, (
+                    1, 0, 0, 0.1, 1, 0), resample=Image.BICUBIC, fillcolor=(0, 0, 0, 0))
+
+                img_arr = np.array(tempImg)
+                mask = np.random.randint(
+                    0, 2, size=img_arr.shape[:2]).astype(bool)
+                mask = np.repeat(mask[:, :, np.newaxis], 4, axis=2)
+
+                img_arr[mask] = img_arr[np.roll(mask, 5, axis=1)]
+                tempImg = Image.fromarray(img_arr)
+
+                img = blendLayers(img, tempImg, BlendType.NORMAL, .44)
+
+            if not clearEXIFCheckbox:
+                img.info['parameters'] = proc.info
+
+            if len(customEXIF) > 0:
+                img.info['parameters'] = customEXIF
+
+            result.append(img)
 
         if dontShowOriginalCheckbox:
             proc.images.clear()
 
-        if not clearEXIFCheckbox:
-            img.info['parameters'] = proc.info
+        for i in result:
+            proc.images.append(i)
+            try:
+                images.save_image(i, p.outpath_samples, "", info=i.info['parameters'])
+            except:
+                images.save_image(i, p.outpath_samples, "", info='')
 
-        proc.images.insert(0, img)
         return Processed(p, proc.images, p.seed, '')

user.js

@@ -1,53 +1,67 @@
 // Custom scripts by XpucT
 // Homepage: https://boosty.to/xpuct
 
+document.addEventListener('keydown', function(e)
+{
+    // Показать предыдущую генерацию по клавише Shift
+    if (e.keyCode === 16 && document.querySelector('.livePreview'))
+        document.querySelector('.livePreview').style.display = 'none'
+
+    // Переключить Mask Mode по Ctrl + F2
+    else if (e.ctrlKey && e.code === 'F2')
+    {
+		const commonRadio = document.querySelector('#img2img_mask_mode').children[2]
+        commonRadio.children[0].className.includes('selected') ? commonRadio.children[1].click() : commonRadio.children[0].click()
 
-document.addEventListener('keydown', function (e) {
+        e.preventDefault()
+    }
 	
-	// Reload UI по F2
-    if (e.code === 'F2') {
-        document.querySelector('#settings_restart_gradio').click()
+	// Выгрузить модели по F4
+	else if (e.code === 'F4')
+    {
+        document.querySelector('#sett_unload_sd_model').click()
         e.preventDefault()
+    }
 
-	// Показать предыдущую генерацию по клавише Shift
-    } else if (e.keyCode === 16 && document.querySelector('.livePreview'))
-        document.querySelector('.livePreview').style.display = 'none'
-});
+    // Reload UI по F2
+    else if (e.code === 'F2')
+    {
+        document.querySelector('#settings_restart_gradio').click()
+        e.preventDefault()
+    }
+})
 
-document.addEventListener('keyup', function (e) {
-    if (e.keyCode === 16 && document.querySelector('.livePreview')) {
+document.addEventListener('keyup', function(e)
+{
+    if (e.keyCode === 16 && document.querySelector('.livePreview'))
+    {
         document.querySelector('.livePreview').style.display = 'block'
     }
-});
+})
 
-onUiLoaded(function () {
-	
-	// Удаление рекламы в Photopea (работает не всегда)
+onUiLoaded(function()
+{
+    // Удаление рекламы в Photopea (работает не всегда)
     const result = document.evaluate("//div[@class='flexrow app']/div[2]", document, null, XPathResult.ANY_TYPE, null)
     var ad = result.iterateNext()
-    while (ad) {
+    while (ad)
+    {
         ad.parentNode.removeChild(ad)
         ad = result.iterateNext()
     }
-	
-	// Граница в txt2img немного левее, а не посередине
-	document.querySelector('gradio-app .resize-handle-row').style.gridTemplateColumns = '676px 16px 1fr'
-	
-	// Вставить выбранные стили колесом
-	document.querySelectorAll('button[id$=_styles_edit_button]').forEach(x =>
-		x.addEventListener('mousedown', e =>
-			e.button === 1 && get_uiCurrentTabContent().querySelector('button[id$=_style_apply]').click()))
-})
-
-
-
-
-
-
-
-
-
-
-
 
 
+    // Граница в txt2img немного левее, а не посередине
+    document.querySelector('gradio-app .resize-handle-row').style.gridTemplateColumns = '676px 16px 1fr'
+
+    document.querySelectorAll('button[id$=_generate]').forEach((x) => x.addEventListener('mousedown', (e) =>
+    {
+        if (e.button === 1)
+        {
+            get_uiCurrentTabContent().querySelector('div[id$=_adetailer_ad_enable]').children[1].click()
+            get_uiCurrentTabContent().querySelector('button[id$=_generate]').click()
+            setTimeout(() => get_uiCurrentTabContent().querySelector('div[id$=_adetailer_ad_enable]').children[1].click(), 100)
+            e.preventDefault()
+        }
+    }))
+})