comfyui_pil.py

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