TIMI

TAMI Inventory Management Interface

“timi is always at ~/”

TIMI is the combined weekend-hackathon brainchild of TAMI folks building an audio-visual inventory dataset for the space — and eventually a space-aware inventory tagging, logging and querying system. It is critical infrastructure. It is also complete and utter bullshit. This is a hackerspace.

• 2026-04-27 — Rerun-based dataset viewer for browsing local and remote captures; agent tmux workflow for dashboard, viewer, and GoPro services.
• 2026-04-27 — gopro-scicam merged inline from submodule to simplify builds and eliminate sync friction.
• 2026-04-26 — Unified sidecar schema v1.5 across Android and GoPro: qr_item_id, capture_id, device_name, and device_id now present everywhere.
• 2026-04-26 — Dashboard enhancements: gallery and sidecar preview, capture_alert feedback, beacon-based auto-discovery sync.
• 2026-04-25 — GoPro station mode: split-screen live preview + last capture; QR debounce (2× consecutive); real camera settings (ISO, shutter, aperture, AE/AWB) queried for sidecars.

Full history: TIMI Changelog

At its core TIMI is four things:

• SciCam — an Android camera app that snaps photos (and videos), writes JSON sidecars with EXIF + metadata, exposes a NanoHTTPD REST API, and auto-captures via QR codes.
• GoPro Bridge — a Flask server that talks to a GoPro over USB WiFi, pulls captures, runs a live preview stream, and does motion-based auto-capture with an ROI editor. Writes the same SciCam-compatible sidecars.
• Dashboard — a Rust TUI that discovers devices via UDP multicast, monitors them, and one-way mirrors captures to a local archive.
• Dataset — a growing folder of images, videos, and .json sidecars that describe stuff in the space.

The long-term dream: walk into a room, point a camera at an object (or let a fixed camera see it), and have the system know what it is, where it lives, and how many we have.

All capture sources broadcast UDP multicast beacons every 5 s to 239.255.0.1:9876. The Dashboard / Sync Server (Rust TUI) auto-discovers them, monitors their state over HTTP/SSE, and one-way mirrors captures (JPEG, MP4, JSON sidecars) into ~/timi/capture.

The current focus is capturing and collecting the dataset. More processing stages will follow:

• Segmentation — isolating objects from backgrounds
• Labeling — assigning metadata and categories
• Localization — determining where an object lives in the space

These ML workloads will likely run on the Fedora workstation with its NVIDIA P40 GPU.

• REST API on port 8080 — see the API Spec.
• Photo capture with CameraX, saved to Pictures/SciCam/.
• Video recording — toggle with POST /record, saved to Movies/SciCam/.
• JSON sidecars v1.5 — every capture gets a .json buddy with EXIF, camera settings, qr_item_id, capture_id, device_name, device_id, tags, and timestamp. Stored in Documents/SciCam/.
• QR auto-capture — point the camera at a QR code, the app snaps automatically. Great for rapid inventory sweeps.
• SSE stream — live events at /events so the dashboard sees captures in real-time.

• Flask server connecting to GoPro HERO12 (and compatible) via the Open GoPro USB WiFi API.
• Full web UI — capture button, live MJPEG preview, gallery, sidecar viewer, and a table-boundary ROI editor.
• Motion-based auto-capture — monitors the live preview stream for structural change inside a masked region. Only fires when something actually stays on the table (ignores hands passing through). Adjustable motion and structural thresholds.
• Background sync — on startup, pulls every photo/video from the GoPro SD card that hasn't been downloaded yet. Persists sync history so clearing local files doesn't cause re-downloads.
• SciCam-compatible sidecars — writes the same *.json format as the Android app (qr_item_id, capture_id, tags, timestamp, camera settings, origin, source=“gopro”, device_name, device_id). Includes a background QR-retry hunter that tries ZBar, CLAHE, adaptive threshold, and morphological close to read tricky codes.
• Live QR detection — scans preview frames and downloaded images; updates item_id automatically when a code is found.
• Multicast beacons — broadcasts UDP presence just like SciCam, so the Rust dashboard can discover it.

• Rust terminal UI.
• Auto-discovers devices every 5 s via UDP multicast beacons.
• Syncs *.jpg, *.mp4, and *.json from devices to ~/timi/capture.
• Hotkeys: r/R refresh, s/S sync, w watch SSE, a add, d delete, q quit.
• Config lives in repo-root timi.conf.

• Go CLI (clients/go-scicam) — curl-friendly wrapper.
• Web client (clients/web-scicam) — vanilla JS, static HTML.

Not just one camera — the idea is everything that can see should feed TIMI.

The first TIMI sprint produced a working end-to-end pipeline in about 48 hours:

• Android app rewritten as API-first: fullscreen preview with IP overlay.
• QR detection switched from ZXing to BoofCV — runs on preview frames, no Activity hop.
• REST API with OpenAPI 3 spec.
• Dashboard built in Rust with auto-discovery and sync.
• Go and web clients consuming the API.
• Full test suite in scicam_api_test.sh.
• GoPro bridge added later — brings a rugged wide-angle camera into the TIMI pipeline with motion auto-capture and the same sidecar format.

The SciCam API lives at http:<device-ip>:8080. Critical rule: POST only for state-changing endpoints; GET returns 404. | Method | Endpoint | Purpose | | POST | /capture | Trigger photo | | POST | /record | Toggle video recording | | POST | /settings | Set qr_item_id, tags, lock, debug, capture_alert | | POST | /auto-capture | Enable/disable QR auto-capture | | GET | /status | Current state (qr_item_id, tags, locked, last_qr, …) | | GET | /captures | List all images/videos with sidecar status | | GET | /photo/last | Download latest JPEG | | GET | /photo/<filename> | Download specific JPEG | | GET | /video/last | Download latest MP4 | | GET | /video/<filename> | Download specific MP4 | | GET | /sidecar/<filename> | Download JSON sidecar | | GET | /events | SSE stream | Full spec: api_spec.yaml ===== Git Repository ===== * Origin: git.telavivmakers.space/tami/timi * Local dev desk: ~/timi/ The repo is a multi-component monorepo: <code> timi/ ├── scicam/ # Android app (Kotlin + Gradle Groovy DSL) ├── dashboard/ # Rust TUI ├── clients/ │ ├── go-scicam/ # Go CLI (submodule) │ ├── web-scicam/ # Vanilla JS static client (submodule) │ ├── gopro-scicam/ # Flask GoPro bridge (inline, was submodule) — KEY PLAYER ├── api_spec.yaml # OpenAPI 3 source of truth ├── timi.conf # Dashboard registry & config └── capture/ # Default local archive (gitignored) </code> ===== Roadmap / Dreams ===== * [ ] Prototype PreviewView overlay for QR region feedback in SciCam. * [ ] Camera calibration data in sidecars (lens distortion via BoofCV). * [ ] Database sync — non-destructive to existing images/sidecars. * [ ] Canon 70D scripted capture producing TIMI-compatible sidecars. * [ ] Lixel 2 Pro research and integration. * [ ] Space-aware querying: “what's in the CNC room?” “how many stepper motors?” ===== Philosophy ===== * Treat captures as immutable — this is an archive and dataset. Don't mess with existing files. * API-first UI — the app is primarily a remote-controlled camera. The dashboard and CLI are the main interfaces. * Bullshit acceptable — it is a hackerspace. It should work well enough to be useful and broken enough to be fun. ===== Contact / Hacking ===== Ping the usual suspects on Matrix/Discord/Telegram, or just show up at the space and break things. The code is all there in ~/timi'' on the dev desk. If you improve it, push to Gitea. <code> # Quick start on the dev desk cd ~/timi # Build and install the Android app cd scicam && ./gradlew assembleDebug && adb install app/build/outputs/apk/debug/app-debug.apk # Start the GoPro bridge (needs GoPro in USB Connect mode) cd clients/gopro-scicam && python3 app.py # Start the dashboard cd ~/timi/dashboard && cargo build –release && ./target/release/scicam-dashboard # Test against a device on the network cd ~/timi && ./scicam_api_test.sh <device-ip> </code>