| |
| |
|
|
| 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) |
|
|
| |
| 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, '') |
|
|
