655 lines
31 KiB
Python
655 lines
31 KiB
Python
import torch
|
|
import numpy as np
|
|
from PIL import Image, ImageDraw, ImageFont
|
|
import os
|
|
import json
|
|
import re
|
|
import random
|
|
from dataclasses import dataclass, field
|
|
from typing import Optional, Tuple, List, Dict, Any
|
|
|
|
# Author: KARAS
|
|
# Version: 3.9.0 - Implemented dynamic scaling for small images
|
|
#
|
|
# --- 依赖导入 ---
|
|
try:
|
|
import piexif
|
|
except ImportError:
|
|
piexif = None
|
|
|
|
# --- 插件资源路径设置 ---
|
|
current_dir = os.path.dirname(os.path.abspath(__file__))
|
|
fonts_dir = os.path.join(current_dir, "fonts")
|
|
logos_dir = os.path.join(current_dir, "logos")
|
|
os.makedirs(fonts_dir, exist_ok=True)
|
|
os.makedirs(logos_dir, exist_ok=True)
|
|
|
|
# --- 资源扫描与缓存 ---
|
|
def get_resource_files(directory: str, extensions: Tuple[str, ...]) -> List[str]:
|
|
"""Scans a directory for files with given extensions."""
|
|
try:
|
|
return sorted([f for f in os.listdir(directory) if f.lower().endswith(extensions)])
|
|
except FileNotFoundError:
|
|
return []
|
|
|
|
font_files = get_resource_files(fonts_dir, ('.ttf', '.ttc', '.otf')) or ["default"]
|
|
bold_font_files = [f for f in font_files if 'bold' in f.lower() or 'bd' in f.lower()] or font_files
|
|
logo_files = ["None"] + sorted([os.path.splitext(f)[0] for f in get_resource_files(logos_dir, ('.png',))])
|
|
|
|
# --- 预设数据 ---
|
|
PHONE_MODELS = [
|
|
"HUAWEI Pura 70 Ultra", "HUAWEI Pura 70 Pro", "HUAWEI Mate 60 Pro",
|
|
"iPhone 15 Pro Max", "iPhone 15 Pro",
|
|
"Samsung Galaxy S24 Ultra", "Xiaomi 14 Ultra",
|
|
"OPPO Find X7 Ultra", "vivo X100 Ultra", "Google Pixel 8 Pro", "自定义型号"
|
|
]
|
|
|
|
LAYOUT_OPTIONS = [
|
|
"1. 底部留白 - 左右分布",
|
|
"2. 底部留白 - 居中",
|
|
"3. 右侧留白 - 上下竖排",
|
|
"4. 顶部 & 底部留白",
|
|
"5. 画内叠加 - 左下角",
|
|
"6. 画内叠加 - 右下角",
|
|
"7. 画内叠加 - 左上角",
|
|
"8. 画内叠加 - 右上角",
|
|
"9. 画内叠加 - 居中",
|
|
"10. 独立信息条"
|
|
]
|
|
|
|
LAYOUT_PRESETS = {
|
|
LAYOUT_OPTIONS[0]: {
|
|
"logo": "leica",
|
|
"logo_size_ratio": 1.0,
|
|
"bar_size": 200,
|
|
"bg_color": "#FFFFFF",
|
|
"title_color": "#000000",
|
|
"subtitle_color": "#888888",
|
|
},
|
|
LAYOUT_OPTIONS[1]: {
|
|
"block_b_text_1": "",
|
|
"block_a_text_1": "",
|
|
"block_a_text_2": "",
|
|
"logo": "hasselblad",
|
|
"logo_size_ratio": 1,
|
|
"bg_color": "#FFFFFF",
|
|
"title_color": "#000000",
|
|
"subtitle_color": "#888888",
|
|
},
|
|
LAYOUT_OPTIONS[2]: {
|
|
"bar_size": 300,
|
|
"block_a_text_2": "",
|
|
"logo_size_ratio": 1.0,
|
|
},
|
|
LAYOUT_OPTIONS[3]: {
|
|
"bar_size": 150,
|
|
"block_a_text_2": "",
|
|
"logo_size_ratio": 1.0,
|
|
},
|
|
LAYOUT_OPTIONS[4]: {
|
|
"logo": "zeiss",
|
|
"title_color": "#FFFFFF",
|
|
"subtitle_color": "#CCCCCC",
|
|
"logo_size_ratio": 1.0,
|
|
},
|
|
LAYOUT_OPTIONS[5]: {
|
|
"logo": "zeiss",
|
|
"title_color": "#FFFFFF",
|
|
"subtitle_color": "#CCCCCC",
|
|
"logo_size_ratio": 1.0,
|
|
},
|
|
LAYOUT_OPTIONS[6]: {
|
|
"logo": "zeiss",
|
|
"title_color": "#FFFFFF",
|
|
"subtitle_color": "#CCCCCC",
|
|
"logo_size_ratio": 1.0,
|
|
},
|
|
LAYOUT_OPTIONS[7]: {
|
|
"logo": "zeiss",
|
|
"title_color": "#FFFFFF",
|
|
"subtitle_color": "#CCCCCC",
|
|
"logo_size_ratio": 1.0,
|
|
},
|
|
LAYOUT_OPTIONS[8]: {
|
|
"logo": "zeiss",
|
|
"title_color": "#FFFFFF",
|
|
"subtitle_color": "#CCCCCC",
|
|
"logo_size_ratio": 1.0,
|
|
},
|
|
}
|
|
|
|
|
|
# -----------------------------------------------------------------
|
|
# 节点 1: 加载图片/附加EXIF
|
|
# -----------------------------------------------------------------
|
|
class ImageLoaderWithEXIF:
|
|
@classmethod
|
|
def INPUT_TYPES(s):
|
|
input_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), "..", "..", "input")
|
|
files = get_resource_files(input_dir, ('.jpg', '.jpeg', '.png', '.webp'))
|
|
return {
|
|
"required": { "image_file": (sorted(files), {"image_upload": True}) },
|
|
"optional": { "image_passthrough": ("IMAGE",) }
|
|
}
|
|
|
|
RETURN_TYPES = ("IMAGE", "STRING")
|
|
RETURN_NAMES = ("image", "exif_json")
|
|
FUNCTION = "load_or_passthrough"
|
|
CATEGORY = "Watermark"
|
|
|
|
def load_or_passthrough(self, image_file: str, image_passthrough: Optional[torch.Tensor] = None) -> Tuple[torch.Tensor, str]:
|
|
if piexif is None:
|
|
raise ImportError("需要 'piexif' 库。请运行: pip install piexif")
|
|
|
|
image_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), "..", "..", "input", image_file)
|
|
output_exif_json = "{}"
|
|
try:
|
|
with Image.open(image_path) as img_for_exif:
|
|
if 'exif' in img_for_exif.info and img_for_exif.info['exif']:
|
|
exif_dict = piexif.load(img_for_exif.info['exif'])
|
|
exif_data = self.parse_exif(exif_dict)
|
|
output_exif_json = json.dumps(exif_data)
|
|
except Exception as e:
|
|
print(f"无法从 '{image_file}' 读取EXIF: {e}")
|
|
|
|
if image_passthrough is not None:
|
|
return (image_passthrough, output_exif_json)
|
|
else:
|
|
with Image.open(image_path) as img:
|
|
img_rgb = img.convert("RGB")
|
|
if "exif" in img.info:
|
|
try:
|
|
exif_dict = piexif.load(img.info["exif"])
|
|
orientation = exif_dict.get("0th", {}).get(piexif.ImageIFD.Orientation, 1)
|
|
if orientation > 1:
|
|
img_rgb = self.apply_exif_orientation(img_rgb, orientation)
|
|
except Exception as e:
|
|
print(f"处理EXIF方向时出错: {e}")
|
|
|
|
image_tensor = np.array(img_rgb).astype(np.float32) / 255.0
|
|
return (torch.from_numpy(image_tensor)[None,], output_exif_json)
|
|
|
|
def apply_exif_orientation(self, image: Image.Image, orientation: int) -> Image.Image:
|
|
"""Applies EXIF orientation to the image."""
|
|
if orientation == 2: return image.transpose(Image.FLIP_LEFT_RIGHT)
|
|
if orientation == 3: return image.rotate(180)
|
|
if orientation == 4: return image.transpose(Image.FLIP_TOP_BOTTOM)
|
|
if orientation == 5: return image.rotate(-90, expand=True).transpose(Image.FLIP_LEFT_RIGHT)
|
|
if orientation == 6: return image.rotate(-90, expand=True)
|
|
if orientation == 7: return image.rotate(90, expand=True).transpose(Image.FLIP_LEFT_RIGHT)
|
|
if orientation == 8: return image.rotate(90, expand=True)
|
|
return image
|
|
|
|
def parse_exif(self, exif_dict: Dict) -> Dict[str, Any]:
|
|
"""Parses raw EXIF data into a structured dictionary."""
|
|
exif_data = {}
|
|
zeroth_ifd = exif_dict.get('0th', {})
|
|
exif_ifd = exif_dict.get('Exif', {})
|
|
|
|
if piexif.ImageIFD.Make in zeroth_ifd:
|
|
exif_data['Make'] = zeroth_ifd[piexif.ImageIFD.Make].decode('utf-8', errors='ignore').strip('\x00').strip()
|
|
if piexif.ImageIFD.Model in zeroth_ifd:
|
|
exif_data['Model'] = zeroth_ifd[piexif.ImageIFD.Model].decode('utf-8', errors='ignore').strip('\x00').strip()
|
|
if piexif.ExifIFD.LensModel in exif_ifd:
|
|
exif_data['LensModel'] = exif_ifd[piexif.ExifIFD.LensModel].decode('utf-8', errors='ignore').strip('\x00').strip()
|
|
if piexif.ExifIFD.DateTimeOriginal in exif_ifd:
|
|
exif_data['Timestamp'] = exif_ifd[piexif.ExifIFD.DateTimeOriginal].decode('utf-8', errors='ignore').strip('\x00').strip()
|
|
if piexif.ExifIFD.FNumber in exif_ifd:
|
|
f_num = exif_ifd[piexif.ExifIFD.FNumber]
|
|
exif_data['Aperture'] = f"f/{(f_num[0]/f_num[1]):.1f}" if f_num[1] > 0 else "f/0.0"
|
|
if piexif.ExifIFD.ExposureTime in exif_ifd:
|
|
exp = exif_ifd[piexif.ExifIFD.ExposureTime]
|
|
if exp[0] > 0 and exp[1] > 0:
|
|
shutter = exp[0] / exp[1]
|
|
exif_data['ShutterSpeed'] = f"1/{int(1/shutter)}s" if shutter < 1 else f"{shutter}s"
|
|
if piexif.ExifIFD.ISOSpeedRatings in exif_ifd:
|
|
exif_data['ISO'] = f"ISO{exif_ifd[piexif.ExifIFD.ISOSpeedRatings]}"
|
|
if piexif.ExifIFD.FocalLength in exif_ifd:
|
|
focal = exif_ifd[piexif.ExifIFD.FocalLength]
|
|
if focal[1] > 0:
|
|
exif_data['FocalLength'] = f"{int(focal[0]/focal[1])}mm"
|
|
return exif_data
|
|
|
|
# -----------------------------------------------------------------
|
|
# 节点 2: 相机水印生成器
|
|
# -----------------------------------------------------------------
|
|
@dataclass
|
|
class TextContent:
|
|
block_a: List[str]
|
|
block_b: List[str]
|
|
|
|
@dataclass
|
|
class TextBlock:
|
|
lines: List[Tuple[str, ImageFont.FreeTypeFont, str]] = field(default_factory=list)
|
|
width: int = 0
|
|
height: int = 0
|
|
line_bboxes: List[Tuple[int, int, int, int]] = field(default_factory=list)
|
|
|
|
class CameraWatermarkNode:
|
|
_font_cache = {}
|
|
|
|
@classmethod
|
|
def INPUT_TYPES(s):
|
|
return {
|
|
"required": {
|
|
"image": ("IMAGE",),
|
|
"layout": (LAYOUT_OPTIONS,),
|
|
"restore_preset": ("BOOLEAN", {"default": False, "label_on": "应用当前样式预设", "label_off": "应用当前样式预设"}),
|
|
"randomize_style": ("BOOLEAN", {"default": False}),
|
|
"random_style_selection": ("STRING", {"multiline": False, "default": "1-10"}),
|
|
"seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
|
|
"use_exif": ("BOOLEAN", {"default": True}),
|
|
"block_a_text_1": ("STRING", {"multiline": False, "default": "iPhone 15 Pro Max"}),
|
|
"block_a_text_2": ("STRING", {"multiline": False, "default": "Main Camera"}),
|
|
"block_a_text_3": ("STRING", {"multiline": False, "default": "© KARAS"}),
|
|
"block_b_text_1": ("STRING", {"multiline": False, "default": "SONY"}),
|
|
"block_b_text_2": ("STRING", {"multiline": False, "default": "24mm | f/1.8 | 1/125s | ISO 50"}),
|
|
"block_b_text_3": ("STRING", {"multiline": False, "default": ""}),
|
|
"logo": (logo_files, {"default": "leica" if "leica" in [lf.lower() for lf in logo_files] else logo_files[0]}),
|
|
"logo_size_ratio": ("FLOAT", {"default": 1.0, "min": 0.1, "max": 3.0, "step": 0.1}),
|
|
"bar_size": ("INT", {"default": 200, "min": 0, "max": 2048, "step": 10}),
|
|
"bar_width": ("INT", {"default": 1894, "min": 64, "max": 8192, "step": 64}),
|
|
"bar_height": ("INT", {"default": 165, "min": 64, "max": 8192, "step": 64}),
|
|
"padding": ("INT", {"default": 50, "min": 0, "max": 400, "step": 1}),
|
|
"spacing": ("INT", {"default": 15, "min": 0, "max": 200, "step": 1}),
|
|
"font_name": (font_files, {}),
|
|
"font_bold_name": (bold_font_files, {}),
|
|
"font_size_large": ("INT", {"default": 48, "min": 8, "max": 200, "step": 1}),
|
|
"font_size_medium": ("INT", {"default": 28, "min": 8, "max": 200, "step": 1}),
|
|
"font_size_small": ("INT", {"default": 24, "min": 8, "max": 200, "step": 1}),
|
|
"bg_color": ("STRING", {"multiline": False, "default": "#FFFFFF"}),
|
|
"title_color": ("STRING", {"multiline": False, "default": "#000000"}),
|
|
"subtitle_color": ("STRING", {"multiline": False, "default": "#888888"}),
|
|
},
|
|
"optional": { "exif_data": ("STRING", {"forceInput": True}), }
|
|
}
|
|
|
|
RETURN_TYPES = ("IMAGE",)
|
|
FUNCTION = "generate_image"
|
|
CATEGORY = "Watermark"
|
|
|
|
def tensor_to_pil(self, tensor: torch.Tensor) -> Optional[Image.Image]:
|
|
if tensor is None: return None
|
|
return Image.fromarray(np.clip(255. * tensor.cpu().numpy().squeeze(0), 0, 255).astype(np.uint8))
|
|
|
|
def pil_to_tensor(self, pil_image: Image.Image) -> torch.Tensor:
|
|
return torch.from_numpy(np.array(pil_image).astype(np.float32) / 255.0).unsqueeze(0)
|
|
|
|
def get_font(self, font_name: str, size: int) -> ImageFont.FreeTypeFont:
|
|
cache_key = f"{font_name}_{size}"
|
|
if cache_key in self._font_cache:
|
|
return self._font_cache[cache_key]
|
|
|
|
if not font_name or font_name == "default":
|
|
try: font = ImageFont.load_default(size=size)
|
|
except AttributeError: font = ImageFont.load_default()
|
|
else:
|
|
font_path = os.path.join(fonts_dir, font_name)
|
|
try: font = ImageFont.truetype(font_path, size=size)
|
|
except Exception as e:
|
|
print(f"警告: 无法加载字体 '{font_name}'。错误: {e}")
|
|
try: font = ImageFont.load_default(size=size)
|
|
except AttributeError: font = ImageFont.load_default()
|
|
|
|
self._font_cache[cache_key] = font
|
|
return font
|
|
|
|
def get_text_bbox(self, text: str, font: ImageFont.FreeTypeFont) -> Tuple[int, int, int, int]:
|
|
if hasattr(font, 'getbbox'):
|
|
return font.getbbox(text)
|
|
else:
|
|
w, h = font.getsize(text)
|
|
return (0, 0, w, h)
|
|
|
|
def _crop_transparent_border(self, pil_image: Image.Image) -> Image.Image:
|
|
"""Crops the transparent border from a PIL image."""
|
|
if pil_image.mode != "RGBA":
|
|
return pil_image
|
|
|
|
bbox = pil_image.getbbox()
|
|
if bbox:
|
|
return pil_image.crop(bbox)
|
|
return pil_image
|
|
|
|
def _parse_range_string(self, range_string: str) -> List[int]:
|
|
numbers = set()
|
|
parts = range_string.split(',')
|
|
for part in parts:
|
|
part = part.strip()
|
|
if not part: continue
|
|
if '-' in part:
|
|
try:
|
|
start, end = map(int, part.split('-'))
|
|
if start <= end:
|
|
numbers.update(range(start, end + 1))
|
|
except ValueError:
|
|
print(f"警告: 无效的范围 '{part}' in random style selection.")
|
|
else:
|
|
try:
|
|
numbers.add(int(part))
|
|
except ValueError:
|
|
print(f"警告: 无效的数字 '{part}' in random style selection.")
|
|
return sorted(list(numbers))
|
|
|
|
def _prepare_content(self, **kwargs) -> Tuple[TextContent, str]:
|
|
exif_data_str = kwargs.get('exif_data')
|
|
has_valid_exif = kwargs['use_exif'] and exif_data_str and exif_data_str.strip() != "{}"
|
|
|
|
b_a1, b_a2, b_a3 = kwargs['block_a_text_1'], kwargs['block_a_text_2'], kwargs['block_a_text_3']
|
|
b_b1, b_b2, b_b3 = kwargs['block_b_text_1'], kwargs['block_b_text_2'], kwargs['block_b_text_3']
|
|
logo_match_source = b_a1.lower()
|
|
|
|
if has_valid_exif:
|
|
try:
|
|
data = json.loads(exif_data_str)
|
|
param_parts = [data.get("FocalLength"), data.get("Aperture"), data.get("ShutterSpeed"), data.get("ISO")]
|
|
b_a1 = data.get("Model", "")
|
|
b_a2 = data.get("LensModel", "")
|
|
b_a3 = kwargs.get('author', '© KARAS')
|
|
b_b1 = data.get("Make", "")
|
|
b_b2 = " | ".join(filter(None, param_parts))
|
|
b_b3 = data.get("Timestamp", "")
|
|
logo_match_source = data.get("Make", "").lower()
|
|
except (json.JSONDecodeError, KeyError) as e:
|
|
print(f"无法解析EXIF: {e}")
|
|
|
|
content = TextContent(block_a=[b_a1, b_a2, b_a3], block_b=[b_b1, b_b2, b_b3])
|
|
|
|
final_logo = kwargs['logo']
|
|
if final_logo == "None" and logo_match_source:
|
|
for logo_name in logo_files:
|
|
if logo_name != "None" and logo_name.lower() in logo_match_source:
|
|
final_logo = logo_name
|
|
break
|
|
|
|
return content, final_logo
|
|
|
|
def _draw_block(self, draw, block: TextBlock, start_x: int, start_y: int, align: str = 'left', spacing: int = 10):
|
|
y = start_y
|
|
for i, (text, font, color) in enumerate(block.lines):
|
|
bbox = block.line_bboxes[i]
|
|
text_width, text_height = bbox[2] - bbox[0], bbox[3] - bbox[1]
|
|
|
|
x = start_x
|
|
if align == 'center':
|
|
x = start_x - text_width / 2
|
|
elif align == 'right':
|
|
x = start_x - text_width
|
|
|
|
draw.text((x - bbox[0], y - bbox[1]), text, font=font, fill=color)
|
|
y += text_height + spacing
|
|
|
|
def _draw_vertical_text_block(self, draw_layer, block: TextBlock, center_x: int, start_y: int, spacing: int):
|
|
if not block.lines:
|
|
return 0
|
|
|
|
temp_surface = Image.new("RGBA", (block.width, block.height), (0, 0, 0, 0))
|
|
temp_draw = ImageDraw.Draw(temp_surface)
|
|
|
|
y_cursor = 0
|
|
min_x_offset = min(box[0] for box in block.line_bboxes)
|
|
|
|
for i, (text, font, color) in enumerate(block.lines):
|
|
bbox = block.line_bboxes[i]
|
|
text_height = bbox[3] - bbox[1]
|
|
temp_draw.text((-min_x_offset, y_cursor - bbox[1]), text, font=font, fill=color)
|
|
y_cursor += text_height + spacing
|
|
|
|
rotated_surface = temp_surface.rotate(90, expand=True, resample=Image.Resampling.LANCZOS)
|
|
|
|
paste_x = center_x - rotated_surface.width / 2
|
|
paste_y = start_y
|
|
|
|
draw_layer.paste(rotated_surface, (int(paste_x), int(paste_y)), rotated_surface)
|
|
|
|
return rotated_surface.height
|
|
|
|
def generate_image(self, **kwargs):
|
|
|
|
params = kwargs.copy()
|
|
layout = params['layout']
|
|
seed = params['seed']
|
|
restore_preset = params.pop('restore_preset', False)
|
|
|
|
if params.get('randomize_style', False):
|
|
random.seed(seed)
|
|
selection_str = params.get('random_style_selection', '1-10')
|
|
allowed_indices = self._parse_range_string(selection_str)
|
|
allowed_indices_0based = [i - 1 for i in allowed_indices if 1 <= i <= len(LAYOUT_OPTIONS)]
|
|
if allowed_indices_0based:
|
|
chosen_index = random.choice(allowed_indices_0based)
|
|
layout = LAYOUT_OPTIONS[chosen_index]
|
|
print(f"随机样式已启用 (种子: {seed})，选择: {layout}")
|
|
|
|
if restore_preset:
|
|
if layout in LAYOUT_PRESETS:
|
|
print(f"恢复预设: {layout}")
|
|
params.update(LAYOUT_PRESETS[layout])
|
|
|
|
content, final_logo_name = self._prepare_content(**params)
|
|
|
|
input_pil = self.tensor_to_pil(params['image'])
|
|
img_w, img_h = input_pil.size
|
|
|
|
# --- Dynamic Scaling Logic ---
|
|
base_width = 1200.0 # Standard width for scaling
|
|
scale_factor = min(1.0, img_w / base_width)
|
|
|
|
bar_size = int(params['bar_size'] * scale_factor)
|
|
padding = int(params['padding'] * scale_factor)
|
|
spacing = int(params['spacing'] * scale_factor)
|
|
font_size_large = int(params['font_size_large'] * scale_factor)
|
|
font_size_medium = int(params['font_size_medium'] * scale_factor)
|
|
font_size_small = int(params['font_size_small'] * scale_factor)
|
|
|
|
bg_color = params['bg_color']
|
|
|
|
if layout.startswith("1.") or layout.startswith("2.") or layout.startswith("10."):
|
|
canvas = Image.new("RGBA", (img_w, img_h + bar_size), bg_color)
|
|
canvas.paste(input_pil.convert("RGBA"), (0, 0))
|
|
draw_area = (0, img_h, img_w, bar_size)
|
|
elif layout.startswith("3."):
|
|
canvas = Image.new("RGBA", (img_w + bar_size, img_h), bg_color)
|
|
canvas.paste(input_pil.convert("RGBA"), (0, 0))
|
|
draw_area = (img_w, 0, bar_size, img_h)
|
|
elif layout.startswith("4."):
|
|
canvas = Image.new("RGBA", (img_w, img_h + bar_size * 2), bg_color)
|
|
canvas.paste(input_pil.convert("RGBA"), (0, bar_size))
|
|
draw_area_top = (0, 0, img_w, bar_size)
|
|
draw_area_bottom = (0, img_h + bar_size, img_w, bar_size)
|
|
draw_area = draw_area_top
|
|
elif layout.startswith("5.") or layout.startswith("6.") or layout.startswith("7.") or layout.startswith("8.") or layout.startswith("9."):
|
|
canvas = input_pil.convert("RGBA")
|
|
draw_area = (0, 0, img_w, img_h)
|
|
else:
|
|
bar_width = int(params['bar_width'] * scale_factor)
|
|
bar_height = int(params['bar_height'] * scale_factor)
|
|
canvas = Image.new("RGBA", (bar_width, bar_height), bg_color)
|
|
draw_area = (0, 0, canvas.width, canvas.height)
|
|
|
|
draw_layer = Image.new("RGBA", canvas.size, (0, 0, 0, 0))
|
|
draw = ImageDraw.Draw(draw_layer)
|
|
|
|
fonts = {
|
|
'large_bold': self.get_font(params['font_bold_name'], font_size_large),
|
|
'medium': self.get_font(params['font_name'], font_size_medium),
|
|
'small': self.get_font(params['font_name'], font_size_small)
|
|
}
|
|
|
|
block_a_fonts = [fonts['large_bold'], fonts['medium'], fonts['small']]
|
|
block_b_fonts = [fonts['large_bold'], fonts['medium'], fonts['small']]
|
|
block_a_colors = [params['title_color'], params['subtitle_color'], params['subtitle_color']]
|
|
block_b_colors = [params['title_color'], params['subtitle_color'], params['subtitle_color']]
|
|
|
|
block_a = TextBlock()
|
|
for i, text in enumerate(content.block_a):
|
|
if text:
|
|
block_a.lines.append((text, block_a_fonts[i], block_a_colors[i]))
|
|
if block_a.lines:
|
|
block_a.line_bboxes = [self.get_text_bbox(line[0], line[1]) for line in block_a.lines]
|
|
min_x = min(box[0] for box in block_a.line_bboxes)
|
|
max_x = max(box[2] for box in block_a.line_bboxes)
|
|
block_a.width = max_x - min_x
|
|
line_heights = [box[3] - box[1] for box in block_a.line_bboxes]
|
|
block_a.height = int(sum(line_heights) + max(0, len(line_heights) - 1) * spacing)
|
|
|
|
block_b = TextBlock()
|
|
for i, text in enumerate(content.block_b):
|
|
if text:
|
|
block_b.lines.append((text, block_b_fonts[i], block_b_colors[i]))
|
|
if block_b.lines:
|
|
block_b.line_bboxes = [self.get_text_bbox(line[0], line[1]) for line in block_b.lines]
|
|
min_x = min(box[0] for box in block_b.line_bboxes)
|
|
max_x = max(box[2] for box in block_b.line_bboxes)
|
|
block_b.width = max_x - min_x
|
|
line_heights = [box[3] - box[1] for box in block_b.line_bboxes]
|
|
block_b.height = int(sum(line_heights) + max(0, len(line_heights) - 1) * spacing)
|
|
|
|
pil_logo = None
|
|
if final_logo_name != "None":
|
|
try:
|
|
logo_filename = next((f for f in os.listdir(logos_dir) if os.path.splitext(f)[0].lower() == final_logo_name.lower()), None)
|
|
if logo_filename:
|
|
pil_logo = Image.open(os.path.join(logos_dir, logo_filename)).convert("RGBA")
|
|
pil_logo = self._crop_transparent_border(pil_logo)
|
|
except Exception as e:
|
|
print(f"无法加载内置Logo '{final_logo_name}': {e}")
|
|
|
|
if pil_logo:
|
|
bar_based_target_height = 0
|
|
if not (layout.startswith("5.") or layout.startswith("6.") or layout.startswith("7.") or layout.startswith("8.") or layout.startswith("9.")):
|
|
max_size_ref = draw_area[3] if not layout.startswith("3.") else draw_area[2]
|
|
bar_based_target_height = int(max_size_ref * 0.5)
|
|
|
|
text_based_target_height = 0
|
|
if layout in [LAYOUT_OPTIONS[0], LAYOUT_OPTIONS[9]]:
|
|
text_based_target_height = block_b.height
|
|
elif layout in [LAYOUT_OPTIONS[1], LAYOUT_OPTIONS[3]] or layout.startswith("5.") or layout.startswith("6.") or layout.startswith("7.") or layout.startswith("8.") or layout.startswith("9."):
|
|
text_based_target_height = block_a.height if block_a.height > 0 else block_b.height
|
|
|
|
base_height = max(text_based_target_height, bar_based_target_height)
|
|
final_target_height = int(base_height * params['logo_size_ratio'])
|
|
|
|
if final_target_height > 0:
|
|
original_width, original_height = pil_logo.size
|
|
if original_height > 0:
|
|
ratio = final_target_height / original_height
|
|
new_width = int(original_width * ratio)
|
|
pil_logo = pil_logo.resize((new_width, final_target_height), Image.Resampling.LANCZOS)
|
|
|
|
if layout == LAYOUT_OPTIONS[0] or layout == LAYOUT_OPTIONS[9]:
|
|
x, y, w, h = draw_area
|
|
y_a = y + (h - block_a.height) / 2
|
|
self._draw_block(draw, block_a, x + padding, y_a, spacing=spacing)
|
|
|
|
y_b = y + (h - block_b.height) / 2
|
|
if pil_logo:
|
|
right_group_width = block_b.width + spacing + pil_logo.width
|
|
start_x_right = x + w - padding - right_group_width
|
|
logo_x = start_x_right
|
|
logo_y = y + (h - pil_logo.height) / 2
|
|
draw_layer.paste(pil_logo, (int(logo_x), int(logo_y)), pil_logo)
|
|
block_b_x = logo_x + pil_logo.width + spacing
|
|
self._draw_block(draw, block_b, block_b_x, y_b, align='left', spacing=spacing)
|
|
else:
|
|
self._draw_block(draw, block_b, x + w - padding, y_b, align='right', spacing=spacing)
|
|
|
|
elif layout == LAYOUT_OPTIONS[1]:
|
|
x, y, w, h = draw_area
|
|
elements = []
|
|
if pil_logo: elements.append({'type': 'logo', 'data': pil_logo, 'height': pil_logo.height})
|
|
if block_a.lines: elements.append({'type': 'block', 'data': block_a, 'height': block_a.height})
|
|
if block_b.lines: elements.append({'type': 'block', 'data': block_b, 'height': block_b.height})
|
|
|
|
total_height = sum(el['height'] for el in elements) + max(0, len(elements) - 1) * spacing
|
|
y_start = y + (h - total_height) / 2
|
|
|
|
for el in elements:
|
|
if el['type'] == 'logo':
|
|
logo = el['data']
|
|
logo_x = x + (w - logo.width) / 2
|
|
draw_layer.paste(logo, (int(logo_x), int(y_start)), logo)
|
|
else:
|
|
self._draw_block(draw, el['data'], x + w/2, y_start, align='center', spacing=spacing)
|
|
y_start += el['height'] + spacing
|
|
|
|
elif layout == LAYOUT_OPTIONS[2]:
|
|
x, y, w, h = draw_area
|
|
center_x = x + w / 2
|
|
|
|
if block_b.lines:
|
|
y_b = y + padding
|
|
self._draw_vertical_text_block(draw_layer, block_b, center_x, y_b, spacing)
|
|
|
|
if block_a.lines:
|
|
rotated_height_a = block_a.width
|
|
y_a = y + h - padding - rotated_height_a
|
|
self._draw_vertical_text_block(draw_layer, block_a, center_x, y_a, spacing)
|
|
|
|
if pil_logo:
|
|
logo_x = center_x - pil_logo.width / 2
|
|
logo_y = y + (h - pil_logo.height) / 2
|
|
draw_layer.paste(pil_logo, (int(logo_x), int(logo_y)), pil_logo)
|
|
|
|
elif layout == LAYOUT_OPTIONS[3]:
|
|
x_top, y_top, w_top, h_top = draw_area_top
|
|
x_bot, y_bot, w_bot, h_bot = draw_area_bottom
|
|
|
|
if pil_logo:
|
|
total_top_width = pil_logo.width + spacing + block_a.width
|
|
start_x_top = x_top + (w_top - total_top_width) / 2
|
|
logo_x = start_x_top
|
|
logo_y = y_top + (h_top - pil_logo.height) / 2
|
|
draw_layer.paste(pil_logo, (int(logo_x), int(logo_y)), pil_logo)
|
|
block_a_x = start_x_top + pil_logo.width + spacing
|
|
self._draw_block(draw, block_a, block_a_x, y_top + (h_top - block_a.height) / 2, align='left', spacing=spacing)
|
|
else:
|
|
self._draw_block(draw, block_a, x_top + w_top / 2, y_top + (h_top - block_a.height) / 2, align='center', spacing=spacing)
|
|
|
|
self._draw_block(draw, block_b, x_bot + w_bot / 2, y_bot + (h_bot - block_b.height) / 2, align='center', spacing=spacing)
|
|
|
|
elif layout.startswith("5.") or layout.startswith("6.") or layout.startswith("7.") or layout.startswith("8.") or layout.startswith("9."):
|
|
x, y, w, h = draw_area
|
|
elements = []
|
|
if block_a.lines: elements.append({'type': 'block', 'data': block_a, 'height': block_a.height, 'width': block_a.width})
|
|
if block_b.lines: elements.append({'type': 'block', 'data': block_b, 'height': block_b.height, 'width': block_b.width})
|
|
if pil_logo: elements.append({'type': 'logo', 'data': pil_logo, 'height': pil_logo.height, 'width': pil_logo.width})
|
|
|
|
if elements:
|
|
total_height = sum(el['height'] for el in elements) + max(0, len(elements) - 1) * spacing
|
|
max_width = max(el['width'] for el in elements) if elements else 0
|
|
|
|
if "左下角" in layout: y_start, x_start, align = h - padding - total_height, padding, 'left'
|
|
elif "右下角" in layout: y_start, x_start, align = h - padding - total_height, w - padding, 'right'
|
|
elif "左上角" in layout: y_start, x_start, align = padding, padding, 'left'
|
|
elif "右上角" in layout: y_start, x_start, align = padding, w - padding, 'right'
|
|
else: y_start, x_start, align = (h - total_height) / 2, w / 2, 'center'
|
|
|
|
current_y = y_start
|
|
for el in elements:
|
|
el_width = el['width']
|
|
if el['type'] == 'logo':
|
|
logo = el['data']
|
|
if align == 'left': logo_x = x_start
|
|
elif align == 'right': logo_x = x_start - el_width
|
|
else: logo_x = x_start - el_width / 2
|
|
draw_layer.paste(logo, (int(logo_x), int(current_y)), logo)
|
|
else:
|
|
self._draw_block(draw, el['data'], x_start, current_y, align=align, spacing=spacing)
|
|
current_y += el['height'] + spacing
|
|
|
|
canvas.alpha_composite(draw_layer)
|
|
final_image = canvas.convert("RGB")
|
|
|
|
return (self.pil_to_tensor(final_image),)
|
|
|
|
# --- ComfyUI 节点注册 ---
|
|
NODE_CLASS_MAPPINGS = {
|
|
"CameraWatermarkNode": CameraWatermarkNode,
|
|
"ImageLoaderWithEXIF": ImageLoaderWithEXIF,
|
|
}
|
|
NODE_DISPLAY_NAME_MAPPINGS = {
|
|
"CameraWatermarkNode": "相机水印",
|
|
"ImageLoaderWithEXIF": "加载/附加 EXIF",
|
|
}
|