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