| """Deterministic movie-style title cards for Small Cuts.""" |
|
|
| from PIL import Image, ImageDraw, ImageFont |
|
|
| from .styles import STYLES |
|
|
| TITLE_MAX_LEN = 60 |
|
|
| STYLE_CARDS = { |
| "deadpan": ("#F2EFE6", "#1A1A1A", "rules"), |
| "noir": ("#0D0D0F", "#E8E4D8", "hard_frame"), |
| "nature_doc": ("#0E2A1B", "#F0E9D2", "double_frame"), |
| "trailer": ("#101014", "#D4AF37", "spaced"), |
| "telenovela": ("#5C0A14", "#FFE9EC", "ornament"), |
| "symmetrist": ("#F7D6C9", "#5B3A29", "thin_frame"), |
| } |
|
|
|
|
| def derive_title(text: str, max_len: int = TITLE_MAX_LEN) -> str: |
| value = text.strip() |
| if value.startswith("["): |
| tag_end = value.find("]") |
| if tag_end != -1: |
| value = value[tag_end + 1 :].strip() |
| if not value: |
| return "Untitled Scene" |
| title = _first_clause(value).strip() |
| if not title: |
| return "Untitled Scene" |
| return _truncate_title(title, max_len) |
|
|
|
|
| def render_title_card( |
| title: str, |
| style_key: str, |
| size: tuple[int, int] = (1280, 720), |
| ) -> Image.Image: |
| style = STYLES[style_key] |
| bg, fg, treatment = STYLE_CARDS[style_key] |
| width, height = size |
| image = Image.new("RGB", size, bg) |
| draw = ImageDraw.Draw(image) |
| if treatment == "hard_frame": |
| inset = max(8, min(width, height) // 22) |
| box = (inset, inset, width - inset - 1, height - inset - 1) |
| draw.rectangle(box, outline=fg, width=2) |
| elif treatment == "double_frame": |
| inset = max(8, min(width, height) // 24) |
| for offset in (inset, inset + max(4, inset // 3)): |
| box = (offset, offset, width - offset - 1, height - offset - 1) |
| draw.rectangle(box, outline=fg) |
| elif treatment == "thin_frame": |
| draw.rectangle((8, 8, width - 9, height - 9), outline=fg) |
| margin = max(12, width // 9) |
| content_width = max(1, width - margin * 2) |
| max_title_height = max(24, int(height * 0.42)) |
| spaced = treatment == "spaced" |
| for size_px in range(max(12, int(height * 0.12)), 5, -2): |
| title_font = _font(size_px) |
| lines = _wrap(draw, title.strip().upper(), title_font, content_width, spaced) |
| block_width, block_height = _block(draw, lines, title_font) |
| if block_width <= content_width and block_height <= max_title_height: |
| break |
| else: |
| title_font = _font(6) |
| lines = _wrap(draw, title.strip().upper(), title_font, content_width, spaced) |
| _, block_height = _block(draw, lines, title_font) |
| kicker_font = _font(max(10, int(height * 0.04))) |
| subtitle_font = _font(max(10, int(height * 0.035))) |
| _center(draw, "A SMALL CUTS PICTURE", width, int(height * 0.17), kicker_font, fg) |
| if lines: |
| title_top = max(int(height * 0.28), (height - block_height) // 2) |
| title_size = getattr(title_font, "size", 12) |
| if treatment == "rules": |
| top_rule = max(8, title_top - title_size // 2) |
| bottom_rule = min(height - 8, title_top + block_height + title_size // 2) |
| draw.line((margin, top_rule, width - margin, top_rule), fill=fg) |
| draw.line((margin, bottom_rule, width - margin, bottom_rule), fill=fg) |
| line_height = _measure(draw, "Ag", title_font)[1] |
| y = title_top |
| for line in lines: |
| _center(draw, line, width, y, title_font, fg) |
| y += line_height |
| if treatment == "ornament": |
| _center(draw, "♦ ─── ♦", width, y + max(8, title_size // 4), subtitle_font, fg) |
| subtitle_y = min(height - getattr(subtitle_font, "size", 10) * 2, int(height * 0.78)) |
| _center(draw, style.label.upper(), width, subtitle_y, subtitle_font, fg) |
| return image |
|
|
|
|
| def _first_clause(text: str) -> str: |
| index = 0 |
| while index < len(text): |
| if text.startswith("...", index): |
| if _ellipsis_ends_clause(text, index, 3): |
| return text[:index] |
| index += 3 |
| continue |
| if text[index] == "…": |
| if _ellipsis_ends_clause(text, index, 1): |
| return text[:index] |
| elif text[index] in ".!?;—": |
| return text[:index] |
| index += 1 |
| return text |
|
|
|
|
| def _ellipsis_ends_clause(text: str, index: int, width: int) -> bool: |
| if len(text[:index].split()) < 3: |
| return False |
| next_index = index + width |
| if next_index >= len(text) or not text[next_index].isspace(): |
| return False |
| while next_index < len(text) and text[next_index].isspace(): |
| next_index += 1 |
| return next_index < len(text) and text[next_index].isupper() |
|
|
|
|
| def _truncate_title(title: str, max_len: int) -> str: |
| if max_len < 1: |
| return "" |
| if len(title) <= max_len: |
| return title |
| if max_len == 1: |
| return "…" |
| cut = -1 |
| for index, char in enumerate(title[:max_len]): |
| if char.isspace(): |
| cut = index |
| if cut <= 0: |
| return "…" |
| return f"{title[:cut].rstrip()}…" |
|
|
|
|
| def _font(size): |
| try: |
| return ImageFont.load_default(size=size) |
| except TypeError: |
| return ImageFont.load_default() |
|
|
|
|
| def _wrap(draw, text, font, max_width, spaced): |
| def show(value): |
| return " ".join(value) if spaced else value |
|
|
| def fits(value): |
| return _measure(draw, show(value), font)[0] <= max_width |
|
|
| lines = [] |
| current = "" |
| for word in text.split(): |
| candidate = f"{current} {word}".strip() |
| if fits(candidate): |
| current = candidate |
| continue |
| if current: |
| lines.append(show(current)) |
| current = word |
| while len(current) > 1 and not fits(current): |
| split = 1 |
| while split < len(current) and fits(current[: split + 1]): |
| split += 1 |
| lines.append(show(current[:split])) |
| current = current[split:] |
| if current: |
| lines.append(show(current)) |
| return lines |
|
|
|
|
| def _block(draw, lines, font): |
| line_height = _measure(draw, "Ag", font)[1] |
| widths = [_measure(draw, line, font)[0] for line in lines] |
| return max(widths, default=0), len(lines) * line_height |
|
|
|
|
| def _center(draw, text, width, y, font, fill): |
| x = (width - _measure(draw, text, font)[0]) / 2 |
| draw.text((x, y), text, font=font, fill=fill) |
|
|
|
|
| def _measure(draw, text, font): |
| left, top, right, bottom = draw.textbbox((0, 0), text, font=font) |
| return right - left, bottom - top |
|
|
