Upload 6 files

Revision by XpucT.py

@@ -0,0 +1,617 @@
+# Author: XpucT
+# Script's homepage: https://boosty.to/xpuct
+
+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 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):
+    saturationSlider = 1
+    temperatureSlider = 1
+    brightnessSlider = 1
+    contrastSlider = 1
+    sharpnessSlider = 0
+    blurSlider = 0
+    noiseSlider = 0
+    vignetteSlider = 0
+    exposureOffsetSlider = 0
+    hdrSlider = 0
+    return [saturationSlider, temperatureSlider, brightnessSlider, contrastSlider, sharpnessSlider, blurSlider, noiseSlider, vignetteSlider, exposureOffsetSlider, hdrSlider]
+
+
+def bestChoiceValues(saturationSlider, temperatureSlider, brightnessSlider, contrastSlider, sharpnessSlider, blurSlider, noiseSlider, vignetteSlider, exposureOffsetSlider, hdrSlider):
+    saturationSlider = .98
+    temperatureSlider = 1.04
+    brightnessSlider = 1.01
+    contrastSlider = .97
+    sharpnessSlider = .02
+    blurSlider = 0
+    noiseSlider = .03
+    vignetteSlider = .05
+    exposureOffsetSlider = .1
+    hdrSlider = .16
+    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):
+        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:
+                        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()
+
+        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='')
+
+        return Processed(p, proc.images, p.seed, '')

config.json

@@ -0,0 +1,437 @@
+{
+    "samples_save": true,
+    "samples_format": "png",
+    "samples_filename_pattern": "[seed]-[datetime<%M%S>]-[prompt_spaces]",
+    "save_images_add_number": true,
+    "save_images_replace_action": "Replace",
+    "grid_save": true,
+    "grid_format": "png",
+    "grid_extended_filename": true,
+    "grid_only_if_multiple": true,
+    "grid_prevent_empty_spots": false,
+    "grid_zip_filename_pattern": "",
+    "n_rows": -1,
+    "font": "Segoe UI Semilight",
+    "grid_text_active_color": "#d5d6d7",
+    "grid_text_inactive_color": "#999999",
+    "grid_background_color": "#121517",
+    "save_images_before_face_restoration": false,
+    "save_images_before_highres_fix": false,
+    "save_images_before_color_correction": false,
+    "save_mask": false,
+    "save_mask_composite": false,
+    "jpeg_quality": 80,
+    "webp_lossless": false,
+    "export_for_4chan": false,
+    "img_downscale_threshold": 4.0,
+    "target_side_length": 4000,
+    "img_max_size_mp": 1000.0,
+    "use_original_name_batch": true,
+    "use_upscaler_name_as_suffix": false,
+    "save_selected_only": true,
+    "save_init_img": false,
+    "temp_dir": "",
+    "clean_temp_dir_at_start": false,
+    "save_incomplete_images": false,
+    "notification_audio": true,
+    "notification_volume": 100,
+    "outdir_samples": "output",
+    "outdir_txt2img_samples": "output",
+    "outdir_img2img_samples": "",
+    "outdir_extras_samples": "",
+    "outdir_grids": "output",
+    "outdir_txt2img_grids": "output",
+    "outdir_img2img_grids": "output",
+    "outdir_save": "output",
+    "outdir_init_images": "output",
+    "save_to_dirs": false,
+    "grid_save_to_dirs": false,
+    "use_save_to_dirs_for_ui": false,
+    "directories_filename_pattern": "[date]",
+    "directories_max_prompt_words": 8,
+    "ESRGAN_tile": 192,
+    "ESRGAN_tile_overlap": 8,
+    "realesrgan_enabled_models": [],
+    "upscaler_for_img2img": "4x_NMKD-Siax_200k",
+    "face_restoration": false,
+    "face_restoration_model": "CodeFormer",
+    "code_former_weight": 0.5,
+    "face_restoration_unload": false,
+    "auto_launch_browser": "Local",
+    "enable_console_prompts": false,
+    "show_warnings": false,
+    "show_gradio_deprecation_warnings": true,
+    "memmon_poll_rate": 8,
+    "samples_log_stdout": false,
+    "multiple_tqdm": false,
+    "print_hypernet_extra": true,
+    "list_hidden_files": true,
+    "disable_mmap_load_safetensors": false,
+    "hide_ldm_prints": true,
+    "dump_stacks_on_signal": false,
+    "api_enable_requests": true,
+    "api_forbid_local_requests": true,
+    "api_useragent": "",
+    "unload_models_when_training": true,
+    "pin_memory": true,
+    "save_optimizer_state": false,
+    "save_training_settings_to_txt": false,
+    "dataset_filename_word_regex": "",
+    "dataset_filename_join_string": " ",
+    "training_image_repeats_per_epoch": 1,
+    "training_write_csv_every": 0.0,
+    "training_xattention_optimizations": true,
+    "training_enable_tensorboard": false,
+    "training_tensorboard_save_images": false,
+    "training_tensorboard_flush_every": 120,
+    "sd_model_checkpoint": "Deliberate_v6.safetensors [bcce73a08e]",
+    "sd_checkpoints_limit": 3,
+    "sd_checkpoints_keep_in_cpu": false,
+    "sd_checkpoint_cache": 3,
+    "sd_unet": "Automatic",
+    "enable_quantization": true,
+    "enable_emphasis": true,
+    "enable_batch_seeds": true,
+    "comma_padding_backtrack": 20,
+    "CLIP_stop_at_last_layers": 1,
+    "upcast_attn": false,
+    "randn_source": "GPU",
+    "tiling": false,
+    "hires_fix_refiner_pass": "second pass",
+    "sdxl_crop_top": 0,
+    "sdxl_crop_left": 0,
+    "sdxl_refiner_low_aesthetic_score": 2.5,
+    "sdxl_refiner_high_aesthetic_score": 6.0,
+    "sd_vae_checkpoint_cache": 2,
+    "sd_vae": "None",
+    "sd_vae_overrides_per_model_preferences": true,
+    "auto_vae_precision": true,
+    "sd_vae_encode_method": "Full",
+    "sd_vae_decode_method": "Full",
+    "inpainting_mask_weight": 1.0,
+    "initial_noise_multiplier": 1.0,
+    "img2img_extra_noise": 0.0,
+    "img2img_color_correction": false,
+    "img2img_fix_steps": false,
+    "img2img_background_color": "#ffffff",
+    "img2img_editor_height": 720,
+    "img2img_sketch_default_brush_color": "#ffffff",
+    "img2img_inpaint_mask_brush_color": "#ff0000",
+    "img2img_inpaint_sketch_default_brush_color": "#ffffff",
+    "return_mask": false,
+    "return_mask_composite": false,
+    "img2img_batch_show_results_limit": 32,
+    "cross_attention_optimization": "Automatic",
+    "s_min_uncond": 0.0,
+    "token_merging_ratio": 0.0,
+    "token_merging_ratio_img2img": 0.0,
+    "token_merging_ratio_hr": 0.0,
+    "pad_cond_uncond": false,
+    "persistent_cond_cache": true,
+    "batch_cond_uncond": true,
+    "use_old_emphasis_implementation": false,
+    "use_old_karras_scheduler_sigmas": false,
+    "no_dpmpp_sde_batch_determinism": false,
+    "use_old_hires_fix_width_height": false,
+    "dont_fix_second_order_samplers_schedule": false,
+    "hires_fix_use_firstpass_conds": false,
+    "use_old_scheduling": false,
+    "interrogate_keep_models_in_memory": false,
+    "interrogate_return_ranks": false,
+    "interrogate_clip_num_beams": 1,
+    "interrogate_clip_min_length": 24,
+    "interrogate_clip_max_length": 48,
+    "interrogate_clip_dict_limit": 1500,
+    "interrogate_clip_skip_categories": [
+        "artists"
+    ],
+    "interrogate_deepbooru_score_threshold": 0.5,
+    "deepbooru_sort_alpha": true,
+    "deepbooru_use_spaces": true,
+    "deepbooru_escape": true,
+    "deepbooru_filter_tags": "",
+    "extra_networks_show_hidden_directories": true,
+    "extra_networks_dir_button_function": false,
+    "extra_networks_hidden_models": "When searched",
+    "extra_networks_default_multiplier": 0.9,
+    "extra_networks_card_width": 140.0,
+    "extra_networks_card_height": 210.0,
+    "extra_networks_card_text_scale": 1.0,
+    "extra_networks_card_show_desc": true,
+    "extra_networks_card_order_field": "Path",
+    "extra_networks_card_order": "Ascending",
+    "extra_networks_add_text_separator": " ",
+    "ui_extra_networks_tab_reorder": "Lora",
+    "textual_inversion_print_at_load": false,
+    "textual_inversion_add_hashes_to_infotext": true,
+    "sd_hypernetwork": "None",
+    "keyedit_precision_attention": 0.1,
+    "keyedit_precision_extra": 0.1,
+    "keyedit_delimiters": " .,\\/!?%^*;:{}=`~() ",
+    "keyedit_delimiters_whitespace": [
+        "Tab",
+        "Carriage Return",
+        "Line Feed"
+    ],
+    "keyedit_move": true,
+    "disable_token_counters": false,
+    "return_grid": false,
+    "do_not_show_images": false,
+    "js_modal_lightbox": true,
+    "js_modal_lightbox_initially_zoomed": false,
+    "js_modal_lightbox_gamepad": false,
+    "js_modal_lightbox_gamepad_repeat": 250,
+    "gallery_height": "",
+    "compact_prompt_box": false,
+    "samplers_in_dropdown": true,
+    "dimensions_and_batch_together": true,
+    "sd_checkpoint_dropdown_use_short": false,
+    "hires_fix_show_sampler": true,
+    "hires_fix_show_prompts": false,
+    "txt2img_settings_accordion": false,
+    "img2img_settings_accordion": false,
+    "localization": "None",
+    "quicksettings_list": [
+        "sd_model_checkpoint"
+    ],
+    "ui_tab_order": [],
+    "hidden_tabs": [
+        "Train"
+    ],
+    "ui_reorder_list": [
+        "prompt",
+        "image",
+        "inpaint",
+        "sampler",
+        "accordions",
+        "checkboxes",
+        "dimensions",
+        "cfg",
+        "denoising",
+        "seed",
+        "batch",
+        "override_settings",
+        "scripts",
+        "extra_options"
+    ],
+    "gradio_theme": "Default",
+    "gradio_themes_cache": true,
+    "show_progress_in_title": true,
+    "send_seed": true,
+    "send_size": true,
+    "enable_pnginfo": true,
+    "save_txt": false,
+    "add_model_name_to_info": true,
+    "add_model_hash_to_info": true,
+    "add_vae_name_to_info": true,
+    "add_vae_hash_to_info": true,
+    "add_user_name_to_info": false,
+    "add_version_to_infotext": true,
+    "disable_weights_auto_swap": true,
+    "infotext_skip_pasting": [],
+    "infotext_styles": "Apply if any",
+    "show_progressbar": true,
+    "live_previews_enable": true,
+    "live_previews_image_format": "jpeg",
+    "show_progress_grid": true,
+    "show_progress_every_n_steps": 1,
+    "show_progress_type": "Approx NN",
+    "live_preview_allow_lowvram_full": false,
+    "live_preview_content": "Prompt",
+    "live_preview_refresh_period": 100.0,
+    "live_preview_fast_interrupt": true,
+    "js_live_preview_in_modal_lightbox": false,
+    "hide_samplers": [
+        "DPM++ SDE Karras",
+        "DPM++ 2M SDE Exponential",
+        "DPM++ 2M SDE Karras",
+        "Euler",
+        "LMS",
+        "DPM2",
+        "DPM2 a",
+        "DPM++ 2S a",
+        "DPM++ 2M SDE",
+        "DPM++ 2M SDE Heun",
+        "DPM++ 2M SDE Heun Karras",
+        "DPM++ 2M SDE Heun Exponential",
+        "DPM++ 3M SDE",
+        "DPM++ 3M SDE Karras",
+        "DPM++ 3M SDE Exponential",
+        "DPM fast",
+        "DPM adaptive",
+        "LMS Karras",
+        "DPM2 Karras",
+        "DPM2 a Karras",
+        "DPM++ 2S a Karras",
+        "DDIM",
+        "PLMS",
+        "LCM"
+    ],
+    "eta_ddim": 0.0,
+    "eta_ancestral": 1.0,
+    "ddim_discretize": "uniform",
+    "s_churn": 0.0,
+    "s_tmin": 0.0,
+    "s_tmax": 0.0,
+    "s_noise": 1.0,
+    "k_sched_type": "Automatic",
+    "sigma_min": 0.0,
+    "sigma_max": 0.0,
+    "rho": 0.0,
+    "eta_noise_seed_delta": 31337,
+    "always_discard_next_to_last_sigma": false,
+    "sgm_noise_multiplier": false,
+    "uni_pc_variant": "bh2",
+    "uni_pc_skip_type": "time_uniform",
+    "uni_pc_order": 3,
+    "uni_pc_lower_order_final": true,
+    "postprocessing_enable_in_main_ui": [],
+    "postprocessing_operation_order": [],
+    "upscaling_max_images_in_cache": 5,
+    "postprocessing_existing_caption_action": "Ignore",
+    "disabled_extensions": [
+        "canvas-zoom-and-pan"
+    ],
+    "disable_all_extensions": "none",
+    "restore_config_state_file": "",
+    "sd_checkpoint_hash": "bcce73a08e95a4d4a3332875342792a50ab9bf9f07fdedcab49fd425fac173be",
+    "ldsr_steps": 100,
+    "ldsr_cached": false,
+    "SCUNET_tile": 256,
+    "SCUNET_tile_overlap": 8,
+    "SWIN_tile": 192,
+    "SWIN_tile_overlap": 8,
+    "hypertile_enable_unet": true,
+    "hypertile_enable_unet_secondpass": true,
+    "hypertile_max_depth_unet": 3,
+    "hypertile_max_tile_unet": 256,
+    "hypertile_swap_size_unet": 3,
+    "hypertile_enable_vae": false,
+    "hypertile_max_depth_vae": 3,
+    "hypertile_max_tile_vae": 128,
+    "hypertile_swap_size_vae": 3,
+    "ad_max_models": 2,
+    "ad_extra_models_dir": "",
+    "ad_save_previews": false,
+    "ad_save_images_before": false,
+    "ad_only_seleted_scripts": true,
+    "ad_script_names": "dynamic_prompting,dynamic_thresholding,wildcard_recursive,wildcards,lora_block_weight,negpip",
+    "ad_bbox_sortby": "None",
+    "ad_same_seed_for_each_tap": false,
+    "control_net_detectedmap_dir": "detected_maps",
+    "control_net_models_path": "",
+    "control_net_modules_path": "",
+    "control_net_unit_count": 3,
+    "control_net_model_cache_size": 1,
+    "control_net_inpaint_blur_sigma": 7,
+    "control_net_no_high_res_fix": false,
+    "control_net_no_detectmap": true,
+    "control_net_detectmap_autosaving": false,
+    "control_net_allow_script_control": true,
+    "control_net_sync_field_args": true,
+    "controlnet_show_batch_images_in_ui": false,
+    "controlnet_increment_seed_during_batch": false,
+    "controlnet_disable_openpose_edit": false,
+    "controlnet_ignore_noninpaint_mask": false,
+    "lora_functional": false,
+    "sd_lora": "None",
+    "lora_preferred_name": "Alias from file",
+    "lora_add_hashes_to_infotext": true,
+    "lora_show_all": false,
+    "lora_hide_unknown_for_versions": [],
+    "lora_in_memory_limit": 2,
+    "extra_options_txt2img": [
+        "tiling",
+        "CLIP_stop_at_last_layers"
+    ],
+    "extra_options_img2img": [],
+    "extra_options_cols": 1,
+    "extra_options_accordion": false,
+    "canvas_disabled_functions": [
+        "Overlap"
+    ],
+    "canvas_hotkey_zoom": "Alt",
+    "canvas_hotkey_adjust": "Ctrl",
+    "canvas_hotkey_move": "F",
+    "canvas_hotkey_fullscreen": "S",
+    "canvas_hotkey_reset": "R",
+    "canvas_hotkey_overlap": "O",
+    "canvas_show_tooltip": true,
+    "canvas_auto_expand": true,
+    "canvas_blur_prompt": true,
+    "canvas_zoom_undo_extra_key": "Ctrl",
+    "canvas_zoom_hotkey_undo": "Z",
+    "canvas_zoom_inc_brush_size": "]",
+    "canvas_zoom_dec_brush_size": "[",
+    "canvas_zoom_hotkey_open_colorpanel": "Q",
+    "canvas_zoom_hotkey_pin_colorpanel": "T",
+    "canvas_zoom_hotkey_dropper": "A",
+    "canvas_zoom_hotkey_fill": "X",
+    "canvas_zoom_hotkey_transparency": "C",
+    "canvas_zoom_hide_btn": true,
+    "canvas_zoom_mask_clear": true,
+    "canvas_zoom_enable_integration": true,
+    "canvas_zoom_brush_size": 250,
+    "canvas_zoom_brush_size_change": 5,
+    "canvas_zoom_transparency_level": 60,
+    "canvas_zoom_brush_opacity": true,
+    "canvas_zoom_inpaint_label": false,
+    "canvas_zoom_inpaint_warning": true,
+    "canvas_zoom_inpaint_change_btn_color": true,
+    "canvas_zoom_inpaint_btn_color": "#ff1486",
+    "canvas_zoom_brush_outline": true,
+    "canvas_zoom_add_buttons": false,
+    "canvas_zoom_draw_staight_lines": true,
+    "canvas_zoom_inpaint_brushcolor": "#ff0000",
+    "canvas_zoom_disabled_functions": [
+        "Overlap"
+    ],
+    "SWIN_torch_compile": false,
+    "auto_backcompat": true,
+    "use_downcasted_alpha_bar": false,
+    "extra_networks_card_description_is_html": false,
+    "extra_networks_tree_view_default_enabled": false,
+    "lora_not_found_warning_console": false,
+    "lora_not_found_gradio_warning": false,
+    "pad_cond_uncond_v0": false,
+    "fp8_storage": "Disable",
+    "cache_fp16_weight": false,
+    "sd_noise_schedule": "Default",
+    "emphasis": "Original",
+    "enable_prompt_comments": true,
+    "auto_vae_precision_bfloat16": false,
+    "overlay_inpaint": true,
+    "sd_webui_modal_lightbox_icon_opacity": 1,
+    "sd_webui_modal_lightbox_toolbar_opacity": 0.9,
+    "open_dir_button_choice": "Subdirectory",
+    "include_styles_into_token_counters": true,
+    "interrupt_after_current": false,
+    "enable_upscale_progressbar": true,
+    "dat_enabled_models": [
+        "DAT x2",
+        "DAT x3",
+        "DAT x4"
+    ],
+    "DAT_tile": 192,
+    "DAT_tile_overlap": 8,
+    "refiner_switch_by_sample_steps": false,
+    "extra_networks_tree_view_style": "Dirs",
+    "extra_networks_tree_view_default_width": 180.0,
+    "enable_reloading_ui_scripts": false,
+    "prioritized_callbacks_app_started": [],
+    "prioritized_callbacks_model_loaded": [],
+    "prioritized_callbacks_ui_settings": [],
+    "prioritized_callbacks_infotext_pasted": [],
+    "prioritized_callbacks_script_unloaded": [],
+    "prioritized_callbacks_before_ui": [],
+    "prioritized_callbacks_list_optimizers": [],
+    "prioritized_callbacks_before_token_counter": [],
+    "prioritized_callbacks_script_before_process": [],
+    "prioritized_callbacks_script_process": [],
+    "prioritized_callbacks_script_postprocess": [],
+    "prioritized_callbacks_script_post_sample": [],
+    "prioritized_callbacks_script_on_mask_blend": [],
+    "prioritized_callbacks_script_postprocess_maskoverlay": [],
+    "postprocessing_disable_in_extras": [],
+    "set_scale_by_when_changing_upscaler": false
+}

styles.csv

@@ -0,0 +1,30 @@
+name,prompt,negative_prompt
++ Details,maximum details,
++ Natural Skin,"{prompt}, natural skin texture, hyperrealism, soft light, muted colors","oversaturated, illustration, anime, (mannequin:0.6), graphic, cg, cgi, cartoon, glitch, 3d, 2d, octane, sketch, acrylic, painting, drawing"
+- Negative Lite,,"oversaturated, disfigured, poorly, bad, wrong, mutated"
+- Negative Basic,,"oversaturated, [disfigured, poorly drawn], [bad : wrong] anatomy, [extra | missing | floating | disconnected] limb, mutated, blurry"
+- Negative Strong,,"(deformed, distorted, disfigured:1.3), poorly drawn, bad anatomy, wrong anatomy, extra limb, missing limb, floating limbs, (mutated hands and fingers:1.4), disconnected limbs, mutation, mutated, ugly, disgusting, blurry, amputation, oversaturated"
+- Anime Negative,,"(worst quality:1.2), mutated hands and fingers, [bad : wrong] anatomy"
+Illustration,"(illustration:1.15), {prompt}, [cory loftis, strobist, pascal campion :: 0.2]","octane, 3d, {prompt}, photo"
+Painting,"(pascal campion:0.38), vivid colors, (painting art:0.06), [eclectic:clear:0.8]","vignette, cinematic, grayscale, bokeh, blurred, depth of field"
+Acrylic,"acrylic illustration, {prompt}, acrylic paint, oily sketch","red, photo, 3d, octane, {prompt}"
+Retro futuristic,"{prompt}, art by angus mckie","watermark, signature"
+Caricature,"big head, big eyes, caricature, a caricature, rendering, (figurativism:0.8)",
+Paper-cut,"(paper-cut craft:1.2), {prompt}","photo, {prompt}"
+3d (render) 👎,"eevee, 3d, render, 3 point light, (glossy:0.76), ambient occlusion","watermark, signature"
+3d (render) 👍,"epic realistic, hyperdetailed, (cycles render:1.3), caustics, (glossy:0.58), (artstation:0.82)",
+3d (movie),"epic realistic, pixar style, disney, (cycles render:1.3), caustics, (glossy:0.58), (artstation:0.2), cute",
+Isometric,"{prompt}, (isometric:1.2) 3d art, artstation, demo","watermark, signature"
+8bit,"pixel art, 8bit, aliasing","photo, octane, fabric, realistic, material, grain, grainy"
+Logo,"(logo:1.3), vector graphics, brand, design, inspired, (straight:1.3), (symmetrical:0.4)",
+Logo (minimalistic),"art by keith negley, (logo:1.3), vector graphics, design, (straight:1.3), (symmetrical:0.4), by keith negley, [[jean arp]], minimalistic",
+Engraving,"(grayscale, woodcut:1.2), (etching:1.1), (engraving:0.2), {prompt}","photo, 3d, colored"
+Comic book,"comic style, illustration, cartoon, {prompt}, [[by phil jimenez]]",bw {prompt}
+Cinematic,"{prompt}, cinematic, (muted colors:1.2), background (filmic:0.7)","3d, dof, rutkowski, oversaturated, [doll :: 0.33], {prompt}"
+Cinematic (horror),"slate atmosphere, cinematic, dimmed colors, dark shot, muted colors, film grainy, lut, spooky",
+Cinematic (art),"art by greg rutkowski and artgerm, soft cinematic light, adobe lightroom, photolab, hdr, intricate, highly detailed, (depth of field:1.4)",
+Gloomy,"complex background, background, highly detailed, gloomy, eerie, dark, dimmed, hdr, vignette, grimy, (slate atmosphere:0.4)","(depth of field:1.3), (bokeh:1.2), (blur), pink"
+Professional photo,"professional detailed photography, {prompt}, (muted colors, dim colors, soothing tones), (vsco:0.3)","oversaturated, [doll :: 0.5], {prompt}"
+Midjourney,"hdr, epic realistic, {prompt}, rutkowski, rim light",
+XpucT (Art),"[dark theme :: 0.3], {prompt}, (hdr:1.2), art (by jordan grimmer:0.2)","dof, {prompt}"
+XpucT (cinemArt),"hyperrealism, atmospheric","dof, {prompt}"

user.css

@@ -0,0 +1,256 @@
+* {
+    font-family: Arial !important;
+	}
+
+div#txt2img_prompt > label > textarea,
+div#img2img_prompt > label > textarea {
+    font: 20px Arimo, Arial !important;
+    color: #a7b4c4 !important;
+}
+
+div#txt2img_gallery,
+div#img2img_gallery
+{
+    height: 512px;
+}
+
+.livePreview img {
+    height: 452px;
+}
+
+
+div#txt2img_neg_prompt > label > textarea,
+div#img2img_neg_prompt > label > textarea {
+    font-size: 14px !important;
+    color: #4d5967 !important;
+}
+
+.dark {
+    --body-background-fill: #131a25;
+}
+
+.gradio-container-3-28-1 .prose * {
+    color: #9fa8b6;
+}
+
+div#html_info_txt2img,
+div#html_info_img2img,
+button#txt2img_clear_prompt,
+button#img2img_clear_prompt
+{
+    display: none;
+}
+
+.primary.svelte-cmf5ev {
+	border: none;
+}
+
+.primary.svelte-cmf5ev {
+    border: none;
+    background: #2772c3;
+    border-radius: 5px;
+}
+.primary.svelte-cmf5ev:hover {
+    background: #266ab4;
+}
+
+button#txt2img_generate {
+	background: #2772c3;
+}
+
+.dark .panel.svelte-vt1mxs {
+    background: #131a25;
+    padding: 0;
+}
+
+.dark .preview.svelte-1b19cri.svelte-1b19cri,
+.dark .preview.svelte-1b19cri img.svelte-1b19cri {
+    background: #1f2937;
+}
+
+.livePreview {
+	background: transparent;
+}
+
+.selected.svelte-1g805jl {
+    background: #131a25;
+}
+
+#context-menu {
+    border: 1px solid rgba(255, 255, 255, 0.1);
+    box-shadow: 0px 1px 1px black !important;
+	background: #18212d !important;
+}
+
+.context-menu-items a {
+    padding: 8px;
+}
+
+.context-menu-items a:hover {
+    background: #226bb954;
+    transition: 0.1s;
+}
+
+.thumbnail-small.selected.svelte-1b19cri.svelte-1b19cri,
+.thumbnail-item.svelte-1b19cri.svelte-1b19cri:hover {
+    --ring-color: none;
+    border-color: transparent;
+}
+
+#settings > div.tab-nav {
+    width: 14em;
+}
+
+.progressDiv .progress {
+    font-family: Verdana !important;
+    font-size: 12px;
+    font-weight: normal;
+    background: #0d4f7e;
+    color: #9ecfe9;
+    border-radius: 5px;
+}
+#txt2img_progressbar {
+    width: 118.4% !important;
+}
+
+.progressDiv {
+	z-index: 9999;
+}
+
+.dark .progressDiv {
+    background: #1d2938;
+}
+
+.block.border_focus {
+    border-color: #5290bd !important;
+}
+
+#txt2img_interrupt,
+#img2img_interrupt,
+#txt2img_skip {
+    background: #718396;
+}
+
+#lightboxModal {
+    background-color: #090b0df7;
+}
+
+#txt2img_preview {
+    margin-right: 0 !important;
+}
+
+.dark #txt2img_settings {
+    background: #1f2937 !important;
+}
+
+div#txt2img_settings {
+    padding: 10px !important;
+}
+
+button#save_txt2img,
+button#save_zip_txt2img,
+button#save_img2img,
+button#save_zip_img2img {
+    display: none;
+}
+
+.gradio-container {
+    line-height: 1.15;
+}
+
+#settings > div.flex-wrap {
+    width: 13em;
+}
+
+.extra-network-cards .card .actions .name {
+    font-size: 1.3em;
+    font-weight: 100;
+}
+
+.extra-network-cards .card .metadata-button:hover,
+.extra-network-cards .card ul a:hover {
+    color: #5bffa8;
+}
+
+#footer {
+    display: none;
+}
+
+.unpadded_box.large.svelte-1u5vjgs {
+    min-height: 450px;
+}
+
+.dark .options.svelte-1aonegi {
+    background: #131a25;
+}
+.dark .item.svelte-1aonegi:hover {
+    background: #17202d;
+}
+.dark .gradio-dropdown ul.options li.item.selected {
+    background: #1b2533;
+}
+
+.eta-bar.svelte-j1gjts {
+    background: #2c394b;
+}
+
+svg.svelte-zyxd38 path.svelte-zyxd38 {
+    fill: #6a9cd2;
+}
+
+.wrap.svelte-j1gjts {
+    background: #1f2937;
+}
+
+.block.token-counter span,
+.block.token-counter.error span {
+    box-shadow: none;
+}
+
+.dark .svelte-116rqfv.center.boundedheight.flex {
+    background: #131a25;
+}
+
+.error.svelte-j1gjts {
+    border: solid 1px #de8ab175;
+    border-radius: 7px;
+    background: #181622de;
+    color: #f57cb4;
+}
+
+div#txt2img_column_size {
+    min-width: min(200px, 100%) !important;
+}
+
+button#arc_show_calculator_button,
+div#arc_empty_space {
+	display: none;
+}
+
+#txt2img_row_resolutions button,
+#img2img_row_resolutions button,
+#txt2img_row_aspect_ratio button,
+#img2img_row_aspect_ratio button {
+	max-width: 100% !important;
+}
+
+a {
+    font-weight: normal;
+}
+
+.panel.svelte-15lo0d8 {
+	background: none;
+}
+
+.extra-network-cards {
+	height: 100% !important;
+		max-height: 800px !important;
+}
+
+.selected.svelte-kqij2n {
+	background: transparent;
+}
+
+.extra-networks > div.tab-nav {
+	min-height: auto;
+}

user.js

@@ -0,0 +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()
+
+        e.preventDefault()
+    }
+	
+	// Выгрузить модели по F4
+	else if (e.code === 'F4')
+    {
+        document.querySelector('#sett_unload_sd_model').click()
+        e.preventDefault()
+    }
+
+    // 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.querySelector('.livePreview').style.display = 'block'
+    }
+})
+
+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)
+    {
+        ad.parentNode.removeChild(ad)
+        ad = result.iterateNext()
+    }
+
+
+    // Граница в 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()
+        }
+    }))
+})