#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ 海报服务层 - 重构版本 封装核心功能，支持基于模板的动态内容生成和海报创建 """ import logging import uuid import time import json import importlib import base64 import binascii from io import BytesIO from typing import List, Dict, Any, Optional, Type, Union, cast, Tuple from datetime import datetime from pathlib import Path from PIL import Image from core.config import ConfigManager, PosterConfig from core.ai import AIAgent from utils.file_io import OutputManager from utils.image_processor import ImageProcessor from poster.templates.base_template import BaseTemplate from api.services.database_service import DatabaseService logger = logging.getLogger(__name__) class PosterService: """海报服务类""" def __init__(self, ai_agent: AIAgent, config_manager: ConfigManager, output_manager: OutputManager): """初始化海报服务""" self.ai_agent = ai_agent self.config_manager = config_manager self.output_manager = output_manager self.db_service = DatabaseService(config_manager) self._templates = {} self._template_instances = {} self._image_usage_tracker = {} self._init_templates() def _init_templates(self): """从数据库加载模板配置""" try: db_templates = self.db_service.get_active_poster_templates() if db_templates: self._templates = {t['id']: t for t in db_templates} logger.info(f"从数据库加载了 {len(self._templates)} 个模板") else: self._load_default_templates() logger.info("数据库无模板，使用默认模板配置") except Exception as e: logger.error(f"从数据库加载模板失败: {e}", exc_info=True) self._load_default_templates() def _load_default_templates(self): """加载默认模板配置""" self._templates = { 'vibrant': { 'id': 'vibrant', 'name': '活力风格', 'handler_path': 'poster.templates.vibrant_template', 'class_name': 'VibrantTemplate', 'description': '适合景点、活动等充满活力的场景', 'is_active': True }, 'business': { 'id': 'business', 'name': '商务风格', 'handler_path': 'poster.templates.business_template', 'class_name': 'BusinessTemplate', 'description': '适合酒店、房地产等商务场景', 'is_active': True } } def _load_template_handler(self, template_id: str) -> Optional[BaseTemplate]: """动态加载模板处理器""" if template_id not in self._templates: logger.error(f"未找到模板: {template_id}") return None # 如果已经实例化过，直接返回缓存的实例 if template_id in self._template_instances: return self._template_instances[template_id] template_info = self._templates[template_id] handler_path = template_info.get('handler_path') class_name = template_info.get('class_name') if not handler_path or not class_name: logger.error(f"模板 {template_id} 缺少 handler_path 或 class_name") return None try: # 动态导入模块和类 module = importlib.import_module(handler_path) template_class = getattr(module, class_name) # 实例化模板 template_instance = template_class() # 设置字体目录（如果配置了） from core.config import PosterConfig # poster_config = self.config_manager.get_config('poster', PosterConfig) # if poster_config: # font_dir = poster_config.font_dir # if font_dir and hasattr(template_instance, 'set_font_dir'): # template_instance.set_font_dir(font_dir) # 缓存实例以便重用 self._template_instances[template_id] = template_instance logger.info(f"成功加载模板处理器: {template_id} ({handler_path}.{class_name})") return template_instance except (ImportError, AttributeError) as e: logger.error(f"加载模板处理器失败: {e}", exc_info=True) return None def reload_templates(self): """重新加载模板信息""" logger.info("重新加载模板信息...") self._init_templates() # 清除缓存的模板实例，以便重新加载 self._template_instances = {} def get_available_templates(self) -> List[Dict[str, Any]]: """获取所有可用的模板信息""" result = [] for tid in self._templates: template = self._templates[tid] if template.get('is_active', True): # 默认为激活状态 template_info = { "id": template["id"], "name": template["name"], "description": template["description"], "handlerPath": template.get("handler_path", ""), "className": template.get("class_name", ""), "isActive": template.get("is_active", True) } result.append(template_info) return result def get_template_info(self, template_id: str) -> Optional[Dict[str, Any]]: """获取指定模板的简化信息""" template = self._templates.get(template_id) if not template: return None return { "id": template["id"], "name": template["name"], "description": template["description"], "has_prompts": bool(template.get("system_prompt") and template.get("user_prompt_template")), "input_format": template.get("input_format", {}), "output_format": template.get("output_format", {}), "is_active": template.get("is_active", False) } async def generate_poster(self, template_id: str, poster_content: Optional[Dict[str, Any]], content_id: Optional[str], product_id: Optional[str], scenic_spot_id: Optional[str], images_base64: Optional[List[str]] , num_variations: int = 1, force_llm_generation: bool = False, generate_psd: bool = False, psd_output_path: Optional[str] = None, generate_fabric_json: bool = False) -> Dict[str, Any]: """ 统一的海报生成入口 Args: template_id: 模板ID poster_content: 用户提供的海报内容（可选） content_id: 内容ID，用于从数据库获取内容（可选） product_id: 产品ID，用于从数据库获取产品信息（可选） scenic_spot_id: 景点ID，用于从数据库获取景点信息（可选） images_base64: 图片base64编码，用于生成海报（可选） num_variations: 需要生成的变体数量 force_llm_generation: 是否强制使用LLM生成内容 generate_psd: 是否生成PSD分层文件 psd_output_path: PSD文件输出路径（可选，默认自动生成） generate_fabric_json: 是否生成Fabric.js JSON格式 Returns: 生成结果字典，包含PNG图像和可选的PSD文件、Fabric.js JSON """ start_time = time.time() # 添加参数调试信息 logger.info("=" * 100) logger.info("海报生成服务 - 接收到的参数:") logger.info(f" template_id: {template_id} (类型: {type(template_id)})") logger.info(f" content_id: {content_id} (类型: {type(content_id)})") logger.info(f" product_id: {product_id} (类型: {type(product_id)})") logger.info(f" scenic_spot_id: {scenic_spot_id} (类型: {type(scenic_spot_id)})") logger.info(f" poster_content: {poster_content is not None}") logger.info(f" poster_content详细内容: {poster_content}") logger.info(f" force_llm_generation: {force_llm_generation}") logger.info("=" * 100) # 1. 动态加载模板处理器 template_handler = self._load_template_handler(template_id) if not template_handler: raise ValueError(f"无法为模板ID '{template_id}' 加载处理器。") # 2. 准备内容 (LLM或用户提供) final_content = poster_content if force_llm_generation or not final_content: logger.info(f"为模板 {template_id} 按需生成内容...") final_content = await self._generate_content_with_llm(template_id, content_id, product_id, scenic_spot_id, poster_content) if not final_content: raise ValueError("无法获取用于生成海报的内容") # # 3. 准备图片 # images = [] # if image_ids: # images = self.db_service.get_images_by_ids(image_ids) # if not images: # raise ValueError("无法获取指定的图片") # # 3. 图片解码 images = None # 获取模板的默认尺寸，如果获取不到则使用标准尺寸 template_size = getattr(template_handler, 'size', (900, 1200)) if images_base64 and images_base64.strip(): try: # 移除可能存在的MIME类型前缀 if images_base64.startswith("data:"): images_base64 = images_base64.split(",", 1)[1] # 彻底清理base64字符串 - 移除所有空白字符 images_base64 = ''.join(images_base64.split()) # 验证base64字符串长度（应该是4的倍数） if len(images_base64) % 4 != 0: # 添加必要的填充 images_base64 += '=' * (4 - len(images_base64) % 4) logger.info(f"为base64字符串添加了填充，最终长度: {len(images_base64)}") logger.info(f"准备解码base64数据，长度: {len(images_base64)}, 前20字符: {images_base64[:20]}...") # 解码base64 image_bytes = base64.b64decode(images_base64) logger.info(f"base64解码成功，图片数据大小: {len(image_bytes)} bytes") # 验证解码后的数据不为空 if len(image_bytes) == 0: raise ValueError("解码后的图片数据为空") # 检查文件头判断图片格式 file_header = image_bytes[:10] if file_header.startswith(b'\xff\xd8\xff'): logger.info("检测到JPEG格式图片") elif file_header.startswith(b'\x89PNG'): logger.info("检测到PNG格式图片") else: logger.warning(f"未识别的图片格式，文件头: {file_header.hex()}") # 创建PIL Image对象 image_io = BytesIO(image_bytes) images = Image.open(image_io) # 验证图片是否成功打开 images.verify() # 验证图片完整性 # 重新打开图片（verify后需要重新打开） image_io.seek(0) images = Image.open(image_io) logger.info(f"图片解码成功，格式: {images.format}, 尺寸: {images.size}, 模式: {images.mode}") except binascii.Error as e: logger.error(f"Base64解码失败: {e}") logger.error(f"问题数据长度: {len(images_base64) if 'images_base64' in locals() else 'unknown'}") # 创建一个与目标大小一致的透明底图 images = Image.new('RGBA', template_size, color=(0, 0, 0, 0)) logger.info(f"创建默认透明背景图，尺寸: {template_size}") except Exception as e: logger.error(f"图片处理失败: {e}") logger.error(f"错误类型: {type(e).__name__}") if 'image_bytes' in locals(): logger.error(f"图片数据大小: {len(image_bytes)} bytes, 前20字节: {image_bytes[:20].hex()}") # 创建一个与目标大小一致的透明底图 images = Image.new('RGBA', template_size, color=(0, 0, 0, 0)) logger.info(f"创建默认透明背景图，尺寸: {template_size}") else: logger.warning("未提供图片数据，使用默认透明背景图") # 创建一个与目标大小一致的透明底图 images = Image.new('RGBA', template_size, color=(0, 0, 0, 0)) logger.info(f"创建默认透明背景图，尺寸: {template_size}") # 4. 调用模板生成海报 try: posters = template_handler.generate( content=final_content, images=images, num_variations=num_variations ) if not posters: raise ValueError("模板未能生成有效的海报") # 5. 保存海报并返回结果 variations = [] psd_files = [] fabric_jsons = [] i=0 ## 用于多个海报时，指定海报的编号，此时只有一个没有用上，但是接口开放着。 output_path = self._save_poster(posters, template_id, i) if output_path: # 获取图像尺寸 image_size = [posters.width, posters.height] if hasattr(posters, 'width') else [1350, 1800] variations.append({ "id": f"{template_id}_v{i}", "image": self._image_to_base64(posters), "format": "PNG", "size": image_size, "file_path": str(output_path) }) # 6. 如果需要，生成PSD分层文件 if generate_psd: psd_result = self._generate_psd_file( template_handler, images, final_content, template_id, i, psd_output_path ) if psd_result: psd_files.append(psd_result) # 7. 如果需要，生成Fabric.js JSON if generate_fabric_json: fabric_json = self._generate_fabric_json(final_content, template_id, image_size, images) fabric_jsons.append(fabric_json) # 记录模板使用情况 self._update_template_stats(template_id, bool(variations), time.time() - start_time) return { "requestId": f"poster-{datetime.now().strftime('%Y%m%d-%H%M%S')}-{str(uuid.uuid4())[:8]}", "templateId": template_id, "resultImagesBase64": variations, "psdFiles": psd_files if psd_files else None, "fabricJsons": fabric_jsons if fabric_jsons else None, "metadata": { "generation_time": f"{time.time() - start_time:.2f}s", "model_used": self.ai_agent.config.model if force_llm_generation or not poster_content else None, "num_variations": len(variations), "psd_generated": bool(psd_files), "fabric_json_generated": bool(fabric_jsons) } } except Exception as e: logger.error(f"生成海报时发生错误: {e}", exc_info=True) self._update_template_stats(template_id, False, time.time() - start_time) raise ValueError(f"生成海报失败: {str(e)}") def _save_poster(self, poster: Image.Image, template_id: str, variation_id: int=1) -> Optional[Path]: """保存海报到文件系统""" try: # 创建唯一的主题ID用于保存 topic_id = f"poster_{template_id}_{datetime.now().strftime('%Y%m%d_%H%M%S')}" # 获取输出目录 output_dir = self.output_manager.get_topic_dir(topic_id) # 生成文件名 file_name = f"{template_id}_v{variation_id}.png" file_path = output_dir / file_name # 保存图像 poster.save(file_path, format="PNG") logger.info(f"海报已保存: {file_path}") return file_path except Exception as e: logger.error(f"保存海报失败: {e}", exc_info=True) return None def _image_to_base64(self, image: Image.Image) -> str: """将PIL图像转换为base64字符串""" buffer = BytesIO() image.save(buffer, format="PNG") return base64.b64encode(buffer.getvalue()).decode('utf-8') def _update_template_stats(self, template_id: str, success: bool, duration: float): """更新模板使用统计""" try: # 调用数据库服务的方法更新统计 self.db_service.update_template_usage_stats( template_id=template_id, success=success, processing_time=duration ) except Exception as e: logger.warning(f"更新模板统计失败: {e}") async def _generate_content_with_llm(self, template_id: str, content_id: Optional[str], product_id: Optional[str], scenic_spot_id: Optional[str], poster_content: Optional[Any] = None) -> Optional[Dict[str, Any]]: """使用LLM生成海报内容""" # 获取提示词 - 直接从数据库模板信息中获取 template_info = self._templates.get(template_id, {}) system_prompt = template_info.get('system_prompt', "") user_prompt_template = template_info.get('user_prompt_template', "") if not system_prompt or not user_prompt_template: logger.error(f"模板 {template_id} 缺少提示词配置") logger.debug(f"模板信息: {template_info}") return None logger.info(f"成功加载模板 {template_id} 的提示词配置") # 获取相关数据 - 将字符串ID转换为整数 data = {} def safe_int_convert(id_str: Optional[str]) -> Optional[int]: """安全将字符串ID转换为整数，避免大整数精度丢失""" if not id_str: return None try: # 去除前后空格 id_str = id_str.strip() # 如果ID包含非数字字符，只提取数字部分或返回None if id_str.isdigit(): # 直接转换纯数字字符串，避免精度丢失 converted_id = int(id_str) logger.debug(f"成功转换ID: {id_str} -> {converted_id}") return converted_id else: # 对于类似 "generated_note_1753693091224_0" 的ID，提取数字部分 import re numbers = re.findall(r'\d+', id_str) if numbers: # 使用第一个数字序列，但要验证它是有效的大整数 first_number = numbers[0] converted_id = int(first_number) logger.debug(f"从复合ID中提取数字: {id_str} -> {converted_id}") return converted_id logger.warning(f"无法从ID中提取有效数字: {id_str}") return None except (ValueError, TypeError, OverflowError) as e: logger.error(f"无法转换ID为整数: {id_str}, 类型: {type(id_str)}, 错误: {e}") return None # 添加详细的数据获取调试信息 logger.info(f"开始获取数据 - content_id: {content_id}, product_id: {product_id}, scenic_spot_id: {scenic_spot_id}") if content_id: logger.info(f"处理content_id: {content_id} (类型: {type(content_id)})") # content_id直接用字符串查询，不需要转换 content_data = self.db_service.get_content_by_id(content_id) logger.info(f"从数据库获取的content数据: {content_data is not None}") if content_data: logger.info(f"content数据预览: {list(content_data.keys()) if isinstance(content_data, dict) else type(content_data)}") data['content'] = content_data else: logger.info("未提供content_id") if product_id: logger.info(f"处理product_id: {product_id} (类型: {type(product_id)})") product_id_int = safe_int_convert(product_id) logger.info(f"转换后的product_id_int: {product_id_int}") if product_id_int: product_data = self.db_service.get_product_by_id(product_id_int) logger.info(f"从数据库获取的product数据: {product_data is not None}") if product_data: logger.info(f"product数据预览: {list(product_data.keys()) if isinstance(product_data, dict) else type(product_data)}") data['product'] = product_data else: logger.warning(f"product_id转换失败: {product_id}") else: logger.info("未提供product_id") if scenic_spot_id: logger.info(f"处理scenic_spot_id: {scenic_spot_id} (类型: {type(scenic_spot_id)})") scenic_spot_id_int = safe_int_convert(scenic_spot_id) logger.info(f"转换后的scenic_spot_id_int: {scenic_spot_id_int}") if scenic_spot_id_int: scenic_spot_data = self.db_service.get_scenic_spot_by_id(scenic_spot_id_int) logger.info(f"从数据库获取的scenic_spot数据: {scenic_spot_data is not None}") if scenic_spot_data: logger.info(f"scenic_spot数据预览: {list(scenic_spot_data.keys()) if isinstance(scenic_spot_data, dict) else type(scenic_spot_data)}") data['scenic_spot'] = scenic_spot_data else: logger.warning(f"scenic_spot_id转换失败: {scenic_spot_id}") else: logger.info("未提供scenic_spot_id") logger.info(f"获取到的数据: content={data.get('content') is not None}, product={data.get('product') is not None}, scenic_spot={data.get('scenic_spot') is not None}") # 格式化数据为简洁的文本格式，参考其他模块的做法 try: logger.info("开始格式化数据...") # 景区信息格式化 scenic_info = "无相关景区信息" if data.get('scenic_spot'): logger.info("正在格式化景区信息...") spot = data['scenic_spot'] scenic_info = f"""景区名称: {spot.get('name', '')} 地址: {spot.get('address', '')} 描述: {spot.get('description', '')} 优势: {spot.get('advantage', '')} 亮点: {spot.get('highlight', '')} 交通信息: {spot.get('trafficInfo', '')}""" logger.info("景区信息格式化完成") # 产品信息格式化 product_info = "无相关产品信息" if data.get('product'): logger.info("正在格式化产品信息...") product = data['product'] product_info = f"""产品名称: {product.get('productName', '')} 原价: {product.get('originPrice', '')} 实际价格: {product.get('realPrice', '')} 套餐信息: {product.get('packageInfo', '')} 核心优势: {product.get('keyAdvantages', '')} 亮点: {product.get('highlights', '')} 详细描述: {product.get('detailedDescription', '')}""" logger.info("产品信息格式化完成") # 内容信息格式化 - 优先使用poster_content tweet_info = "无相关内容信息" if poster_content is not None: logger.info(f"使用poster_content作为文章内容，类型: {type(poster_content)}") if isinstance(poster_content, str): tweet_info = f"文章内容: {poster_content}" elif isinstance(poster_content, dict): tweet_info = f"文章内容: {str(poster_content)}" else: tweet_info = f"文章内容: {str(poster_content)}" logger.info(f"poster_content格式化完成，长度: {len(tweet_info)}") elif data.get('content'): logger.info("正在格式化数据库内容信息...") content = data['content'] tweet_info = f"""标题: {content.get('title', '')} 内容: {content.get('content', '')}""" logger.info("数据库内容信息格式化完成") logger.info("开始构建用户提示词...") # 构建用户提示词 user_prompt = user_prompt_template.format( scenic_info=scenic_info, product_info=product_info, tweet_info=tweet_info ) logger.info(f"用户提示词构建成功，长度: {len(user_prompt)}") # 输出系统提示词和用户提示词内容以供调试 logger.info("=" * 80) logger.info("系统提示词内容:") logger.info(system_prompt) logger.info("=" * 80) logger.info("用户提示词内容:") logger.info(user_prompt) logger.info("=" * 80) except Exception as e: logger.error(f"格式化提示词时发生错误: {e}", exc_info=True) # 提供兜底方案 user_prompt = f"""{user_prompt_template} 当前可用数据: - 景区信息: {'有' if data.get('scenic_spot') else '无'} - 产品信息: {'有' if data.get('product') else '无'} - 内容信息: {'有' if data.get('content') else '无'} 请根据可用信息生成海报内容。""" try: response, _, _, _ = await self.ai_agent.generate_text( system_prompt=system_prompt, user_prompt=user_prompt, use_stream=True ) # 提取JSON响应 json_start = response.find('{') json_end = response.rfind('}') + 1 if json_start != -1 and json_end != -1: result = json.loads(response[json_start:json_end]) logger.info(f"LLM生成内容成功: {list(result.keys())}") return result else: logger.error(f"LLM响应中未找到JSON格式内容: {response[:200]}...") return None except json.JSONDecodeError as e: logger.error(f"解析LLM响应JSON失败: {e}") return None except Exception as e: logger.error(f"生成内容时发生错误: {e}", exc_info=True) return None def _generate_psd_file(self, template_handler: BaseTemplate, images: Image.Image, content: Dict[str, Any], template_id: str, variation_id: int, custom_output_path: Optional[str] = None) -> Optional[Dict[str, Any]]: """ 生成Fabric.js JSON文件（保持接口兼容性，实际生成JSON而非PSD） Args: template_handler: 模板处理器实例 images: 图像数据 content: 海报内容 template_id: 模板ID variation_id: 变体ID custom_output_path: 自定义输出路径 Returns: JSON文件信息字典，包含文件路径、base64编码等 """ try: # 获取图像尺寸 image_size = [images.width, images.height] if hasattr(images, 'width') else [900, 1200] # 生成Fabric.js JSON数据 fabric_json = self._generate_fabric_json(content, template_id, image_size, images) # 生成JSON文件路径 if custom_output_path: json_filename = custom_output_path if not json_filename.endswith('.json'): json_filename += '.json' else: timestamp = datetime.now().strftime('%Y%m%d_%H%M%S') json_filename = f"{template_id}_fabric_v{variation_id}_{timestamp}.json" # 获取输出目录 topic_id = f"poster_{template_id}_{datetime.now().strftime('%Y%m%d_%H%M%S')}" output_dir = self.output_manager.get_topic_dir(topic_id) json_path = output_dir / json_filename # 保存JSON文件 logger.info(f"开始生成Fabric.js JSON文件: {json_path}") try: with open(json_path, 'w', encoding='utf-8') as f: json.dump(fabric_json, f, ensure_ascii=False, indent=2) logger.info(f"Fabric.js JSON文件保存成功: {json_path}") except Exception as e: logger.error(f"保存JSON文件失败: {e}") return None # 获取文件信息 file_size = Path(json_path).stat().st_size # 生成JSON的base64编码 json_base64 = None try: json_string = json.dumps(fabric_json, ensure_ascii=False) json_base64 = base64.b64encode(json_string.encode('utf-8')).decode('utf-8') except Exception as e: logger.warning(f"生成JSON base64编码失败: {e}") logger.info(f"Fabric.js JSON文件生成成功: {json_path} ({file_size/1024:.1f}KB)") return { "id": f"{template_id}_v{variation_id}_fabric", "filename": json_filename, "data": json_base64, "size": file_size, "format": "JSON", "json_data": fabric_json # 添加原始JSON数据 } except Exception as e: logger.error(f"生成Fabric.js JSON文件时发生错误: {e}", exc_info=True) return None def _get_json_object_count(self, json_path: str) -> Optional[int]: """获取Fabric.js JSON文件的对象数量""" try: with open(json_path, 'r', encoding='utf-8') as f: fabric_data = json.load(f) return len(fabric_data.get('objects', [])) except Exception as e: logger.warning(f"获取JSON对象数量失败: {e}") return None def _generate_fabric_json(self, content: Dict[str, Any], template_id: str, image_size: List[int], images: Image.Image = None) -> Dict[str, Any]: """ 生成与VibrantTemplate视觉效果一致的Fabric.js JSON格式 Args: content: 海报内容数据 template_id: 模板ID image_size: 图像尺寸 [width, height] images: 用户上传的图片 Returns: Dict: 扁平化的Fabric.js JSON格式数据 """ try: fabric_objects = [] # 基础画布尺寸（VibrantTemplate使用900x1200，最终resize到1350x1800） canvas_width, canvas_height = image_size[0], image_size[1] # 计算缩放比例以匹配VibrantTemplate的最终输出 scale_ratio = min(canvas_width / 900, canvas_height / 1200) # 1. 用户上传的图片（最底层 - Level 0） if images and hasattr(images, 'width'): image_object = self._create_vibrant_image_object(images, canvas_width, canvas_height) fabric_objects.append(image_object) else: # 占位符 placeholder_object = self._create_placeholder_object(canvas_width, canvas_height) fabric_objects.append(placeholder_object) # 2. 毛玻璃渐变背景（Level 1） gradient_start = self._calculate_gradient_start_position(canvas_height) gradient_object = self._create_gradient_background_object(canvas_width, canvas_height, gradient_start) fabric_objects.append(gradient_object) # 3. VibrantTemplate风格的文字布局（Level 2） text_objects = self._create_vibrant_text_objects(content, canvas_width, canvas_height, gradient_start, scale_ratio) fabric_objects.extend(text_objects) # 构建完整的Fabric.js JSON fabric_json = { "version": "5.3.0", "objects": fabric_objects, "background": "transparent", "backgroundImage": None, "overlayImage": None, "clipPath": None, "width": canvas_width, "height": canvas_height, "viewportTransform": [1, 0, 0, 1, 0, 0], "backgroundVpt": True, "overlayVpt": True, "selection": True, "preserveObjectStacking": True, "snapAngle": 0, "snapThreshold": 10, "centeredScaling": False, "centeredRotation": True, "interactive": True, "skipTargetFind": False, "enableRetinaScaling": True, "imageSmoothingEnabled": True, "perPixelTargetFind": False, "targetFindTolerance": 0, "skipOffscreen": True, "includeDefaultValues": True } logger.info(f"成功生成扁平化Fabric.js JSON，包含 {len(fabric_objects)} 个独立对象") return fabric_json except Exception as e: logger.error(f"生成Fabric.js JSON失败: {e}") return { "version": "5.3.0", "objects": [], "background": "transparent", "width": image_size[0], "height": image_size[1] } def _create_image_object(self, images: Image.Image, canvas_width: int, canvas_height: int) -> Dict[str, Any]: """创建用户上传的图片对象（最底层）""" # 将PIL图像转换为base64 image_base64 = self._image_to_base64(images) # 计算图片的缩放比例，保持宽高比 image_width, image_height = images.width, images.height scale_x = canvas_width / image_width scale_y = canvas_height / image_height scale = min(scale_x, scale_y) # 保持宽高比的适应缩放 # 计算居中位置 scaled_width = image_width * scale scaled_height = image_height * scale left = (canvas_width - scaled_width) / 2 top = (canvas_height - scaled_height) / 2 return { "type": "image", "version": "5.3.0", "originX": "left", "originY": "top", "left": left, "top": top, "width": image_width, "height": image_height, "scaleX": scale, "scaleY": scale, "angle": 0, "flipX": False, "flipY": False, "opacity": 1, "visible": True, "src": f"data:image/png;base64,{image_base64}", "crossOrigin": "anonymous", "name": "user_uploaded_image", "data": { "type": "user_image", "layer": "image", "level": 0, "replaceable": True, "original_size": [image_width, image_height], "scale_ratio": scale }, "selectable": True, "evented": True } def _create_placeholder_object(self, canvas_width: int, canvas_height: int) -> Dict[str, Any]: """创建图片占位符对象""" return { "type": "rect", "version": "5.3.0", "originX": "left", "originY": "top", "left": 0, "top": 0, "width": canvas_width, "height": canvas_height, "fill": "#f8f9fa", "stroke": "#dee2e6", "strokeWidth": 2, "strokeDashArray": [10, 5], "angle": 0, "flipX": False, "flipY": False, "opacity": 1, "visible": True, "name": "image_placeholder", "data": { "type": "placeholder", "layer": "image", "level": 0, "replaceable": True, "placeholder_text": "点击上传图片" }, "selectable": True, "evented": True } def _create_background_object(self, canvas_width: int, canvas_height: int) -> Dict[str, Any]: """创建半透明背景对象""" return { "type": "rect", "version": "5.3.0", "originX": "left", "originY": "top", "left": 0, "top": 0, "width": canvas_width, "height": canvas_height, "fill": "rgba(255, 255, 255, 0.8)", "stroke": None, "angle": 0, "flipX": False, "flipY": False, "opacity": 0.8, "visible": True, "name": "background_overlay", "data": { "type": "background", "layer": "background", "level": 1 }, "selectable": False, "evented": False } def _create_text_objects(self, content: Dict[str, Any], canvas_width: int, canvas_height: int) -> List[Dict[str, Any]]: """创建文本对象列表""" text_objects = [] # 文本元素配置 text_configs = { 'title': {'fontSize': 48, 'top': 100, 'fontWeight': 'bold', 'fill': '#2c3e50'}, 'slogan': {'fontSize': 24, 'top': 180, 'fontWeight': 'normal', 'fill': '#7f8c8d'}, 'content': {'fontSize': 18, 'top': 250, 'fontWeight': 'normal', 'fill': '#34495e'}, 'price': {'fontSize': 36, 'top': 400, 'fontWeight': 'bold', 'fill': '#e74c3c'}, 'remarks': {'fontSize': 14, 'top': 500, 'fontWeight': 'normal', 'fill': '#95a5a6'} } for key, config in text_configs.items(): if key in content and content[key]: text_content = content[key] if isinstance(text_content, list): text_content = '\n'.join(text_content) elif not isinstance(text_content, str): text_content = str(text_content) text_object = { "type": "textbox", "version": "5.3.0", "originX": "left", "originY": "top", "left": 50, "top": config['top'], "width": canvas_width - 100, "height": 60 if key != 'content' else 120, "fill": config['fill'], "fontFamily": "Arial, sans-serif", "fontWeight": config['fontWeight'], "fontSize": config['fontSize'], "text": text_content, "textAlign": "center" if key in ['title', 'slogan', 'price'] else "left", "lineHeight": 1.2, "angle": 0, "flipX": False, "flipY": False, "opacity": 1, "visible": True, "name": f"text_{key}", "data": { "type": "text", "layer": "content", "level": 2, "content_type": key, "priority": "high" if key in ['title', 'price'] else "medium" }, "selectable": True, "evented": True } text_objects.append(text_object) return text_objects def _create_decoration_objects(self, canvas_width: int, canvas_height: int) -> List[Dict[str, Any]]: """创建装饰对象列表""" decoration_objects = [] # 装饰边框 border_object = { "type": "rect", "version": "5.3.0", "originX": "left", "originY": "top", "left": 20, "top": 20, "width": canvas_width - 40, "height": canvas_height - 40, "fill": "transparent", "stroke": "#3498db", "strokeWidth": 3, "strokeDashArray": [10, 5], "angle": 0, "flipX": False, "flipY": False, "opacity": 1, "visible": True, "name": "decoration_border", "data": { "type": "decoration", "layer": "decoration", "level": 3 }, "selectable": False, "evented": False } decoration_objects.append(border_object) # 角落装饰 corner_object = { "type": "circle", "version": "5.3.0", "originX": "center", "originY": "center", "left": canvas_width - 50, "top": 50, "radius": 20, "fill": "#f39c12", "angle": 0, "flipX": False, "flipY": False, "opacity": 1, "visible": True, "name": "corner_decoration", "data": { "type": "decoration", "layer": "decoration", "level": 3 }, "selectable": False, "evented": False } decoration_objects.append(corner_object) return decoration_objects def _calculate_gradient_start_position(self, canvas_height: int) -> int: """计算毛玻璃渐变开始位置（模拟VibrantTemplate的逻辑）""" # VibrantTemplate中大约从画布的60%位置开始渐变 return int(canvas_height * 0.6) def _create_vibrant_image_object(self, images: Image.Image, canvas_width: int, canvas_height: int) -> Dict[str, Any]: """创建VibrantTemplate风格的图片对象""" # 将PIL图像转换为base64 image_base64 = self._image_to_base64(images) # VibrantTemplate将图片resize到画布大小 return { "type": "image", "version": "5.3.0", "originX": "left", "originY": "top", "left": 0, "top": 0, "width": images.width, "height": images.height, "scaleX": canvas_width / images.width, "scaleY": canvas_height / images.height, "angle": 0, "flipX": False, "flipY": False, "opacity": 1, "visible": True, "src": f"data:image/png;base64,{image_base64}", "crossOrigin": "anonymous", "name": "background_image", "data": { "type": "background_image", "layer": "image", "level": 0, "replaceable": True }, "selectable": True, "evented": True } def _create_gradient_background_object(self, canvas_width: int, canvas_height: int, gradient_start: int) -> Dict[str, Any]: """创建模拟毛玻璃效果的渐变背景（简化版本，提高兼容性）""" return { "type": "rect", "version": "5.3.0", "originX": "left", "originY": "top", "left": 0, "top": gradient_start, "width": canvas_width, "height": canvas_height - gradient_start, "fill": "rgba(0, 50, 120, 0.6)", # 简化为单一颜色，提高兼容性 "stroke": "", "strokeWidth": 0, "angle": 0, "flipX": False, "flipY": False, "opacity": 0.8, "visible": True, "name": "glass_gradient", "data": { "type": "glass_effect", "layer": "background", "level": 1 }, "selectable": False, "evented": False } def _create_vibrant_text_objects(self, content: Dict[str, Any], canvas_width: int, canvas_height: int, gradient_start: int, scale_ratio: float) -> List[Dict[str, Any]]: """创建VibrantTemplate风格的文字对象（复用VibrantTemplate的精确计算）""" text_objects = [] # 复用VibrantTemplate的边距计算逻辑 left_margin, right_margin = self._calculate_vibrant_content_margins(content, canvas_width, canvas_width // 2) content_width = right_margin - left_margin # 标题位置和样式（使用VibrantTemplate的精确参数） title_y = gradient_start + int(40 * scale_ratio) if title := content.get("title"): # 使用VibrantTemplate的精确计算：目标宽度为内容区域的98%，字体范围40-140 title_target_width = int(content_width * 0.98) title_size, title_actual_width = self._calculate_vibrant_font_size_precise( title, title_target_width, min_size=40, max_size=140 ) # 居中计算，与VibrantTemplate一致 title_x = canvas_width // 2 - title_actual_width // 2 title_obj = { "type": "textbox", "version": "5.3.0", "originX": "left", # 改为left，使用计算的x位置 "originY": "top", "left": title_x, "top": title_y, "width": title_actual_width, "height": title_size + 20, "fill": "#ffffff", "stroke": "#001e50", "strokeWidth": 4, # 与VibrantTemplate一致的描边宽度 "fontFamily": "Arial Black, sans-serif", "fontWeight": "bold", "fontSize": title_size, "text": title, "textAlign": "center", "lineHeight": 1.1, "name": "vibrant_title", "data": { "type": "title", "layer": "content", "level": 2, "style": "vibrant_title", "target_width": title_target_width, "actual_width": title_actual_width }, "selectable": True, "evented": True } text_objects.append(title_obj) # 添加标题下方装饰线（与VibrantTemplate一致） line_y = title_y + title_size + 5 line_start_x = title_x - title_actual_width * 0.025 line_end_x = title_x + title_actual_width * 1.025 decoration_line = { "type": "line", "version": "5.3.0", "originX": "center", "originY": "center", "left": (line_start_x + line_end_x) / 2, "top": line_y, "x1": line_start_x - (line_start_x + line_end_x) / 2, "y1": 0, "x2": line_end_x - (line_start_x + line_end_x) / 2, "y2": 0, "stroke": "rgba(215, 215, 215, 0.3)", "strokeWidth": 3, "name": "title_decoration_line", "data": { "type": "decoration", "layer": "content", "level": 2 }, "selectable": False, "evented": False } text_objects.append(decoration_line) # 副标题位置和样式（使用VibrantTemplate的精确参数） subtitle_y = title_y + int(100 * scale_ratio) if slogan := content.get("slogan"): # 使用VibrantTemplate的精确计算：目标宽度为内容区域的95%，字体范围20-75 subtitle_target_width = int(content_width * 0.95) subtitle_size, subtitle_actual_width = self._calculate_vibrant_font_size_precise( slogan, subtitle_target_width, min_size=20, max_size=75 ) # 居中计算，与VibrantTemplate一致 subtitle_x = canvas_width // 2 - subtitle_actual_width // 2 subtitle_obj = { "type": "textbox", "version": "5.3.0", "originX": "left", # 改为left，使用计算的x位置 "originY": "top", "left": subtitle_x, "top": subtitle_y, "width": subtitle_actual_width, "height": subtitle_size + 15, "fill": "#ffffff", "shadow": "rgba(0, 0, 0, 0.7) 2px 2px 5px", "fontFamily": "Arial, sans-serif", "fontWeight": "normal", "fontSize": subtitle_size, "text": slogan, "textAlign": "center", "lineHeight": 1.2, "name": "vibrant_slogan", "data": { "type": "slogan", "layer": "content", "level": 2, "style": "vibrant_subtitle", "target_width": subtitle_target_width, "actual_width": subtitle_actual_width }, "selectable": True, "evented": True } text_objects.append(subtitle_obj) # 双栏布局（使用VibrantTemplate的精确边距） column_start_y = subtitle_y + int(80 * scale_ratio) left_column_width = int(content_width * 0.5) right_column_x = left_margin + left_column_width # 左栏：内容按钮和项目列表 left_objects = self._create_left_column_objects(content, left_margin, column_start_y, left_column_width, scale_ratio) text_objects.extend(left_objects) # 右栏：价格和票种信息（使用VibrantTemplate的精确参数） right_objects = self._create_right_column_objects_precise(content, right_column_x, column_start_y, right_margin, scale_ratio) text_objects.extend(right_objects) # 底部标签和分页 footer_objects = self._create_footer_objects(content, left_margin, canvas_height - int(30 * scale_ratio), content_width, scale_ratio) text_objects.extend(footer_objects) return text_objects def _calculate_vibrant_font_size(self, text: str, target_width: int, min_size: int, max_size: int, scale_ratio: float) -> int: """计算VibrantTemplate风格的字体大小""" # 简化的字体大小计算，基于文本长度和目标宽度 char_count = len(text) if char_count == 0: return int(min_size * scale_ratio) # 估算字符宽度（中文字符按1.5倍计算） avg_char_width = target_width / max(1, char_count * 1.2) estimated_font_size = int(avg_char_width * 0.8) # 应用缩放比例并限制在范围内 scaled_size = int(estimated_font_size * scale_ratio) return max(int(min_size * scale_ratio), min(int(max_size * scale_ratio), scaled_size)) def _create_left_column_objects(self, content: Dict[str, Any], x: int, y: int, width: int, scale_ratio: float) -> List[Dict[str, Any]]: """创建左栏对象：按钮和项目列表""" objects = [] # 内容按钮 button_text = content.get("content_button", "套餐内容") button_width = min(width - 20, int(len(button_text) * 20 * scale_ratio + 40)) button_height = int(50 * scale_ratio) # 按钮背景 button_bg = { "type": "rect", "version": "5.3.0", "originX": "left", "originY": "top", "left": x, "top": y, "width": button_width, "height": button_height, "fill": "rgba(0, 140, 210, 0.7)", "stroke": "#ffffff", "strokeWidth": 1, "rx": 20, "ry": 20, "name": "content_button_bg", "data": {"type": "button", "layer": "content", "level": 2}, "selectable": False, "evented": False } objects.append(button_bg) # 按钮文字 button_text_obj = { "type": "textbox", "version": "5.3.0", "originX": "center", "originY": "center", "left": x + button_width / 2, "top": y + button_height / 2, "width": button_width - 20, "height": button_height, "fill": "#ffffff", "fontFamily": "Arial, sans-serif", "fontWeight": "bold", "fontSize": int(30 * scale_ratio), "text": button_text, "textAlign": "center", "name": "content_button_text", "data": {"type": "button_text", "layer": "content", "level": 2}, "selectable": True, "evented": True } objects.append(button_text_obj) # 项目列表 items = content.get("content_items", []) list_y = y + button_height + int(20 * scale_ratio) font_size = int(28 * scale_ratio) line_spacing = int(36 * scale_ratio) for i, item in enumerate(items): item_obj = { "type": "textbox", "version": "5.3.0", "originX": "left", "originY": "top", "left": x, "top": list_y + i * line_spacing, "width": width, "height": font_size + 10, "fill": "#ffffff", "fontFamily": "Arial, sans-serif", "fontWeight": "normal", "fontSize": font_size, "text": f"• {item}", "textAlign": "left", "name": f"content_item_{i}", "data": {"type": "content_item", "layer": "content", "level": 2}, "selectable": True, "evented": True } objects.append(item_obj) return objects def _create_right_column_objects(self, content: Dict[str, Any], x: int, y: int, right_margin: int, scale_ratio: float) -> List[Dict[str, Any]]: """创建右栏对象：价格和票种""" objects = [] column_width = right_margin - x # 价格 if price := content.get("price"): price_size = self._calculate_vibrant_font_size(str(price), column_width * 0.7, 40, 120, scale_ratio) price_obj = { "type": "textbox", "version": "5.3.0", "originX": "right", "originY": "top", "left": right_margin, "top": y, "width": column_width, "height": price_size + 20, "fill": "#ffffff", "shadow": "rgba(0, 0, 0, 0.7) 2px 2px 5px", "fontFamily": "Arial Black, sans-serif", "fontWeight": "bold", "fontSize": price_size, "text": f"¥{price}", "textAlign": "right", "name": "vibrant_price", "data": {"type": "price", "layer": "content", "level": 2}, "selectable": True, "evented": True } objects.append(price_obj) # 价格下划线 underline_y = y + price_size + int(18 * scale_ratio) underline = { "type": "line", "version": "5.3.0", "originX": "center", "originY": "center", "left": right_margin - column_width * 0.5, "top": underline_y, "x1": -column_width * 0.4, "y1": 0, "x2": column_width * 0.4, "y2": 0, "stroke": "rgba(255, 255, 255, 0.3)", "strokeWidth": 2, "name": "price_underline", "data": {"type": "decoration", "layer": "content", "level": 2}, "selectable": False, "evented": False } objects.append(underline) # 票种 if ticket_type := content.get("ticket_type"): ticket_y = y + price_size + int(35 * scale_ratio) ticket_size = self._calculate_vibrant_font_size(ticket_type, column_width * 0.7, 30, 60, scale_ratio) ticket_obj = { "type": "textbox", "version": "5.3.0", "originX": "right", "originY": "top", "left": right_margin, "top": ticket_y, "width": column_width, "height": ticket_size + 10, "fill": "#ffffff", "shadow": "rgba(0, 0, 0, 0.5) 1px 1px 3px", "fontFamily": "Arial, sans-serif", "fontWeight": "normal", "fontSize": ticket_size, "text": ticket_type, "textAlign": "right", "name": "ticket_type", "data": {"type": "ticket_type", "layer": "content", "level": 2}, "selectable": True, "evented": True } objects.append(ticket_obj) return objects def _create_footer_objects(self, content: Dict[str, Any], x: int, y: int, width: int, scale_ratio: float) -> List[Dict[str, Any]]: """创建底部对象：标签和分页""" objects = [] font_size = int(18 * scale_ratio) # 左侧标签 if tag := content.get("tag"): tag_obj = { "type": "textbox", "version": "5.3.0", "originX": "left", "originY": "top", "left": x, "top": y, "width": width // 2, "height": font_size + 5, "fill": "#ffffff", "fontFamily": "Arial, sans-serif", "fontWeight": "normal", "fontSize": font_size, "text": tag, "textAlign": "left", "name": "footer_tag", "data": {"type": "tag", "layer": "content", "level": 2}, "selectable": True, "evented": True } objects.append(tag_obj) # 右侧分页 if pagination := content.get("pagination"): pagination_obj = { "type": "textbox", "version": "5.3.0", "originX": "right", "originY": "top", "left": x + width, "top": y, "width": width // 2, "height": font_size + 5, "fill": "#ffffff", "fontFamily": "Arial, sans-serif", "fontWeight": "normal", "fontSize": font_size, "text": pagination, "textAlign": "right", "name": "footer_pagination", "data": {"type": "pagination", "layer": "content", "level": 2}, "selectable": True, "evented": True } objects.append(pagination_obj) return objects def _calculate_vibrant_content_margins(self, content: Dict[str, Any], width: int, center_x: int) -> Tuple[int, int]: """复用VibrantTemplate的边距计算逻辑""" # 计算标题位置 title_text = content.get("title", "") title_target_width = int(width * 0.95) title_size, title_width = self._calculate_vibrant_font_size_precise( title_text, title_target_width, min_size=40, max_size=130 ) title_x = center_x - title_width // 2 # 计算副标题位置 slogan_text = content.get("slogan", "") subtitle_target_width = int(width * 0.9) subtitle_size, subtitle_width = self._calculate_vibrant_font_size_precise( slogan_text, subtitle_target_width, max_size=50, min_size=20 ) subtitle_x = center_x - subtitle_width // 2 # 计算内容区域边距 - 与VibrantTemplate一致 padding = 20 content_left_margin = min(title_x, subtitle_x) - padding content_right_margin = max(title_x + title_width, subtitle_x + subtitle_width) + padding # 确保边距不超出合理范围 content_left_margin = max(40, content_left_margin) content_right_margin = min(width - 40, content_right_margin) # 如果内容区域太窄，强制使用更宽的区域 min_content_width = int(width * 0.75) # 至少使用75%的宽度 current_width = content_right_margin - content_left_margin if current_width < min_content_width: extra_width = min_content_width - current_width content_left_margin = max(30, content_left_margin - extra_width // 2) content_right_margin = min(width - 30, content_right_margin + extra_width // 2) return content_left_margin, content_right_margin def _calculate_vibrant_font_size_precise(self, text: str, target_width: int, min_size: int = 10, max_size: int = 120) -> Tuple[int, int]: """复用VibrantTemplate的精确字体大小计算算法""" if not text: return min_size, 0 # 简化的二分查找算法，估算字体大小 tolerance = 0.08 # 容差值 # 使用字符估算来模拟精确计算 avg_char_width_factor = { '中': 1.5, # 中文字符通常比英文宽 '英': 0.6, # 英文字符相对较窄 } # 分析文本，统计中英文字符 chinese_chars = sum(1 for char in text if '\u4e00' <= char <= '\u9fff') english_chars = len(text) - chinese_chars # 估算平均字符宽度 estimated_char_width = (chinese_chars * avg_char_width_factor['中'] + english_chars * avg_char_width_factor['英']) / max(1, len(text)) # 二分查找最佳字体大小 low = min_size high = max_size best_size = min_size best_width = 0 for _ in range(20): # 限制迭代次数 mid = (low + high) // 2 # 估算当前字体大小下的文本宽度 estimated_width = len(text) * estimated_char_width * mid * 0.6 # 检查是否在容差范围内 if target_width * (1 - tolerance) <= estimated_width <= target_width * (1 + tolerance): best_size = mid best_width = int(estimated_width) break if estimated_width < target_width: if estimated_width > best_width: best_width = int(estimated_width) best_size = mid low = mid + 1 else: high = mid - 1 # 确保在范围内 best_size = max(min_size, min(max_size, best_size)) # 重新计算最终宽度 final_width = int(len(text) * estimated_char_width * best_size * 0.6) logger.info(f"精确字体计算 - 文本:'{text[:10]}...', 目标宽度:{target_width}, 字体大小:{best_size}, 实际宽度:{final_width}") return best_size, final_width def _create_right_column_objects_precise(self, content: Dict[str, Any], x: int, y: int, right_margin: int, scale_ratio: float) -> List[Dict[str, Any]]: """创建右栏对象（使用VibrantTemplate的精确价格计算）""" objects = [] column_width = right_margin - x # 价格（使用VibrantTemplate的精确参数） if price := content.get("price"): # VibrantTemplate参数：目标宽度为栏宽的70%，字体范围40-120 price_target_width = int(column_width * 0.7) price_size, price_actual_width = self._calculate_vibrant_font_size_precise( str(price), price_target_width, min_size=40, max_size=120 ) # 计算"CNY起"后缀 suffix_text = "CNY起" suffix_size = int(price_size * 0.3) # VibrantTemplate中后缀是价格字体的30% suffix_estimated_width = len(suffix_text) * suffix_size * 0.6 # 右对齐价格和后缀 price_x = right_margin - price_actual_width - suffix_estimated_width # 价格文本 price_obj = { "type": "textbox", "version": "5.3.0", "originX": "left", "originY": "top", "left": price_x, "top": y, "width": price_actual_width, "height": price_size + 20, "fill": "#ffffff", "shadow": "rgba(0, 0, 0, 0.7) 2px 2px 5px", "fontFamily": "Arial Black, sans-serif", "fontWeight": "bold", "fontSize": price_size, "text": f"¥{price}", "textAlign": "left", "name": "vibrant_price", "data": { "type": "price", "layer": "content", "level": 2, "target_width": price_target_width, "actual_width": price_actual_width }, "selectable": True, "evented": True } objects.append(price_obj) # "CNY起"后缀 suffix_y = y + price_size - suffix_size # 与价格底部对齐 suffix_obj = { "type": "textbox", "version": "5.3.0", "originX": "left", "originY": "top", "left": price_x + price_actual_width, "top": suffix_y, "width": suffix_estimated_width, "height": suffix_size + 5, "fill": "#ffffff", "fontFamily": "Arial, sans-serif", "fontWeight": "normal", "fontSize": suffix_size, "text": suffix_text, "textAlign": "left", "name": "price_suffix", "data": { "type": "price_suffix", "layer": "content", "level": 2 }, "selectable": True, "evented": True } objects.append(suffix_obj) # 价格下划线（与VibrantTemplate一致） underline_y = y + price_size + int(18 * scale_ratio) underline = { "type": "line", "version": "5.3.0", "originX": "center", "originY": "center", "left": (price_x - 10 + right_margin) / 2, "top": underline_y, "x1": (price_x - 10) - (price_x - 10 + right_margin) / 2, "y1": 0, "x2": right_margin - (price_x - 10 + right_margin) / 2, "y2": 0, "stroke": "rgba(255, 255, 255, 0.3)", "strokeWidth": 2, "name": "price_underline", "data": {"type": "decoration", "layer": "content", "level": 2}, "selectable": False, "evented": False } objects.append(underline) # 票种（使用VibrantTemplate的精确参数） if ticket_type := content.get("ticket_type"): ticket_y = y + price_size + int(35 * scale_ratio) # VibrantTemplate参数：目标宽度为栏宽的70%，字体范围30-60 ticket_target_width = int(column_width * 0.7) ticket_size, ticket_actual_width = self._calculate_vibrant_font_size_precise( ticket_type, ticket_target_width, min_size=30, max_size=60 ) ticket_x = right_margin - ticket_actual_width ticket_obj = { "type": "textbox", "version": "5.3.0", "originX": "left", "originY": "top", "left": ticket_x, "top": ticket_y, "width": ticket_actual_width, "height": ticket_size + 10, "fill": "#ffffff", "shadow": "rgba(0, 0, 0, 0.5) 1px 1px 3px", "fontFamily": "Arial, sans-serif", "fontWeight": "normal", "fontSize": ticket_size, "text": ticket_type, "textAlign": "left", "name": "ticket_type", "data": { "type": "ticket_type", "layer": "content", "level": 2, "target_width": ticket_target_width, "actual_width": ticket_actual_width }, "selectable": True, "evented": True } objects.append(ticket_obj) return objects