Add composite_cursor.py and .gitignore

composite_cursor.py provides a utility for placing cursors onto
screenshots with correct hotspot alignment and alpha compositing.

Made-with: Cursor

.gitignore

@@ -0,0 +1,5 @@
+cursor_dataset/
+sample_screenshots/
+.cursor/
+__pycache__/
+*.pyc

composite_cursor.py

@@ -0,0 +1,135 @@
+#!/usr/bin/env python3
+# /// script
+# requires-python = ">=3.10"
+# dependencies = [
+#     "Pillow>=10.0",
+#     "datasets>=2.14",
+# ]
+# ///
+"""Composite a cursor from the Fraser/cursors dataset onto a screenshot.
+
+Usage:
+    uv run composite_cursor.py sample_screenshots/some_image.png
+
+Produces: sample_screenshots/some_image_cursored.png
+"""
+
+import random
+import sys
+from pathlib import Path
+
+from datasets import load_dataset
+from PIL import Image
+
+
+def load_cursors(os_filter=None):
+    """Load the cursor dataset, optionally filtering by OS."""
+    ds = load_dataset("Fraser/cursors", split="train")
+    if os_filter:
+        ds = ds.filter(lambda r: r["os"] == os_filter)
+    return ds
+
+
+def composite_cursor(
+    screenshot: Image.Image,
+    cursor_frame: Image.Image,
+    hotspot_x: float,
+    hotspot_y: float,
+    target_x: int,
+    target_y: int,
+    cursor_size: int = 32,
+) -> Image.Image:
+    """Place a cursor onto a screenshot so the hotspot lands at (target_x, target_y).
+
+    Args:
+        screenshot: The background image (any mode, will be converted to RGBA).
+        cursor_frame: A single RGBA cursor frame.
+        hotspot_x: Normalised hotspot x (0-1 within cursor image).
+        hotspot_y: Normalised hotspot y (0-1 within cursor image).
+        target_x: Pixel x on the screenshot where the hotspot should land.
+        target_y: Pixel y on the screenshot where the hotspot should land.
+        cursor_size: Desired cursor height in pixels (width scales proportionally).
+
+    Returns:
+        Composited image in the same mode as the input screenshot.
+    """
+    orig_mode = screenshot.mode
+    canvas = screenshot.convert("RGBA")
+
+    cw, ch = cursor_frame.size
+    scale = cursor_size / max(cw, ch)
+    new_w, new_h = max(1, round(cw * scale)), max(1, round(ch * scale))
+    cursor_scaled = cursor_frame.convert("RGBA").resize(
+        (new_w, new_h), Image.LANCZOS
+    )
+
+    paste_x = target_x - round(hotspot_x * new_w)
+    paste_y = target_y - round(hotspot_y * new_h)
+
+    # Crop cursor if it extends beyond the screenshot edges
+    sw, sh = canvas.size
+    src_left = max(0, -paste_x)
+    src_top = max(0, -paste_y)
+    src_right = min(new_w, sw - paste_x)
+    src_bottom = min(new_h, sh - paste_y)
+
+    if src_left >= src_right or src_top >= src_bottom:
+        return screenshot
+
+    cropped = cursor_scaled.crop((src_left, src_top, src_right, src_bottom))
+    dst_x = paste_x + src_left
+    dst_y = paste_y + src_top
+
+    canvas.alpha_composite(cropped, (dst_x, dst_y))
+
+    if orig_mode != "RGBA":
+        canvas = canvas.convert(orig_mode)
+    return canvas
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("Usage: uv run composite_cursor.py <screenshot.png> [x y] [cursor_size]")
+        print("  x, y: click-point position (default: random)")
+        print("  cursor_size: cursor height in pixels (default: 32)")
+        sys.exit(1)
+
+    screenshot_path = Path(sys.argv[1])
+    screenshot = Image.open(screenshot_path)
+    sw, sh = screenshot.size
+
+    if len(sys.argv) >= 4:
+        tx, ty = int(sys.argv[2]), int(sys.argv[3])
+    else:
+        tx = random.randint(int(sw * 0.05), int(sw * 0.95))
+        ty = random.randint(int(sh * 0.05), int(sh * 0.95))
+
+    cursor_size = int(sys.argv[4]) if len(sys.argv) >= 5 else 32
+
+    print(f"Screenshot: {screenshot_path} ({sw}x{sh})")
+    print(f"Loading cursors...")
+    ds = load_cursors()
+
+    # Pick a random static cursor
+    static = [i for i in range(len(ds)) if len(ds[i]["frames"]) == 1]
+    idx = random.choice(static)
+    row = ds[idx]
+
+    cursor_frame = row["frames"][0]
+    print(f"Cursor: {row['cursor_type']} / {row['os']} / {row['variant']}")
+    print(f"Hotspot: ({row['hotspot_x']:.2f}, {row['hotspot_y']:.2f})")
+    print(f"Placing at: ({tx}, {ty}), size={cursor_size}px")
+
+    result = composite_cursor(
+        screenshot, cursor_frame,
+        row["hotspot_x"], row["hotspot_y"],
+        tx, ty, cursor_size,
+    )
+
+    out_path = screenshot_path.with_stem(screenshot_path.stem + "_cursored")
+    result.save(out_path)
+    print(f"Saved: {out_path}")
+
+
+if __name__ == "__main__":
+    main()