How to add a star wipe with Claude

Join clipA.mp4 and clipB.mp4 with a 1.0 second star wipe that starts 1.0 seconds before A ends, so the result is 11 seconds. On each of the 30 transition frames, with progress p from 0 to 1, ease it as e = p*p*(3 - 2p) and draw an upright five-pointed star (one tip straight up) centered on the frame: tips at radius R = e * 1.05 * (half the frame diagonal) / 0.45 and inner corners at 0.45 R, so at the end even the inner corners are past the frame's corners. Show B inside the star and A outside it, and draw a 6 pixel pure white (255, 255, 255) outline along the star's edge. Draw the star with Pillow at 3x size and shrink it so the edges are smooth, and mix the frames in Python with numpy, piping frames to and from ffmpeg. Before the transition show only A, after it only B. Fit B to A's size (scale to cover, center crop) at 30fps. Crossfade the audio over the same 1.0 second. Encode H.264 yuv420p and save it as output.mp4.

#!/usr/bin/env python3
"""Star wipe: a white-edged five-pointed star opens in the middle of clip A and grows until clip B fills the frame.

Usage: python3 star-wipe.py clipA.mp4 clipB.mp4 output.mp4  (both clips need an audio track)
Needs ffmpeg, Pillow and numpy (pip install pillow numpy).
"""
import json
import math
import subprocess
import sys

import numpy as np
from PIL import Image, ImageDraw

D = 1.0          # transition length in seconds
POINTS = 5       # points on the star
INNER = 0.45     # inner corners' distance from the center, as a share of the tips' distance
EDGE = 6         # width of the white outline round the star, in pixels
EDGE_COLOR = (255, 255, 255)   # outline color
FPS = 30         # output frame rate
AA = 3           # the mask is drawn this many times larger, then shrunk, for smooth edges


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


def frames(path):
    """Every frame of a clip, fitted to A's size at 30fps, as an RGB array."""
    fit = f"scale={w}:{h}:force_original_aspect_ratio=increase,crop={w}:{h},fps={FPS}"
    ff = subprocess.Popen(["ffmpeg", "-v", "error", "-i", path, "-vf", fit, "-f", "rawvideo", "-pix_fmt", "rgb24", "-"],
                          stdout=subprocess.PIPE)
    while chunk := ff.stdout.read(w * h * 3):
        yield np.frombuffer(chunk, np.uint8).reshape(h, w, 3)


def star_masks(radius):
    """The inside of an upright star of the given tip radius (pixels) centered on the frame, and its outline,
    each as 0-1 arrays."""
    corners = []
    for k in range(POINTS * 2):
        r = radius * AA * (1 if k % 2 == 0 else INNER)
        angle = math.pi * k / POINTS - math.pi / 2    # first tip straight up
        corners.append((w * AA / 2 + r * math.cos(angle), h * AA / 2 + r * math.sin(angle)))
    inside, outline = Image.new("L", (w * AA, h * AA)), Image.new("L", (w * AA, h * AA))
    ImageDraw.Draw(inside).polygon(corners, fill=255)
    ImageDraw.Draw(outline).line(corners + corners[:2], fill=255, width=EDGE * AA, joint="curve")
    return [np.asarray(m.resize((w, h), Image.LANCZOS), np.float32)[..., None] / 255 for m in (inside, outline)]


def star_wipe(a, b, p):
    """A with B inside the star at progress p (0-1). The star grows, easing in and out, until its inner
    corners pass the frame's corners."""
    eased = p * p * (3 - 2 * p)
    inside, outline = star_masks(eased * math.hypot(w, h) / 2 / INNER * 1.05)
    mix = a * (1 - inside) + b * inside
    return (mix * (1 - outline) + np.array(EDGE_COLOR) * outline).astype(np.uint8)


a_path, b_path, out = sys.argv[1:4]
w, h, a_len = probe(a_path)
start = round((a_len - D) * FPS)    # first frame of the transition
ff = subprocess.Popen(["ffmpeg", "-y", "-v", "error", "-f", "rawvideo", "-pix_fmt", "rgb24", "-s", f"{w}x{h}",
                       "-r", str(FPS), "-i", "-", "-i", a_path, "-i", b_path,
                       "-filter_complex", f"[1:a][2:a]acrossfade=d={D}[au]", "-map", "0:v", "-map", "[au]",
                       "-c:v", "libx264", "-crf", "18", "-pix_fmt", "yuv420p", "-c:a", "aac", out], stdin=subprocess.PIPE)
b_frames = frames(b_path)
for i, a in enumerate(frames(a_path)):
    if i >= start:
        a = star_wipe(a, next(b_frames), (i - start + 1) / (round(D * FPS) + 1))
    ff.stdin.write(a.tobytes())
for b in b_frames:
    ff.stdin.write(b.tobytes())
ff.stdin.close()
if ff.wait():
    sys.exit("ffmpeg failed")