769 lines
30 KiB
Python
769 lines
30 KiB
Python
import os
|
|
|
|
import numpy as np
|
|
import torch
|
|
from PIL import Image, ImageFilter, ImageEnhance, ImageCms, ImageOps, ImageDraw, ImageFont
|
|
|
|
sRGB_profile = ImageCms.createProfile("sRGB")
|
|
Lab_profile = ImageCms.createProfile("LAB")
|
|
|
|
|
|
# Tensor to PIL
|
|
def tensor2pil(image):
|
|
return Image.fromarray(np.clip(255. * image.cpu().numpy().squeeze(), 0, 255).astype(np.uint8))
|
|
|
|
|
|
# PIL to Tensor
|
|
def pil2tensor(image):
|
|
return torch.from_numpy(np.array(image).astype(np.float32) / 255.0).unsqueeze(0)
|
|
|
|
|
|
def adjust_shadows(luminance_array, shadow_intensity, hdr_intensity):
|
|
# Darken shadows more as shadow_intensity increases, scaled by hdr_intensity
|
|
return np.clip(luminance_array - luminance_array * shadow_intensity * hdr_intensity * 0.5, 0, 255)
|
|
|
|
|
|
def adjust_highlights(luminance_array, highlight_intensity, hdr_intensity):
|
|
# Brighten highlights more as highlight_intensity increases, scaled by hdr_intensity
|
|
return np.clip(luminance_array + (255 - luminance_array) * highlight_intensity * hdr_intensity * 0.5, 0, 255)
|
|
|
|
|
|
def apply_adjustment(base, factor, intensity_scale):
|
|
"""Apply positive adjustment scaled by intensity."""
|
|
# Ensure the adjustment increases values within [0, 1] range, scaling by intensity
|
|
adjustment = base + (base * factor * intensity_scale)
|
|
# Ensure adjustment stays within bounds
|
|
return np.clip(adjustment, 0, 1)
|
|
|
|
|
|
def multiply_blend(base, blend):
|
|
"""Multiply blend mode."""
|
|
return np.clip(base * blend, 0, 255)
|
|
|
|
|
|
def overlay_blend(base, blend):
|
|
"""Overlay blend mode."""
|
|
# Normalize base and blend to [0, 1] for blending calculation
|
|
base = base / 255.0
|
|
blend = blend / 255.0
|
|
return np.where(base < 0.5, 2 * base * blend, 1 - 2 * (1 - base) * (1 - blend)) * 255
|
|
|
|
|
|
def adjust_shadows_non_linear(luminance, shadow_intensity, max_shadow_adjustment=1.5):
|
|
lum_array = np.array(luminance, dtype=np.float32) / 255.0 # Normalize
|
|
# Apply a non-linear darkening effect based on shadow_intensity
|
|
shadows = lum_array ** (1 / (1 + shadow_intensity * max_shadow_adjustment))
|
|
return np.clip(shadows * 255, 0, 255).astype(np.uint8) # Re-scale to [0, 255]
|
|
|
|
|
|
def adjust_highlights_non_linear(luminance, highlight_intensity, max_highlight_adjustment=1.5):
|
|
lum_array = np.array(luminance, dtype=np.float32) / 255.0 # Normalize
|
|
# Brighten highlights more aggressively based on highlight_intensity
|
|
highlights = 1 - (1 - lum_array) ** (1 + highlight_intensity * max_highlight_adjustment)
|
|
return np.clip(highlights * 255, 0, 255).astype(np.uint8) # Re-scale to [0, 255]
|
|
|
|
|
|
def merge_adjustments_with_blend_modes(luminance, shadows, highlights, hdr_intensity, shadow_intensity,
|
|
highlight_intensity):
|
|
# Ensure the data is in the correct format for processing
|
|
base = np.array(luminance, dtype=np.float32)
|
|
|
|
# Scale the adjustments based on hdr_intensity
|
|
scaled_shadow_intensity = shadow_intensity ** 2 * hdr_intensity
|
|
scaled_highlight_intensity = highlight_intensity ** 2 * hdr_intensity
|
|
|
|
# Create luminance-based masks for shadows and highlights
|
|
shadow_mask = np.clip((1 - (base / 255)) ** 2, 0, 1)
|
|
highlight_mask = np.clip((base / 255) ** 2, 0, 1)
|
|
|
|
# Apply the adjustments using the masks
|
|
adjusted_shadows = np.clip(base * (1 - shadow_mask * scaled_shadow_intensity), 0, 255)
|
|
adjusted_highlights = np.clip(base + (255 - base) * highlight_mask * scaled_highlight_intensity, 0, 255)
|
|
|
|
# Combine the adjusted shadows and highlights
|
|
adjusted_luminance = np.clip(adjusted_shadows + adjusted_highlights - base, 0, 255)
|
|
|
|
# Blend the adjusted luminance with the original luminance based on hdr_intensity
|
|
final_luminance = np.clip(base * (1 - hdr_intensity) + adjusted_luminance * hdr_intensity, 0, 255).astype(np.uint8)
|
|
|
|
return Image.fromarray(final_luminance)
|
|
|
|
|
|
def apply_gamma_correction(lum_array, gamma):
|
|
"""
|
|
Apply gamma correction to the luminance array.
|
|
:param lum_array: Luminance channel as a NumPy array.
|
|
:param gamma: Gamma value for correction.
|
|
"""
|
|
if gamma == 0:
|
|
return np.clip(lum_array, 0, 255).astype(np.uint8)
|
|
|
|
epsilon = 1e-7 # Small value to avoid dividing by zero
|
|
gamma_corrected = 1 / (1.1 - gamma)
|
|
adjusted = 255 * ((lum_array / 255) ** gamma_corrected)
|
|
return np.clip(adjusted, 0, 255).astype(np.uint8)
|
|
|
|
|
|
# create a wrapper function that can apply a function to multiple images in a batch while passing all other arguments to the function
|
|
def apply_to_batch(func):
|
|
def wrapper(self, image, *args, **kwargs):
|
|
images = []
|
|
for img in image:
|
|
images.append(func(self, img, *args, **kwargs))
|
|
batch_tensor = torch.cat(images, dim=0)
|
|
return (batch_tensor,)
|
|
|
|
return wrapper
|
|
|
|
|
|
# 领域降噪
|
|
def calculate_noise_count(img_obj, w, h, width, height):
|
|
count = 0
|
|
for _w_ in [w - 1, w, w + 1]:
|
|
for _h_ in [h - 1, h, h + 1]:
|
|
if _w_ > width - 1:
|
|
continue
|
|
if _h_ > height - 1:
|
|
continue
|
|
if _w_ == w and _h_ == h:
|
|
continue
|
|
if img_obj[_w_, _h_] < 230: # 这里因为是灰度图像，设置小于230为非白色
|
|
count += 1
|
|
return count
|
|
|
|
|
|
# 领域降噪
|
|
def row_noise(pim, height, weight, w):
|
|
for h in range(height):
|
|
if calculate_noise_count(pim, w, h, weight, height) < 4:
|
|
pim[w, h] = 255
|
|
|
|
|
|
def mexx_image_filter(img, image_filter,
|
|
write_text = '画画的Baby',
|
|
font_name = 'YangRenDongZhuShiTi-Light-2.ttf',
|
|
padding_height = 120,
|
|
font_size = 80):
|
|
if image_filter == "线稿-LINE0":
|
|
# 转换为灰度图
|
|
gray_image = img.convert("L")
|
|
array = np.array(gray_image).astype(np.float32)
|
|
# 根据灰度变化来模拟人类视觉的明暗程度
|
|
depth = 10 # 预设虚拟深度值为10 范围为0-100
|
|
# 提取x y方向梯度值 解构赋给grad_x, grad_y
|
|
grad_x, grad_y = np.gradient(array)
|
|
# 利用像素之间的梯度值和虚拟深度值对图像进行重构
|
|
grad_x = grad_x * depth / 100
|
|
grad_y = grad_y * depth / 100
|
|
# 梯度归一化 定义z深度为1. 将三个梯度绝对值转化为相对值，在三维中是相对于斜对角线A的值
|
|
dis = np.sqrt(grad_x ** 2 + grad_y ** 2 + 1.0)
|
|
uni_x = grad_x / dis
|
|
uni_y = grad_y / dis
|
|
uni_z = 1.0 / dis
|
|
# 光源俯视角度和光源方位角度
|
|
vec_el = np.pi / 2.2
|
|
vec_az = np.pi / 4
|
|
# 光源对x、y、z轴的影响
|
|
dx = np.cos(vec_el) * np.cos(vec_az)
|
|
dy = np.cos(vec_el) * np.sin(vec_az)
|
|
dz = np.sin(vec_el)
|
|
# 光源归一化
|
|
out = 255 * (uni_x * dx + uni_y * dy + uni_z * dz)
|
|
out = out.clip(0, 255)
|
|
img = Image.fromarray(out.astype(np.uint8))
|
|
return img.convert("RGB")
|
|
if image_filter == "线稿-LINE1":
|
|
gray_image = img.convert("L")
|
|
im = gray_image.filter(ImageFilter.GaussianBlur(radius=0.75)) # 高斯模糊 75%
|
|
a = np.asarray(im).astype(np.float32)
|
|
|
|
depth = 10. # 设定虚拟深度
|
|
grad = np.gradient(a)
|
|
grad_x, grad_y = grad
|
|
grad_x = grad_x * depth / 100.
|
|
grad_y = grad_y * depth / 100.
|
|
# 梯度向量计算
|
|
A = np.sqrt(grad_x ** 2 + grad_y ** 2 + 1.)
|
|
uni_x = grad_x / A
|
|
uni_y = grad_y / A
|
|
uni_z = 1. / A
|
|
vec_el = np.pi / 2.2
|
|
vec_az = np.pi / 4.
|
|
dx = np.cos(vec_el) * np.cos(vec_az)
|
|
dy = np.cos(vec_el) * np.sin(vec_az)
|
|
dz = np.sin(vec_el)
|
|
|
|
b = 255 * (dx * uni_x + dy * uni_y + dz * uni_z)
|
|
b = b.clip(0, 255) # 二值化处理，要么为0，（黑色边缘）要么为255（白色背景）
|
|
im2 = Image.fromarray(b.astype(np.uint8))
|
|
im2 = im2.filter(ImageFilter.SHARPEN)
|
|
weight, height = im2.size
|
|
# 降噪
|
|
pim = im2.load()
|
|
map(row_noise, [(pim, height, weight, w,) for w in range(weight)])
|
|
# 填充新图像的像素数据
|
|
for i in range(im2.size[0]):
|
|
for j in range(im2.size[1]):
|
|
im2.putpixel((i, j), pim[i, j])
|
|
return im2.convert("RGB")
|
|
if image_filter == "线稿-LINE2":
|
|
# 转换为灰度图
|
|
gray_image = img.convert("L")
|
|
# 应用高斯模糊（可选，根据需要决定是否使用）
|
|
blurred_image = gray_image.filter(ImageFilter.GaussianBlur(0.75))
|
|
# 应用边缘检测
|
|
edge_image = blurred_image.filter(ImageFilter.FIND_EDGES)
|
|
# 锐化边缘
|
|
edge_enhance_image2 = edge_image.filter(ImageFilter.EDGE_ENHANCE)
|
|
inverted_image = ImageOps.invert(edge_enhance_image2)
|
|
return inverted_image.convert("RGB")
|
|
if image_filter == "线稿-LINE3":
|
|
# 转换为灰度图
|
|
gray_image = img.convert("L")
|
|
# 应用高斯模糊（可选，根据需要决定是否使用）
|
|
blurred_image = gray_image.filter(ImageFilter.GaussianBlur(0.75))
|
|
# 应用边缘检测
|
|
edge_image = blurred_image.filter(ImageFilter.CONTOUR)
|
|
# 锐化边缘
|
|
sharpen_image2 = edge_image.filter(ImageFilter.SHARPEN)
|
|
return sharpen_image2.convert("RGB")
|
|
if image_filter == "线稿-LINE3.1":
|
|
# 转换为灰度图
|
|
gray_image = img.convert("L")
|
|
# 应用高斯模糊（可选，根据需要决定是否使用）
|
|
blurred_image = gray_image.filter(ImageFilter.GaussianBlur(0.75))
|
|
# 应用边缘检测
|
|
edge_image = blurred_image.filter(ImageFilter.CONTOUR)
|
|
# 创建边缘图像，例如使用边缘检测滤镜
|
|
# 定义一个锐化的卷积核
|
|
kernel = (-1, -1, -1,
|
|
-1, 9, -1,
|
|
-1, -1, -1)
|
|
# 创建自定义滤镜
|
|
custom_filter = ImageFilter.Kernel((3, 3), kernel)
|
|
return edge_image.filter(custom_filter).convert("RGB")
|
|
if image_filter == "线稿-LINE3.2":
|
|
# 转换为灰度图
|
|
gray_image = img.convert("L")
|
|
# 应用高斯模糊（可选，根据需要决定是否使用）
|
|
blurred_image = gray_image.filter(ImageFilter.GaussianBlur(0.75))
|
|
# 应用边缘检测
|
|
edge_image = blurred_image.filter(ImageFilter.FIND_EDGES)
|
|
# 创建边缘图像，例如使用边缘检测滤镜
|
|
blurred_image2 = edge_image.filter(ImageFilter.SMOOTH_MORE)
|
|
inverted_image = ImageOps.invert(blurred_image2)
|
|
return inverted_image.filter(ImageFilter.EDGE_ENHANCE).convert("RGB")
|
|
if image_filter == "线稿-LINE4":
|
|
# 转换为灰度图
|
|
gray_image = img.convert("L")
|
|
# 应用边缘检测
|
|
edge_image = gray_image.filter(ImageFilter.CONTOUR)
|
|
# 锐化边缘
|
|
edge_enhance_image2 = edge_image.filter(ImageFilter.EDGE_ENHANCE)
|
|
return edge_enhance_image2.convert("RGB")
|
|
if image_filter == "线稿-LINE5":
|
|
# 转换为灰度图
|
|
gray_image = img.convert("L")
|
|
# 应用边缘检测
|
|
edge_image = gray_image.filter(ImageFilter.CONTOUR)
|
|
# 对比度
|
|
contrast_enhancer = ImageEnhance.Sharpness(edge_image)
|
|
enhanced_image = contrast_enhancer.enhance(1.2)
|
|
return enhanced_image.convert("RGB")
|
|
elif image_filter == "边缘检测-FIND_EDGES":
|
|
return img.filter(ImageFilter.FIND_EDGES)
|
|
elif image_filter == "轮廓-CONTOUR":
|
|
return img.filter(ImageFilter.CONTOUR)
|
|
elif image_filter == "灰度-L":
|
|
gray_image = img.convert("L")
|
|
return gray_image.convert("RGB")
|
|
elif image_filter == "锐化-SHARPEN":
|
|
return img.filter(ImageFilter.SHARPEN)
|
|
elif image_filter == "锐化-UNSHARP_MASK":
|
|
return img.filter(ImageFilter.UnsharpMask(2))
|
|
elif image_filter == "边缘增强-EDGE_ENHANCE":
|
|
return img.filter(ImageFilter.EDGE_ENHANCE)
|
|
elif image_filter == "边缘增强-EDGE_ENHANCE_MORE":
|
|
return img.filter(ImageFilter.EDGE_ENHANCE_MORE)
|
|
elif image_filter == "浮雕-EMBOSS":
|
|
return img.filter(ImageFilter.EMBOSS)
|
|
elif image_filter == "平滑-SMOOTH":
|
|
return img.filter(ImageFilter.SMOOTH)
|
|
elif image_filter == "平滑-SMOOTH_MORE":
|
|
return img.filter(ImageFilter.SMOOTH_MORE)
|
|
elif image_filter == "细节-DETAIL":
|
|
return img.filter(ImageFilter.DETAIL)
|
|
elif image_filter == "模糊-BLUR":
|
|
return img.filter(ImageFilter.BLUR)
|
|
elif image_filter == "模糊-BOX_BLUR":
|
|
return img.filter(ImageFilter.BoxBlur(2))
|
|
elif image_filter == "模糊-GAUSSIAN_BLUR":
|
|
return img.filter(ImageFilter.GaussianBlur(0.75))
|
|
elif image_filter == "反相-INVERT":
|
|
return ImageOps.invert(img)
|
|
elif image_filter == "去燥-中值滤波器":
|
|
return img.filter(ImageFilter.MedianFilter(size=3))
|
|
elif image_filter == "翻转_FLIP_LEFT_RIGHT":
|
|
return img.transpose(Image.FLIP_LEFT_RIGHT)
|
|
elif image_filter == "翻转_FLIP_TOP_BOTTOM":
|
|
return img.transpose(Image.FLIP_TOP_BOTTOM)
|
|
elif image_filter == "旋转_ROTATE_45":
|
|
return img.rotate(45)
|
|
elif image_filter == "旋转_ROTATE_90":
|
|
return img.rotate(90)
|
|
elif image_filter == "旋转_ROTATE_180":
|
|
return img.rotate(180)
|
|
elif image_filter == "旋转_ROTATE_270":
|
|
return img.rotate(270)
|
|
elif image_filter == "对比度_0.8":
|
|
contrast_enhancer = ImageEnhance.Contrast(img)
|
|
enhanced_image = contrast_enhancer.enhance(0.8)
|
|
return enhanced_image
|
|
elif image_filter == "对比度_1.2":
|
|
contrast_enhancer = ImageEnhance.Contrast(img)
|
|
enhanced_image = contrast_enhancer.enhance(1.2)
|
|
return enhanced_image
|
|
elif image_filter == "对比度_1.5":
|
|
contrast_enhancer = ImageEnhance.Contrast(img)
|
|
enhanced_image = contrast_enhancer.enhance(1.5)
|
|
return enhanced_image
|
|
elif image_filter == "对比度_2.0":
|
|
contrast_enhancer = ImageEnhance.Contrast(img)
|
|
enhanced_image = contrast_enhancer.enhance(2.0)
|
|
return enhanced_image
|
|
elif image_filter == "对比度_3.0":
|
|
contrast_enhancer = ImageEnhance.Contrast(img)
|
|
enhanced_image = contrast_enhancer.enhance(3.0)
|
|
return enhanced_image
|
|
elif image_filter == "对比度_5.0":
|
|
contrast_enhancer = ImageEnhance.Contrast(img)
|
|
enhanced_image = contrast_enhancer.enhance(5.0)
|
|
return enhanced_image
|
|
elif image_filter == "色彩_0.5":
|
|
contrast_enhancer = ImageEnhance.Color(img)
|
|
enhanced_image = contrast_enhancer.enhance(0.5)
|
|
return enhanced_image
|
|
elif image_filter == "色彩_0.8":
|
|
contrast_enhancer = ImageEnhance.Color(img)
|
|
enhanced_image = contrast_enhancer.enhance(0.8)
|
|
return enhanced_image
|
|
elif image_filter == "色彩_0.9":
|
|
contrast_enhancer = ImageEnhance.Color(img)
|
|
enhanced_image = contrast_enhancer.enhance(0.9)
|
|
return enhanced_image
|
|
elif image_filter == "色彩_1.1":
|
|
contrast_enhancer = ImageEnhance.Color(img)
|
|
enhanced_image = contrast_enhancer.enhance(1.1)
|
|
return enhanced_image
|
|
elif image_filter == "色彩_1.2":
|
|
contrast_enhancer = ImageEnhance.Color(img)
|
|
enhanced_image = contrast_enhancer.enhance(1.2)
|
|
return enhanced_image
|
|
elif image_filter == "色彩_1.5":
|
|
contrast_enhancer = ImageEnhance.Color(img)
|
|
enhanced_image = contrast_enhancer.enhance(1.5)
|
|
return enhanced_image
|
|
elif image_filter == "框":
|
|
border_size = 20
|
|
# 获取原始图片的尺寸
|
|
img_width, img_height = img.size
|
|
|
|
# 计算相框的尺寸（原始图片的尺寸加上边框的厚度）
|
|
frame_width = img_width + 2 * border_size
|
|
frame_height = img_height + 2 * border_size
|
|
|
|
# 创建一个新的图像对象作为相框
|
|
frame = Image.new('RGB', (frame_width, frame_height), 'white') # 相框背景为白色
|
|
draw = ImageDraw.Draw(frame) # 创建绘图对象
|
|
|
|
# 将原始图片粘贴到相框中（居中）
|
|
x = border_size
|
|
y = border_size
|
|
frame.paste(img, (x, y))
|
|
|
|
return frame.convert("RGB")
|
|
elif image_filter == "留白":
|
|
text = write_text
|
|
text_color = "black"
|
|
# 获取原始图片的尺寸
|
|
img_width, img_height = img.size
|
|
|
|
# 创建一个新的图像对象，宽度和高度分别为原始图片宽度和原始高度加上留白高度
|
|
new_height = img_height + padding_height
|
|
new_img = Image.new('RGB', (img_width, new_height), 'white') # 新图像背景为白色
|
|
|
|
# 将原始图片粘贴到新图像上（留白在上方）
|
|
new_img.paste(img, (0, padding_height))
|
|
|
|
# 准备绘制文字
|
|
draw = ImageDraw.Draw(new_img)
|
|
|
|
current_directory = os.path.dirname(os.path.realpath(__file__))
|
|
font_file = current_directory + "/font/" + font_name
|
|
|
|
font = ImageFont.truetype(font_file, font_size)
|
|
|
|
# 计算文字的位置（位于留白区域的中间）
|
|
bbox = draw.textbbox((0, 0), text, font=font)
|
|
text_width = bbox[2] - bbox[0]
|
|
text_height = bbox[3] - bbox[1]
|
|
text_x = (img_width - text_width) / 2
|
|
text_y = (padding_height - text_height) / 2
|
|
|
|
# 在留白区域写上文字
|
|
draw.text((text_x, text_y), text, fill=text_color, font=font)
|
|
|
|
return new_img.convert("RGB")
|
|
return img
|
|
|
|
|
|
class PilEffects:
|
|
@classmethod
|
|
def INPUT_TYPES(self):
|
|
list = ["NO",
|
|
"线稿-LINE0", "线稿-LINE1", "线稿-LINE2", "线稿-LINE3", "线稿-LINE3.1", "线稿-LINE3.2", "线稿-LINE4",
|
|
"线稿-LINE5",
|
|
"边缘检测-FIND_EDGES", "轮廓-CONTOUR", "灰度-L",
|
|
"细节-DETAIL",
|
|
"平滑-SMOOTH", "平滑-SMOOTH_MORE",
|
|
"锐化-SHARPEN", "锐化-UNSHARP_MASK",
|
|
"边缘增强-EDGE_ENHANCE", "边缘增强-EDGE_ENHANCE_MORE",
|
|
"模糊-BLUR", "模糊-BOX_BLUR", "模糊-GAUSSIAN_BLUR",
|
|
"反相-INVERT",
|
|
"去燥-中值滤波器",
|
|
"浮雕-EMBOSS",
|
|
"翻转_FLIP_LEFT_RIGHT", "翻转_FLIP_TOP_BOTTOM",
|
|
"旋转_ROTATE_45", "旋转_ROTATE_90", "旋转_ROTATE_180", "旋转_ROTATE_270",
|
|
"对比度_0.8", "对比度_1.2", "对比度_1.5", "对比度_2.0", "对比度_3.0", "对比度_5.0",
|
|
"色彩_0.5", "色彩_0.8","色彩_0.9","色彩_1.1", "色彩_1.2", "色彩_1.5",
|
|
"框"
|
|
]
|
|
return {'required': {'image': ('IMAGE', {'default': None}),
|
|
"image_filter": (list, {"default": "NO"})
|
|
}}
|
|
|
|
RETURN_TYPES = ('IMAGE',)
|
|
RETURN_NAMES = ('result_img',)
|
|
FUNCTION = 'apply_pil1'
|
|
CATEGORY = 'ComfyUI_Mexx'
|
|
|
|
@apply_to_batch
|
|
def apply_pil1(self, image, image_filter="NO", write_text="画画的Baby"):
|
|
# Load the image
|
|
img = tensor2pil(image)
|
|
result_img = mexx_image_filter(img, image_filter, write_text)
|
|
return pil2tensor(result_img)
|
|
|
|
|
|
class PilTitle:
|
|
@classmethod
|
|
def INPUT_TYPES(self):
|
|
list = ["NO",
|
|
"留白"
|
|
]
|
|
font_names = ["YangRenDongZhuShiTi-Light-2.ttf",
|
|
"JinNianYeYaoJiaYouYa-2.ttf",
|
|
"CEFFontsCJKMono-Regular.ttf",
|
|
"庞门正道粗书体6.0.ttf",
|
|
"白路飞云手写体.ttf"
|
|
]
|
|
return {'required': {'image': ('IMAGE', {'default': None}),
|
|
"image_filter": (list, {"default": "留白"}),
|
|
"padding_height": ("INT", {"default": 100}),
|
|
"font_size": ("INT", {"default": 60}),
|
|
"font_name": (font_names, {"default": "YangRenDongZhuShiTi-Light-2.ttf"}),
|
|
"write_text": ("STRING", {"default": "画画的Baby", "multiline": True}),
|
|
}}
|
|
|
|
RETURN_TYPES = ('IMAGE',)
|
|
RETURN_NAMES = ('result_img',)
|
|
FUNCTION = 'apply_pil2'
|
|
CATEGORY = 'ComfyUI_Mexx'
|
|
|
|
@apply_to_batch
|
|
def apply_pil2(self, image, image_filter="NO",
|
|
write_text="画画的Baby",
|
|
font_name = 'YangRenDongZhuShiTi-Light-2.ttf',
|
|
padding_height = 120,
|
|
font_size = 80):
|
|
# Load the image
|
|
img = tensor2pil(image)
|
|
result_img = mexx_image_filter(img, image_filter, write_text, font_name, padding_height, font_size)
|
|
return pil2tensor(result_img)
|
|
|
|
|
|
class PilMergeImage:
|
|
@classmethod
|
|
def INPUT_TYPES(self):
|
|
merge_type_list = ["上下", "左右", "平行四边形"]
|
|
return {'required': {'merge_type': (merge_type_list, {"default": "左右"}),
|
|
'image': ('IMAGE', {'default': None}),
|
|
'image2': ('IMAGE', {'default': None}),
|
|
},
|
|
'optional': {
|
|
'image3': ('IMAGE', {'default': None}),
|
|
'image4': ('IMAGE', {'default': None}),
|
|
'image5': ('IMAGE', {'default': None}),
|
|
'image6': ('IMAGE', {'default': None}),
|
|
}}
|
|
|
|
RETURN_TYPES = ('IMAGE',)
|
|
RETURN_NAMES = ('result_img',)
|
|
FUNCTION = 'apply_pil3'
|
|
CATEGORY = 'ComfyUI_Mexx'
|
|
|
|
@apply_to_batch
|
|
def apply_pil3(self, image, image2, image3 = None, image4 = None, image5 = None, image6 = None, merge_type="左右"):
|
|
print(f"PIL Merge Image Start")
|
|
images = []
|
|
# Load the image
|
|
img1 = tensor2pil(image)
|
|
images.append(img1)
|
|
print(f"Image1: {img1.size}")
|
|
img2 = tensor2pil(image2)
|
|
images.append(img2)
|
|
print(f"Image2: {img2.size}")
|
|
if image3 is not None:
|
|
img3 = tensor2pil(image3)
|
|
images.append(img3)
|
|
print(f"Image3: {img3.size}")
|
|
if image4 is not None:
|
|
img4 = tensor2pil(image4)
|
|
images.append(img4)
|
|
print(f"Image4: {img4.size}")
|
|
if image5 is not None:
|
|
img5 = tensor2pil(image5)
|
|
images.append(img5)
|
|
print(f"Image5: {img5.size}")
|
|
if image6 is not None:
|
|
img6 = tensor2pil(image6)
|
|
images.append(img6)
|
|
print(f"Image6: {img6.size}")
|
|
|
|
# 确保所有图片尺寸相同
|
|
for img in images:
|
|
if img.size != images[0].size:
|
|
raise ValueError("All images must be the same size")
|
|
|
|
# 获取图片的宽度和高度
|
|
width, height = images[0].size
|
|
print(f"PIL Merge Image: {width}, {height}")
|
|
|
|
if merge_type == "左右":
|
|
# 计算每张图片的宽度部分
|
|
part_width = width // len(images)
|
|
print(f"PIL Merge part_width: {part_width}")
|
|
|
|
# 创建一个新的图片，用于合成
|
|
combined_image = Image.new('RGB', (width, height))
|
|
|
|
# 依次将每张图片的相应部分粘贴到合成图片上
|
|
for i, image in enumerate(images):
|
|
part = image.crop((i * part_width, 0, (i + 1) * part_width, height))
|
|
combined_image.paste(part, (i * part_width, 0))
|
|
print(f"PIL Merge i = {i}")
|
|
|
|
print(f"result_img: {combined_image.size}")
|
|
return pil2tensor(combined_image)
|
|
if merge_type == "上下":
|
|
|
|
# 计算每张图片的宽度部分
|
|
part_height = height // len(images)
|
|
# 创建一个新的图片，用于合成
|
|
combined_image = Image.new('RGB', (width, height))
|
|
|
|
# 依次将每张图片的相应部分粘贴到合成图片上
|
|
for i, image in enumerate(images):
|
|
part = image.crop((0, i * part_height, width, (i + 1) * part_height))
|
|
combined_image.paste(part, (0, i * part_height))
|
|
print(f"PIL Merge i = {i}")
|
|
|
|
print(f"result_img: {combined_image.size}")
|
|
return pil2tensor(combined_image)
|
|
|
|
if merge_type == "平行四边形":
|
|
# 定义平行四边形的四个顶点坐标（相对于图片左上角）
|
|
# 例如，这里定义了一个从左上角开始的平行四边形
|
|
points = [
|
|
(0, 0),
|
|
(img1.width // 2, 0),
|
|
(img1.width, img1.height),
|
|
(img1.width // 2, img1.height)
|
|
]
|
|
|
|
# 创建一个和图片同样大小的透明遮罩
|
|
mask = Image.new('L', img1.size, 0)
|
|
draw = ImageDraw.Draw(mask)
|
|
|
|
# 绘制平行四边形遮罩
|
|
draw.polygon(points, fill=255)
|
|
|
|
# 将图2的平行四边形区域应用遮罩
|
|
img2 = img2.copy()
|
|
img2.putalpha(mask)
|
|
|
|
# 将图1和图2合成
|
|
combined_image = Image.composite(img2, img1, mask)
|
|
return pil2tensor(combined_image)
|
|
|
|
raise ValueError("Merge Type Error")
|
|
|
|
class PilRemoveBlackDots:
|
|
@classmethod
|
|
def INPUT_TYPES(self):
|
|
return {'required': {'image': ('IMAGE', {'default': None}),
|
|
'threshold': ('INT', {'default': 128}),
|
|
'dot_size': ('INT', {'default': 2}),
|
|
}}
|
|
|
|
RETURN_TYPES = ('IMAGE',)
|
|
RETURN_NAMES = ('result_img',)
|
|
FUNCTION = 'apply_pil4'
|
|
CATEGORY = 'ComfyUI_Mexx'
|
|
|
|
@apply_to_batch
|
|
def apply_pil4(self, image, threshold, dot_size):
|
|
img = tensor2pil(image)
|
|
# 加载像素数据
|
|
pixels = img.load()
|
|
width, height = img.size
|
|
|
|
# 遍历图像中的每个像素
|
|
for x in range(width):
|
|
for y in range(height):
|
|
r, g, b = pixels[x, y]
|
|
# 计算灰色程度，如果接近灰色，则将其转换为白色
|
|
if r > threshold and g > threshold and b > threshold:
|
|
pixels[x, y] = (255, 255, 255)
|
|
|
|
# 将图像转换为灰度模式
|
|
img = img.convert('L')
|
|
# 加载像素数据
|
|
pixels = img.load()
|
|
|
|
# 遍历图像中的每个像素
|
|
for x in range(width):
|
|
for y in range(height):
|
|
# 如果像素值低于某个阈值，则认为是黑点
|
|
if pixels[x, y] < threshold:
|
|
# 检查周围的像素，如果黑点很小，则去除
|
|
if all(pixels[max(x-i, 0), max(y-j, 0)] > 128 for i in range(dot_size) for j in range(dot_size)):
|
|
pixels[x, y] = 255
|
|
# 遍历图像中的每个像素
|
|
for x in range(width):
|
|
for y in range(height):
|
|
# 如果像素值低于某个阈值，则认为是黑点
|
|
if pixels[x, y] < threshold:
|
|
# 检查周围的像素，如果黑点很小，则去除
|
|
if all(pixels[max(x-i, 0), max(y-j, 0)] > 128 for i in range(dot_size) for j in range(dot_size)):
|
|
pixels[x, y] = 255
|
|
# 遍历图像中的每个像素
|
|
for x in range(width):
|
|
for y in range(height):
|
|
# 如果像素值低于某个阈值，则认为是黑点
|
|
if pixels[x, y] < threshold:
|
|
# 检查周围的像素，如果黑点很小，则去除
|
|
if all(pixels[max(x-i, 0), max(y-j, 0)] > 128 for i in range(dot_size) for j in range(dot_size)):
|
|
pixels[x, y] = 255
|
|
|
|
return pil2tensor(img.convert('RGB'))
|
|
|
|
|
|
def adjust_brightness(image, brightness_factor):
|
|
enhancer = ImageEnhance.Brightness(image)
|
|
adjusted_image = enhancer.enhance(brightness_factor)
|
|
return adjusted_image
|
|
|
|
|
|
def calculate_brightness_factor(target_brightness, current_brightness):
|
|
return target_brightness / current_brightness
|
|
|
|
|
|
def get_average_brightness(image):
|
|
grayscale_image = image.convert("L")
|
|
histogram = grayscale_image.histogram()
|
|
pixels = sum(histogram)
|
|
brightness = scale = len(histogram)
|
|
|
|
total_brightness = sum(i * w for i, w in enumerate(histogram))
|
|
return total_brightness / pixels
|
|
|
|
|
|
def apply_dithering(image):
|
|
return image.convert("P", palette=Image.ADAPTIVE, colors=256).convert("RGB")
|
|
|
|
|
|
def apply_noise_reduction(image, strength):
|
|
return image.filter(ImageFilter.GaussianBlur(radius=strength))
|
|
|
|
|
|
def apply_gradient_smoothing(image, strength):
|
|
return image.filter(ImageFilter.SMOOTH_MORE if strength > 1 else ImageFilter.SMOOTH)
|
|
|
|
|
|
def blend_images(image1, image2, alpha):
|
|
return Image.blend(image1, image2, alpha)
|
|
|
|
|
|
def temporal_smoothing(frames, window_size):
|
|
num_frames = len(frames)
|
|
smoothed_frames = []
|
|
|
|
for i in range(num_frames):
|
|
start = max(0, i - window_size // 2)
|
|
end = min(num_frames, i + window_size // 2 + 1)
|
|
window_frames = frames[start:end]
|
|
|
|
smoothed_frame = np.mean(window_frames, axis=0)
|
|
smoothed_frames.append(smoothed_frame)
|
|
|
|
return smoothed_frames
|
|
|
|
|
|
def resize_and_crop(pil_img, target_width, target_height):
|
|
"""Resize and crop an image to fit exactly the specified dimensions."""
|
|
original_width, original_height = pil_img.size
|
|
aspect_ratio = original_width / original_height
|
|
target_aspect_ratio = target_width / target_height
|
|
|
|
if target_aspect_ratio > aspect_ratio:
|
|
# Target is wider than the image
|
|
scale_factor = target_width / original_width
|
|
scaled_height = int(original_height * scale_factor)
|
|
scaled_width = target_width
|
|
else:
|
|
# Target is taller than the image
|
|
scale_factor = target_height / original_height
|
|
scaled_height = target_height
|
|
scaled_width = int(original_width * scale_factor)
|
|
|
|
# Resize the image
|
|
resized_img = pil_img.resize((scaled_width, scaled_height), Image.BILINEAR)
|
|
|
|
# Crop the image
|
|
if scaled_width != target_width or scaled_height != target_height:
|
|
left = (scaled_width - target_width) // 2
|
|
top = (scaled_height - target_height) // 2
|
|
right = left + target_width
|
|
bottom = top + target_height
|
|
cropped_img = resized_img.crop((left, top, right, bottom))
|
|
else:
|
|
cropped_img = resized_img
|
|
|
|
return cropped_img
|
|
|
|
|
|
NODE_CLASS_MAPPINGS = {
|
|
'PIL Effects (Mexx)': PilEffects,
|
|
'PIL TITLE (Mexx)': PilTitle,
|
|
'PIL Merge Image (Mexx)': PilMergeImage,
|
|
'PIL Remove Black Dots (Mexx)': PilRemoveBlackDots
|
|
}
|
|
|
|
NODE_DISPLAY_NAME_MAPPINGS = {
|
|
'PIL_Effects': 'PIL Effects (Mexx)',
|
|
'PIL_TITLE': 'PIL TITLE (Mexx)',
|
|
'PIL_MergeImage': 'PIL Merge Image (Mexx)',
|
|
'PIL_RemoveBlackDots': 'PIL Remove Black Dots (Mexx)'
|
|
}
|