| |
| |
| |
| |
| |
| |
| |
| |
| """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) |
|
|
| |
| 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() |
|
|
| |
| 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() |
|
|
