How to add a marquee bulb text with Claude

Add a theater marquee sign to input.mp4. From 0.5 seconds on, show a dark (28, 12, 18) rounded board centered across the frame and 12% of the way down, with the word "NEW" on it in red (200, 25, 40) Impact letters 30% of the frame width tall, each letter with a thin brown (120, 70, 20) rim and 36 pixels between letters. Ring each letter with light bulbs: 10-pixel circles every 16 pixels along a line 12 pixels outside the letter's edge, ordered as you trace round each letter, left letter first. From 0.5 to 1.1 seconds the bulbs switch on one after another in that order (warm white (255, 246, 210) with a yellow (255, 190, 40) glow; bulbs not yet on are dark brown (70, 45, 30)). From 1.1 seconds to the end, run a chase: every third bulb is bright with the glow and the others are dim amber (150, 95, 30), and the bright ones move one bulb along every 0.1 seconds. Nothing shows before 0.5 seconds and the rest of the frame is untouched. Use Python with Pillow to draw it and ffmpeg to put it on the video (don't rely on ffmpeg's drawtext filter), keep the audio, and save it as output.mp4.

#!/usr/bin/env python3
"""Marquee bulb text: a theater sign switches on bulb by bulb round its red letters, then the lights chase.

Usage: python3 marquee-bulb-text.py input.mp4 output.mp4
Needs ffmpeg, Pillow and numpy (pip install pillow numpy).
"""
import json
import math
import subprocess
import sys
from pathlib import Path

import numpy as np
from PIL import Image, ImageDraw, ImageFilter, ImageFont

TEXT = "NEW"                        # the sign's word
START = 0.5                         # second the sign appears and its bulbs start switching on
BUILD = 0.6                         # seconds for every bulb to light, one after another
STEP = 0.1                          # seconds between each move of the chase
EVERY = 3                           # one bulb in this many is bright at a time
Y = 0.12                            # sign center, 0-1 down the frame
SIZE = 0.30                         # letter height as a share of the frame width
GAP = 12                            # pixels from the letter edges out to the ring of bulbs
SPACING = 16                        # pixels between bulbs along the ring
BULB = 5                            # bulb radius in pixels
FACE = (200, 25, 40)                # letter color
RIM = (120, 70, 20)                 # thin rim round each letter, under the bulbs
BOARD = (28, 12, 18)                # sign board behind the letters
BRIGHT = (255, 246, 210)            # a bulb at full brightness
GLOW = (255, 190, 40)               # halo round the bright bulbs
DIM = (150, 95, 30)                 # a bulb between chase steps
OFF = (70, 45, 30)                  # a bulb before it switches on
FONTS = ["/System/Library/Fonts/Supplemental/Impact.ttf",          # macOS
         "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf",  # Linux
         "C:/Windows/Fonts/impact.ttf"]                           # Windows
FONT_FILE = next((f for f in FONTS if Path(f).exists()), None) or sys.exit("No bold font found: add one to FONTS")


def sign():
    """The board and red letters, plus one mask per letter for its ring of bulbs to follow."""
    font = ImageFont.truetype(FONT_FILE, round(w * SIZE))
    track = 2 * GAP + 2 * BULB + 2
    widths = [font.getlength(c) for c in TEXT]
    x = (w - sum(widths) - track * (len(TEXT) - 1)) / 2
    img = Image.new("RGBA", (w, h))
    draw = ImageDraw.Draw(img)
    masks = []
    for c, cw in zip(TEXT, widths):
        mask = Image.new("L", (w, h))
        ImageDraw.Draw(mask).text((x + cw / 2, h * Y), c, font=font, anchor="mm", fill=255)
        masks.append(mask)
        x += cw + track
    x0, y0 = min(m.getbbox()[0] for m in masks), min(m.getbbox()[1] for m in masks)
    x1, y1 = max(m.getbbox()[2] for m in masks), max(m.getbbox()[3] for m in masks)
    pad = GAP + round(w * 0.04)
    draw.rounded_rectangle([x0 - pad, y0 - pad, x1 + pad, y1 + pad], radius=pad // 2, fill=BOARD, outline=RIM, width=3)
    for m in masks:
        draw.bitmap((0, 0), m.filter(ImageFilter.MaxFilter(5)), fill=RIM)
        draw.bitmap((0, 0), m, fill=FACE)
    return img, masks


def ring(mask):
    """Points every SPACING pixels round a letter, GAP pixels outside its edge, in the order a pen would trace them."""
    grown = mask.filter(ImageFilter.MaxFilter(2 * GAP + 1))
    edge = (np.array(grown) > 127) & ~(np.array(grown.filter(ImageFilter.MinFilter(3))) > 127)
    pts = np.argwhere(edge)[:, ::-1].astype(np.float32)
    left = np.ones(len(pts), bool)
    i, path = 0, []
    while True:
        left[i] = False
        path.append(pts[i])
        if not left.any():
            break
        i = int(np.where(left, ((pts - pts[i]) ** 2).sum(axis=1), np.inf).argmin())
    bulbs = [path[0]]
    for p in path[1:]:
        if min(np.hypot(*(p - b)) for b in bulbs[-40:]) >= SPACING:
            bulbs.append(p)
    return [(float(x), float(y)) for x, y in bulbs]


def lights(states):
    """The bulbs drawn on a clear layer: 2 = bright with a halo, 1 = dim, 0 = off."""
    img = Image.new("RGBA", (w, h))
    halo = Image.new("RGBA", (w, h))
    draw, glow = ImageDraw.Draw(img), ImageDraw.Draw(halo)
    for (x, y), s in zip(bulbs, states):
        r = BULB + 3
        if s == 2:
            glow.ellipse([x - r, y - r, x + r, y + r], fill=GLOW + (230,))
        draw.ellipse([x - BULB, y - BULB, x + BULB, y + BULB], fill=(BRIGHT, DIM, OFF)[2 - s])
    out = halo.filter(ImageFilter.GaussianBlur(4))
    out.alpha_composite(halo)
    out.alpha_composite(img)
    return out


def overlay(t):
    if t < START:
        return None
    if t < START + BUILD:
        on = len(bulbs) * (t - START) / BUILD
        return frame_with([2 if k < on else 0 for k in range(len(bulbs))])
    step = int((t - START - BUILD) / STEP) % EVERY
    if step not in chase:
        chase[step] = frame_with([2 if (k - step) % EVERY == 0 else 1 for k in range(len(bulbs))])
    return chase[step]


def frame_with(states):
    img = board.copy()
    img.alpha_composite(lights(states))
    return img


def probe(path):
    info = json.loads(subprocess.check_output(["ffprobe", "-v", "error", "-select_streams", "v:0", "-show_entries",
                                               "stream=width,height,r_frame_rate:format=duration", "-of", "json", path]))
    s = info["streams"][0]
    num, den = s["r_frame_rate"].split("/")
    return s["width"], s["height"], s["r_frame_rate"], float(num) / float(den), float(info["format"]["duration"])


def render(src, out):
    """Draw overlay(t) on every frame of src and save to out, keeping the audio."""
    ff = subprocess.Popen(["ffmpeg", "-y", "-v", "error", "-i", src,
                           "-f", "rawvideo", "-pix_fmt", "rgba", "-s", f"{w}x{h}", "-r", rate, "-i", "-",
                           "-filter_complex", "[0:v][1:v]overlay=shortest=1,format=yuv420p[v]",
                           "-map", "[v]", "-map", "0:a?", "-c:v", "libx264", "-crf", "18", "-c:a", "copy", out],
                          stdin=subprocess.PIPE)
    blank = bytes(w * h * 4)
    for i in range(math.ceil(duration * fps)):
        img = overlay(i / fps)
        ff.stdin.write(blank if img is None else img.tobytes())
    ff.stdin.close()
    if ff.wait():
        sys.exit("ffmpeg failed")


src, out = sys.argv[1:3]
w, h, rate, fps, duration = probe(src)
board, letters = sign()
bulbs = [p for mask in letters for p in ring(mask)]
chase = {}
render(src, out)