How to add an animated bar chart with Claude

Add an animated bar chart to input.mp4. At 0.4 seconds fade in, over 0.3 seconds, a dark (15, 15, 25) rounded card at 84% opacity spanning 6% to 94% across and 60% to 88% down, titled "Brighter skin, by week" in white bold text 5.5% of the frame width tall, its middle 3.5% of the frame height below the card's top and 4% of the frame width in from its left edge. Inside it put three rows centered 70%, 76.5% and 83% down: a white bold label 4.8% of the frame width tall, 4% of the frame width in from the card's left edge ("Week 1", "Week 4", "Week 8"), a faint white rounded track from 30% to 76% across and 4% of the frame height thick, and a yellow (255, 196, 0) rounded bar on that track that grows from zero to 42%, 68% and 91% of the track's length. The first bar starts at 0.8 seconds, each next one 0.2 seconds later, and each takes 1.2 seconds with an ease-out cubic. Right-aligned at the card's right edge (4% of the frame width in) on each row, a white bold percentage of the same size counts up from 0% with its bar. Everything then stays to the end. 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
"""Animated bar chart: three yellow bars grow from zero in turn while their percentages count up beside them.

Usage: python3 animated-bar-chart.py input.mp4 output.mp4
Needs ffmpeg and Pillow (pip install pillow).
"""
import json
import math
import subprocess
import sys
from pathlib import Path

from PIL import Image, ImageDraw, ImageFont

TITLE = "Brighter skin, by week"                      # heading on the chart card
BARS = [("Week 1", 42), ("Week 4", 68), ("Week 8", 91)]  # label and value (0-100) for each bar
CARD_IN = 0.4            # second the card fades in
FADE = 0.3               # seconds the fade takes
START = 0.8              # second the first bar starts growing
STAGGER = 0.2            # seconds between one bar starting and the next
GROW = 1.2               # seconds each bar takes to reach its value
CARD = (0.06, 0.60, 0.94, 0.88)  # card box: left, top, right, bottom (0-1 of the frame)
TRACK = (0.30, 0.76)     # where a 0% and a 100% bar end (0-1 across the frame); the counting value sits to the right
ROW_Y = [0.70, 0.765, 0.83]      # bar centers (0-1 down the frame)
BAR_HEIGHT = 0.04        # bar thickness as a share of the frame height
COLOR = (255, 196, 0)    # bar color
FONTS = ["/System/Library/Fonts/Supplemental/Arial Bold.ttf",     # macOS
         "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf",  # Linux
         "C:/Windows/Fonts/arialbd.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 overlay(t):
    img = Image.new("RGBA", (w, h))
    fade = min(max((t - CARD_IN) / FADE, 0), 1)
    if fade == 0:
        return img
    draw = ImageDraw.Draw(img)
    x0, y0, x1, y1 = CARD[0] * w, CARD[1] * h, CARD[2] * w, CARD[3] * h
    draw.rounded_rectangle([x0, y0, x1, y1], radius=w * 0.04, fill=(15, 15, 25, round(215 * fade)))
    white = (255, 255, 255, round(255 * fade))
    draw.text((x0 + w * 0.04, y0 + h * 0.035), TITLE, font=title_font, anchor="lm", fill=white)
    left, right = TRACK[0] * w, TRACK[1] * w
    half = BAR_HEIGHT * h / 2
    for i, ((label, value), cy) in enumerate(zip(BARS, ROW_Y)):
        y = cy * h
        draw.text((x0 + w * 0.04, y), label, font=label_font, anchor="lm", fill=white)
        draw.rounded_rectangle([left, y - half, right, y + half], radius=half, fill=(255, 255, 255, round(30 * fade)))
        grown = ease_out_cubic((t - START - i * STAGGER) / GROW)
        if grown > 0:
            tip = left + (right - left) * value / 100 * grown
            draw.rounded_rectangle([left, y - half, max(tip, left + 2 * half), y + half], radius=half, fill=COLOR)
            draw.text((x1 - w * 0.04, y), f"{round(value * grown)}%", font=label_font, anchor="rm", fill="white")
    return img


def ease_out_cubic(p):
    """0 -> 1, fast at first and slowing into the final value."""
    p = min(max(p, 0), 1)
    return 1 - (1 - p) ** 3


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)
title_font = ImageFont.truetype(FONT_FILE, round(w * 0.055))
label_font = ImageFont.truetype(FONT_FILE, round(w * 0.048))
render(src, out)