730 lines
23 KiB
Python
730 lines
23 KiB
Python
"""产品推介材料宣传长图固定模板渲染器。"""
|
||
|
||
from __future__ import annotations
|
||
|
||
from pathlib import Path
|
||
from typing import Any
|
||
|
||
from app.service.promotion_renderer import STYLE_CONFIG, resolve_visual_palette
|
||
|
||
|
||
class PromotionPosterRenderer:
|
||
"""把同一份结构化草稿填入竖版宣传长图模板。"""
|
||
|
||
WIDTH = 1800
|
||
HEIGHT = 2600
|
||
|
||
def render(
|
||
self,
|
||
draft: dict[str, Any],
|
||
output_path: str | Path,
|
||
*,
|
||
photo_path: str | None = None,
|
||
chart_paths: list[str] | None = None,
|
||
background_path: str | None = None,
|
||
) -> str:
|
||
try:
|
||
from PIL import Image, ImageDraw, ImageFont
|
||
except ImportError as exc:
|
||
raise RuntimeError("缺少 Pillow 依赖，无法生成宣传长图") from exc
|
||
|
||
style_code = str(draft.get("style_code") or "balanced_allocation")
|
||
style = STYLE_CONFIG.get(style_code, STYLE_CONFIG["balanced_allocation"])
|
||
palette = resolve_visual_palette(
|
||
style_code,
|
||
background_path,
|
||
draft.get("visual_palette"),
|
||
)
|
||
colors = {
|
||
"primary": f"#{palette['primary']}",
|
||
"secondary": f"#{palette['secondary']}",
|
||
"accent": f"#{style['accent']}",
|
||
"ink": f"#{palette['ink']}",
|
||
"muted": f"#{palette['muted']}",
|
||
"paper": f"#{palette['background']}",
|
||
"panel": f"#{palette['panel']}",
|
||
"panel_alt": f"#{palette['panel_alt']}",
|
||
"white": "#FFFFFF",
|
||
"line": f"#{palette['line']}",
|
||
"headline": f"#{palette['headline']}",
|
||
}
|
||
fonts = self._fonts(ImageFont)
|
||
layout_plan = draft.get("layout_plan") or {}
|
||
profile = layout_plan.get("design_profile") or {}
|
||
tone = str(profile.get("design_tone") or "institutional_tech")
|
||
section_color = colors["primary"] if tone == "institutional_tech" else colors["accent"]
|
||
canvas = Image.new("RGB", (self.WIDTH, self.HEIGHT), colors["paper"])
|
||
if background_path and Path(background_path).exists():
|
||
with Image.open(background_path) as background:
|
||
canvas.paste(self._cover(background.convert("RGB"), self.WIDTH, self.HEIGHT))
|
||
# 正文区使用主题浅色保护层，让 AI 纹理可见但不压过中文内容。
|
||
body = canvas.crop((0, 462, self.WIDTH, self.HEIGHT - 115))
|
||
protection = 0.42 if profile.get("background_role") == "soft_paper" else 0.34
|
||
body = Image.blend(
|
||
body,
|
||
Image.new("RGB", body.size, colors["paper"]),
|
||
protection,
|
||
)
|
||
canvas.paste(body, (0, 462))
|
||
draw = ImageDraw.Draw(canvas)
|
||
chapters = {
|
||
str(item.get("title", "")): item
|
||
for item in draft.get("chapters", [])
|
||
if item.get("title")
|
||
}
|
||
poster_layout = str(layout_plan.get("poster_layout") or "poster_balanced")
|
||
chart_focus = (
|
||
poster_layout == "poster_chart_focus"
|
||
or profile.get("performance_layout") == "chart_dominant"
|
||
)
|
||
column_ratio = self._column_ratio(str(profile.get("column_ratio") or "50_50"))
|
||
product_y = 590
|
||
product_height = 320 if chart_focus else 365
|
||
manager_header_y = 1030
|
||
manager_y = 1115
|
||
manager_height = 355
|
||
history_header_y = 1505 if chart_focus else 1550
|
||
chart_y = 1585 if chart_focus else 1635
|
||
chart_height = 560 if chart_focus else 520
|
||
metrics_y = 2225
|
||
self._draw_visual_background(
|
||
draw, layout_plan.get("background_theme"), colors, fonts
|
||
)
|
||
|
||
self._draw_cover(
|
||
draw,
|
||
canvas,
|
||
draft,
|
||
colors,
|
||
fonts,
|
||
has_ai_background=bool(background_path and Path(background_path).exists()),
|
||
)
|
||
self._draw_section_header(
|
||
draw,
|
||
"产品定位与投资策略",
|
||
90,
|
||
500,
|
||
colors,
|
||
fonts,
|
||
fill=section_color,
|
||
)
|
||
self._draw_two_columns(
|
||
draw,
|
||
chapters.get("产品基本信息", {}).get("body", ""),
|
||
chapters.get("投资范围、策略与限制", {}).get("body", ""),
|
||
90,
|
||
product_y,
|
||
colors,
|
||
fonts,
|
||
height=product_height,
|
||
left_ratio=column_ratio,
|
||
)
|
||
self._draw_section_header(
|
||
draw,
|
||
"基金经理与投研团队",
|
||
90,
|
||
manager_header_y,
|
||
colors,
|
||
fonts,
|
||
fill=section_color,
|
||
)
|
||
self._draw_manager(
|
||
draw,
|
||
canvas,
|
||
chapters.get("管理人及投研团队", {}).get("body", ""),
|
||
photo_path,
|
||
90,
|
||
manager_y,
|
||
colors,
|
||
fonts,
|
||
panel_height=manager_height,
|
||
photo_width=350 if profile.get("manager_layout") == "profile_feature" else 300,
|
||
)
|
||
self._draw_section_header(
|
||
draw,
|
||
"历史业绩与风险指标",
|
||
90,
|
||
history_header_y,
|
||
colors,
|
||
fonts,
|
||
fill=section_color,
|
||
)
|
||
chart_path = next(
|
||
(
|
||
item
|
||
for item in (chart_paths or [])
|
||
if item and Path(item).exists()
|
||
),
|
||
None,
|
||
)
|
||
if chart_path:
|
||
self._draw_chart(
|
||
canvas,
|
||
chart_path,
|
||
90,
|
||
chart_y,
|
||
1620,
|
||
chart_height,
|
||
colors,
|
||
)
|
||
else:
|
||
self._draw_note(
|
||
draw,
|
||
"当前未提供可展示的业绩曲线附件",
|
||
90,
|
||
chart_y + 100,
|
||
1620,
|
||
chart_height - 100,
|
||
colors,
|
||
fonts,
|
||
)
|
||
self._draw_metrics(
|
||
draw,
|
||
chapters.get("收益与风险指标", {}).get("body", ""),
|
||
90,
|
||
metrics_y,
|
||
colors,
|
||
fonts,
|
||
)
|
||
self._draw_footer(draw, colors, fonts)
|
||
|
||
output = Path(output_path)
|
||
output.parent.mkdir(parents=True, exist_ok=True)
|
||
canvas.save(output, format="PNG", optimize=True)
|
||
return str(output)
|
||
|
||
def _draw_visual_background(
|
||
self,
|
||
draw: Any,
|
||
theme: Any,
|
||
colors: dict[str, str],
|
||
fonts: dict[str, Any],
|
||
) -> None:
|
||
del fonts
|
||
if theme in (None, "none"):
|
||
return
|
||
for index in range(7):
|
||
x = 1120 + index * 90
|
||
y = 90 + index * 42
|
||
draw.line((x, y, x + 460, y + 160), fill=colors["secondary"], width=4)
|
||
draw.ellipse(
|
||
(x + 450, y + 150, x + 466, y + 166),
|
||
fill=colors["accent"],
|
||
)
|
||
if theme == "geometric_grid":
|
||
for index in range(8):
|
||
x = 1260 + (index % 2) * 160
|
||
y = 620 + index * 105
|
||
draw.ellipse((x, y, x + 14, y + 14), fill=colors["accent"])
|
||
|
||
@staticmethod
|
||
def _column_ratio(value: str) -> float:
|
||
return {
|
||
"40_60": 0.40,
|
||
"45_55": 0.45,
|
||
"50_50": 0.50,
|
||
"55_45": 0.55,
|
||
"60_40": 0.60,
|
||
}.get(value, 0.50)
|
||
|
||
@staticmethod
|
||
def _fonts(image_font: Any) -> dict[str, Any]:
|
||
candidates = (
|
||
Path(r"C:\Windows\Fonts\msyh.ttc"),
|
||
Path(r"C:\Windows\Fonts\simhei.ttf"),
|
||
Path("/usr/share/fonts/opentype/noto/NotoSansCJK-Regular.ttc"),
|
||
Path("/usr/share/fonts/truetype/noto/NotoSansCJK-Regular.ttc"),
|
||
)
|
||
font_path = next((item for item in candidates if item.exists()), None)
|
||
if font_path is None:
|
||
return {
|
||
"title": image_font.load_default(),
|
||
"section": image_font.load_default(),
|
||
"body": image_font.load_default(),
|
||
"small": image_font.load_default(),
|
||
}
|
||
return {
|
||
"title": image_font.truetype(str(font_path), 58),
|
||
"section": image_font.truetype(str(font_path), 32),
|
||
"body": image_font.truetype(str(font_path), 24),
|
||
"small": image_font.truetype(str(font_path), 19),
|
||
"metric": image_font.truetype(str(font_path), 29),
|
||
}
|
||
|
||
def _draw_cover(
|
||
self,
|
||
draw: Any,
|
||
canvas: Any,
|
||
draft: dict[str, Any],
|
||
colors: dict[str, str],
|
||
fonts: dict[str, Any],
|
||
*,
|
||
has_ai_background: bool = False,
|
||
) -> None:
|
||
if has_ai_background:
|
||
from PIL import Image
|
||
|
||
cover = canvas.crop((0, 0, self.WIDTH, 430))
|
||
cover = Image.blend(
|
||
cover,
|
||
Image.new("RGB", cover.size, colors["primary"]),
|
||
0.58,
|
||
)
|
||
canvas.paste(cover, (0, 0))
|
||
else:
|
||
draw.rectangle((0, 0, self.WIDTH, 430), fill=colors["primary"])
|
||
draw.rectangle((0, 430, self.WIDTH, 462), fill=colors["accent"])
|
||
title = str(draft.get("title") or draft.get("subtitle") or "基金产品推介材料")
|
||
self._draw_wrapped(
|
||
draw,
|
||
title,
|
||
90,
|
||
86,
|
||
1550,
|
||
fonts["title"],
|
||
colors["headline"],
|
||
max_lines=2,
|
||
line_gap=14,
|
||
)
|
||
draw.text(
|
||
(95, 300),
|
||
"产品推介材料",
|
||
font=fonts["section"],
|
||
fill=colors["headline"],
|
||
)
|
||
draw.text(
|
||
(95, 350),
|
||
"仅供内部审核和专业投顾使用",
|
||
font=fonts["small"],
|
||
fill=colors["secondary"],
|
||
)
|
||
# 右上角使用抽象数据线和节点，模仿参考图的金融科技视觉。
|
||
points = [(1330, 150), (1410, 188), (1490, 146), (1570, 212), (1680, 170)]
|
||
draw.line(points, fill=colors["secondary"], width=5)
|
||
for x, y in points:
|
||
draw.ellipse((x - 10, y - 10, x + 10, y + 10), fill=colors["accent"])
|
||
draw.line((1320, 272, 1710, 272), fill=colors["secondary"], width=3)
|
||
|
||
def _draw_section_header(
|
||
self,
|
||
draw: Any,
|
||
title: str,
|
||
x: int,
|
||
y: int,
|
||
colors: dict[str, str],
|
||
fonts: dict[str, Any],
|
||
*,
|
||
fill: str | None = None,
|
||
) -> None:
|
||
color = fill or colors["accent"]
|
||
draw.rectangle((x, y, x + 720, y + 62), fill=color)
|
||
draw.polygon(
|
||
((x + 720, y), (x + 760, y + 31), (x + 720, y + 62)),
|
||
fill=color,
|
||
)
|
||
draw.text((x + 24, y + 14), title, font=fonts["section"], fill=colors["white"])
|
||
|
||
def _draw_two_columns(
|
||
self,
|
||
draw: Any,
|
||
left_body: str,
|
||
right_body: str,
|
||
x: int,
|
||
y: int,
|
||
colors: dict[str, str],
|
||
fonts: dict[str, Any],
|
||
*,
|
||
height: int = 365,
|
||
left_ratio: float = 0.5,
|
||
) -> dict[str, Any]:
|
||
total_width = 1620
|
||
gap = 54
|
||
resolved_ratio, body_font = self._resolve_two_column_layout(
|
||
draw,
|
||
left_body,
|
||
right_body,
|
||
total_width=total_width,
|
||
height=height,
|
||
requested_ratio=left_ratio,
|
||
font=fonts["body"],
|
||
)
|
||
left_width = int((total_width - gap) * resolved_ratio)
|
||
right_width = total_width - gap - left_width
|
||
self._draw_text_panel(
|
||
draw,
|
||
left_body,
|
||
x,
|
||
y,
|
||
left_width,
|
||
height,
|
||
colors,
|
||
{**fonts, "body": body_font},
|
||
)
|
||
self._draw_text_panel(
|
||
draw,
|
||
right_body,
|
||
x + left_width + gap,
|
||
y,
|
||
right_width,
|
||
height,
|
||
colors,
|
||
{**fonts, "body": body_font},
|
||
)
|
||
return {
|
||
"column_ratio": resolved_ratio,
|
||
"font_size": getattr(body_font, "size", None),
|
||
}
|
||
|
||
def _resolve_two_column_layout(
|
||
self,
|
||
draw: Any,
|
||
left_body: str,
|
||
right_body: str,
|
||
*,
|
||
total_width: int,
|
||
height: int,
|
||
requested_ratio: float,
|
||
font: Any,
|
||
) -> tuple[float, Any]:
|
||
"""在模型版式落地前检查文字容量，避免栏位比例造成溢出。"""
|
||
gap = 54
|
||
ratios = [requested_ratio]
|
||
if requested_ratio == 0.5:
|
||
ratios.extend((0.4, 0.6))
|
||
elif requested_ratio < 0.5:
|
||
ratios.append(0.45)
|
||
else:
|
||
ratios.append(0.55)
|
||
|
||
for ratio in ratios:
|
||
left_width = int((total_width - gap) * ratio) - 68
|
||
right_width = total_width - gap - int((total_width - gap) * ratio) - 68
|
||
if self._text_fits(draw, left_body, left_width, height - 60, font) and (
|
||
self._text_fits(draw, right_body, right_width, height - 60, font)
|
||
):
|
||
return ratio, font
|
||
fitted_font = self._fit_font(
|
||
draw,
|
||
(left_body, left_width),
|
||
(right_body, right_width),
|
||
height=height - 60,
|
||
font=font,
|
||
)
|
||
if self._text_fits(draw, left_body, left_width, height - 60, fitted_font) and (
|
||
self._text_fits(draw, right_body, right_width, height - 60, fitted_font)
|
||
):
|
||
return ratio, fitted_font
|
||
smallest = self._font_variant(font, 15)
|
||
return ratios[-1], smallest
|
||
|
||
def _fit_font(
|
||
self,
|
||
draw: Any,
|
||
*text_blocks: tuple[str, int],
|
||
height: int,
|
||
font: Any,
|
||
) -> Any:
|
||
base_size = int(getattr(font, "size", 24))
|
||
for size in range(base_size, 14, -1):
|
||
candidate = self._font_variant(font, size)
|
||
if all(
|
||
self._text_fits(draw, text, width, height, candidate)
|
||
for text, width in text_blocks
|
||
):
|
||
return candidate
|
||
return self._font_variant(font, 15)
|
||
|
||
@staticmethod
|
||
def _font_variant(font: Any, size: int) -> Any:
|
||
variant = getattr(font, "font_variant", None)
|
||
return variant(size=size) if variant is not None else font
|
||
|
||
@classmethod
|
||
def _text_fits(
|
||
cls,
|
||
draw: Any,
|
||
text: str,
|
||
width: int,
|
||
height: int,
|
||
font: Any,
|
||
) -> bool:
|
||
line_height = int(getattr(font, "size", 24) * 1.35)
|
||
lines = cls._wrapped_lines(draw, text or "资料待补充", width, font)
|
||
return len(lines) * line_height + max(0, len(lines) - 1) * 8 <= height
|
||
|
||
def _draw_manager(
|
||
self,
|
||
draw: Any,
|
||
canvas: Any,
|
||
body: str,
|
||
photo_path: str | None,
|
||
x: int,
|
||
y: int,
|
||
colors: dict[str, str],
|
||
fonts: dict[str, Any],
|
||
*,
|
||
panel_height: int = 355,
|
||
photo_width: int = 300,
|
||
) -> None:
|
||
panel_width = 1620
|
||
draw.rectangle(
|
||
(x, y, x + panel_width, y + panel_height),
|
||
fill=colors["panel"],
|
||
outline=colors["line"],
|
||
width=2,
|
||
)
|
||
photo_height = min(297, panel_height - 56)
|
||
photo_box = (x + 30, y + 28, x + 30 + photo_width, y + 28 + photo_height)
|
||
if photo_path and Path(photo_path).exists():
|
||
from PIL import Image
|
||
|
||
with Image.open(photo_path) as source:
|
||
portrait = self._contain(source.convert("RGB"), photo_width, photo_height)
|
||
canvas.paste(portrait, (photo_box[0], photo_box[1]))
|
||
else:
|
||
draw.rectangle(photo_box, fill=colors["secondary"])
|
||
draw.text(
|
||
(photo_box[0] + 70, photo_box[1] + max(20, photo_height // 2 - 10)),
|
||
"未上传头像",
|
||
font=fonts["small"],
|
||
fill=colors["muted"],
|
||
)
|
||
text_x = x + photo_width + 95
|
||
draw.line(
|
||
(text_x - 45, y + 28, text_x - 45, y + panel_height - 30),
|
||
fill=colors["line"],
|
||
width=2,
|
||
)
|
||
self._draw_wrapped(
|
||
draw,
|
||
body,
|
||
text_x,
|
||
y + 36,
|
||
panel_width - photo_width - 135,
|
||
fonts["body"],
|
||
colors["ink"],
|
||
max_lines=7 if panel_height < 355 else 9,
|
||
line_gap=8,
|
||
)
|
||
|
||
def _draw_chart(
|
||
self,
|
||
canvas: Any,
|
||
chart_path: str,
|
||
x: int,
|
||
y: int,
|
||
width: int,
|
||
height: int,
|
||
colors: dict[str, str],
|
||
) -> None:
|
||
from PIL import Image
|
||
|
||
with Image.open(chart_path) as source:
|
||
chart = self._contain(
|
||
source.convert("RGB"),
|
||
width,
|
||
height,
|
||
fill=colors["panel_alt"],
|
||
)
|
||
chart = self._recolor_light_background(chart, colors["panel_alt"])
|
||
canvas.paste(chart, (x, y))
|
||
|
||
def _draw_metrics(
|
||
self,
|
||
draw: Any,
|
||
body: str,
|
||
x: int,
|
||
y: int,
|
||
colors: dict[str, str],
|
||
fonts: dict[str, Any],
|
||
) -> None:
|
||
backdrop_top = y - 34
|
||
draw.rectangle(
|
||
(x, backdrop_top, x + 1620, self.HEIGHT - 115),
|
||
fill=colors["panel_alt"],
|
||
outline=colors["line"],
|
||
width=2,
|
||
)
|
||
metrics: list[str] = []
|
||
for line in body.splitlines():
|
||
if any(keyword in line for keyword in ("产品收益", "最大回撤", "波动率", "夏普比率")):
|
||
metrics.extend(
|
||
part.strip()
|
||
for part in line.replace("。", "，").split("，")
|
||
if part.strip()
|
||
)
|
||
metrics = metrics[:4]
|
||
if not metrics:
|
||
metrics = ["收益指标待补充", "风险指标待补充"]
|
||
box_width = 375
|
||
for index, text in enumerate(metrics):
|
||
left = x + index * (box_width + 30)
|
||
draw.rectangle(
|
||
(left, y, left + box_width, y + 125),
|
||
fill=colors["secondary"],
|
||
outline=colors["line"],
|
||
width=2,
|
||
)
|
||
draw.rectangle(
|
||
(left, y, left + 12, y + 125),
|
||
fill=colors["accent"],
|
||
)
|
||
self._draw_wrapped(
|
||
draw,
|
||
text,
|
||
left + 20,
|
||
y + 28,
|
||
box_width - 40,
|
||
fonts.get("metric", fonts["body"]),
|
||
colors["primary"],
|
||
max_lines=2,
|
||
)
|
||
|
||
def _draw_text_panel(
|
||
self,
|
||
draw: Any,
|
||
body: str,
|
||
x: int,
|
||
y: int,
|
||
width: int,
|
||
height: int,
|
||
colors: dict[str, str],
|
||
fonts: dict[str, Any],
|
||
) -> None:
|
||
draw.rectangle(
|
||
(x, y, x + width, y + height),
|
||
fill=colors["panel" if x < self.WIDTH // 2 else "panel_alt"],
|
||
outline=colors["line"],
|
||
width=2,
|
||
)
|
||
draw.rectangle((x, y, x + 16, y + height), fill=colors["accent"])
|
||
self._draw_wrapped(
|
||
draw,
|
||
body or "资料待补充",
|
||
x + 34,
|
||
y + 30,
|
||
width - 68,
|
||
fonts["body"],
|
||
colors["ink"],
|
||
max_lines=1000,
|
||
line_gap=8,
|
||
)
|
||
|
||
def _draw_note(
|
||
self,
|
||
draw: Any,
|
||
text: str,
|
||
x: int,
|
||
y: int,
|
||
width: int,
|
||
height: int,
|
||
colors: dict[str, str],
|
||
fonts: dict[str, Any],
|
||
) -> None:
|
||
draw.rectangle(
|
||
(x, y, x + width, y + height),
|
||
fill=colors["secondary"],
|
||
)
|
||
self._draw_wrapped(
|
||
draw,
|
||
text,
|
||
x + 40,
|
||
y + 70,
|
||
width - 80,
|
||
fonts["body"],
|
||
colors["muted"],
|
||
max_lines=3,
|
||
)
|
||
|
||
def _draw_footer(
|
||
self,
|
||
draw: Any,
|
||
colors: dict[str, str],
|
||
fonts: dict[str, Any],
|
||
) -> None:
|
||
y = self.HEIGHT - 115
|
||
draw.rectangle(
|
||
(0, y, self.WIDTH, self.HEIGHT),
|
||
fill=colors["panel_alt"],
|
||
)
|
||
draw.rectangle((0, y, self.WIDTH, y + 8), fill=colors["primary"])
|
||
draw.text(
|
||
(90, y + 32),
|
||
"基金的过往业绩并不预示其未来表现，材料使用前须完成合规审核。",
|
||
font=fonts["small"],
|
||
fill=colors["muted"],
|
||
)
|
||
|
||
@staticmethod
|
||
def _contain(image: Any, width: int, height: int, *, fill: str = "#FFFFFF") -> Any:
|
||
from PIL import Image
|
||
|
||
ratio = min(width / image.width, height / image.height)
|
||
size = (max(1, int(image.width * ratio)), max(1, int(image.height * ratio)))
|
||
resized = image.resize(size, Image.Resampling.LANCZOS)
|
||
canvas = Image.new("RGB", (width, height), fill)
|
||
canvas.paste(resized, ((width - size[0]) // 2, (height - size[1]) // 2))
|
||
return canvas
|
||
|
||
@staticmethod
|
||
def _cover(image: Any, width: int, height: int) -> Any:
|
||
from PIL import Image
|
||
|
||
ratio = max(width / image.width, height / image.height)
|
||
size = (
|
||
max(width, int(round(image.width * ratio))),
|
||
max(height, int(round(image.height * ratio))),
|
||
)
|
||
resized = image.resize(size, Image.Resampling.LANCZOS)
|
||
left = max(0, (resized.width - width) // 2)
|
||
top = max(0, (resized.height - height) // 2)
|
||
return resized.crop((left, top, left + width, top + height))
|
||
|
||
@staticmethod
|
||
def _recolor_light_background(image: Any, color: str) -> Any:
|
||
pixels = image.load()
|
||
replacement = tuple(int(color[index:index + 2], 16) for index in (1, 3, 5))
|
||
for y in range(image.height):
|
||
for x in range(image.width):
|
||
red, green, blue = pixels[x, y]
|
||
if red >= 242 and green >= 242 and blue >= 242:
|
||
pixels[x, y] = replacement
|
||
return image
|
||
|
||
@staticmethod
|
||
def _draw_wrapped(
|
||
draw: Any,
|
||
text: str,
|
||
x: int,
|
||
y: int,
|
||
width: int,
|
||
font: Any,
|
||
fill: str,
|
||
*,
|
||
max_lines: int,
|
||
line_gap: int = 6,
|
||
) -> int:
|
||
lines = PromotionPosterRenderer._wrapped_lines(draw, text, width, font)
|
||
lines = lines[:max_lines]
|
||
cursor = y
|
||
line_height = int(font.size * 1.35)
|
||
for line in lines:
|
||
draw.text((x, cursor), line, font=font, fill=fill)
|
||
cursor += line_height + line_gap
|
||
return cursor
|
||
|
||
@staticmethod
|
||
def _wrapped_lines(draw: Any, text: str, width: int, font: Any) -> list[str]:
|
||
lines: list[str] = []
|
||
for paragraph in str(text).splitlines() or [""]:
|
||
current = ""
|
||
for char in paragraph:
|
||
candidate = current + char
|
||
if draw.textlength(candidate, font=font) > width and current:
|
||
lines.append(current)
|
||
current = char
|
||
else:
|
||
current = candidate
|
||
lines.append(current)
|
||
return lines
|