How to add a brush stroke text reveal with Claude

Add a brush stroke text reveal to input.mp4. Paint a crimson (205, 30, 55) brush stroke 22% of the frame width thick, centered 74% of the way down and running from 4% to 96% across, sloping up slightly to the right (0.04 pixels per pixel across), with ragged top and bottom edges, dry-brush ragged ends and faint lighter and darker streaks along its length. Inside it, centered on the stroke and tilted with it, write "NEW FORMULA" in white (255, 255, 255) Arial Black (or another heavy bold font) with text height 8% of the frame width. Nothing shows before 0.8 seconds; from 0.8 to 2.0 seconds the stroke is painted left to right, easing out, with a ragged bristle edge at the front, and the words appear only where the paint has already reached. Then it stays to the end. Use Python with Pillow and numpy to draw it (don't rely on ffmpeg's drawtext filter) and ffmpeg to put it on the video, keep the audio, and save it as output.mp4.

#!/usr/bin/env python3
"""Brush stroke text reveal: a crimson paint stroke drags left to right across the lower third, uncovering white words painted into it.

Usage: python3 brush-stroke-text-reveal.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 FORMULA"
START = 0.8              # second the brush touches down
SWEEP = 1.2              # seconds the brush takes to cross
Y = 0.74                 # stroke center, as a share of the frame height down
LEFT, RIGHT = 0.04, 0.96  # where the stroke starts and ends, as shares of the frame width
THICK = 0.22             # stroke thickness, as a share of the frame width
TILT = -0.04             # slope of the stroke (pixels down per pixel across; negative rises to the right)
PAINT = (205, 30, 55)    # paint color, a crimson
TEXT_COLOR = (255, 255, 255)  # words, white
SIZE = 0.08              # text height, as a share of the frame width
BRISTLES = 0.10          # how ragged the brush's leading edge and the stroke's ends are, as a share of the frame width
SEED = 7                 # change for different bristles
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 wander(n, rng):
    """A wandering line of n values between 0 and 1: broad clumps of bristles plus single fine ones."""
    line = np.zeros(n)
    for cells, amp in [(4, 0.45), (18, 0.35), (90, 0.2)]:
        knots = rng.uniform(0, 1, cells + 1)
        line += amp * np.interp(np.linspace(0, cells, n), np.arange(cells + 1), knots)
    return line


def painted_stroke():
    """The finished stroke with its words as an RGBA array, and for every pixel how far the brush must travel
    before it's painted."""
    rng = np.random.default_rng(SEED)
    y, x = np.mgrid[0:h, 0:w].astype(np.float32)
    thick = THICK * w
    across = y - (Y * h + TILT * (x - w / 2))                          # distance from the stroke's center line
    row = np.clip(across + thick / 2, 0, thick - 1).astype(int)        # which bristle row each pixel is in
    edge = thick / 2 * (0.88 + 0.12 * wander(w, rng))[None, :]          # ragged top and bottom edges
    start = LEFT * w + wander(round(thick), rng)[row] * BRISTLES * w   # ragged, dry-brush ends
    end = RIGHT * w - wander(round(thick), rng)[row] * BRISTLES * w
    inside = (np.clip(edge - np.abs(across) + 0.5, 0, 1) * np.clip(x - start, 0, 1) * np.clip(end - x, 0, 1))
    streak = 0.72 + 0.36 * wander(round(thick), rng)[row]               # bristle streaks running along the stroke
    rgba = np.zeros((h, w, 4), np.float32)
    rgba[..., :3] = np.clip(np.array(PAINT, np.float32) * streak[..., None], 0, 255)
    rgba[..., 3] = inside * 255

    words = Image.new("L", (w, h))
    ImageDraw.Draw(words).text((w / 2, Y * h), TEXT, font=ImageFont.truetype(FONT_FILE, round(SIZE * w)),
                               anchor="mm", fill=255)
    ink = np.asarray(words.rotate(math.degrees(math.atan(-TILT)), resample=Image.BICUBIC,
                                  center=(w / 2, Y * h)), np.float32)[..., None] / 255 * inside[..., None]
    rgba[..., :3] = rgba[..., :3] * (1 - ink) + np.array(TEXT_COLOR, np.float32) * ink

    lag = wander(round(thick), rng)[row] * BRISTLES * w                 # some bristles trail behind the others
    return rgba, x + lag


def overlay(t):
    p = min(max((t - START) / SWEEP, 0), 1)
    front = LEFT * w + (1 - (1 - p) ** 2) * ((RIGHT - LEFT) * w + BRISTLES * w)   # eases out as the brush lifts
    img = full.copy()
    img[..., 3] *= np.clip((front - reach) / 4, 0, 1)
    return img.astype(np.uint8)


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)
full, reach = painted_stroke()
render(src, out)