import random from io import BytesIO from PIL import Image, ImageFilter, ImageDraw, ImageStat, ImageFont from PIL import ImageEnhance from PIL import ImageChops from PIL import ImageOps import cv2 from nonebot import logger from konabot.common.path import FONTS_PATH from konabot.plugins.fx_process.color_handle import ColorHandle import math from konabot.plugins.fx_process.gradient import GradientGenerator import numpy as np from konabot.plugins.fx_process.image_storage import ImageStorager from konabot.plugins.fx_process.math_helper import expand_contours from konabot.plugins.fx_process.types import SenderInfo, StoredInfo class ImageFilterImplement: @staticmethod def apply_blur(image: Image.Image, radius: float = 10) -> Image.Image: if image.mode != 'RGBA': image = image.convert('RGBA') return image.filter(ImageFilter.GaussianBlur(radius)) # 马赛克 @staticmethod def apply_mosaic(image: Image.Image, pixel_size: int = 10) -> Image.Image: if image.mode != 'RGBA': image = image.convert('RGBA') if pixel_size <= 0: pixel_size = 1 # 缩小图像 small_image = image.resize( (image.width // pixel_size, image.height // pixel_size), Image.Resampling.NEAREST ) # 放大图像 return small_image.resize(image.size, Image.Resampling.NEAREST) @staticmethod def apply_contour(image: Image.Image) -> Image.Image: if image.mode != 'RGBA': image = image.convert('RGBA') return image.filter(ImageFilter.CONTOUR) @staticmethod def apply_sharpen(image: Image.Image) -> Image.Image: if image.mode != 'RGBA': image = image.convert('RGBA') return image.filter(ImageFilter.SHARPEN) @staticmethod def apply_edge_enhance(image: Image.Image) -> Image.Image: if image.mode != 'RGBA': image = image.convert('RGBA') return image.filter(ImageFilter.EDGE_ENHANCE) @staticmethod def apply_emboss(image: Image.Image) -> Image.Image: if image.mode != 'RGBA': image = image.convert('RGBA') return image.filter(ImageFilter.EMBOSS) @staticmethod def apply_find_edges(image: Image.Image) -> Image.Image: if image.mode != 'RGBA': image = image.convert('RGBA') return image.filter(ImageFilter.FIND_EDGES) @staticmethod def apply_smooth(image: Image.Image) -> Image.Image: if image.mode != 'RGBA': image = image.convert('RGBA') return image.filter(ImageFilter.SMOOTH) # 反色 @staticmethod def apply_invert(image: Image.Image) -> Image.Image: if image.mode != 'RGBA': image = image.convert('RGBA') # 转换为 numpy 数组 arr = np.array(image) # 只反转 RGB 通道，保持 Alpha 不变 arr[:, :, :3] = 255 - arr[:, :, :3] return Image.fromarray(arr) # 黑白灰度 @staticmethod def apply_black_white(image: Image.Image) -> Image.Image: # 保留透明度通道 if image.mode != 'RGBA': image = image.convert('RGBA') r, g, b, a = image.split() gray = Image.merge('RGB', (r, g, b)).convert('L') return Image.merge('RGBA', (gray, gray, gray, a)) # 阈值 @staticmethod def apply_threshold(image: Image.Image, threshold: int = 128) -> Image.Image: # 保留透明度通道 if image.mode != 'RGBA': image = image.convert('RGBA') r, g, b, a = image.split() gray = Image.merge('RGB', (r, g, b)).convert('L') bw = gray.point(lambda x: 255 if x >= threshold else 0, '1') return Image.merge('RGBA', (bw.convert('L'), bw.convert('L'), bw.convert('L'), a)) # 对比度 @staticmethod def apply_contrast(image: Image.Image, factor: float = 1.5) -> Image.Image: if image.mode != 'RGBA': image = image.convert('RGBA') enhancer = ImageEnhance.Contrast(image) return enhancer.enhance(factor) # 亮度 @staticmethod def apply_brightness(image: Image.Image, factor: float = 1.5) -> Image.Image: if image.mode != 'RGBA': image = image.convert('RGBA') enhancer = ImageEnhance.Brightness(image) return enhancer.enhance(factor) # 色彩 @staticmethod def apply_color(image: Image.Image, factor: float = 1.5) -> Image.Image: if image.mode != 'RGBA': image = image.convert('RGBA') enhancer = ImageEnhance.Color(image) return enhancer.enhance(factor) # 三色调 @staticmethod def apply_to_color(image: Image.Image, color: str = 'rgb(255,0,0)') -> Image.Image: if image.mode != 'RGBA': image = image.convert('RGBA') rgb_color = ColorHandle.parse_color(color) # 转换为灰度并获取数组 gray = image.convert('L') lum = np.array(gray, dtype=np.float32) / 255.0 # 归一化到 [0,1] # 获取 alpha alpha = np.array(image.getchannel('A')) target_r = rgb_color[0] * lum target_g = rgb_color[1] * lum target_b = rgb_color[2] * lum # 堆叠通道 result_rgb = np.stack([target_r, target_g, target_b], axis=-1) result_rgb = np.clip(result_rgb, 0, 255).astype(np.uint8) # 创建结果图像 result = np.zeros((image.height, image.width, 4), dtype=np.uint8) result[:, :, :3] = result_rgb result[:, :, 3] = alpha return Image.fromarray(result, 'RGBA') # JPEG 损坏感压缩 @staticmethod def apply_jpeg_damage(image: Image.Image, quality: int = 10) -> Image.Image: quality = max(1, min(95, int(quality))) alpha = None if image.mode in ('RGBA', 'LA') or (image.mode == 'P' and 'transparency' in image.info): rgba_image = image.convert('RGBA') alpha = rgba_image.getchannel('A') rgb_image = Image.new('RGB', rgba_image.size, (255, 255, 255)) rgb_image.paste(rgba_image, mask=alpha) else: rgb_image = image.convert('RGB') output = BytesIO() rgb_image.save(output, format='JPEG', quality=quality, optimize=False) output.seek(0) damaged = Image.open(output).convert('RGB') if alpha is not None: return Image.merge('RGBA', (*damaged.split(), alpha)) return damaged.convert('RGBA') # 缩放 @staticmethod def apply_resize(image: Image.Image, scale: float = 1.5, scale_y = None) -> Image.Image: # scale 可以为负 # 如果 scale 为负，则代表翻转 if scale_y is not None: if float(scale_y) < 0: image = ImageOps.flip(image) scale_y = abs(float(scale_y)) if scale < 0: image = ImageOps.mirror(image) scale = abs(scale) new_size = (int(image.width * scale), int(image.height * float(scale_y))) return image.resize(new_size, Image.Resampling.LANCZOS) if scale < 0: image = ImageOps.mirror(image) image = ImageOps.flip(image) scale = abs(scale) new_size = (int(image.width * scale), int(image.height * scale)) return image.resize(new_size, Image.Resampling.LANCZOS) # 波纹 @staticmethod def apply_wave(image: Image.Image, amplitude: float = 5, wavelength: float = 20) -> Image.Image: if image.mode != 'RGBA': image = image.convert('RGBA') width, height = image.size arr = np.array(image) # 创建坐标网格 y_coords, x_coords = np.mgrid[0:height, 0:width] # 计算偏移量（向量化） offset_x = (amplitude * np.sin(2 * np.pi * y_coords / wavelength)).astype(np.int32) offset_y = (amplitude * np.cos(2 * np.pi * x_coords / wavelength)).astype(np.int32) # 计算新坐标 new_x = x_coords + offset_x new_y = y_coords + offset_y # 创建有效坐标掩码 valid_mask = (new_x >= 0) & (new_x < width) & (new_y >= 0) & (new_y < height) # 创建结果图像（初始为透明） result = np.zeros((height, width, 4), dtype=np.uint8) # 只复制有效像素 if valid_mask.any(): # 使用花式索引复制像素 result[valid_mask] = arr[new_y[valid_mask], new_x[valid_mask]] return Image.fromarray(result, 'RGBA') def apply_color_key(image: Image.Image, target_color: str = 'rgb(255,0,0)', tolerance: int = 60) -> Image.Image: if image.mode != 'RGBA': image = image.convert('RGBA') target_rgb = ColorHandle.parse_color(target_color) arr = np.array(image) # 计算颜色距离（使用平方距离避免 sqrt） target_arr = np.array(target_rgb, dtype=np.int32) diff = arr[:, :, :3] - target_arr distance_sq = np.sum(diff * diff, axis=2) # (r-r0)² + (g-g0)² + (b-b0)² # 创建掩码（距离 <= 容差） mask = distance_sq <= (tolerance * tolerance) # 复制原图，只修改 alpha 通道 result = arr.copy() result[:, :, 3] = np.where(mask, 0, arr[:, :, 3]) # 符合条件的设为透明 return Image.fromarray(result) # 暗角 @staticmethod def apply_vignette(image: Image.Image, radius: float = 1.5) -> Image.Image: if image.mode != 'RGBA': image = image.convert('RGBA') # 转换为 numpy 数组 arr = np.array(image, dtype=np.float32) height, width = arr.shape[:2] # 创建网格 y_coords, x_coords = np.ogrid[:height, :width] # 计算中心距离 center_x = width / 2 center_y = height / 2 max_distance = np.sqrt(center_x**2 + center_y**2) # 向量化距离计算 distances = np.sqrt((x_coords - center_x)**2 + (y_coords - center_y)**2) # 计算暗角因子 factors = 1 - (distances / max_distance) ** radius factors = np.clip(factors, 0, 1) # 应用暗角效果到 RGB 通道 arr[:, :, :3] = arr[:, :, :3] * factors[:, :, np.newaxis] # 转换回 uint8 result = np.clip(arr, 0, 255).astype(np.uint8) return Image.fromarray(result) # 发光 @staticmethod def apply_glow(image: Image.Image, intensity: float = 0.5, blur_radius: float = 15) -> Image.Image: if image.mode != 'RGBA': image = image.convert('RGBA') # 创建发光图层 glow_layer = image.filter(ImageFilter.GaussianBlur(blur_radius)) # 增强亮度 enhancer = ImageEnhance.Brightness(glow_layer) glow_layer = enhancer.enhance(intensity) # 转换为 numpy 数组 img_arr = np.array(image, dtype=np.float32) # 使用 float32 避免溢出 glow_arr = np.array(glow_layer, dtype=np.float32) # 向量化合并（只合并 RGB，A 保持不变） result_arr = np.zeros_like(img_arr, dtype=np.float32) # RGB 通道相加并限制到 255 result_arr[:, :, :3] = np.clip(img_arr[:, :, :3] + glow_arr[:, :, :3], 0, 255) # Alpha 通道保持原图 result_arr[:, :, 3] = img_arr[:, :, 3] return Image.fromarray(result_arr.astype(np.uint8)) # RGB分离 @staticmethod def apply_rgb_split(image: Image.Image, offset: int = 5) -> Image.Image: if image.mode != 'RGBA': image = image.convert('RGBA') r, g, b, a = image.split() r_offset = r.transform(r.size, Image.AFFINE, (1, 0, offset, 0, 1, 0)) g_offset = g.transform(g.size, Image.AFFINE, (1, 0, 0, 0, 1, offset)) return Image.merge('RGBA', (r_offset, g_offset, b, a)) # 光学补偿 @staticmethod def apply_optical_compensation(image: Image.Image, amount: float = 100.0, reverse: bool = False) -> Image.Image: if image.mode != 'RGBA': image = image.convert('RGBA') width, height = image.size arr = np.array(image) # 中心点 center_x, center_y = width / 2, height / 2 # 归一化amount amount_norm = amount / 100.0 # 创建坐标网格 y_coords, x_coords = np.mgrid[0:height, 0:width] # 计算相对中心的归一化坐标 dx = (x_coords - center_x) / center_x dy = (y_coords - center_y) / center_y # 计算距离（避免除零） distance = np.sqrt(dx**2 + dy**2) # 创建掩码：中心点和其他点 center_mask = distance == 0 other_mask = ~center_mask # 初始化缩放因子 scale_factor = np.ones_like(distance) if reverse: # 反鱼眼效果 # 对于非中心点 if other_mask.any(): # 使用arcsin进行反鱼眼映射 theta = np.arcsin(np.clip(distance[other_mask], 0, 0.999)) new_distance = np.sin(theta * amount_norm) scale_factor[other_mask] = new_distance / distance[other_mask] else: # 鱼眼效果 if other_mask.any(): # 使用sin或tanh进行鱼眼映射 theta = distance[other_mask] * amount_norm if amount_norm <= 1.0: new_distance = np.sin(theta) else: new_distance = np.tanh(theta) scale_factor[other_mask] = new_distance / distance[other_mask] # 计算源坐标 src_x = center_x + dx * center_x * scale_factor src_y = center_y + dy * center_y * scale_factor # 裁剪坐标到有效范围 src_x = np.clip(src_x, 0, width - 1) src_y = np.clip(src_y, 0, height - 1) # 准备插值 # 获取整数和小数部分 x0 = np.floor(src_x).astype(np.int32) x1 = np.minimum(x0 + 1, width - 1) y0 = np.floor(src_y).astype(np.int32) y1 = np.minimum(y0 + 1, height - 1) fx = src_x - x0 fy = src_y - y0 # 确保索引在范围内 x0 = np.clip(x0, 0, width - 1) x1 = np.clip(x1, 0, width - 1) y0 = np.clip(y0, 0, height - 1) y1 = np.clip(y1, 0, height - 1) # 双线性插值 - 向量化版本 # 获取四个角的像素值 c00 = arr[y0, x0] c01 = arr[y0, x1] c10 = arr[y1, x0] c11 = arr[y1, x1] # 扩展fx, fy用于3D广播 fx_3d = fx[:, :, np.newaxis] fy_3d = fy[:, :, np.newaxis] # 双线性插值公式 top = c00 * (1 - fx_3d) + c01 * fx_3d bottom = c10 * (1 - fx_3d) + c11 * fx_3d result_arr = top * (1 - fy_3d) + bottom * fy_3d # 转换为uint8 result_arr = np.clip(result_arr, 0, 255).astype(np.uint8) return Image.fromarray(result_arr, 'RGBA') # 球面化 @staticmethod def apply_spherize(image: Image.Image, strength: float = 0.5) -> Image.Image: if image.mode != 'RGBA': image = image.convert('RGBA') width, height = image.size arr = np.array(image) # 创建坐标网格 y_coords, x_coords = np.mgrid[0:height, 0:width] # 计算中心点 center_x = width / 2 center_y = height / 2 # 计算归一化坐标 norm_x = (x_coords - center_x) / (width / 2) norm_y = (y_coords - center_y) / (height / 2) radius = np.sqrt(norm_x**2 + norm_y**2) # 计算球面化偏移（向量化） factor = 1 + strength * (radius**2) new_x = (norm_x * factor) * (width / 2) + center_x new_y = (norm_y * factor) * (height / 2) + center_y new_x = new_x.astype(np.int32) new_y = new_y.astype(np.int32) # 创建有效坐标掩码 valid_mask = (new_x >= 0) & (new_x < width) & (new_y >= 0) & (new_y < height) # 创建结果图像（初始为透明） result = np.zeros((height, width, 4), dtype=np.uint8) # 只复制有效像素 if valid_mask.any(): # 使用花式索引复制像素 result[valid_mask] = arr[new_y[valid_mask], new_x[valid_mask]] # 计算裁剪边界 ys, xs = np.where(valid_mask) min_y, max_y = ys.min(), ys.max() + 1 min_x, max_x = xs.min(), xs.max() + 1 # 裁剪结果图像 result = result[min_y:max_y, min_x:max_x] return Image.fromarray(result, 'RGBA') # 平移 @staticmethod def apply_translate(image: Image.Image, x_offset: int = 10, y_offset: int = 10) -> Image.Image: return image.transform(image.size, Image.AFFINE, (1, 0, x_offset, 0, 1, y_offset)) # 拓展边缘 @staticmethod def apply_expand_edges(image: Image.Image, border_size: int = 10) -> Image.Image: # 拓展边缘，填充全透明 return ImageOps.expand(image, border=border_size, fill=(0, 0, 0, 0)) # 旋转 @staticmethod def apply_rotate(image: Image.Image, angle: float = 45) -> Image.Image: return image.rotate(angle, expand=True) # 透视变换 @staticmethod def apply_perspective_transform(image: Image.Image, coeffs: list[float]) -> Image.Image: return image.transform(image.size, Image.PERSPECTIVE, coeffs, Image.Resampling.BICUBIC) # 裁剪 @staticmethod def apply_crop(image: Image.Image, left: float = 0, upper: float = 0, right: float = 100, lower: float = 100) -> Image.Image: if image.mode != 'RGBA': image = image.convert('RGBA') # 按百分比裁剪 width, height = image.size left_px = int(width * left / 100) upper_px = int(height * upper / 100) right_px = int(width * right / 100) lower_px = int(height * lower / 100) # 如果为负数，则扩展边缘 if left_px < 0 or upper_px < 0 or right_px > width or lower_px > height: border_left = max(0, -left_px) border_top = max(0, -upper_px) border_right = max(0, right_px - width) border_bottom = max(0, lower_px - height) image = ImageOps.expand(image, border=(border_left, border_top, border_right, border_bottom), fill=(0,0,0,0)) left_px += border_left upper_px += border_top right_px += border_left lower_px += border_top return image.crop((left_px, upper_px, right_px, lower_px)) # 噪点 @staticmethod def apply_noise(image: Image.Image, amount: float = 0.05) -> Image.Image: if image.mode != 'RGBA': image = image.convert('RGBA') arr = np.array(image) noise = np.random.randint(0, 256, arr.shape, dtype=np.uint8) # 为每个像素创建掩码，然后扩展到所有通道，除了 alpha 通道 mask = np.random.rand(*arr.shape[:2]) < amount mask_3d = np.repeat(mask[:, :, np.newaxis], 4, axis=2) mask_3d[:, :, 3] = False # 保持 alpha 通道不变 # 混合噪点 result = np.where(mask_3d, noise, arr) return Image.fromarray(result, 'RGBA') # 素描 @staticmethod def apply_sketch(image: Image.Image) -> Image.Image: if image.mode != 'RGBA': image = image.convert('RGBA') # 转为灰度图 gray_image = image.convert('L') # 反相 inverted_image = ImageChops.invert(gray_image) # 高斯模糊 blurred_image = inverted_image.filter(ImageFilter.GaussianBlur(radius=10)) # 混合 def dodge(front, back): result = front * 255 / (255 - back) result[result > 255] = 255 result[back == 255] = 255 return result.astype(np.uint8) gray_arr = np.array(gray_image, dtype=np.float32) blurred_arr = np.array(blurred_image, dtype=np.float32) sketch_arr = dodge(gray_arr, blurred_arr) # 创建结果图像，保留原始 alpha 通道 alpha_channel = np.array(image.getchannel('A')) result_arr = np.zeros((image.height, image.width, 4), dtype=np.uint8) result_arr[:, :, 0] = sketch_arr result_arr[:, :, 1] = sketch_arr result_arr[:, :, 2] = sketch_arr result_arr[:, :, 3] = alpha_channel return Image.fromarray(result_arr, 'RGBA') # 两张图像混合，可指定叠加模式 @staticmethod def apply_blend(image1: Image.Image, image2: Image.Image, mode: str = 'normal', alpha: float = 0.5) -> Image.Image: if image1.mode != 'RGBA': image1 = image1.convert('RGBA') if image2.mode != 'RGBA': image2 = image2.convert('RGBA') image2 = image2.resize(image1.size, Image.Resampling.LANCZOS) arr1 = np.array(image1, dtype=np.float32) arr2 = np.array(image2, dtype=np.float32) if mode == 'normal': blended = arr1 * (1 - alpha) + arr2 * alpha elif mode == 'multiply': blended = (arr1 / 255.0) * (arr2 / 255.0) * 255.0 elif mode == 'screen': blended = 255 - (1 - arr1 / 255.0) * (1 - arr2 / 255.0) * 255.0 elif mode == 'overlay': mask = arr1 < 128 blended = np.zeros_like(arr1) blended[mask] = (2 * (arr1[mask] / 255.0) * (arr2[mask] / 255.0)) * 255.0 blended[~mask] = (1 - 2 * (1 - arr1[~mask] / 255.0) * (1 - arr2[~mask] / 255.0)) * 255.0 else: blended = arr1 blended = np.clip(blended, 0, 255).astype(np.uint8) return Image.fromarray(blended, 'RGBA') # 两张图像直接覆盖 @staticmethod def apply_overlay(image1: Image.Image, image2: Image.Image) -> Image.Image: if image1.mode != 'RGBA': image1 = image1.convert('RGBA') if image2.mode != 'RGBA': image2 = image2.convert('RGBA') image2 = image2.resize(image1.size, Image.Resampling.LANCZOS) return Image.alpha_composite(image1, image2) # 叠加渐变色 @staticmethod def apply_gradient_overlay( image: Image.Image, color_list: str = '[rgb(255,0,0)|(0,0),rgb(0,255,0)|(0,100),rgb(0,0,255)|(50,100)]', overlay_mode: str = 'overlay', ) -> Image.Image: gradient_gen = GradientGenerator() color_nodes = gradient_gen.parse_color_list(color_list) gradient = gradient_gen.create_gradient(image.size[0], image.size[1], color_nodes) return ImageFilterImplement.apply_blend(image, gradient, mode=overlay_mode, alpha=0.5) # 生成颜色，类似固态层 @staticmethod def generate_solid( image: Image.Image, color_list: str = '[rgb(255,0,0)|(0,0),rgb(0,255,0)|(0,100),rgb(0,0,255)|(50,100)]' ): gradient_gen = GradientGenerator() color_nodes = gradient_gen.parse_color_list(color_list) gradient = gradient_gen.create_gradient(image.size[0], image.size[1], color_nodes) return gradient # 阴影 @staticmethod def apply_shadow(image: Image.Image, x_offset: int = 10, y_offset: int = 10, blur: float = 10, opacity: float = 0.5, shadow_color: str = "black") -> Image.Image: if image.mode != 'RGBA': image = image.convert('RGBA') offset = (-x_offset, -y_offset) # 创建阴影图层 shadow_rgb = ColorHandle.parse_color(shadow_color) logger.debug(f"Shadow color RGB: {shadow_rgb}") shadow = Image.new('RGBA', image.size, (0, 0, 0, 0)) shadow_draw = ImageDraw.Draw(shadow) # 填充阴影颜色 shadow_draw.rectangle([(0, 0), image.size], fill=(shadow_rgb[0], shadow_rgb[1], shadow_rgb[2], 255)) # 应用遮罩 alpha = image.split()[-1].point(lambda p: p * opacity) shadow.putalpha(alpha) # 移动 shadow = shadow.transform( shadow.size, Image.AFFINE, (1, 0, offset[0], 0, 1, offset[1]) ) # 应用模糊 shadow = shadow.filter(ImageFilter.GaussianBlur(blur)) # 将阴影叠加在原图下方 result = ImageFilterImplement.apply_overlay(shadow, image) return result @staticmethod def apply_radial_blur(image: Image.Image, strength: float = 3.0, samples: int = 6) -> Image.Image: """ 快速径向模糊 - 使用预计算网格和向量化 """ if image.mode != 'RGBA': image = image.convert('RGBA') width, height = image.size arr = np.array(image, dtype=np.uint8) # 转换为float32并归一化 arr_float = arr.astype(np.float32) / 255.0 # 计算中心点 center_x = width / 2 center_y = height / 2 # 预计算坐标网格（只计算一次） x_indices = np.arange(width, dtype=np.float32) y_indices = np.arange(height, dtype=np.float32) x_grid, y_grid = np.meshgrid(x_indices, y_indices) # 预计算相对坐标和距离 dx = x_grid - center_x dy = y_grid - center_y distance = np.sqrt(dx*dx + dy*dy + 1e-6) # 避免除零 max_dist = np.max(distance) # 生成采样强度 if samples > 1: strengths = np.linspace(-strength/2, strength/2, samples) / 100 else: strengths = np.array([0]) # 初始化结果 result = np.zeros_like(arr_float) for s in strengths: # 计算缩放因子 scale = 1.0 + s * distance / max_dist # 计算变形坐标 new_x = np.clip(center_x + dx * scale, 0, width - 1) new_y = np.clip(center_y + dy * scale, 0, height - 1) # 快速双线性插值 x0 = np.floor(new_x).astype(np.int32) x1 = np.minimum(x0 + 1, width - 1) y0 = np.floor(new_y).astype(np.int32) y1 = np.minimum(y0 + 1, height - 1) # 计算权重 wx = new_x - x0 wy = new_y - y0 w00 = (1 - wx) * (1 - wy) w01 = wx * (1 - wy) w10 = (1 - wx) * wy w11 = wx * wy # 向量化插值所有通道 for c in range(4): result[:, :, c] += ( arr_float[y0, x0, c] * w00 + arr_float[y0, x1, c] * w01 + arr_float[y1, x0, c] * w10 + arr_float[y1, x1, c] * w11 ) # 平均并转换 result /= len(strengths) result = np.clip(result * 255, 0, 255).astype(np.uint8) return Image.fromarray(result, 'RGBA') @staticmethod def apply_spin_blur(image: Image.Image, strength: float = 30.0, samples: int = 6) -> Image.Image: """ 快速旋转模糊 """ if image.mode != 'RGBA': image = image.convert('RGBA') width, height = image.size arr = np.array(image, dtype=np.uint8) arr_float = arr.astype(np.float32) / 255.0 # 计算中心点 center_x = width / 2 center_y = height / 2 # 预计算坐标网格 x_indices = np.arange(width, dtype=np.float32) y_indices = np.arange(height, dtype=np.float32) x_grid, y_grid = np.meshgrid(x_indices, y_indices) # 预计算相对坐标 dx = x_grid - center_x dy = y_grid - center_y # 生成角度采样 if samples > 1: angles = np.linspace(-strength/2, strength/2, samples) * np.pi / 180 else: angles = np.array([0]) result = np.zeros_like(arr_float) for angle in angles: # 预计算三角函数值 cos_a = math.cos(angle) sin_a = math.sin(angle) # 计算旋转坐标 new_x = center_x + dx * cos_a - dy * sin_a new_y = center_y + dx * sin_a + dy * cos_a # 边界裁剪 new_x = np.clip(new_x, 0, width - 1) new_y = np.clip(new_y, 0, height - 1) # 快速双线性插值 x0 = np.floor(new_x).astype(np.int32) x1 = np.minimum(x0 + 1, width - 1) y0 = np.floor(new_y).astype(np.int32) y1 = np.minimum(y0 + 1, height - 1) wx = new_x - x0 wy = new_y - y0 w00 = (1 - wx) * (1 - wy) w01 = wx * (1 - wy) w10 = (1 - wx) * wy w11 = wx * wy # 向量化插值 for c in range(4): result[:, :, c] += ( arr_float[y0, x0, c] * w00 + arr_float[y0, x1, c] * w01 + arr_float[y1, x0, c] * w10 + arr_float[y1, x1, c] * w11 ) result /= len(angles) result = np.clip(result * 255, 0, 255).astype(np.uint8) return Image.fromarray(result, 'RGBA') @staticmethod def apply_directional_blur(image: Image.Image, angle: float = 0.0, distance: int = 20, samples: int = 6) -> Image.Image: """ 快速方向模糊 - 使用累积缓冲区技术 """ if image.mode != 'RGBA': image = image.convert('RGBA') width, height = image.size arr = np.array(image, dtype=np.uint8) arr_float = arr.astype(np.float32) / 255.0 # 计算角度和步长 rad = math.radians(angle) cos_a = math.cos(rad) sin_a = math.sin(rad) # 生成偏移位置 if samples > 1: offsets = np.linspace(-distance/2, distance/2, samples) else: offsets = np.array([0]) result = np.zeros_like(arr_float) for offset in offsets: # 计算偏移量 shift_x = offset * cos_a shift_y = offset * sin_a # 预计算变形坐标 x_indices = np.arange(width, dtype=np.float32) y_indices = np.arange(height, dtype=np.float32) x_grid, y_grid = np.meshgrid(x_indices, y_indices) new_x = x_grid - shift_x new_y = y_grid - shift_y # 边界裁剪 new_x = np.clip(new_x, 0, width - 1) new_y = np.clip(new_y, 0, height - 1) # 快速双线性插值 x0 = np.floor(new_x).astype(np.int32) x1 = np.minimum(x0 + 1, width - 1) y0 = np.floor(new_y).astype(np.int32) y1 = np.minimum(y0 + 1, height - 1) wx = new_x - x0 wy = new_y - y0 w00 = (1 - wx) * (1 - wy) w01 = wx * (1 - wy) w10 = (1 - wx) * wy w11 = wx * wy # 向量化插值 for c in range(4): result[:, :, c] += ( arr_float[y0, x0, c] * w00 + arr_float[y0, x1, c] * w01 + arr_float[y1, x0, c] * w10 + arr_float[y1, x1, c] * w11 ) result /= len(offsets) result = np.clip(result * 255, 0, 255).astype(np.uint8) return Image.fromarray(result, 'RGBA') @staticmethod def apply_zoom_blur(image: Image.Image, strength: float = 0.1, samples: int = 6) -> Image.Image: """ 快速缩放模糊 """ if image.mode != 'RGBA': image = image.convert('RGBA') width, height = image.size arr = np.array(image, dtype=np.uint8) arr_float = arr.astype(np.float32) / 255.0 # 计算中心点 center_x = width / 2 center_y = height / 2 # 预计算坐标网格 x_indices = np.arange(width, dtype=np.float32) y_indices = np.arange(height, dtype=np.float32) x_grid, y_grid = np.meshgrid(x_indices, y_indices) # 预计算相对坐标 dx = x_grid - center_x dy = y_grid - center_y # 生成缩放因子 if samples > 1: scales = np.linspace(1 - strength, 1 + strength, samples) else: scales = np.array([1.0]) result = np.zeros_like(arr_float) for scale in scales: # 计算缩放坐标 new_x = center_x + dx / scale new_y = center_y + dy / scale # 边界裁剪 new_x = np.clip(new_x, 0, width - 1) new_y = np.clip(new_y, 0, height - 1) # 快速双线性插值 x0 = np.floor(new_x).astype(np.int32) x1 = np.minimum(x0 + 1, width - 1) y0 = np.floor(new_y).astype(np.int32) y1 = np.minimum(y0 + 1, height - 1) wx = new_x - x0 wy = new_y - y0 w00 = (1 - wx) * (1 - wy) w01 = wx * (1 - wy) w10 = (1 - wx) * wy w11 = wx * wy # 向量化插值 for c in range(4): result[:, :, c] += ( arr_float[y0, x0, c] * w00 + arr_float[y0, x1, c] * w01 + arr_float[y1, x0, c] * w10 + arr_float[y1, x1, c] * w11 ) result /= len(scales) result = np.clip(result * 255, 0, 255).astype(np.uint8) return Image.fromarray(result, 'RGBA') # 中心清晰，边缘模糊 @staticmethod def apply_focus_blur(image: Image.Image, radius: float = 10.0) -> Image.Image: if image.mode != 'RGBA': image = image.convert('RGBA') width, height = image.size arr = np.array(image) # 创建坐标网格 y_coords, x_coords = np.mgrid[0:height, 0:width] # 计算中心点 center_x = width / 2 center_y = height / 2 # 计算归一化坐标 norm_x = (x_coords - center_x) / (width / 2) norm_y = (y_coords - center_y) / (height / 2) distance = np.sqrt(norm_x**2 + norm_y**2) # 创建模糊图像 blurred_image = image.filter(ImageFilter.GaussianBlur(radius)) blurred_arr = np.array(blurred_image) # 创建结果图像（向量化） result = np.zeros_like(arr, dtype=np.float32) # 根据距离混合原图和模糊图 for c in range(4): # 对每个通道 result[:, :, c] = arr[:, :, c] * (1 - distance) + blurred_arr[:, :, c] * distance return Image.fromarray(np.clip(result, 0, 255).astype(np.uint8), 'RGBA') # 复制画面 @staticmethod def copy_area(image: Image.Image, dst_move: str = '(100,100)', scale: float = 1.0, src_area: str = '(0,0,100,100)') -> Image.Image: if image.mode != 'RGBA': image = image.convert('RGBA') result = image.copy() # 参数表示的是百分比 width, height = image.size # 首先裁剪出源区域 src_tuple = eval(src_area) src_area = ImageFilterImplement.apply_crop(image, src_tuple[0], src_tuple[1], src_tuple[2], src_tuple[3]) # 计算目标位置 dst_tuple = eval(dst_move) dst_x = int(width * dst_tuple[0] / 100) dst_y = int(height * dst_tuple[1] / 100) # 缩放源区域 if scale != 1.0: new_width = int(src_area.width * scale) new_height = int(src_area.height * scale) src_area = src_area.resize((new_width, new_height), Image.Resampling.LANCZOS) # 粘贴到目标位置 result.paste(src_area, (dst_x, dst_y), src_area) return result # 水平翻转 @staticmethod def apply_flip_horizontal(image: Image.Image) -> Image.Image: return image.transpose(Image.Transpose.FLIP_LEFT_RIGHT) # 垂直翻转 @staticmethod def apply_flip_vertical(image: Image.Image) -> Image.Image: return image.transpose(Image.Transpose.FLIP_TOP_BOTTOM) # 依方向镜像一半画面 @staticmethod def apply_mirror_half(image: Image.Image, angle: float = 90) -> Image.Image: if image.mode != 'RGBA': image = image.convert('RGBA') width, height = image.size arr = np.array(image, dtype=np.uint8) # 角度标准化 angle = angle % 360 # 计算折痕的斜率 # 注意：我们的角度是折痕与水平线的夹角 # 0° = 垂直线，90° = 水平线 rad = math.radians(angle) # 计算中心点 center_x = width / 2 center_y = height / 2 # 创建坐标网格 y_coords, x_coords = np.mgrid[0:height, 0:width] # 计算折痕的方向向量 # 折痕方向垂直于法向量 # 对于角度θ，折痕方向向量为(cosθ, sinθ) direction_x = math.cos(rad) direction_y = math.sin(rad) # 计算法向量（垂直于折痕） # 旋转90度：(-sinθ, cosθ) normal_x = -direction_y normal_y = direction_x # 计算每个像素相对于折痕的位置 # 点到直线的有向距离: (x-cx)*nx + (y-cy)*ny rel_x = x_coords - center_x rel_y = y_coords - center_y signed_distance = rel_x * normal_x + rel_y * normal_y source_mask = signed_distance >= 0 # 创建结果图像 result = arr.copy() # 获取镜像侧的像素（需要被替换的像素） mirror_mask = ~source_mask if mirror_mask.any(): # 对于镜像侧的每个像素，计算其关于折痕的镜像点 mirror_x = x_coords[mirror_mask] mirror_y = y_coords[mirror_mask] # 计算相对坐标 mirror_rel_x = mirror_x - center_x mirror_rel_y = mirror_y - center_y # 计算到折痕的距离（带符号） dist_to_line = signed_distance[mirror_mask] # 计算镜像点的相对坐标 # 镜像公式: p' = p - 2 * (p·n) * n # 其中p是相对中心点的向量，n是单位法向量 mirror_target_rel_x = mirror_rel_x - 2 * dist_to_line * normal_x mirror_target_rel_y = mirror_rel_y - 2 * dist_to_line * normal_y # 计算镜像点的绝对坐标 target_x = np.round(center_x + mirror_target_rel_x).astype(int) target_y = np.round(center_y + mirror_target_rel_y).astype(int) # 确保坐标在图像范围内 valid = (target_x >= 0) & (target_x < width) & (target_y >= 0) & (target_y < height) if valid.any(): # 将源侧的像素复制到镜像侧的位置 valid_target_x = target_x[valid] valid_target_y = target_y[valid] valid_mirror_x = mirror_x[valid] valid_mirror_y = mirror_y[valid] # 获取源侧的像素值 source_pixels = arr[valid_target_y, valid_target_x] # 复制到镜像位置 result[valid_mirror_y, valid_mirror_x] = source_pixels return Image.fromarray(result, 'RGBA') # 随机画面整体晃动，对于动图会很有效 @staticmethod def apply_random_wiggle(image: Image.Image, max_offset: int = 5, motion_blur = False) -> Image.Image: if image.mode != 'RGBA': image = image.convert('RGBA') # 生成随机偏移 x_offset = random.randint(-max_offset, max_offset) y_offset = random.randint(-max_offset, max_offset) # 画面平移 translated_image = ImageFilterImplement.apply_translate(image, x_offset, y_offset) if motion_blur: # 添加运动模糊 translated_image = ImageFilterImplement.apply_directional_blur(translated_image, angle=random.uniform(0, 360), distance=max_offset, samples=6) return translated_image # 像素随机抖动 @staticmethod def apply_pixel_jitter(image: Image.Image, max_offset: int = 2) -> Image.Image: if image.mode != 'RGBA': image = image.convert('RGBA') width, height = image.size arr = np.array(image) # 创建结果图像 result = np.zeros_like(arr) # numpy 向量化随机偏移 x_indices = np.arange(width) y_indices = np.arange(height) x_grid, y_grid = np.meshgrid(x_indices, y_indices) x_offsets = np.random.randint(-max_offset, max_offset + 1, size=(height, width)) y_offsets = np.random.randint(-max_offset, max_offset + 1, size=(height, width)) new_x = np.clip(x_grid + x_offsets, 0, width - 1) new_y = np.clip(y_grid + y_offsets, 0, height - 1) result[y_grid, x_grid] = arr[new_y, new_x] return Image.fromarray(result, 'RGBA') # 描边 @staticmethod def apply_stroke(image: Image.Image, stroke_width: int = 5, stroke_color: str = 'black') -> Image.Image: if image.mode != 'RGBA': image = image.convert('RGBA') # 基于图像的 alpha 通道创建描边 alpha = image.split()[3] # 创建描边图像 stroke_image = Image.new('RGBA', image.size, (0, 0, 0, 0)) # 根据 alpha 通道的值，以每个像素为中心，扩大描边区域 expanded_alpha = alpha.filter(ImageFilter.MaxFilter(size=stroke_width*2+1)) draw = Image.new('RGBA', image.size, ColorHandle.parse_color(stroke_color) + (255,)) stroke_image.paste(draw, (0, 0), expanded_alpha) # 将描边和原图合并 result = Image.alpha_composite(stroke_image, image) return result # 基于形状的描边 @staticmethod def apply_shape_stroke(image: Image.Image, stroke_width: int = 5, stroke_color: str = 'black', roughness: float = None) -> Image.Image: if image.mode != 'RGBA': image = image.convert('RGBA') img = cv2.cvtColor(np.array(image), cv2.COLOR_RGBA2BGRA) # 提取alpha通道 alpha = img[:, :, 3] # 应用阈值创建二值掩码 _, binary_mask = cv2.threshold(alpha, 0.5, 255, cv2.THRESH_BINARY) # 寻找轮廓 contours, hierarchy = cv2.findContours( binary_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE ) # 减少轮廓点数，以实现尖角效果 if roughness is not None: epsilon = roughness * cv2.arcLength(contours[0], True) contours = [cv2.approxPolyDP(cnt, epsilon, True) for cnt in contours] # 将轮廓点沿法线方向外扩 expanded_contours = expand_contours(contours, stroke_width) # 创建描边图像 stroke_img = np.zeros_like(img) # 如果没有轮廓，直接返回原图 if not expanded_contours[0].any(): return image cv2.fillPoly(stroke_img, expanded_contours, ColorHandle.parse_color(stroke_color) + (255,)) # 轮廓图像转为PIL格式 stroke_pil = Image.fromarray(cv2.cvtColor(stroke_img, cv2.COLOR_BGRA2RGBA)) # 合并描边和原图 result = Image.alpha_composite(stroke_pil, image) return result # 半调 @staticmethod def apply_halftone(image: Image.Image, dot_size: int = 5) -> Image.Image: if image.mode != 'L': grayscale = image.convert('L') else: grayscale = image.copy() # 获取图像尺寸 width, height = grayscale.size # 计算网格数量 grid_width = math.ceil(width / dot_size) grid_height = math.ceil(height / dot_size) # 创建输出图像（白色背景） output = Image.new('RGB', (width, height), 'white') draw = ImageDraw.Draw(output) # 遍历每个网格单元 for gy in range(grid_height): for gx in range(grid_width): # 计算当前网格的边界 left = gx * dot_size top = gy * dot_size right = min(left + dot_size, width) bottom = min(top + dot_size, height) # 获取当前网格的区域 grid_region = grayscale.crop((left, top, right, bottom)) # 计算网格内像素的平均亮度（0-255） stat = ImageStat.Stat(grid_region) avg_brightness = stat.mean[0] # 将亮度转换为网点半径 # 亮度越高（越白），网点越小；亮度越低（越黑），网点越大 max_radius = dot_size / 2 radius = max_radius * (1 - avg_brightness / 255) # 如果半径太小，则不绘制网点 if radius > 0.5: # 计算网点中心坐标 center_x = left + (right - left) / 2 center_y = top + (bottom - top) / 2 # 绘制黑色网点 draw.ellipse([ center_x - radius + 0.5, center_y - radius + 0.5, center_x + radius + 0.5, center_y + radius + 0.5 ], fill='black') # 叠加 alpha 通道 if image.mode == 'RGBA': alpha = image.split()[3] output.putalpha(alpha) return output # 设置通道 @staticmethod def apply_set_channel(image: Image.Image, apply_image: Image.Image, channel: str = 'A') -> Image.Image: if image.mode != 'RGBA': image = image.convert('RGBA') if apply_image.mode != 'RGBA': apply_image = apply_image.convert('RGBA') # 将 apply_image 的通道设置给 image image_arr = np.array(image) apply_arr = np.array(apply_image.resize(image.size, Image.Resampling.LANCZOS)) channel_index = {'R':0, 'G':1, 'B':2, 'A':3}.get(channel.upper(), 0) image_arr[:, :, channel_index] = apply_arr[:, :, channel_index] return Image.fromarray(image_arr, 'RGBA') # 设置遮罩 def apply_set_mask(image: Image.Image, mask_image: Image.Image) -> Image.Image: if image.mode != 'RGBA': image = image.convert('RGBA') if mask_image.mode != 'L': mask_image = mask_image.convert('L') # 应用遮罩 image.putalpha(mask_image.resize(image.size, Image.Resampling.LANCZOS)) return image @staticmethod def generate_empty(image: Image.Image, images: list[Image.Image], width: int = 512, height: int = 512) -> Image.Image: # 生成空白图像 empty_image = Image.new('RGBA', (width, height), (255, 255, 255, 0)) images.append(empty_image) return image @staticmethod def generate_text(image: Image.Image, images: list[Image.Image], text: str = "请输入文本", font_size: int = 32, font_color: str = "black", font_path: str = "HarmonyOS_Sans_SC_Regular.ttf") -> Image.Image: # 生成文本图像 font = ImageFont.truetype(FONTS_PATH / font_path, font_size) # 获取文本边界框 padding = 10 temp_draw = ImageDraw.Draw(Image.new('RGBA', (1,1))) bbox = temp_draw.textbbox((0, 0), text, font=font) text_width = bbox[2] - bbox[0] + padding * 2 text_height = bbox[3] - bbox[1] + padding * 2 # 创建文本图像 text_image = Image.new('RGBA', (text_width, text_height), (255, 255, 255, 0)) draw = ImageDraw.Draw(text_image) draw_x = padding - bbox[0] draw_y = padding - bbox[1] draw.text((draw_x,draw_y), text, font=font, fill=ColorHandle.parse_color(font_color) + (255,)) images.append(text_image) return image class ImageFilterEmpty: # 空滤镜，不做任何处理，形式化参数用 @staticmethod def empty_filter(image): return image @staticmethod def empty_filter_param(image, param = 10): return image class ImageFilterStorage: # 用于暂存图像，存储在第一项的后面 @staticmethod def temp_store_image(image: Image.Image, images: list[Image.Image]) -> Image.Image: images.insert(1, image.copy()) return image # 用于交换移动索引 @staticmethod def swap_image_index(image: Image.Image, images: list[Image.Image], src: int = 2, dest: int = 1) -> Image.Image: if len(images) == 0: return image # 将二者交换 src -= 1 dest -= 1 if 0 <= src < len(images) and 0 <= dest < len(images): images[src], images[dest] = images[dest], images[src] return images[0] # 用于删除指定索引的图像 @staticmethod def delete_image_by_index(image: Image.Image, images: list[Image.Image], index: int = 1) -> Image.Image: # 以 1 为基准 index -= 1 if len(images) == 1: # 只有一张图像，不能删除 return image if 0 <= index < len(images): del images[index] return images[0] # 用于选择指定索引的图像为首图 @staticmethod def select_image_by_index(image: Image.Image, images: list[Image.Image], index: int = 2) -> Image.Image: # 以 1 为基准 index -= 1 if 0 <= index < len(images): return images[index] return image # 用于存储图像 @staticmethod def store_image(image: Image.Image, name: str, sender_info: SenderInfo) -> StoredInfo: ImageStorager.save_image_by_pil(image, name, sender_info.group_id, sender_info.qq_id) return StoredInfo(name=name) # 用于读取图像 @staticmethod def load_image(image: Image.Image, name: str, images: list[Image.Image], sender_info: SenderInfo) -> Image.Image: loaded_image = ImageStorager.load_image(name, sender_info.group_id, sender_info.qq_id) if loaded_image is not None: images.append(loaded_image) return image