834 lines
36 KiB
Python
834 lines
36 KiB
Python
import numpy as np
|
|
from PIL import Image, ImageDraw, ImageFont, ImageFilter, ImageEnhance, ImageChops, ImageOps
|
|
import math
|
|
|
|
class EffectsProcessor:
|
|
"""Processes and applies various text effects based on styles."""
|
|
|
|
def __init__(self, debug_output=False):
|
|
"""Initialize the effects processor.
|
|
|
|
Args:
|
|
debug_output: Whether to save debug images during processing
|
|
"""
|
|
self.debug_output = debug_output
|
|
|
|
def _save_debug_image(self, img, filename):
|
|
"""Save a debug image if debug_output is enabled."""
|
|
if self.debug_output:
|
|
img.save(filename)
|
|
|
|
def hex_to_rgba(self, hex_color, alpha=255):
|
|
"""Convert hex color to RGBA tuple."""
|
|
if not hex_color:
|
|
return (255, 255, 255, alpha)
|
|
|
|
hex_color = hex_color.lstrip('#')
|
|
length = len(hex_color)
|
|
|
|
if length == 6:
|
|
return (*tuple(int(hex_color[i:i+2], 16) for i in (0, 2, 4)), alpha)
|
|
elif length == 8:
|
|
r, g, b, a = tuple(int(hex_color[i:i+2], 16) for i in (0, 2, 4, 6))
|
|
return (r, g, b, alpha if alpha != 255 else a)
|
|
return (255, 255, 255, alpha)
|
|
|
|
def apply_all_effects(self, base_img, style, style_name="unknown"):
|
|
"""应用所有效果在同一图像上，确保正确的叠加顺序和透明度"""
|
|
print(f"[Style: {style_name}] 开始应用组合效果")
|
|
|
|
# 确保图像有alpha通道
|
|
img = base_img.convert('RGBA') if base_img.mode != 'RGBA' else base_img.copy()
|
|
|
|
# 获取文本区域mask，用于限制效果
|
|
original_r, original_g, original_b, text_mask = img.split()
|
|
|
|
# 创建一个底层图像，用于收集所有效果
|
|
result = Image.new('RGBA', img.size, (0, 0, 0, 0))
|
|
|
|
# 保存各效果层的临时图像，用于调试
|
|
layers = {}
|
|
|
|
# 确定要应用的效果列表 - 按SVG标准的顺序：
|
|
# 1. Shadow（阴影）
|
|
# 2. Glow (外发光)
|
|
# 3. Fill（填充）
|
|
# 4. Outline（描边）
|
|
# 5. Inner Shadow（内阴影）
|
|
effects_order = []
|
|
|
|
if 'shadow' in style and style.get('shadow', {}).get('opacity', 0) > 0:
|
|
effects_order.append('shadow')
|
|
|
|
if 'glow' in style and style.get('glow', {}).get('opacity', 0) > 0:
|
|
effects_order.append('glow')
|
|
|
|
effects_order.append('fill') # 填充始终应用
|
|
|
|
if 'outline' in style and style.get('outline', {}).get('width', 0) > 0 and style.get('outline', {}).get('opacity', 0) > 0:
|
|
effects_order.append('outline')
|
|
|
|
if 'inner_shadow' in style and style.get('inner_shadow', {}).get('opacity', 0) > 0:
|
|
effects_order.append('inner_shadow')
|
|
|
|
print(f"[Style: {style_name}] 图层信息: {', '.join(effects_order)}")
|
|
|
|
# 现在应用所有效果按照effects_order列表的顺序
|
|
for effect_name in effects_order:
|
|
if effect_name == 'shadow':
|
|
shadow_img = self.apply_shadow(img, style)
|
|
if shadow_img:
|
|
# 保存用于调试
|
|
self._save_debug_image(shadow_img, f"debug_{style_name}_shadow.png")
|
|
layers['shadow'] = shadow_img
|
|
result = Image.alpha_composite(result, shadow_img)
|
|
print(f"[Style: {style_name}] 已合成阴影图层")
|
|
|
|
elif effect_name == 'outline':
|
|
# 创建基础图像用于描边
|
|
outline_base = Image.new('RGBA', img.size, (0, 0, 0, 0))
|
|
outline_base.paste(img, (0, 0), text_mask)
|
|
|
|
# 应用描边
|
|
if 'gradient' in style.get('outline', {}):
|
|
outline_img = self._apply_gradient_outline(outline_base, style, style_name)
|
|
else:
|
|
outline_img = self.apply_outline(outline_base, style)
|
|
|
|
if outline_img:
|
|
# 保存用于调试
|
|
self._save_debug_image(outline_img, f"debug_{style_name}_outline.png")
|
|
layers['outline'] = outline_img
|
|
|
|
# 修改合成方式 - 只覆盖非透明部分
|
|
# 使用alpha_composite，而不是简单的覆盖
|
|
# 这样填充颜色仍然可以在透明区域显示
|
|
result = Image.alpha_composite(result, outline_img)
|
|
print(f"[Style: {style_name}] 已合成描边图层")
|
|
|
|
elif effect_name == 'fill':
|
|
fill_img = self.apply_fill(img, style)
|
|
if fill_img:
|
|
# 保存用于调试
|
|
self._save_debug_image(fill_img, f"debug_{style_name}_fill.png")
|
|
layers['fill'] = fill_img
|
|
result = Image.alpha_composite(result, fill_img)
|
|
print(f"[Style: {style_name}] 已合成填充图层")
|
|
|
|
elif effect_name == 'inner_shadow':
|
|
inner_shadow_img = self.apply_inner_shadow(img, style)
|
|
if inner_shadow_img:
|
|
# 保存用于调试
|
|
self._save_debug_image(inner_shadow_img, f"debug_{style_name}_inner_shadow.png")
|
|
layers['inner_shadow'] = inner_shadow_img
|
|
try:
|
|
# 确保inner_shadow_img是PIL图像对象
|
|
if hasattr(inner_shadow_img, 'format') or hasattr(inner_shadow_img, 'split'):
|
|
# 修改合成方式 - 保留原始填充色的可见性
|
|
# 获取inner_shadow的alpha通道
|
|
_, _, _, inner_alpha = inner_shadow_img.split()
|
|
|
|
# 为了确保填充色可见，调整内阴影的alpha通道
|
|
inner_alpha = inner_alpha.point(lambda x: min(x, 200)) # 降低最大不透明度
|
|
|
|
# 重建内阴影图像
|
|
r, g, b, _ = inner_shadow_img.split()
|
|
adjusted_inner_shadow = Image.merge('RGBA', (r, g, b, inner_alpha))
|
|
|
|
# 使用调整后的内阴影图像进行合成
|
|
result = Image.alpha_composite(result, adjusted_inner_shadow)
|
|
print(f"[Style: {style_name}] 已合成内阴影图层 (已调整透明度)")
|
|
else:
|
|
print(f"[警告] inner_shadow_img不是有效的PIL图像对象，跳过内阴影效果")
|
|
except Exception as e:
|
|
print(f"[错误] 合成内阴影效果时出错: {e}")
|
|
|
|
elif effect_name == 'glow':
|
|
glow_img = self.apply_glow(img, style)
|
|
if glow_img:
|
|
# 保存用于调试
|
|
self._save_debug_image(glow_img, f"debug_{style_name}_glow.png")
|
|
layers['glow'] = glow_img
|
|
|
|
# 外发光直接合成，不需要特殊处理
|
|
# 因为我们已经在apply_glow中确保它只应用于文本外部
|
|
try:
|
|
if hasattr(glow_img, 'format') or hasattr(glow_img, 'split'):
|
|
result = Image.alpha_composite(result, glow_img)
|
|
print(f"[Style: {style_name}] 已合成发光图层")
|
|
else:
|
|
print(f"[警告] glow_img不是有效的PIL图像对象，跳过发光效果")
|
|
except Exception as e:
|
|
print(f"[错误] 合成发光效果时出错: {e}")
|
|
|
|
print(f"[Style: {style_name}] 样式应用完成!")
|
|
return result, layers
|
|
|
|
def _create_gradient(self, width, height, colors, angle=0, direction=None):
|
|
"""创建渐变背景
|
|
|
|
Args:
|
|
width: 图像宽度
|
|
height: 图像高度
|
|
colors: 颜色列表
|
|
angle: 渐变角度（度）
|
|
direction: 预定义方向（如果指定，则忽略angle）
|
|
可能值：'left_right', 'right_left', 'top_bottom', 'bottom_top',
|
|
'diagonal', 'diagonal_reverse', 'diagonal_bottom', 'diagonal_bottom_reverse'
|
|
|
|
Returns:
|
|
渐变图像
|
|
"""
|
|
# 创建空白RGBA图像
|
|
gradient = Image.new('RGBA', (width, height), (0, 0, 0, 0))
|
|
draw = ImageDraw.Draw(gradient)
|
|
|
|
# 确保colors是有效的RGB颜色列表
|
|
if not colors or not isinstance(colors, list):
|
|
# 使用默认颜色
|
|
colors = [(238, 40, 131), (255, 220, 125)] # 默认粉色到黄色
|
|
|
|
# 打印实际传入的颜色值和渐变方向进行调试
|
|
print(f"\n======= 渐变填充调试 =======")
|
|
print(f"尺寸={width}x{height}, 颜色数量={len(colors)}, 角度={angle}, 方向={direction}")
|
|
for i, color in enumerate(colors):
|
|
print(f" 颜色{i}: {color}")
|
|
|
|
# 将角度映射到[-180, 180]范围
|
|
if angle is not None:
|
|
angle = angle % 360
|
|
if angle > 180:
|
|
angle -= 360
|
|
|
|
# 预定义方向映射到角度
|
|
if direction:
|
|
if direction == 'left_right':
|
|
angle = 0
|
|
print("渐变方向: 从左到右")
|
|
elif direction == 'right_left':
|
|
angle = 180
|
|
print("渐变方向: 从右到左")
|
|
elif direction == 'top_bottom':
|
|
angle = 90
|
|
print("渐变方向: 从上到下")
|
|
elif direction == 'bottom_top':
|
|
angle = -90
|
|
print("渐变方向: 从下到上")
|
|
elif direction == 'diagonal':
|
|
angle = 45
|
|
print("渐变方向: 对角线(左上到右下)")
|
|
elif direction == 'diagonal_reverse':
|
|
angle = -135
|
|
print("渐变方向: 对角线(右下到左上)")
|
|
elif direction == 'diagonal_bottom':
|
|
angle = 135
|
|
print("渐变方向: 对角线(左下到右上)")
|
|
elif direction == 'diagonal_bottom_reverse':
|
|
angle = -45
|
|
print("渐变方向: 对角线(右上到左下)")
|
|
else:
|
|
print(f"渐变方向: 自定义角度 {angle}度")
|
|
|
|
# 确定渐变的起点和终点坐标
|
|
if direction:
|
|
# 直接使用与SVG相同的坐标映射
|
|
if direction == 'left_right': # 从左到右
|
|
x1, y1, x2, y2 = 0, height//2, width, height//2
|
|
elif direction == 'right_left': # 从右到左
|
|
x1, y1, x2, y2 = width, height//2, 0, height//2
|
|
elif direction == 'top_bottom': # 从上到下
|
|
x1, y1, x2, y2 = width//2, 0, width//2, height
|
|
elif direction == 'bottom_top': # 从下到上
|
|
x1, y1, x2, y2 = width//2, height, width//2, 0
|
|
elif direction == 'diagonal': # 左上到右下
|
|
x1, y1, x2, y2 = 0, 0, width, height
|
|
elif direction == 'diagonal_reverse': # 右下到左上
|
|
x1, y1, x2, y2 = width, height, 0, 0
|
|
elif direction == 'diagonal_bottom': # 左下到右上
|
|
x1, y1, x2, y2 = 0, height, width, 0
|
|
elif direction == 'diagonal_bottom_reverse': # 右上到左下
|
|
x1, y1, x2, y2 = width, 0, 0, height
|
|
else:
|
|
# 默认从上到下
|
|
x1, y1, x2, y2 = width//2, 0, width//2, height
|
|
else:
|
|
# 如果提供角度，计算渐变线的端点
|
|
rads = math.radians(angle)
|
|
diagonal = math.sqrt(width**2 + height**2)
|
|
center_x, center_y = width // 2, height // 2
|
|
|
|
# 计算渐变线端点
|
|
dx = math.cos(rads) * diagonal / 2
|
|
dy = math.sin(rads) * diagonal / 2
|
|
|
|
x1 = center_x - dx
|
|
y1 = center_y - dy
|
|
x2 = center_x + dx
|
|
y2 = center_y + dy
|
|
|
|
# 计算渐变线长度
|
|
gradient_length = math.sqrt((x2 - x1)**2 + (y2 - y1)**2)
|
|
|
|
# 遍历图像中的每个像素
|
|
for y in range(height):
|
|
for x in range(width):
|
|
# 计算像素到渐变线的投影位置
|
|
if x2 != x1:
|
|
# 非垂直线
|
|
m = (y2 - y1) / (x2 - x1)
|
|
b = y1 - m * x1
|
|
|
|
# 计算垂直于渐变线的直线方程
|
|
if m != 0:
|
|
m_perp = -1 / m
|
|
b_perp = y - m_perp * x
|
|
|
|
# 计算交点
|
|
intersect_x = (b_perp - b) / (m - m_perp)
|
|
intersect_y = m * intersect_x + b
|
|
else:
|
|
# 水平渐变线
|
|
intersect_x = x
|
|
intersect_y = y1
|
|
else:
|
|
# 垂直渐变线
|
|
intersect_x = x1
|
|
intersect_y = y
|
|
|
|
# 计算交点在渐变线上的相对位置
|
|
if gradient_length > 0:
|
|
# 计算线段参数t，表示交点在渐变线上的位置
|
|
if x2 != x1:
|
|
t = (intersect_x - x1) / (x2 - x1)
|
|
else:
|
|
t = (intersect_y - y1) / (y2 - y1)
|
|
|
|
# 确保t在[0,1]范围内
|
|
t = max(0, min(1, t))
|
|
|
|
# 根据颜色列表，计算渐变颜色
|
|
if len(colors) > 1:
|
|
# 至少有2种颜色时才需要计算渐变
|
|
index = int(t * (len(colors) - 1))
|
|
next_index = min(index + 1, len(colors) - 1)
|
|
|
|
# 颜色位置的局部参数
|
|
local_t = (t * (len(colors) - 1)) - index
|
|
|
|
# 插值计算颜色
|
|
r = int(colors[index][0] * (1 - local_t) + colors[next_index][0] * local_t)
|
|
g = int(colors[index][1] * (1 - local_t) + colors[next_index][1] * local_t)
|
|
b = int(colors[index][2] * (1 - local_t) + colors[next_index][2] * local_t)
|
|
else:
|
|
# 只有一种颜色时，直接使用该颜色
|
|
r, g, b = colors[0]
|
|
|
|
# 设置渐变图像中的像素颜色
|
|
draw.point((x, y), fill=(r, g, b, 255))
|
|
|
|
return gradient
|
|
|
|
def apply_shadow(self, img, style):
|
|
"""Apply shadow effect to text."""
|
|
if 'shadow' not in style:
|
|
return None
|
|
|
|
# 获取阴影参数
|
|
shadow = style['shadow']
|
|
color_hex = shadow.get('color', '#000000')
|
|
# 确保使用SVG中指定的精确不透明度，而不是硬编码值
|
|
opacity = float(shadow.get('opacity', 1.0))
|
|
offset_x = float(shadow.get('offset_x', 5.0))
|
|
offset_y = float(shadow.get('offset_y', 5.0))
|
|
blur = float(shadow.get('blur', 5.0))
|
|
|
|
# 如果不透明度为0，则不应用阴影
|
|
if opacity <= 0:
|
|
return None
|
|
|
|
# 将十六进制颜色转换为RGBA
|
|
shadow_color = self.hex_to_rgba(color_hex, int(opacity * 255))
|
|
|
|
# 创建阴影画布
|
|
shadow_img = Image.new('RGBA', img.size, (0, 0, 0, 0))
|
|
|
|
# 使用alpha通道作为蒙版
|
|
if img.mode == 'RGBA':
|
|
mask = img.split()[3]
|
|
else:
|
|
mask = img.convert('L')
|
|
|
|
# 根据指定偏移创建阴影图像
|
|
shadow_canvas = Image.new('RGBA', img.size, shadow_color)
|
|
shadow_canvas.putalpha(mask)
|
|
|
|
# 应用高斯模糊
|
|
if blur > 0:
|
|
shadow_canvas = shadow_canvas.filter(ImageFilter.GaussianBlur(radius=blur))
|
|
|
|
# 应用偏移
|
|
shadow_img.paste(shadow_canvas, (int(offset_x), int(offset_y)), shadow_canvas)
|
|
|
|
# 确保最终的阴影不透明度符合指定值
|
|
r, g, b, a = shadow_img.split()
|
|
a = a.point(lambda x: int(x * opacity))
|
|
shadow_img = Image.merge('RGBA', (r, g, b, a))
|
|
|
|
return shadow_img
|
|
|
|
def apply_outline(self, img, style):
|
|
"""Apply outline to text."""
|
|
if 'outline' not in style:
|
|
return img
|
|
|
|
outline = style['outline']
|
|
outline_width = outline.get('width', 1)
|
|
outline_color = self.hex_to_rgba(outline.get('color', '#000000'))
|
|
|
|
if outline_width <= 0:
|
|
return img
|
|
|
|
# Create a mask from the alpha channel
|
|
mask = img.split()[3]
|
|
|
|
# Create outline layer
|
|
outline_img = Image.new('RGBA', img.size, (0, 0, 0, 0))
|
|
|
|
# Apply dilation to the mask for each outline pixel
|
|
dilated = mask
|
|
for i in range(1, int(round(outline_width)) + 1):
|
|
dilated = dilated.filter(ImageFilter.MaxFilter(3))
|
|
|
|
# Create the outline
|
|
outline_layer = Image.new('RGBA', img.size, outline_color)
|
|
outline_layer.putalpha(dilated)
|
|
|
|
# Composite with the existing outline
|
|
outline_img = Image.alpha_composite(outline_img, outline_layer)
|
|
|
|
# Composite the original image on top of the outline
|
|
result = Image.alpha_composite(outline_img, img)
|
|
return result
|
|
|
|
def _apply_gradient_outline(self, img, style, style_name=None):
|
|
"""使用渐变效果应用描边。"""
|
|
# Get the text mask
|
|
mask = img.split()[3]
|
|
|
|
# 如果未提供style_name，尝试从style字典中获取，如果都没有则使用默认值
|
|
if style_name is None:
|
|
style_name = style.get('name', 'unknown')
|
|
|
|
# Handle gradient outline
|
|
outline_data = style.get('outline', {})
|
|
width = float(outline_data.get('width', 0))
|
|
opacity = float(outline_data.get('opacity', 1.0))
|
|
|
|
# 获取渐变对象，确保在此之后不要覆盖它
|
|
gradient = None
|
|
if 'gradient' in outline_data:
|
|
gradient = outline_data['gradient']
|
|
else:
|
|
gradient = outline_data
|
|
|
|
# 获取颜色信息，这里仅获取原始16进制颜色用于日志显示
|
|
hex_colors = gradient.get('colors', ['#EE2883', '#FFDC7D']) # 使用设计指定的粉色到黄色渐变作为默认值
|
|
|
|
# 处理渐变角度 - 支持SVG渐变方向
|
|
angle = 0 # 默认从左到右（SVG: x1=0% -> x2=100%, y相同）
|
|
|
|
# 检查渐变方向类型
|
|
direction = gradient.get('direction', 'left_right')
|
|
|
|
# 如果是SVG定义的方向，检查是否包含x1,y1,x2,y2坐标
|
|
if direction == 'custom' and 'svg_coords' in gradient:
|
|
svg_coords = gradient['svg_coords']
|
|
try:
|
|
x1 = float(svg_coords.get('x1', 0)) / 100 # 转换为0-1范围
|
|
y1 = float(svg_coords.get('y1', 0)) / 100
|
|
x2 = float(svg_coords.get('x2', 100)) / 100
|
|
y2 = float(svg_coords.get('y2', 0)) / 100
|
|
|
|
# 计算角度 - arctan2 返回弧度，convert to degrees
|
|
if x2 != x1 or y2 != y1: # 避免除以零
|
|
dx = x2 - x1
|
|
dy = y2 - y1
|
|
|
|
# 在PIL中，y轴向下为正方向，所以反转y差值
|
|
angle_rad = math.atan2(-dy, dx) # 注意这里反转y轴方向
|
|
angle = math.degrees(angle_rad)
|
|
# 调整角度到0-360范围
|
|
angle = (angle + 360) % 360
|
|
|
|
except (ValueError, TypeError) as e:
|
|
print(f"无法解析描边SVG坐标: {e}, 使用默认角度")
|
|
# 处理预定义的方向
|
|
elif direction == 'left_right':
|
|
angle = 0 # 水平从左到右
|
|
elif direction == 'right_left':
|
|
angle = 180 # 水平从右到左
|
|
elif direction == 'top_bottom':
|
|
angle = 90 # 垂直从上到下
|
|
elif direction == 'bottom_top':
|
|
angle = 270 # 垂直从下到上
|
|
elif direction == 'diagonal':
|
|
angle = 45 # 对角线 左上到右下
|
|
elif direction == 'diagonal_reverse':
|
|
angle = 225 # 对角线 右下到左上
|
|
elif direction == 'diagonal_bottom':
|
|
angle = 315 # 对角线 左下到右上
|
|
elif direction == 'diagonal_bottom_reverse':
|
|
angle = 135 # 对角线 右上到左下
|
|
else:
|
|
# 使用直接指定的角度
|
|
angle = gradient.get('angle', 0)
|
|
|
|
# 检查是否是径向渐变
|
|
if gradient.get('type') == 'radial':
|
|
angle = 'radial'
|
|
|
|
# Create outline by dilating the mask
|
|
dilated_mask = mask.copy()
|
|
|
|
# Apply the outline width (dilate the mask)
|
|
w = int(width)
|
|
|
|
# Only apply if width > 0
|
|
if w > 0:
|
|
# Apply multiple dilations for better results
|
|
for _ in range(w):
|
|
dilated_mask = dilated_mask.filter(ImageFilter.MaxFilter(3))
|
|
|
|
# Create outline mask (only keep the dilated area, excluding the original text area)
|
|
outline_only_mask_array = np.clip(np.array(dilated_mask) - np.array(mask), 0, 255)
|
|
|
|
# 转换为PIL Image
|
|
outline_only_mask = Image.fromarray(outline_only_mask_array)
|
|
|
|
# 将HEX颜色转换为RGB (只处理一次颜色，不重复处理)
|
|
rgb_colors = []
|
|
for color in hex_colors:
|
|
if isinstance(color, str):
|
|
# 如果是十六进制字符串，转换为RGB
|
|
rgb = self.hex_to_rgba(color)[:3] # 只取RGB部分
|
|
print(f"转换十六进制颜色 '{color}' 到RGB: {rgb}")
|
|
rgb_colors.append(rgb)
|
|
elif isinstance(color, (list, tuple)) and len(color) >= 3:
|
|
# 如果已经是RGB(A)元组或列表，直接使用
|
|
rgb = color[:3] # 确保只取RGB部分
|
|
print(f"使用已有RGB颜色: {rgb}")
|
|
rgb_colors.append(rgb)
|
|
else:
|
|
print(f"无法识别的颜色格式: {color}，使用默认白色")
|
|
rgb_colors.append((255, 255, 255))
|
|
|
|
if not rgb_colors:
|
|
# 如果没有有效颜色，使用默认颜色
|
|
rgb_colors = [(238, 40, 131), (255, 220, 125)] # 使用粉色到黄色的默认渐变
|
|
|
|
# 打印方向向量进行调试
|
|
if isinstance(angle, (int, float)):
|
|
radians = math.radians(angle)
|
|
dx = round(math.cos(radians), 2)
|
|
dy = round(math.sin(radians), 2)
|
|
print(f"描边渐变角度: {angle}度, 方向向量: [{dx:.2f}, {dy:.2f}]")
|
|
|
|
# 打印最终使用的渐变信息进行调试
|
|
print(f"[Style: {style_name}] 描边渐变填充颜色: {hex_colors}, 角度/类型: {angle}, 方向: {direction}")
|
|
|
|
# 创建渐变并应用到描边
|
|
gradient_array = self._create_gradient(
|
|
img.size[0],
|
|
img.size[1],
|
|
rgb_colors,
|
|
angle,
|
|
direction # 确保传递方向参数
|
|
)
|
|
|
|
# 创建一个新的透明图像作为结果
|
|
result = Image.new('RGBA', img.size, (0, 0, 0, 0))
|
|
|
|
# 将渐变应用到描边区域（只有轮廓部分）
|
|
gradient_img = gradient_array.convert('RGBA')
|
|
|
|
# 确保描边只应用到轮廓上
|
|
if opacity < 1.0:
|
|
# 调整透明度
|
|
outline_only_mask = outline_only_mask.point(lambda x: int(x * opacity))
|
|
|
|
# 应用轮廓蒙版到渐变
|
|
gradient_img.putalpha(outline_only_mask)
|
|
|
|
# 将原始图像复制到结果中
|
|
result = gradient_img.copy()
|
|
|
|
# 保存调试图像
|
|
self._save_debug_image(result, f"debug_{style_name}_outline_only.png")
|
|
|
|
return result
|
|
|
|
def apply_glow(self, img, style):
|
|
"""应用外发光效果"""
|
|
# 检查是否使用了outer_glow或glow的命名
|
|
style_glow = {}
|
|
if 'outer_glow' in style:
|
|
style_glow = style.get('outer_glow', {})
|
|
print("使用outer_glow参数")
|
|
elif 'glow' in style:
|
|
style_glow = style.get('glow', {})
|
|
print("使用glow参数")
|
|
else:
|
|
print("未找到glow或outer_glow参数")
|
|
|
|
# 如果不需要发光效果，直接返回空
|
|
if not style_glow or style_glow.get('opacity', 0) <= 0:
|
|
return None
|
|
|
|
# 获取发光参数
|
|
glow_color = style_glow.get('color', '#ffffff')
|
|
glow_opacity = style_glow.get('opacity', 80)
|
|
if isinstance(glow_opacity, (int, float)) and glow_opacity <= 1:
|
|
pass
|
|
else:
|
|
glow_opacity = glow_opacity / 100.0
|
|
|
|
glow_radius = int(style_glow.get('radius', 10))
|
|
glow_intensity = style_glow.get('intensity', 100)
|
|
if isinstance(glow_intensity, (int, float)) and glow_intensity <= 1:
|
|
pass
|
|
else:
|
|
glow_intensity = glow_intensity / 100.0
|
|
|
|
print(f"\n======= 外发光效果调试 =======")
|
|
print(f"颜色: {glow_color}")
|
|
print(f"颜色源数据: {style_glow}")
|
|
print(f"完整样式数据键: {list(style.keys())}")
|
|
print(f"不透明度(原始值): {style_glow.get('opacity')}")
|
|
print(f"不透明度(调整后): {glow_opacity}")
|
|
print(f"半径: {glow_radius}")
|
|
print(f"强度(原始值): {style_glow.get('intensity')}")
|
|
print(f"强度(调整后): {glow_intensity}")
|
|
|
|
try:
|
|
r, g, b = self.hex_to_rgba(glow_color)[:3]
|
|
print(f"解析RGB颜色: R={r}, G={g}, B={b}")
|
|
|
|
source_alpha = img.split()[3]
|
|
|
|
blurred_alpha = source_alpha.filter(ImageFilter.GaussianBlur(radius=glow_radius))
|
|
|
|
# 应用强度参数 - 强度越高，发光效果越明显
|
|
# 创建发光颜色层
|
|
glow_img = Image.new('RGBA', img.size, (r, g, b, 0))
|
|
|
|
# 强度参数影响最终的不透明度
|
|
effective_opacity = glow_opacity * glow_intensity
|
|
print(f"有效不透明度(opacity * intensity): {effective_opacity}")
|
|
|
|
# 应用不透明度到发光蒙版
|
|
glow_mask = blurred_alpha.point(lambda x: min(int(x * effective_opacity), 255))
|
|
glow_img.putalpha(glow_mask)
|
|
|
|
return glow_img
|
|
|
|
except Exception as e:
|
|
print(f"[错误] 创建外发光效果时出错: {e}")
|
|
return None
|
|
|
|
def apply_inner_shadow(self, img, style):
|
|
"""应用内阴影效果"""
|
|
style_inner_shadow = style.get('inner_shadow', {})
|
|
|
|
# 如果不需要内阴影效果，直接返回空
|
|
if not style_inner_shadow or style_inner_shadow.get('opacity', 0) <= 0:
|
|
return None
|
|
|
|
# 获取内阴影参数
|
|
shadow_color = style_inner_shadow.get('color', '#000000')
|
|
shadow_opacity = style_inner_shadow.get('opacity', 50)
|
|
if isinstance(shadow_opacity, (int, float)) and shadow_opacity <= 1:
|
|
pass
|
|
else:
|
|
shadow_opacity = shadow_opacity / 100.0
|
|
|
|
shadow_offset_x = style_inner_shadow.get('offset_x', 2)
|
|
shadow_offset_y = style_inner_shadow.get('offset_y', 2)
|
|
shadow_blur = style_inner_shadow.get('blur', 3)
|
|
|
|
print(f"\n======= 内阴影效果调试 =======")
|
|
print(f"颜色: {shadow_color}")
|
|
print(f"颜色源数据: {style_inner_shadow}")
|
|
print(f"完整样式数据: {style}")
|
|
print(f"不透明度(原始值): {style_inner_shadow.get('opacity')}")
|
|
print(f"不透明度(调整后): {shadow_opacity}")
|
|
print(f"X偏移: {shadow_offset_x}")
|
|
print(f"Y偏移: {shadow_offset_y}")
|
|
print(f"模糊: {shadow_blur}")
|
|
|
|
try:
|
|
r, g, b = self.hex_to_rgba(shadow_color)[:3]
|
|
|
|
# 获取alpha通道作为蒙版
|
|
source_alpha = img.split()[3]
|
|
|
|
# 创建偏移的alpha通道
|
|
offset_alpha = Image.new('L', img.size, 0)
|
|
offset_alpha.paste(source_alpha, (int(-shadow_offset_x), int(-shadow_offset_y)))
|
|
|
|
# 直接跳过模糊效果，无论模糊值是多少
|
|
print(f"跳过模糊效果，强制设置为0，原模糊值: {shadow_blur}")
|
|
|
|
# 执行内阴影合成计算
|
|
source_array = np.array(source_alpha, dtype=np.float32) / 255.0
|
|
offset_array = np.array(offset_alpha, dtype=np.float32) / 255.0
|
|
|
|
# 内阴影 = 原图 - 偏移图, 限制在[0,1]范围内
|
|
inner_shadow_array = np.clip(source_array - offset_array, 0, 1)
|
|
|
|
# 确保内阴影仅出现在文本内部
|
|
inner_shadow_array = inner_shadow_array * source_array
|
|
|
|
# 转换回PIL图像
|
|
inner_shadow_mask = Image.fromarray((inner_shadow_array * 255).astype(np.uint8), 'L')
|
|
|
|
# 创建内阴影颜色图像
|
|
shadow_img = Image.new('RGBA', img.size, (r, g, b, 0))
|
|
|
|
# 计算最终不透明度
|
|
shadow_mask_with_opacity = inner_shadow_mask
|
|
|
|
# 如果需要增强对比度，让内阴影边缘更明显
|
|
if shadow_opacity > 0:
|
|
# 应用对比度增强
|
|
enhancer = ImageEnhance.Contrast(shadow_mask_with_opacity)
|
|
shadow_mask_with_opacity = enhancer.enhance(1.5) # 增强对比度
|
|
|
|
# 应用不透明度
|
|
shadow_mask_with_opacity = shadow_mask_with_opacity.point(lambda x: int(x * shadow_opacity))
|
|
|
|
shadow_img.putalpha(shadow_mask_with_opacity)
|
|
|
|
return shadow_img
|
|
|
|
except Exception as e:
|
|
print(f"[错误] 创建内阴影效果时出错: {e}")
|
|
return None
|
|
|
|
def apply_fill(self, img, style):
|
|
"""应用填充效果，支持纯色和渐变填充"""
|
|
if not img:
|
|
return None
|
|
|
|
try:
|
|
width, height = img.size
|
|
|
|
binary_mask = Image.new('1', img.size, 0)
|
|
if img.mode == 'RGBA':
|
|
text_mask = img.split()[3]
|
|
binary_mask.paste(1, (0, 0), text_mask)
|
|
else:
|
|
text_mask = img.convert('L')
|
|
binary_mask.paste(1, (0, 0), text_mask)
|
|
|
|
if 'fill' in style:
|
|
fill_type = None
|
|
|
|
if isinstance(style['fill'], dict):
|
|
fill_type = style['fill'].get('type')
|
|
print(f"检测到填充类型: {fill_type}")
|
|
elif style['fill'] == 'gradient':
|
|
fill_type = 'gradient'
|
|
|
|
if fill_type == 'gradient' or fill_type == 'linear' or fill_type == 'radial':
|
|
fill = style.get('fill', {})
|
|
if not isinstance(fill, dict):
|
|
fill = {'type': 'gradient', 'colors': ['#FFFFFF', '#0066FF'], 'angle': 90}
|
|
|
|
colors = fill.get('colors', ['#FFFFFF', '#0066FF'])
|
|
if isinstance(colors, str):
|
|
colors = [colors, '#0066FF']
|
|
|
|
rgb_colors = []
|
|
for color in colors:
|
|
if isinstance(color, str):
|
|
rgb = self.hex_to_rgba(color)[:3]
|
|
print(f"转换十六进制颜色 '{color}' 到RGB: {rgb}")
|
|
rgb_colors.append(rgb)
|
|
elif isinstance(color, (list, tuple)) and len(color) >= 3:
|
|
rgb = color[:3]
|
|
print(f"使用已有RGB颜色: {rgb}")
|
|
rgb_colors.append(rgb)
|
|
else:
|
|
print(f"无法识别的颜色格式: {color}，使用默认白色")
|
|
rgb_colors.append((255, 255, 255))
|
|
|
|
if not rgb_colors:
|
|
rgb_colors = [(255, 255, 255), (0, 102, 255)]
|
|
print(f"未找到有效颜色，使用默认值: {rgb_colors}")
|
|
|
|
print(f"渐变填充使用的最终颜色: {rgb_colors}")
|
|
|
|
angle = fill.get('angle', 90)
|
|
direction = fill.get('direction', None)
|
|
|
|
gradient_img = self._create_gradient(width, height, rgb_colors, angle, direction)
|
|
|
|
gradient_masked_rgba = Image.new('RGBA', img.size, (0, 0, 0, 0))
|
|
|
|
gradient_masked_rgba.paste(gradient_img, (0, 0), text_mask)
|
|
|
|
print(f"使用PIL直接粘贴模式应用蒙版")
|
|
|
|
opacity = float(fill.get('opacity', 1.0))
|
|
if opacity < 1.0:
|
|
r, g, b, a = gradient_masked_rgba.split()
|
|
a = a.point(lambda x: int(x * opacity))
|
|
gradient_masked_rgba = Image.merge('RGBA', (r, g, b, a))
|
|
|
|
return gradient_masked_rgba
|
|
else:
|
|
fill_color = (64, 150, 255)
|
|
if 'fill' in style:
|
|
if isinstance(style['fill'], dict):
|
|
color_value = style['fill'].get('color', '#4096FF')
|
|
if isinstance(color_value, str):
|
|
print(f"处理填充颜色: {color_value}")
|
|
fill_color = self.hex_to_rgba(color_value)[:3]
|
|
print(f"转换后的RGB颜色: {fill_color}")
|
|
elif isinstance(color_value, (list, tuple)) and len(color_value) >= 3:
|
|
fill_color = color_value[:3]
|
|
print(f"使用直接提供的RGB颜色: {fill_color}")
|
|
elif isinstance(style['fill'], str):
|
|
print(f"处理直接提供的颜色值: {style['fill']}")
|
|
fill_color = self.hex_to_rgba(style['fill'])[:3]
|
|
print(f"转换后的RGB颜色: {fill_color}")
|
|
|
|
print(f"使用单色填充: RGB{fill_color}")
|
|
|
|
fill_img = Image.new('RGB', img.size, fill_color)
|
|
|
|
fill_rgba = Image.new('RGBA', img.size, (0, 0, 0, 0))
|
|
fill_rgba.paste(fill_img, (0, 0), binary_mask)
|
|
|
|
opacity = 1.0
|
|
if isinstance(style['fill'], dict) and 'opacity' in style['fill']:
|
|
opacity = float(style['fill']['opacity'])
|
|
|
|
if opacity < 1.0:
|
|
r, g, b, a = fill_rgba.split()
|
|
a = a.point(lambda x: int(x * opacity))
|
|
fill_rgba = Image.merge('RGBA', (r, g, b, a))
|
|
|
|
return fill_rgba
|
|
|
|
fill_img = Image.new('RGB', img.size, (255, 255, 255))
|
|
fill_rgba = Image.new('RGBA', img.size, (0, 0, 0, 0))
|
|
fill_rgba.paste(fill_img, (0, 0), binary_mask)
|
|
return fill_rgba
|
|
|
|
except Exception as e:
|
|
print(f"应用填充效果时出错: {e}")
|
|
import traceback
|
|
traceback.print_exc()
|
|
return None
|