var

KO | EN

gitlite — search

#graphql #docker #claude-code #rag #web #macos #cloud-native #typescript #ui #chatgpt

(★ 9)

VAR system for Billiardino (on a RP4)

파일 탐색기

ZIP 다운로드

- slowmo-cam.service
- slowmo-referee.service
- - card_01_SparseAttention.png
  - card_02_DreamTeam.png
  - card_03_TeamX.png
  - card_04_CSTTers.png
  - card_05_Digital_Power.png
  - card_06_MK5.png
  - card_07_MACHETE_CREW.png
  - card_08_VVimers.png
  - card_09_GGGG.png
  - card_10_The_Optimization_Passes.png
  - card_11_Backward_Pass.png
  - card_12_Messina.png
  - card_13_T_ggeli_J_ggeli.png
  - card_14_The_Anti-Heroes.png
  - mapping.json
- calibration.jpg
- calibration_rois.jpg
- gen_cards.py
- live_cards.jpg
- masked_check.jpg
- referee.json
- referee.py
- truth93.jpg
- compute_scores.py
- page_rank_biliardino_algorithm.py
- page_rank_biliardino_algorithm_bias.py
- README.md
- weight_function_dark.png
- weight_function_light.png
- ball_speed.py
.gitignore
Makefile
README.md
set-web-password.sh
slowmo_cam.cpp
slowmo_cam.py

# CDN으로 사용하기

jsDelivr

jsDelivr는 공개 GitHub 리포지토리를 별도 설정 없이 CDN으로 즉시 서빙합니다. 버전과 파일을 고르면 웹페이지에 바로 붙일 수 있는 링크와 예시 코드가 만들어집니다.

버전

파일

링크

예시

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

A Raspberry Pi 4 + OV9281 USB camera (1280×720 @ 120 fps) record continuously
into RAM. One key — or one button in any browser — replays the last 5 seconds
in 4× slow motion while the clip saves in the background. Only the newest 20
clips are kept (`--max-clips`, renamed clips are kept forever). Includes a
tournament scoreboard.

| File | What it is |
|---|---|
| `slowmo_cam.cpp` | the recorder (C++, standalone; `slowmo_cam.py` = old reference) |
| `score_function/` | PageRank score algorithms + `compute_scores.py` bridge |
| `deploy/slowmo-cam.service` | systemd unit (source of the installed one) |
| `set-web-password.sh` | change a web login password (`biliardino` or `admin`) |

## Running it (systemd)

The recorder runs as a service: starts on boot, retries every 5 s until the
camera appears (hot-plug works — unplugging mid-game is fine), restarts on
crashes. **`kill`/htop won't stop it — systemd revives it in 5 s.** Use:

```bash
sudo systemctl stop  slowmo-cam            # off (until next boot)
sudo systemctl start slowmo-cam            # on
sudo systemctl disable --now slowmo-cam    # off + no autostart
sudo systemctl enable  --now slowmo-cam    # undo that
sudo systemctl restart slowmo-cam          # after `make`
journalctl -u slowmo-cam -f                # live logs
# reinstall after editing the unit:
sudo cp deploy/slowmo-cam.service /etc/systemd/system/ && \
  sudo systemctl daemon-reload && sudo systemctl enable --now slowmo-cam
```

Build with `make` (needs `g++ make ffmpeg`), then restart the service.

## Web page

```
https://<pi-ip>/        user: biliardino   password: ~/slowmo-cam-password.txt
```

nginx terminates TLS on 443 (self-signed cert, accept the one-time warning;
TLSv1.2 + ChaCha20 pinned — the Pi has no AES hardware, ChaCha is ~11×
faster) and proxies to the recorder on `127.0.0.1:8081`. Old
`http://…:8080` links redirect. Change a password with
`./set-web-password.sh [biliardino|admin]`.

**Two logins:** `biliardino` is the shared everyone-account;
**`admin`** (password: `~/slowmo-cam-admin-password.txt`) additionally
gets the **PageRank algorithm switch** and the **damping-d slider**.
nginx forwards the logged-in account as `X-Remote-User` (a client-sent
header is overwritten, so it can't be spoofed); requests that never
passed nginx — SSH tunnel, the TV's localhost browser — count as admin,
because reaching `127.0.0.1:8081` means owning the Pi.

Over SSH, tunnel instead:
`ssh -L 8081:localhost:8081 noabauma@<pi-ip>` → `http://localhost:8081`.
**Prefer it open (no TLS/login)?** Set `--bind 0.0.0.0` in the service and
browse `http://<pi-ip>:8081` — only do this if 443 isn't internet-exposed.

On the page: live view, status bar (fps / buffer / drops / 👁 viewer count),
**Save + replay**, **Replay last**, **Live**, fullscreen (⛶/`f`), and a
**recordings panel** (click to replay a clip, ✎ rename = keep forever,
⬇ download, 🗑 delete). Keys: `space` save, `r` replay, `f` fullscreen,
`l`/`esc` live. Saves are written instantly as lossless MJPEG-AVI, then a
background worker converts them to **H.264 MP4 on the Pi's hardware
encoder** (~35 s, ~6x smaller) and removes the AVI — so clips in
`~/recordings` are MP4: they play in a native `<video>` player with
pause/scrubbing and download small. AVIs still around (older saves,
failed conversions) keep working via the legacy MJPEG replay.

**🎲 Virtual betting (no money, just glory):** spectators and players sign
in with just a name, someone opens betting on the match about to start,
and everyone picks a team at odds derived from the bias PageRank standings
(locked at bet time; underdogs pay more). Bets settle automatically when
the result is entered — a win pays `odds×10` points — and a bettor
leaderboard tracks points and records in `<out-dir>/bets.tsv`.
Endpoints: `GET /bets`, `POST /bets/open?a=X&b=Y`,
`POST /bets/place?who=N&pick=X`, `POST /bets/cancel`.

**📷 Camera ON/OFF (privacy switch, admin-only):** the `admin` login can
pause recording from the page (server-gated: `POST /camera` returns 403
for others). OFF discards every frame the moment it arrives — the ring buffer is
wiped (nothing from before the press can be saved), nothing new is stored
or served, `/save` and `/frame` are refused, and the video area shows
"Camera is OFF". ON is instant. Saved clips on disk are not affected.
`POST /camera?on=0|1`. (The device itself stays open and streaming into
the void: the AR0234's USB bridge can return from a close+reopen as a
zombie — and USB-resetting that zombie once oopsed the kernel — so
close/reopen is avoided entirely.)

**⚽ Goal speed:** after each save is converted to MP4, `speed/ball_speed.py`
replays the clip in the background (~40 s, nice'd): it finds the moving
ball inside the calibrated playfield, and if the trajectory dies in a goal
mouth without bouncing back out, the clip is a **goal** — the shot's speed
lands in `<clip>.speed.json`, shows up green in the recordings list and
pops up in the player at the goal moment. No goal, occluded view or a
moved camera (background no longer matches `speed/ref_bg.jpg`, re-store it
with `ball_speed.py calibrate <clip>`) = honest silence instead of a made-up
number. Speeds assume a 1200×680 mm playfield (`table_mm` in
`speed/speed_cal.json`) — tape-measure it once for exact numbers.

**Slow link (VPN/weak WiFi)?** The full stream is ~24 Mbit/s. Pick a lower
rate in the **fps selector** next to Live (remembered per browser); slow
viewers also self-adapt server-side to fresh-not-stale frames.

The camera is opened exactly once, by the recorder — the browser gets the
same compressed MJPEG frames from the ring buffer (no transcoding), so live
view, saves and replays all run simultaneously without conflict.

Endpoints: `GET /stream` (`?fps=N`), `GET /replay` (`?file=x.avi` for disk
clips), `POST /save`, `GET /status`, `GET /recordings`,
`POST /recordings/rename?file=X&name=Y`, `POST /recordings/delete?file=X`.

## Tournament scoreboard

Rankings switchable between **bias PageRank**
(`page_rank_biliardino_algorithm_bias.py`, baseline ∝ games played) and
**classic PageRank** (`page_rank_biliardino_algorithm.py`). The Python files
are the single source of truth — edit them and the board follows
(`recursive_deletion` is deliberately not applied mid-tournament).
A third ranking, **weighted bias**, runs the bias algorithm on a
goal-difference-weighted matrix: each match's edge weight is
`1 + x·|totals_A − totals_B| / (games·10)` — the win itself always earns
the base credit, and hyperparameter `x ∈ [0, 10)` (`POST /scores/x`,
0 = plain binary) tunes how much a dominant goal difference adds on top
(see `score_function/README.md`). The bias/weighted/classic switch, the
damping-d slider (default 0.85) and the x input are visible to the
`admin` login only and admin-gated server-side; neither d nor x is
persisted.

**⚔ Knockout (top 8):** the bracket below the camera view seeds the
current top 8 of the bias ranking (1v8, 4v5, 3v6, 2v7) and stays **live**
— teams can still move in and out — until the **first result is entered,
which freezes the seeding** into `<out-dir>/knockout.tsv`. Click a match
to enter its game scores (same best-of-three syntax as group matches;
click again to edit, 🗑 deletes — deleting the last result un-freezes).
Winners advance automatically to the semis, final and the 🏆.
Below the main tree, the **losing tree** plays out places 3–8: the four
QF losers pair up (loser QF1 vs loser QF2, loser QF3 vs loser QF4), the
winners meet the SF losers **crossed** (winner LR1 vs loser SF2, winner
LR2 vs loser SF1 — nobody rematches the team that just beat them), and
those two winners contest the 🥉 3rd-place final.
Endpoints: `GET /ko`,
`POST /ko/add?stage=qf1..qf4|sf1|sf2|f|lr1|lr2|lq1|lq2|p3&a=X&b=Y&games=…`,
`POST /ko/del?stage=X`. Knockout results live outside the group ranking —
they never touch the PageRank matrix.

One big group; **each pair plays at most once**. Enter *team A*, *team B*,
game scores from A's view (`10-9, 10-4` or `7-5, 4-7, 11-9`) — each game
goes to whoever scored more (play to 10, to 7, or deuce — any non-tied
score counts), the match to whoever won more games; tied matches and
rematches are rejected. New names create teams
(**Add team** also works); click a team row for its match history, per-match
✎ edit / 🗑 delete, **rename**, and **Delete team**. **Undo** removes the
last match. Below the table: head-to-head **matrix + directed graph**.

**Persistence: every change is written immediately (atomic tmp+rename) to
`~/recordings/tournament.tsv` — stopping, killing, crashing or a power cut
loses nothing.** Start a fresh tournament with:

```bash
: > ~/recordings/tournament.tsv && sudo systemctl restart slowmo-cam
```

(truncate, don't delete — a missing file re-seeds last year's demo data).

Endpoints: `GET /scores`, `POST /scores/add?a=X&b=Y&games=10-9,10-4`,
`/scores/rename?team=X&name=Y`, `/scores/undo`, `/scores/team/add?name=X`,
`/scores/team/delete?name=X`, `/scores/match/edit?a=X&b=Y&games=…`,
`/scores/match/delete?a=X&b=Y`, `/scores/d?value=0.85` (all POST).
Options: `--scores-file`, `--scores-script`, `--no-scores`. Needs
`python3` + `numpy`.

## Terminal keys (when run interactively)

`SPACE`/`s` save + instant replay · `r` replay again · any key stops a
replay · `q` quit.

## Options

```
--device PATH        camera device            (default /dev/video0)
--width N            capture width            (default 1280)
--height N           capture height           (default 720)
--fps N              capture frame rate       (default 120)
--playback-fps N     saved/replay frame rate  (default 30 → 4× slow motion)
--seconds S          seconds kept in RAM      (default 5)
--max-clips N        keep only the newest N clips (default 20, 0 = all)
--out-dir DIR        where clips are saved    (default ~/recordings)
--player CMD         custom replay command (raw MJPEG on stdin)
--no-autoreplay      s only saves; use r to replay
--selftest N         capture N s, save, verify, exit (no keyboard needed)
--selftest-replay    selftest also plays one replay pass
--mjpeg-file PATH    test input: raw .mjpeg file instead of a camera
--port N             web port (default 8080, 0 = off)
--bind ADDR          web listener (default 0.0.0.0; 127.0.0.1 = proxy only)
--http-fps N         default live-stream rate (default 30)
--scores-script PATH python bridge for the scoreboard
--scores-file PATH   tournament state (default <out-dir>/tournament.tsv)
--no-scores          disable the web scoreboard
--speed-script PATH  goal/ball-speed analyzer ("" disables)
```

## Self-test & troubleshooting

```bash
./slowmo_cam --selftest 3        # capture fps + saving, non-zero exit on failure
# no camera? test against a generated stream:
ffmpeg -f lavfi -i testsrc2=duration=4:rate=60:size=1280x720 -c:v mjpeg -f mjpeg test.mjpeg
./slowmo_cam --mjpeg-file test.mjpeg --fps 60 --selftest 3
```

- **fps far below 120** — mode not granted: check
  `v4l2-ctl -d /dev/video0 --list-formats-ext`, request a real mode.
- **`drops` climbing** — USB losing frames: shorter cable / lower fps.
- **no camera** — page shows "no camera", video resumes on plug-in.
- **TV score display goes black** — X blanking/DPMS is disabled on this Pi
  (`xserver-command=X -s 0 -dpms` in `/etc/lightdm/lightdm.conf`); if the
  TV still sleeps, it's the TV's own eco/sleep timer or HDMI-CEC setting.
- **profiling** — `make tracr` builds an instrumented binary (TraCR);
  `~/src/tracr/build/tracr_process tracr/tracr perfetto` → ui.perfetto.dev.

## Design notes

- Saves are a **lossless one-pass AVI write** (own muxer, no ffmpeg, no
  temp file); replays play **from RAM** while the file writes — that, plus
  reading the camera directly via V4L2, is why the C++ version beat the old
  Python one (the SD card was the bottleneck, not Python).
- `.avi` because it writes in one pass and plays everywhere. For sharing:
  `ffmpeg -i clip.avi -c copy clip.mp4` (instant) or
  `-c:v libx264 -crf 20` (small, slower).

var

파일 탐색기

# CDN으로 사용하기

Was this content helpful?

Recent Feedback

Download README