How to add a 3D extruded text with Claude

Add 3D extruded text to input.mp4: the words "NEW DROP" in a heavy font (Arial Black) 14% of the frame width tall, centered 50% across and 15% down. Treat the letters as a solid block 9% of the frame width deep. Draw it with Python, Pillow and numpy as a stack of flat copies of the letters (each thickened by a 3-pixel stroke), one every 2 pixels of depth, drawn from the back to the front: turn each copy around the text's vertical center line and project it in perspective from a camera 1.2 frame widths in front of the text (use Pillow's perspective transform), and also move each copy down 0.35 pixels per pixel of depth so the bottom sides show. Color the sides solid red (215, 35, 55), darkening to 45% of that toward the back, and 15% darker or brighter as they turn away from or toward a light on the left. On the front draw a 3-pixel dark red (120, 10, 30) outline and fill the letters yellow (255, 214, 0), slightly lighter at the top and deeper at the bottom. Animate the turn: at 0.5 seconds the text fades in over 0.15 seconds while flipping from 88 degrees (almost edge-on, right end toward the camera) to -30 degrees (left end toward the camera) over 0.8 seconds, easing out; from 1.3 seconds the angle is -30 * cos(2 * pi * (t - 1.3) / 3) degrees, so it swings smoothly to +30 and back every 3 seconds until the end. Draw any text with Pillow (don't rely on ffmpeg's drawtext filter), use ffmpeg to put it on the video, keep the audio, and save it as output.mp4.

#!/usr/bin/env python3
"""3D extruded text: thick yellow letters with solid red sides flip in from edge-on and keep turning in depth.

Usage: python3 extruded-3d-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, ImageFont

TEXT = "NEW DROP"
START = 0.5                # second the letters flip in, from edge-on
ENTER = 0.8                # seconds the flip-in takes
FADE = 0.15                # seconds the letters take to fade in as they flip
SWING = 30                 # degrees the letters then turn either way
PERIOD = 3.0               # seconds for one full turn left, right and back
SIZE = 0.14                # letter height as a share of the frame width
X, Y = 0.5, 0.15           # text center (0-1 across and down the frame)
DEPTH = 0.09               # extrusion depth as a share of the frame width
DROP = 0.35                # how far the sides also run downward per pixel of depth (we look from slightly above)
CAMERA = 1.2               # camera distance in frame widths: smaller means stronger perspective
FACE = (255, 214, 0)       # front face color
SIDE = (215, 35, 55)       # side color where it meets the face; it darkens toward the back
EDGE = (120, 10, 30)       # thin outline around the front face
FONTS = ["/System/Library/Fonts/Supplemental/Arial Black.ttf",    # macOS
         "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf",  # Linux
         "C:/Windows/Fonts/ariblk.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 letters(stroke):
    """The text as a mask over the rows it covers (band_y to band_y + band_h), thickened by `stroke` pixels."""
    mask = Image.new("L", (w, h))
    font = ImageFont.truetype(FONT_FILE, round(w * SIZE))
    ImageDraw.Draw(mask).text((w * X, h * Y), TEXT, font=font, anchor="mm", fill=255,
                              stroke_width=stroke, stroke_fill=255)
    return mask.crop((0, band_y, w, band_y + band_h))


def project(mask, a, z):
    """The mask as a flat card turned `a` radians around its vertical center line and pushed `z` pixels back,
    seen in perspective from CAMERA frame widths away, then dropped z * DROP pixels."""
    f, c, s = CAMERA * w, math.cos(a), math.sin(a)
    cx, cy = w * X, h * Y - band_y
    to_card = np.array([[1, 0, -cx], [0, 1, -cy - z * DROP], [0, 0, 1]])
    unproject = np.array([[1 + z * c / f, 0, -z * s], [0, c + z / f, 0], [s / f, 0, c]])
    to_mask = np.array([[1, 0, cx], [0, 1, cy], [0, 0, 1]])
    m = to_mask @ unproject @ to_card            # output pixel -> mask pixel
    m = m / m[2, 2]
    return np.asarray(mask.transform(mask.size, Image.PERSPECTIVE, tuple(m.flat[:8]), Image.BILINEAR), np.float32) / 255


def angle(t):
    """Turn in degrees around the vertical axis: 88 is nearly edge-on, 0 faces the camera."""
    p = (t - START) / ENTER
    if p < 1:
        return 88 + (-SWING - 88) * (1 - (1 - p) ** 3)   # flip in, easing out
    return -SWING * math.cos(2 * math.pi * (t - START - ENTER) / PERIOD)


def overlay(t):
    img = np.zeros((h, w, 4), np.uint8)
    if t < START:
        return img
    a = math.radians(angle(t))
    depth = round(DEPTH * w)
    side, nearest = np.zeros((band_h, w), np.float32), np.zeros((band_h, w), np.float32)
    for z in range(depth, 0, -2):   # back to front, so nearer slices cover farther ones
        s = project(body_mask, a, z)
        side = np.maximum(side, s)
        nearest = np.where(s > 0.5, z, nearest)
    body, face = project(body_mask, a, 0), project(face_mask, a, 0)
    side = np.maximum(side, body)
    light = 0.85 - 0.15 * math.sin(a)                   # light from the left: sides facing it are brighter
    shade = (light * (1 - 0.55 * nearest / depth))[..., None]
    rgb = np.array(SIDE, np.float32) * shade
    rgb = rgb * (1 - body[..., None]) + np.array(EDGE, np.float32) * body[..., None]
    rgb = rgb * (1 - face[..., None]) + face_color * face[..., None]
    fade = min((t - START) / FADE, 1)
    img[band_y:band_y + band_h, :, :3] = rgb.clip(0, 255).astype(np.uint8)
    img[band_y:band_y + band_h, :, 3] = (side * fade * 255).astype(np.uint8)
    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)
    for i in range(math.ceil(duration * fps)):
        ff.stdin.write(overlay(i / fps).tobytes())
    ff.stdin.close()
    if ff.wait():
        sys.exit("ffmpeg failed")


src, out = sys.argv[1:3]
w, h, rate, fps, duration = probe(src)
band_y = round(h * Y - w * SIZE * 1.4)                    # rows the turning text and its sides can cover
band_h = round(w * SIZE * 2.8 + DEPTH * w * DROP)
face_mask, body_mask = letters(0), letters(3)
rows = np.linspace(0, 1, band_h)[:, None, None]           # face shades from light yellow at the top to deeper below
face_color = np.array(FACE, np.float32) + np.array([0, 20, 60], np.float32) * (0.5 - rows)
render(src, out)