device-envoy-rp 0.1.0

Build Pico applications with LED panels, easy Wi-Fi, and composable device abstractions
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

#!/usr/bin/env python3
"""
Extract hand frames from examples/data/frame-data/hand_frames_data.rs and create a video with ffmpeg.
"""

import re
import subprocess
import tempfile
from pathlib import Path
from PIL import Image


def parse_rgb(text):
    """Parse RGB8::new(r, g, b) into (r, g, b) tuple."""
    match = re.search(r"RGB8::new\((\d+),\s*(\d+),\s*(\d+)\)", text)
    if match:
        return (int(match.group(1)), int(match.group(2)), int(match.group(3)))
    return None


def extract_frames(rust_file):
    """Extract all frames from the Rust data file."""
    with open(rust_file, "r") as f:
        content = f.read()

    # Find all frames (arrays of 8 rows, each with 12 RGB values)
    frames = []
    current_frame = []
    current_row = []

    in_frame = False
    for line in content.split("\n"):
        # Start of a frame
        if "// Frame" in line:
            if current_frame:
                frames.append(current_frame)
            current_frame = []
            in_frame = True
            continue

        if in_frame:
            # Find all RGB values in this line
            rgb_values = re.findall(r"RGB8::new\(\d+,\s*\d+,\s*\d+\)", line)
            for rgb_str in rgb_values:
                rgb = parse_rgb(rgb_str)
                if rgb:
                    current_row.append(rgb)

            # End of row (contains '],' or '],')
            if "]," in line:
                if current_row:
                    current_frame.append(current_row)
                    current_row = []

    # Add the last frame
    if current_frame:
        frames.append(current_frame)

    return frames


def create_video(frames, output_path, scale=40, fps=10):
    """Create a video from frames using ffmpeg."""
    with tempfile.TemporaryDirectory() as tmpdir:
        tmp_path = Path(tmpdir)

        # Create PNG files for each frame
        for idx, frame_data in enumerate(frames):
            # Create a 12x8 image
            img = Image.new("RGB", (12, 8))
            pixels = img.load()

            for row_idx, row in enumerate(frame_data):
                for col_idx, (r, g, b) in enumerate(row):
                    pixels[col_idx, row_idx] = (r, g, b)

            # Scale up for visibility
            img = img.resize((12 * scale, 8 * scale), Image.NEAREST)

            # Save with zero-padded filename
            img.save(tmp_path / f"frame_{idx:04d}.png")

        # Use ffmpeg to create video
        cmd = [
            "ffmpeg",
            "-y",
            "-framerate",
            str(fps),
            "-i",
            str(tmp_path / "frame_%04d.png"),
            "-c:v",
            "libx264",
            "-pix_fmt",
            "yuv420p",
            "-crf",
            "18",
            str(output_path),
        ]

        print(f"Creating video with {len(frames)} frames at {fps} fps...")
        subprocess.run(cmd, check=True)
        print(f"Video saved to: {output_path}")


def main():
    script_dir = Path(__file__).parent
    repo_dir = script_dir.parent

    rust_file = repo_dir / "examples" / "data" / "frame-data" / "hand_frames_data.rs"
    output_file = repo_dir / "hand_video.mp4"

    if not rust_file.exists():
        print(f"Error: {rust_file} not found")
        return 1

    print(f"Extracting frames from {rust_file}...")
    frames = extract_frames(rust_file)
    print(f"Found {len(frames)} frames")

    if not frames:
        print("No frames found!")
        return 1

    # Validate frame dimensions
    for idx, frame in enumerate(frames):
        if len(frame) != 8:
            print(f"Warning: Frame {idx} has {len(frame)} rows (expected 8)")
        for row_idx, row in enumerate(frame):
            if len(row) != 12:
                print(
                    f"Warning: Frame {idx}, row {row_idx} has {len(row)} pixels (expected 12)"
                )

    create_video(frames, output_file, scale=40, fps=10)
    return 0


if __name__ == "__main__":
    exit(main())