Compare commits
5 Commits
MaTriXy/fe
...
feat/adr-0
| Author | SHA1 | Date | |
|---|---|---|---|
|
4b36d7c9d7 | ||
|
|
7092f83b34 | ||
|
|
aa1059d9e2 | ||
|
|
0826438e0e | ||
|
|
5942d4dd5b |
3
.gitignore
vendored
3
.gitignore
vendored
@@ -193,9 +193,6 @@ cython_debug/
|
||||
# PyPI configuration file
|
||||
.pypirc
|
||||
|
||||
# Compiled Swift helper binaries (macOS WiFi sensing)
|
||||
v1/src/sensing/mac_wifi
|
||||
|
||||
# Cursor
|
||||
# Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to
|
||||
# exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
|
||||
|
||||
276
CHANGELOG.md
276
CHANGELOG.md
@@ -5,246 +5,68 @@ All notable changes to this project will be documented in this file.
|
||||
The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
|
||||
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
|
||||
|
||||
## [Unreleased]
|
||||
|
||||
### Added
|
||||
- **Project MERIDIAN (ADR-027)** — Cross-environment domain generalization for WiFi pose estimation (1,858 lines, 72 tests)
|
||||
- `HardwareNormalizer` — Catmull-Rom cubic interpolation resamples any hardware CSI to canonical 56 subcarriers; z-score + phase sanitization
|
||||
- `DomainFactorizer` + `GradientReversalLayer` — adversarial disentanglement of pose-relevant vs environment-specific features
|
||||
- `GeometryEncoder` + `FilmLayer` — Fourier positional encoding + DeepSets + FiLM for zero-shot deployment given AP positions
|
||||
- `VirtualDomainAugmentor` — synthetic environment diversity (room scale, wall material, scatterers, noise) for 4x training augmentation
|
||||
- `RapidAdaptation` — 10-second unsupervised calibration via contrastive test-time training + LoRA adapters
|
||||
- `CrossDomainEvaluator` — 6-metric evaluation protocol (MPJPE in-domain/cross-domain/few-shot/cross-hardware, domain gap ratio, adaptation speedup)
|
||||
- ADR-027: Cross-Environment Domain Generalization — 10 SOTA citations (PerceptAlign, X-Fi ICLR 2025, AM-FM, DGSense, CVPR 2024)
|
||||
- **Cross-platform RSSI adapters** — macOS CoreWLAN (`MacosCoreWlanScanner`) and Linux `iw` (`LinuxIwScanner`) Rust adapters with `#[cfg(target_os)]` gating
|
||||
- macOS CoreWLAN Python sensing adapter with Swift helper (`mac_wifi.swift`)
|
||||
- macOS synthetic BSSID generation (FNV-1a hash) for Sonoma 14.4+ BSSID redaction
|
||||
- Linux `iw dev <iface> scan` parser with freq-to-channel conversion and `scan dump` (no-root) mode
|
||||
- ADR-025: macOS CoreWLAN WiFi Sensing (ORCA)
|
||||
|
||||
### Fixed
|
||||
- Removed synthetic byte counters from Python `MacosWifiCollector` — now reports `tx_bytes=0, rx_bytes=0` instead of fake incrementing values
|
||||
|
||||
---
|
||||
|
||||
## [3.0.0] - 2026-03-01
|
||||
|
||||
Major release: AETHER contrastive embedding model, Docker Hub images, and comprehensive UI overhaul.
|
||||
|
||||
### Added — AETHER Contrastive Embedding Model (ADR-024)
|
||||
- **Project AETHER** — self-supervised contrastive learning for WiFi CSI fingerprinting, similarity search, and anomaly detection (`9bbe956`)
|
||||
- `embedding.rs` module: `ProjectionHead`, `InfoNceLoss`, `CsiAugmenter`, `FingerprintIndex`, `PoseEncoder`, `EmbeddingExtractor` (909 lines, zero external ML dependencies)
|
||||
- SimCLR-style pretraining with 5 physically-motivated augmentations (temporal jitter, subcarrier masking, Gaussian noise, phase rotation, amplitude scaling)
|
||||
- CLI flags: `--pretrain`, `--pretrain-epochs`, `--embed`, `--build-index <type>`
|
||||
- Four HNSW-compatible fingerprint index types: `env_fingerprint`, `activity_pattern`, `temporal_baseline`, `person_track`
|
||||
- Cross-modal `PoseEncoder` for WiFi-to-camera embedding alignment
|
||||
- VICReg regularization for embedding collapse prevention
|
||||
- 53K total parameters (55 KB at INT8) — fits on ESP32
|
||||
|
||||
### Added — Docker & Deployment
|
||||
- Published Docker Hub images: `ruvnet/wifi-densepose:latest` (132 MB Rust) and `ruvnet/wifi-densepose:python` (569 MB) (`add9f19`)
|
||||
- Multi-stage Dockerfile for Rust sensing server with RuVector crates
|
||||
- `docker-compose.yml` orchestrating both Rust and Python services
|
||||
- RVF model export via `--export-rvf` and load via `--load-rvf` CLI flags
|
||||
|
||||
### Added — Documentation
|
||||
- 33 use cases across 4 vertical tiers: Everyday, Specialized, Robotics & Industrial, Extreme (`0afd9c5`)
|
||||
- "Why WiFi Wins" comparison table (WiFi vs camera vs LIDAR vs wearable vs PIR)
|
||||
- Mermaid architecture diagrams: end-to-end pipeline, signal processing detail, deployment topology (`50f0fc9`)
|
||||
- Models & Training section with RuVector crate links (GitHub + crates.io), SONA component table (`965a1cc`)
|
||||
- RVF container section with deployment targets table (ESP32 0.7 MB to server 50+ MB)
|
||||
- Collapsible README sections for improved navigation (`478d964`, `99ec980`, `0ebd6be`)
|
||||
- Installation and Quick Start moved above Table of Contents (`50acbf7`)
|
||||
- CSI hardware requirement notice (`528b394`)
|
||||
|
||||
### Fixed
|
||||
- **UI auto-detects server port from page origin** — no more hardcoded `localhost:8080`; works on any port (Docker :3000, native :8080, custom) (`3b72f35`, closes #55)
|
||||
- **Docker port mismatch** — server now binds 3000/3001 inside container as documented (`44b9c30`)
|
||||
- Added `/ws/sensing` WebSocket route to the HTTP server so UI only needs one port
|
||||
- Fixed README API endpoint references: `/api/v1/health` → `/health`, `/api/v1/sensing` → `/api/v1/sensing/latest`
|
||||
- Multi-person tracking limit corrected: configurable default 10, no hard software cap (`e2ce250`)
|
||||
|
||||
---
|
||||
|
||||
## [2.0.0] - 2026-02-28
|
||||
|
||||
Major release: complete Rust sensing server, full DensePose training pipeline, RuVector v2.0.4 integration, ESP32-S3 firmware, and 6 security hardening patches.
|
||||
|
||||
### Added — Rust Sensing Server
|
||||
- **Full DensePose-compatible REST API** served by Axum (`d956c30`)
|
||||
- `GET /health` — server health
|
||||
- `GET /api/v1/sensing/latest` — live CSI sensing data
|
||||
- `GET /api/v1/vital-signs` — breathing rate (6-30 BPM) and heartbeat (40-120 BPM)
|
||||
- `GET /api/v1/pose/current` — 17 COCO keypoints derived from WiFi signal field
|
||||
- `GET /api/v1/info` — server build and feature info
|
||||
- `GET /api/v1/model/info` — RVF model container metadata
|
||||
- `ws://host/ws/sensing` — real-time WebSocket stream
|
||||
- Three data sources: `--source esp32` (UDP CSI), `--source windows` (netsh RSSI), `--source simulated` (deterministic reference)
|
||||
- Auto-detection: server probes ESP32 UDP and Windows WiFi, falls back to simulated
|
||||
- Three.js visualization UI with 3D body skeleton, signal heatmap, phase plot, Doppler bars, vital signs panel
|
||||
- Static UI serving via `--ui-path` flag
|
||||
- Throughput: 9,520–11,665 frames/sec (release build)
|
||||
|
||||
### Added — ADR-021: Vital Sign Detection
|
||||
- `VitalSignDetector` with breathing (6-30 BPM) and heartbeat (40-120 BPM) extraction from CSI fluctuations (`1192de9`)
|
||||
- FFT-based spectral analysis with configurable band-pass filters
|
||||
- Confidence scoring based on spectral peak prominence
|
||||
- REST endpoint `/api/v1/vital-signs` with real-time JSON output
|
||||
|
||||
### Added — ADR-023: DensePose Training Pipeline (Phases 1-8)
|
||||
- `wifi-densepose-train` crate with complete 8-phase pipeline (`fc409df`, `ec98e40`, `fce1271`)
|
||||
- Phase 1: `DataPipeline` with MM-Fi and Wi-Pose dataset loaders
|
||||
- Phase 2: `CsiToPoseTransformer` — 4-head cross-attention + 2-layer GCN on COCO skeleton
|
||||
- Phase 3: 6-term composite loss (MSE, bone length, symmetry, joint angle, temporal, confidence)
|
||||
- Phase 4: `DynamicPersonMatcher` via ruvector-mincut (O(n^1.5 log n) Hungarian assignment)
|
||||
- Phase 5: `SonaAdapter` — MicroLoRA rank-4 with EWC++ memory preservation
|
||||
- Phase 6: `SparseInference` — progressive 3-layer model loading (A: essential, B: refinement, C: full)
|
||||
- Phase 7: `RvfContainer` — single-file model packaging with segment-based binary format
|
||||
- Phase 8: End-to-end training with cosine-annealing LR, early stopping, checkpoint saving
|
||||
- CLI: `--train`, `--dataset`, `--epochs`, `--save-rvf`, `--load-rvf`, `--export-rvf`
|
||||
- Benchmark: ~11,665 fps inference, 229 tests passing
|
||||
|
||||
### Added — ADR-016: RuVector Training Integration (all 5 crates)
|
||||
- `ruvector-mincut` → `DynamicPersonMatcher` in `metrics.rs` + subcarrier selection (`81ad09d`, `a7dd31c`)
|
||||
- `ruvector-attn-mincut` → antenna attention in `model.rs` + noise-gated spectrogram
|
||||
- `ruvector-temporal-tensor` → `CompressedCsiBuffer` in `dataset.rs` + compressed breathing/heartbeat
|
||||
- `ruvector-solver` → sparse subcarrier interpolation (114→56) + Fresnel triangulation
|
||||
- `ruvector-attention` → spatial attention in `model.rs` + attention-weighted BVP
|
||||
- Vendored all 11 RuVector crates under `vendor/ruvector/` (`d803bfe`)
|
||||
|
||||
### Added — ADR-017: RuVector Signal & MAT Integration (7 integration points)
|
||||
- `gate_spectrogram()` — attention-gated noise suppression (`18170d7`)
|
||||
- `attention_weighted_bvp()` — sensitivity-weighted velocity profiles
|
||||
- `mincut_subcarrier_partition()` — dynamic sensitive/insensitive subcarrier split
|
||||
- `solve_fresnel_geometry()` — TX-body-RX distance estimation
|
||||
- `CompressedBreathingBuffer` + `CompressedHeartbeatSpectrogram`
|
||||
- `BreathingDetector` + `HeartbeatDetector` (MAT crate, real FFT + micro-Doppler)
|
||||
- Feature-gated behind `cfg(feature = "ruvector")` (`ab2453e`)
|
||||
|
||||
### Added — ADR-018: ESP32-S3 Firmware & Live CSI Pipeline
|
||||
- ESP32-S3 firmware with FreeRTOS CSI extraction (`92a5182`)
|
||||
- ADR-018 binary frame format: `[0xAD, 0x18, len_hi, len_lo, payload]`
|
||||
- Rust `Esp32Aggregator` receiving UDP frames on port 5005
|
||||
- `bridge.rs` converting I/Q pairs to amplitude/phase vectors
|
||||
- NVS provisioning for WiFi credentials
|
||||
- Pre-built binary quick start documentation (`696a726`)
|
||||
|
||||
### Added — ADR-014: SOTA Signal Processing
|
||||
- 6 algorithms, 83 tests (`fcb93cc`)
|
||||
- Hampel filter (median + MAD, resistant to 50% contamination)
|
||||
- Conjugate multiplication (reference-antenna ratio, cancels common-mode noise)
|
||||
- Phase sanitization (unwrap + linear detrend, removes CFO/SFO)
|
||||
- Fresnel zone geometry (TX-body-RX distance from first-principles physics)
|
||||
- Body Velocity Profile (micro-Doppler extraction, 5.7x speedup)
|
||||
- Attention-gated spectrogram (learned noise suppression)
|
||||
|
||||
### Added — ADR-015: Public Dataset Training Strategy
|
||||
- MM-Fi and Wi-Pose dataset specifications with download links (`4babb32`, `5dc2f66`)
|
||||
- Verified dataset dimensions, sampling rates, and annotation formats
|
||||
- Cross-dataset evaluation protocol
|
||||
|
||||
### Added — WiFi-Mat Disaster Detection Module
|
||||
- Multi-AP triangulation for through-wall survivor detection (`a17b630`, `6b20ff0`)
|
||||
- Triage classification (breathing, heartbeat, motion)
|
||||
- Domain events: `survivor_detected`, `survivor_updated`, `alert_created`
|
||||
- WebSocket broadcast at `/ws/mat/stream`
|
||||
|
||||
### Added — Infrastructure
|
||||
- Guided 7-step interactive installer with 8 hardware profiles (`8583f3e`)
|
||||
- Comprehensive build guide for Linux, macOS, Windows, Docker, ESP32 (`45f8a0d`)
|
||||
- 12 Architecture Decision Records (ADR-001 through ADR-012) (`337dd96`)
|
||||
|
||||
### Added — UI & Visualization
|
||||
- Sensing-only UI mode with Gaussian splat visualization (`b7e0f07`)
|
||||
- Three.js 3D body model (17 joints, 16 limbs) with signal-viz components
|
||||
- Tabs: Dashboard, Hardware, Live Demo, Sensing, Architecture, Performance, Applications
|
||||
- WebSocket client with automatic reconnection and exponential backoff
|
||||
|
||||
### Added — Rust Signal Processing Crate
|
||||
- Complete Rust port of WiFi-DensePose with modular workspace (`6ed69a3`)
|
||||
- `wifi-densepose-signal` — CSI processing, phase sanitization, feature extraction
|
||||
- `wifi-densepose-core` — shared types and configuration
|
||||
- `wifi-densepose-nn` — neural network inference (DensePose head, RCNN)
|
||||
- `wifi-densepose-hardware` — ESP32 aggregator, hardware interfaces
|
||||
- `wifi-densepose-config` — configuration management
|
||||
- Comprehensive benchmarks and validation tests (`3ccb301`)
|
||||
|
||||
### Added — Python Sensing Pipeline
|
||||
- `WindowsWifiCollector` — RSSI collection via `netsh wlan show networks`
|
||||
- `RssiFeatureExtractor` — variance, spectral bands (motion 0.5-4 Hz, breathing 0.1-0.5 Hz), change points
|
||||
- `PresenceClassifier` — rule-based 3-state classification (ABSENT / PRESENT_STILL / ACTIVE)
|
||||
- Cross-receiver agreement scoring for multi-AP confidence boosting
|
||||
- WebSocket sensing server (`ws_server.py`) broadcasting JSON at 2 Hz
|
||||
- Deterministic CSI proof bundles for reproducible verification (`v1/data/proof/`)
|
||||
- Commodity sensing unit tests (`b391638`)
|
||||
|
||||
### Changed
|
||||
- Rust hardware adapters now return explicit errors instead of silent empty data (`6e0e539`)
|
||||
|
||||
### Fixed
|
||||
- Review fixes for end-to-end training pipeline (`45f0304`)
|
||||
- Dockerfile paths updated from `src/` to `v1/src/` (`7872987`)
|
||||
- IoT profile installer instructions updated for aggregator CLI (`f460097`)
|
||||
- `process.env` reference removed from browser ES module (`e320bc9`)
|
||||
|
||||
### Performance
|
||||
- 5.7x Doppler extraction speedup via optimized FFT windowing (`32c75c8`)
|
||||
- Single 2.1 MB static binary, zero Python dependencies for Rust server
|
||||
|
||||
### Security
|
||||
- Fix SQL injection in status command and migrations (`f9d125d`)
|
||||
- Fix XSS vulnerabilities in UI components (`5db55fd`)
|
||||
- Fix command injection in statusline.cjs (`4cb01fd`)
|
||||
- Fix path traversal vulnerabilities (`896c4fc`)
|
||||
- Fix insecure WebSocket connections — enforce wss:// on non-localhost (`ac094d4`)
|
||||
- Fix GitHub Actions shell injection (`ab2e7b4`)
|
||||
- Fix 10 additional vulnerabilities, remove 12 dead code instances (`7afdad0`)
|
||||
|
||||
---
|
||||
|
||||
## [1.1.0] - 2025-06-07
|
||||
|
||||
### Added
|
||||
- Complete Python WiFi-DensePose system with CSI data extraction and router interface
|
||||
- CSI processing and phase sanitization modules
|
||||
- Batch processing for CSI data in `CSIProcessor` and `PhaseSanitizer`
|
||||
- Hardware, pose, and stream services for WiFi-DensePose API
|
||||
- Comprehensive CSS styles for UI components and dark mode support
|
||||
- API and Deployment documentation
|
||||
- Multi-column table of contents in README.md for improved navigation
|
||||
- Enhanced documentation structure with better organization
|
||||
- Improved visual layout for better user experience
|
||||
|
||||
### Fixed
|
||||
- Badge links for PyPI and Docker in README
|
||||
- Async engine creation poolclass specification
|
||||
### Changed
|
||||
- Updated README.md table of contents to use a two-column layout
|
||||
- Reorganized documentation sections for better logical flow
|
||||
- Enhanced readability of navigation structure
|
||||
|
||||
---
|
||||
### Documentation
|
||||
- Restructured table of contents for better accessibility
|
||||
- Improved visual hierarchy in documentation
|
||||
- Enhanced user experience for documentation navigation
|
||||
|
||||
## [1.0.0] - 2024-12-01
|
||||
|
||||
### Added
|
||||
- Initial release of WiFi-DensePose
|
||||
- Real-time WiFi-based human pose estimation using Channel State Information (CSI)
|
||||
- DensePose neural network integration for body surface mapping
|
||||
- RESTful API with comprehensive endpoint coverage
|
||||
- WebSocket streaming for real-time pose data
|
||||
- Multi-person tracking with configurable capacity (default 10, up to 50+)
|
||||
- Initial release of WiFi DensePose
|
||||
- Real-time WiFi-based human pose estimation using CSI data
|
||||
- DensePose neural network integration
|
||||
- RESTful API with comprehensive endpoints
|
||||
- WebSocket streaming for real-time data
|
||||
- Multi-person tracking capabilities
|
||||
- Fall detection and activity recognition
|
||||
- Domain configurations: healthcare, fitness, smart home, security
|
||||
- CLI interface for server management and configuration
|
||||
- Hardware abstraction layer for multiple WiFi chipsets
|
||||
- Phase sanitization and signal processing pipeline
|
||||
- Healthcare, fitness, smart home, and security domain configurations
|
||||
- Comprehensive CLI interface
|
||||
- Docker and Kubernetes deployment support
|
||||
- 100% test coverage
|
||||
- Production-ready monitoring and logging
|
||||
- Hardware abstraction layer for multiple WiFi devices
|
||||
- Phase sanitization and signal processing
|
||||
- Authentication and rate limiting
|
||||
- Background task management
|
||||
- Cross-platform support (Linux, macOS, Windows)
|
||||
- Database integration with PostgreSQL and Redis
|
||||
- Prometheus metrics and Grafana dashboards
|
||||
- Comprehensive documentation and examples
|
||||
|
||||
### Features
|
||||
- Privacy-preserving pose detection without cameras
|
||||
- Sub-50ms latency with 30 FPS processing
|
||||
- Support for up to 10 simultaneous person tracking
|
||||
- Enterprise-grade security and scalability
|
||||
- Cross-platform compatibility (Linux, macOS, Windows)
|
||||
- GPU acceleration support
|
||||
- Real-time analytics and alerting
|
||||
- Configurable confidence thresholds
|
||||
- Zone-based occupancy monitoring
|
||||
- Historical data analysis
|
||||
- Performance optimization tools
|
||||
- Load testing capabilities
|
||||
- Infrastructure as Code (Terraform, Ansible)
|
||||
- CI/CD pipeline integration
|
||||
- Comprehensive error handling and logging
|
||||
|
||||
### Documentation
|
||||
- User guide and API reference
|
||||
- Complete user guide and API reference
|
||||
- Deployment and troubleshooting guides
|
||||
- Hardware setup and calibration instructions
|
||||
- Performance benchmarks
|
||||
- Contributing guidelines
|
||||
|
||||
[Unreleased]: https://github.com/ruvnet/wifi-densepose/compare/v3.0.0...HEAD
|
||||
[3.0.0]: https://github.com/ruvnet/wifi-densepose/compare/v2.0.0...v3.0.0
|
||||
[2.0.0]: https://github.com/ruvnet/wifi-densepose/compare/v1.1.0...v2.0.0
|
||||
[1.1.0]: https://github.com/ruvnet/wifi-densepose/compare/v1.0.0...v1.1.0
|
||||
[1.0.0]: https://github.com/ruvnet/wifi-densepose/releases/tag/v1.0.0
|
||||
- Performance benchmarks and optimization tips
|
||||
- Contributing guidelines and code standards
|
||||
- Security best practices
|
||||
- Example configurations and use cases
|
||||
13
CLAUDE.md
13
CLAUDE.md
@@ -89,19 +89,6 @@ All development on: `claude/validate-code-quality-WNrNw`
|
||||
- **HNSW**: Enabled
|
||||
- **Neural**: Enabled
|
||||
|
||||
## Pre-Merge Checklist
|
||||
|
||||
Before merging any PR, verify each item applies and is addressed:
|
||||
|
||||
1. **Tests pass** — `cargo test` (Rust) and `python -m pytest` (Python) green
|
||||
2. **README.md** — Update platform tables, crate descriptions, hardware tables, feature summaries if scope changed
|
||||
3. **CHANGELOG.md** — Add entry under `[Unreleased]` with what was added/fixed/changed
|
||||
4. **User guide** (`docs/user-guide.md`) — Update if new data sources, CLI flags, or setup steps were added
|
||||
5. **ADR index** — Update ADR count in README docs table if a new ADR was created
|
||||
6. **Docker Hub image** — Only rebuild if Dockerfile, dependencies, or runtime behavior changed (not needed for platform-gated code that doesn't affect the Linux container)
|
||||
7. **Crate publishing** — Only needed if a crate is published to crates.io and its public API changed (workspace-internal crates don't need publishing)
|
||||
8. **`.gitignore`** — Add any new build artifacts or binaries
|
||||
|
||||
## Build & Test
|
||||
|
||||
```bash
|
||||
|
||||
298
README.md
298
README.md
@@ -10,7 +10,6 @@ WiFi DensePose turns commodity WiFi signals into real-time human pose estimation
|
||||
[](https://hub.docker.com/r/ruvnet/wifi-densepose)
|
||||
[](#vital-sign-detection)
|
||||
[](#esp32-s3-hardware-pipeline)
|
||||
[](https://crates.io/crates/wifi-densepose-ruvector)
|
||||
|
||||
> | What | How | Speed |
|
||||
> |------|-----|-------|
|
||||
@@ -36,79 +35,25 @@ docker run -p 3000:3000 ruvnet/wifi-densepose:latest
|
||||
> |--------|----------|------|----------|-------------|
|
||||
> | **ESP32 Mesh** (recommended) | 3-6x ESP32-S3 + WiFi router | ~$54 | Yes | Pose, breathing, heartbeat, motion, presence |
|
||||
> | **Research NIC** | Intel 5300 / Atheros AR9580 | ~$50-100 | Yes | Full CSI with 3x3 MIMO |
|
||||
> | **Any WiFi** | Windows, macOS, or Linux laptop | $0 | No | RSSI-only: coarse presence and motion |
|
||||
> | **Any WiFi** | Windows/Linux laptop | $0 | No | RSSI-only: coarse presence and motion |
|
||||
>
|
||||
> No hardware? Verify the signal processing pipeline with the deterministic reference signal: `python v1/data/proof/verify.py`
|
||||
|
||||
---
|
||||
|
||||
## 📖 Documentation
|
||||
|
||||
| Document | Description |
|
||||
|----------|-------------|
|
||||
| [User Guide](docs/user-guide.md) | Step-by-step guide: installation, first run, API usage, hardware setup, training |
|
||||
| [WiFi-Mat User Guide](docs/wifi-mat-user-guide.md) | Disaster response module: search & rescue, START triage |
|
||||
| [Build Guide](docs/build-guide.md) | Building from source (Rust and Python) |
|
||||
| [Architecture Decisions](docs/adr/) | 27 ADRs covering signal processing, training, hardware, security, domain generalization |
|
||||
|
||||
---
|
||||
|
||||
## 🚀 Key Features
|
||||
|
||||
### Sensing
|
||||
|
||||
See people, breathing, and heartbeats through walls — using only WiFi signals already in the room.
|
||||
|
||||
| | Feature | What It Means |
|
||||
|---|---------|---------------|
|
||||
| 🔒 | **Privacy-First** | Tracks human pose using only WiFi signals — no cameras, no video, no images stored |
|
||||
| ⚡ | **Real-Time** | Analyzes WiFi signals in under 100 microseconds per frame — fast enough for live monitoring |
|
||||
| 💓 | **Vital Signs** | Detects breathing rate (6-30 breaths/min) and heart rate (40-120 bpm) without any wearable |
|
||||
| 👥 | **Multi-Person** | Tracks multiple people simultaneously, each with independent pose and vitals — no hard software limit (physics: ~3-5 per AP with 56 subcarriers, more with multi-AP) |
|
||||
| 🧱 | **Through-Wall** | WiFi passes through walls, furniture, and debris — works where cameras cannot |
|
||||
| 🚑 | **Disaster Response** | Detects trapped survivors through rubble and classifies injury severity (START triage) |
|
||||
|
||||
### Intelligence
|
||||
|
||||
The system learns on its own and gets smarter over time — no hand-tuning, no labeled data required.
|
||||
|
||||
| | Feature | What It Means |
|
||||
|---|---------|---------------|
|
||||
| 🧠 | **Self-Learning** | Teaches itself from raw WiFi data — no labeled training sets, no cameras needed to bootstrap ([ADR-024](docs/adr/ADR-024-contrastive-csi-embedding-model.md)) |
|
||||
| 🎯 | **AI Signal Processing** | Attention networks, graph algorithms, and smart compression replace hand-tuned thresholds — adapts to each room automatically ([RuVector](https://github.com/ruvnet/ruvector)) |
|
||||
| 🌍 | **Works Everywhere** | Train once, deploy in any room — adversarial domain generalization strips environment bias so models transfer across rooms, buildings, and hardware ([ADR-027](docs/adr/ADR-027-cross-environment-domain-generalization.md)) |
|
||||
|
||||
### Performance & Deployment
|
||||
|
||||
Fast enough for real-time use, small enough for edge devices, simple enough for one-command setup.
|
||||
|
||||
| | Feature | What It Means |
|
||||
|---|---------|---------------|
|
||||
| ⚡ | **Real-Time** | Analyzes WiFi signals in under 100 microseconds per frame — fast enough for live monitoring |
|
||||
| 🦀 | **810x Faster** | Complete Rust rewrite: 54,000 frames/sec pipeline, 132 MB Docker image, 542+ tests |
|
||||
| 🐳 | **One-Command Setup** | `docker pull ruvnet/wifi-densepose:latest` — live sensing in 30 seconds, no toolchain needed |
|
||||
| 📦 | **Portable Models** | Trained models package into a single `.rvf` file — runs on edge, cloud, or browser (WASM) |
|
||||
|
||||
---
|
||||
|
||||
## 🔬 How It Works
|
||||
|
||||
WiFi routers flood every room with radio waves. When a person moves — or even breathes — those waves scatter differently. WiFi DensePose reads that scattering pattern and reconstructs what happened:
|
||||
|
||||
```
|
||||
WiFi Router → radio waves pass through room → hit human body → scatter
|
||||
↓
|
||||
ESP32 / WiFi NIC captures 56+ subcarrier amplitudes & phases (CSI) at 20 Hz
|
||||
↓
|
||||
Signal Processing cleans noise, removes interference, extracts motion signatures
|
||||
↓
|
||||
AI Backbone (RuVector) applies attention, graph algorithms, and compression
|
||||
↓
|
||||
Neural Network maps processed signals → 17 body keypoints + vital signs
|
||||
↓
|
||||
Output: real-time pose, breathing rate, heart rate, presence, room fingerprint
|
||||
```
|
||||
|
||||
No training cameras required — the [Self-Learning system (ADR-024)](docs/adr/ADR-024-contrastive-csi-embedding-model.md) bootstraps from raw WiFi data alone. [MERIDIAN (ADR-027)](docs/adr/ADR-027-cross-environment-domain-generalization.md) ensures the model works in any room, not just the one it trained in.
|
||||
| 🦀 | **810x Faster** | Complete Rust rewrite: 54,000 frames/sec pipeline, 132 MB Docker image, 542+ tests |
|
||||
|
||||
---
|
||||
|
||||
@@ -198,15 +143,15 @@ These scenarios exploit WiFi's ability to penetrate solid materials — concrete
|
||||
---
|
||||
|
||||
<details>
|
||||
<summary><strong>🧠 Self-Learning WiFi AI (ADR-024)</strong> — Adaptive recognition, self-optimization, and intelligent anomaly detection</summary>
|
||||
<summary><strong>🧠 Contrastive CSI Embedding Model (ADR-024)</strong> — Self-supervised WiFi fingerprinting, similarity search, and anomaly detection</summary>
|
||||
|
||||
Every WiFi signal that passes through a room creates a unique fingerprint of that space. WiFi-DensePose already reads these fingerprints to track people, but until now it threw away the internal "understanding" after each reading. The Self-Learning WiFi AI captures and preserves that understanding as compact, reusable vectors — and continuously optimizes itself for each new environment.
|
||||
Every WiFi signal that passes through a room creates a unique fingerprint of that space. WiFi-DensePose already reads these fingerprints to track people, but until now it threw away the internal "understanding" after each reading. The Contrastive CSI Embedding Model captures and preserves that understanding as compact, reusable vectors.
|
||||
|
||||
**What it does in plain terms:**
|
||||
- Turns any WiFi signal into a 128-number "fingerprint" that uniquely describes what's happening in a room
|
||||
- Learns entirely on its own from raw WiFi data — no cameras, no labeling, no human supervision needed
|
||||
- Recognizes rooms, detects intruders, identifies people, and classifies activities using only WiFi
|
||||
- Runs on an $8 ESP32 chip (the entire model fits in 55 KB of memory)
|
||||
- Runs on an $8 ESP32 chip (the entire model fits in 60 KB of memory)
|
||||
- Produces both body pose tracking AND environment fingerprints in a single computation
|
||||
|
||||
**Key Capabilities**
|
||||
@@ -271,101 +216,10 @@ cargo run -p wifi-densepose-sensing-server -- --model model.rvf --build-index en
|
||||
| Per-room MicroLoRA adapter | ~1,800 | 2 KB |
|
||||
| **Total** | **~55,000** | **55 KB** (of 520 KB available) |
|
||||
|
||||
The self-learning system builds on the [AI Backbone (RuVector)](#ai-backbone-ruvector) signal-processing layer — attention, graph algorithms, and compression — adding contrastive learning on top.
|
||||
|
||||
See [`docs/adr/ADR-024-contrastive-csi-embedding-model.md`](docs/adr/ADR-024-contrastive-csi-embedding-model.md) for full architectural details.
|
||||
|
||||
</details>
|
||||
|
||||
<details>
|
||||
<summary><a id="cross-environment-generalization-adr-027"></a><strong>🌍 Cross-Environment Generalization (ADR-027 — Project MERIDIAN)</strong> — Train once, deploy in any room without retraining</summary>
|
||||
|
||||
WiFi pose models trained in one room lose 40-70% accuracy when moved to another — even in the same building. The model memorizes room-specific multipath patterns instead of learning human motion. MERIDIAN forces the network to forget which room it's in while retaining everything about how people move.
|
||||
|
||||
**What it does in plain terms:**
|
||||
- Models trained in Room A work in Room B, C, D — without any retraining or calibration data
|
||||
- Handles different WiFi hardware (ESP32, Intel 5300, Atheros) with automatic chipset normalization
|
||||
- Knows where the WiFi transmitters are positioned and compensates for layout differences
|
||||
- Generates synthetic "virtual rooms" during training so the model sees thousands of environments
|
||||
- At deployment, adapts to a new room in seconds using a handful of unlabeled WiFi frames
|
||||
|
||||
**Key Components**
|
||||
|
||||
| What | How it works | Why it matters |
|
||||
|------|-------------|----------------|
|
||||
| **Gradient Reversal Layer** | An adversarial classifier tries to guess which room the signal came from; the main network is trained to fool it | Forces the model to discard room-specific shortcuts |
|
||||
| **Geometry Encoder (FiLM)** | Transmitter/receiver positions are Fourier-encoded and injected as scale+shift conditioning on every layer | The model knows *where* the hardware is, so it doesn't need to memorize layout |
|
||||
| **Hardware Normalizer** | Resamples any chipset's CSI to a canonical 56-subcarrier format with standardized amplitude | Intel 5300 and ESP32 data look identical to the model |
|
||||
| **Virtual Domain Augmentation** | Generates synthetic environments with random room scale, wall reflections, scatterers, and noise profiles | Training sees 1000s of rooms even with data from just 2-3 |
|
||||
| **Rapid Adaptation (TTT)** | Contrastive test-time training with LoRA weight generation from a few unlabeled frames | Zero-shot deployment — the model self-tunes on arrival |
|
||||
| **Cross-Domain Evaluator** | Leave-one-out evaluation across all training environments with per-environment PCK/OKS metrics | Proves generalization, not just memorization |
|
||||
|
||||
**Architecture**
|
||||
|
||||
```
|
||||
CSI Frame [any chipset]
|
||||
│
|
||||
▼
|
||||
HardwareNormalizer ──→ canonical 56 subcarriers, N(0,1) amplitude
|
||||
│
|
||||
▼
|
||||
CSI Encoder (existing) ──→ latent features
|
||||
│
|
||||
├──→ Pose Head ──→ 17-joint pose (environment-invariant)
|
||||
│
|
||||
├──→ Gradient Reversal Layer ──→ Domain Classifier (adversarial)
|
||||
│ λ ramps 0→1 via cosine/exponential schedule
|
||||
│
|
||||
└──→ Geometry Encoder ──→ FiLM conditioning (scale + shift)
|
||||
Fourier positional encoding → DeepSets → per-layer modulation
|
||||
```
|
||||
|
||||
**Security hardening:**
|
||||
- Bounded calibration buffer (max 10,000 frames) prevents memory exhaustion
|
||||
- `adapt()` returns `Result<_, AdaptError>` — no panics on bad input
|
||||
- Atomic instance counter ensures unique weight initialization across threads
|
||||
- Division-by-zero guards on all augmentation parameters
|
||||
|
||||
See [`docs/adr/ADR-027-cross-environment-domain-generalization.md`](docs/adr/ADR-027-cross-environment-domain-generalization.md) for full architectural details.
|
||||
|
||||
</details>
|
||||
|
||||
---
|
||||
|
||||
<details>
|
||||
<summary><strong>🔍 Independent Capability Audit (ADR-028)</strong> — 1,031 tests, SHA-256 proof, self-verifying witness bundle</summary>
|
||||
|
||||
A [3-agent parallel audit](docs/adr/ADR-028-esp32-capability-audit.md) independently verified every claim in this repository — ESP32 hardware, signal processing, neural networks, training pipeline, deployment, and security. Results:
|
||||
|
||||
```
|
||||
Rust tests: 1,031 passed, 0 failed
|
||||
Python proof: VERDICT: PASS (SHA-256: 8c0680d7...)
|
||||
Bundle verify: 7/7 checks PASS
|
||||
```
|
||||
|
||||
**33-row attestation matrix:** 31 capabilities verified YES, 2 not measured at audit time (benchmark throughput, Kubernetes deploy).
|
||||
|
||||
**Verify it yourself** (no hardware needed):
|
||||
```bash
|
||||
# Run all tests
|
||||
cd rust-port/wifi-densepose-rs && cargo test --workspace --no-default-features
|
||||
|
||||
# Run the deterministic proof
|
||||
python v1/data/proof/verify.py
|
||||
|
||||
# Generate + verify the witness bundle
|
||||
bash scripts/generate-witness-bundle.sh
|
||||
cd dist/witness-bundle-ADR028-*/ && bash VERIFY.sh
|
||||
```
|
||||
|
||||
| Document | What it contains |
|
||||
|----------|-----------------|
|
||||
| [ADR-028](docs/adr/ADR-028-esp32-capability-audit.md) | Full audit: ESP32 specs, signal algorithms, NN architectures, training phases, deployment infra |
|
||||
| [Witness Log](docs/WITNESS-LOG-028.md) | 11 reproducible verification steps + 33-row attestation matrix with evidence per row |
|
||||
| [`generate-witness-bundle.sh`](scripts/generate-witness-bundle.sh) | Creates self-contained tar.gz with test logs, proof output, firmware hashes, crate versions, VERIFY.sh |
|
||||
|
||||
</details>
|
||||
|
||||
---
|
||||
|
||||
## 📦 Installation
|
||||
@@ -463,46 +317,6 @@ docker run --rm -v $(pwd):/out ruvnet/wifi-densepose:latest --export-rvf /out/mo
|
||||
|
||||
</details>
|
||||
|
||||
<details>
|
||||
<summary><strong>Rust Crates</strong> — Individual crates on crates.io</summary>
|
||||
|
||||
The Rust workspace consists of 15 crates, all published to [crates.io](https://crates.io/):
|
||||
|
||||
```bash
|
||||
# Add individual crates to your Cargo.toml
|
||||
cargo add wifi-densepose-core # Types, traits, errors
|
||||
cargo add wifi-densepose-signal # CSI signal processing (6 SOTA algorithms)
|
||||
cargo add wifi-densepose-nn # Neural inference (ONNX, PyTorch, Candle)
|
||||
cargo add wifi-densepose-vitals # Vital sign extraction (breathing + heart rate)
|
||||
cargo add wifi-densepose-mat # Disaster response (MAT survivor detection)
|
||||
cargo add wifi-densepose-hardware # ESP32, Intel 5300, Atheros sensors
|
||||
cargo add wifi-densepose-train # Training pipeline (MM-Fi dataset)
|
||||
cargo add wifi-densepose-wifiscan # Multi-BSSID WiFi scanning
|
||||
cargo add wifi-densepose-ruvector # RuVector v2.0.4 integration layer (ADR-017)
|
||||
```
|
||||
|
||||
| Crate | Description | RuVector | crates.io |
|
||||
|-------|-------------|----------|-----------|
|
||||
| [`wifi-densepose-core`](https://crates.io/crates/wifi-densepose-core) | Foundation types, traits, and utilities | -- | [](https://crates.io/crates/wifi-densepose-core) |
|
||||
| [`wifi-densepose-signal`](https://crates.io/crates/wifi-densepose-signal) | SOTA CSI signal processing (SpotFi, FarSense, Widar 3.0) | `mincut`, `attn-mincut`, `attention`, `solver` | [](https://crates.io/crates/wifi-densepose-signal) |
|
||||
| [`wifi-densepose-nn`](https://crates.io/crates/wifi-densepose-nn) | Multi-backend inference (ONNX, PyTorch, Candle) | -- | [](https://crates.io/crates/wifi-densepose-nn) |
|
||||
| [`wifi-densepose-train`](https://crates.io/crates/wifi-densepose-train) | Training pipeline with MM-Fi dataset (NeurIPS 2023) | **All 5** | [](https://crates.io/crates/wifi-densepose-train) |
|
||||
| [`wifi-densepose-mat`](https://crates.io/crates/wifi-densepose-mat) | Mass Casualty Assessment Tool (disaster survivor detection) | `solver`, `temporal-tensor` | [](https://crates.io/crates/wifi-densepose-mat) |
|
||||
| [`wifi-densepose-ruvector`](https://crates.io/crates/wifi-densepose-ruvector) | RuVector v2.0.4 integration layer — 7 signal+MAT integration points (ADR-017) | **All 5** | [](https://crates.io/crates/wifi-densepose-ruvector) |
|
||||
| [`wifi-densepose-vitals`](https://crates.io/crates/wifi-densepose-vitals) | Vital signs: breathing (6-30 BPM), heart rate (40-120 BPM) | -- | [](https://crates.io/crates/wifi-densepose-vitals) |
|
||||
| [`wifi-densepose-hardware`](https://crates.io/crates/wifi-densepose-hardware) | ESP32, Intel 5300, Atheros CSI sensor interfaces | -- | [](https://crates.io/crates/wifi-densepose-hardware) |
|
||||
| [`wifi-densepose-wifiscan`](https://crates.io/crates/wifi-densepose-wifiscan) | Multi-BSSID WiFi scanning (Windows, macOS, Linux) | -- | [](https://crates.io/crates/wifi-densepose-wifiscan) |
|
||||
| [`wifi-densepose-wasm`](https://crates.io/crates/wifi-densepose-wasm) | WebAssembly bindings for browser deployment | -- | [](https://crates.io/crates/wifi-densepose-wasm) |
|
||||
| [`wifi-densepose-sensing-server`](https://crates.io/crates/wifi-densepose-sensing-server) | Axum server: UDP ingestion, WebSocket broadcast | -- | [](https://crates.io/crates/wifi-densepose-sensing-server) |
|
||||
| [`wifi-densepose-cli`](https://crates.io/crates/wifi-densepose-cli) | Command-line tool for MAT disaster scanning | -- | [](https://crates.io/crates/wifi-densepose-cli) |
|
||||
| [`wifi-densepose-api`](https://crates.io/crates/wifi-densepose-api) | REST + WebSocket API layer | -- | [](https://crates.io/crates/wifi-densepose-api) |
|
||||
| [`wifi-densepose-config`](https://crates.io/crates/wifi-densepose-config) | Configuration management | -- | [](https://crates.io/crates/wifi-densepose-config) |
|
||||
| [`wifi-densepose-db`](https://crates.io/crates/wifi-densepose-db) | Database persistence (PostgreSQL, SQLite, Redis) | -- | [](https://crates.io/crates/wifi-densepose-db) |
|
||||
|
||||
All crates integrate with [RuVector v2.0.4](https://github.com/ruvnet/ruvector) — see [AI Backbone](#ai-backbone-ruvector) below.
|
||||
|
||||
</details>
|
||||
|
||||
---
|
||||
|
||||
## 🚀 Quick Start
|
||||
@@ -579,8 +393,7 @@ The signal processing stack transforms raw WiFi Channel State Information into a
|
||||
|
||||
| Section | Description | Docs |
|
||||
|---------|-------------|------|
|
||||
| [Key Features](#key-features) | Sensing, Intelligence, and Performance & Deployment capabilities | — |
|
||||
| [How It Works](#how-it-works) | End-to-end pipeline: radio waves → CSI capture → signal processing → AI → pose + vitals | — |
|
||||
| [Key Features](#key-features) | Privacy-first sensing, real-time performance, multi-person tracking, Docker | — |
|
||||
| [ESP32-S3 Hardware Pipeline](#esp32-s3-hardware-pipeline) | 20 Hz CSI streaming, binary frame parsing, flash & provision | [ADR-018](docs/adr/ADR-018-esp32-dev-implementation.md) · [Tutorial #34](https://github.com/ruvnet/wifi-densepose/issues/34) |
|
||||
| [Vital Sign Detection](#vital-sign-detection) | Breathing 6-30 BPM, heartbeat 40-120 BPM, FFT peak detection | [ADR-021](docs/adr/ADR-021-vital-sign-detection-rvdna-pipeline.md) |
|
||||
| [WiFi Scan Domain Layer](#wifi-scan-domain-layer) | 8-stage RSSI pipeline, multi-BSSID fingerprinting, Windows WiFi | [ADR-022](docs/adr/ADR-022-windows-wifi-enhanced-fidelity-ruvector.md) · [Tutorial #36](https://github.com/ruvnet/wifi-densepose/issues/36) |
|
||||
@@ -599,9 +412,6 @@ The neural pipeline uses a graph transformer with cross-attention to map CSI fea
|
||||
| [RVF Model Container](#rvf-model-container) | Binary packaging with Ed25519 signing, progressive 3-layer loading, SIMD quantization | [ADR-023](docs/adr/ADR-023-trained-densepose-model-ruvector-pipeline.md) |
|
||||
| [Training & Fine-Tuning](#training--fine-tuning) | 8-phase pure Rust pipeline (7,832 lines), MM-Fi/Wi-Pose pre-training, 6-term composite loss, SONA LoRA | [ADR-023](docs/adr/ADR-023-trained-densepose-model-ruvector-pipeline.md) |
|
||||
| [RuVector Crates](#ruvector-crates) | 11 vendored Rust crates from [ruvector](https://github.com/ruvnet/ruvector): attention, min-cut, solver, GNN, HNSW, temporal compression, sparse inference | [GitHub](https://github.com/ruvnet/ruvector) · [Source](vendor/ruvector/) |
|
||||
| [AI Backbone (RuVector)](#ai-backbone-ruvector) | 5 AI capabilities replacing hand-tuned thresholds: attention, graph min-cut, sparse solvers, tiered compression | [crates.io](https://crates.io/crates/wifi-densepose-ruvector) |
|
||||
| [Self-Learning WiFi AI (ADR-024)](#self-learning-wifi-ai-adr-024) | Contrastive self-supervised learning, room fingerprinting, anomaly detection, 55 KB model | [ADR-024](docs/adr/ADR-024-contrastive-csi-embedding-model.md) |
|
||||
| [Cross-Environment Generalization (ADR-027)](docs/adr/ADR-027-cross-environment-domain-generalization.md) | Domain-adversarial training, geometry-conditioned inference, hardware normalization, zero-shot deployment | [ADR-027](docs/adr/ADR-027-cross-environment-domain-generalization.md) |
|
||||
|
||||
</details>
|
||||
|
||||
@@ -650,7 +460,7 @@ WiFi DensePose is MIT-licensed open source, developed by [ruvnet](https://github
|
||||
|
||||
| Section | Description | Link |
|
||||
|---------|-------------|------|
|
||||
| [Changelog](#changelog) | v3.0.0 (AETHER AI + Docker), v2.0.0 (Rust port + SOTA + WiFi-Mat) | [CHANGELOG.md](CHANGELOG.md) |
|
||||
| [Changelog](#changelog) | v2.3.0 (training pipeline + Docker), v2.2.0 (SOTA + WiFi-Mat), v2.1.0 (Rust port) | — |
|
||||
| [License](#license) | MIT License | [LICENSE](LICENSE) |
|
||||
| [Support](#support) | Bug reports, feature requests, community discussion | [Issues](https://github.com/ruvnet/wifi-densepose/issues) · [Discussions](https://github.com/ruvnet/wifi-densepose/discussions) |
|
||||
|
||||
@@ -738,8 +548,8 @@ cargo bench --package wifi-densepose-signal
|
||||
| **Confidence** | 0.0-1.0 per sign | Spectral coherence + signal quality |
|
||||
|
||||
```bash
|
||||
./target/release/sensing-server --source simulate --http-port 3000 --ws-port 3001 --ui-path ../../ui
|
||||
curl http://localhost:3000/api/v1/vital-signs
|
||||
./target/release/sensing-server --source simulate --ui-path ../../ui
|
||||
curl http://localhost:8080/api/v1/vital-signs
|
||||
```
|
||||
|
||||
See [ADR-021](docs/adr/ADR-021-vital-sign-detection-rvdna-pipeline.md).
|
||||
@@ -747,7 +557,7 @@ See [ADR-021](docs/adr/ADR-021-vital-sign-detection-rvdna-pipeline.md).
|
||||
</details>
|
||||
|
||||
<details>
|
||||
<summary><a id="wifi-scan-domain-layer"></a><strong>📡 WiFi Scan Domain Layer (ADR-022/025)</strong> — 8-stage RSSI pipeline for Windows, macOS, and Linux WiFi</summary>
|
||||
<summary><a id="wifi-scan-domain-layer"></a><strong>📡 WiFi Scan Domain Layer (ADR-022)</strong> — 8-stage RSSI pipeline for Windows WiFi</summary>
|
||||
|
||||
| Stage | Purpose |
|
||||
|-------|---------|
|
||||
@@ -837,41 +647,6 @@ See [ADR-014](docs/adr/ADR-014-sota-signal-processing.md) for full mathematical
|
||||
|
||||
## 🧠 Models & Training
|
||||
|
||||
<details>
|
||||
<summary><a id="ai-backbone-ruvector"></a><strong>🤖 AI Backbone: RuVector</strong> — Attention, graph algorithms, and edge-AI compression powering the sensing pipeline</summary>
|
||||
|
||||
Raw WiFi signals are noisy, redundant, and environment-dependent. [RuVector](https://github.com/ruvnet/ruvector) is the AI intelligence layer that transforms them into clean, structured input for the DensePose neural network. It uses **attention mechanisms** to learn which signals to trust, **graph algorithms** that automatically discover which WiFi channels are sensitive to body motion, and **compressed representations** that make edge inference possible on an $8 microcontroller.
|
||||
|
||||
Without RuVector, WiFi DensePose would need hand-tuned thresholds, brute-force matrix math, and 4x more memory — making real-time edge inference impossible.
|
||||
|
||||
```
|
||||
Raw WiFi CSI (56 subcarriers, noisy)
|
||||
|
|
||||
+-- ruvector-mincut ---------- Which channels carry body-motion signal? (learned graph partitioning)
|
||||
+-- ruvector-attn-mincut ----- Which time frames are signal vs noise? (attention-gated filtering)
|
||||
+-- ruvector-attention ------- How to fuse multi-antenna data? (learned weighted aggregation)
|
||||
|
|
||||
v
|
||||
Clean, structured signal --> DensePose Neural Network --> 17-keypoint body pose
|
||||
--> FFT Vital Signs -----------> breathing rate, heart rate
|
||||
--> ruvector-solver ------------> physics-based localization
|
||||
```
|
||||
|
||||
The [`wifi-densepose-ruvector`](https://crates.io/crates/wifi-densepose-ruvector) crate ([ADR-017](docs/adr/ADR-017-ruvector-signal-mat-integration.md)) connects all 7 integration points:
|
||||
|
||||
| AI Capability | What It Replaces | RuVector Crate | Result |
|
||||
|--------------|-----------------|----------------|--------|
|
||||
| **Self-optimizing channel selection** | Hand-tuned thresholds that break when rooms change | `ruvector-mincut` | Graph min-cut adapts to any environment automatically |
|
||||
| **Attention-based signal cleaning** | Fixed energy cutoffs that miss subtle breathing | `ruvector-attn-mincut` | Learned gating amplifies body signals, suppresses noise |
|
||||
| **Learned signal fusion** | Simple averaging where one bad channel corrupts all | `ruvector-attention` | Transformer-style attention downweights corrupted channels |
|
||||
| **Physics-informed localization** | Expensive nonlinear solvers | `ruvector-solver` | Sparse least-squares Fresnel geometry in real-time |
|
||||
| **O(1) survivor triangulation** | O(N^3) matrix inversion | `ruvector-solver` | Neumann series linearization for instant position updates |
|
||||
| **75% memory compression** | 13.4 MB breathing buffers that overflow edge devices | `ruvector-temporal-tensor` | Tiered 3-8 bit quantization fits 60s of vitals in 3.4 MB |
|
||||
|
||||
See [issue #67](https://github.com/ruvnet/wifi-densepose/issues/67) for a deep dive with code examples, or [`cargo add wifi-densepose-ruvector`](https://crates.io/crates/wifi-densepose-ruvector) to use it directly.
|
||||
|
||||
</details>
|
||||
|
||||
<details>
|
||||
<summary><a id="rvf-model-container"></a><strong>📦 RVF Model Container</strong> — Single-file deployment with progressive loading</summary>
|
||||
|
||||
@@ -1251,9 +1026,9 @@ GET /api/v1/model/sona/profiles # SONA profiles
|
||||
POST /api/v1/model/sona/activate # Activate SONA profile
|
||||
```
|
||||
|
||||
WebSocket: `ws://localhost:3001/ws/sensing` (real-time sensing + vital signs)
|
||||
WebSocket: `ws://localhost:8765/ws/sensing` (real-time sensing + vital signs)
|
||||
|
||||
> Default ports (Docker): HTTP 3000, WS 3001. Binary defaults: HTTP 8080, WS 8765. Override with `--http-port` / `--ws-port`.
|
||||
> Default ports: HTTP 8080, WS 8765. Docker images remap to 3000/3001 via `--http-port` / `--ws-port`.
|
||||
|
||||
</details>
|
||||
|
||||
@@ -1266,8 +1041,6 @@ WebSocket: `ws://localhost:3001/ws/sensing` (real-time sensing + vital signs)
|
||||
| Intel 5300 | Firmware mod | ~$15 | Linux `iwl-csi` |
|
||||
| Atheros AR9580 | ath9k patch | ~$20 | Linux only |
|
||||
| Any Windows WiFi | RSSI only | $0 | [Tutorial #36](https://github.com/ruvnet/wifi-densepose/issues/36) |
|
||||
| Any macOS WiFi | RSSI only (CoreWLAN) | $0 | [ADR-025](docs/adr/ADR-025-macos-corewlan-wifi-sensing.md) |
|
||||
| Any Linux WiFi | RSSI only (`iw`) | $0 | Requires `iw` + `CAP_NET_ADMIN` |
|
||||
|
||||
</details>
|
||||
|
||||
@@ -1432,32 +1205,37 @@ pre-commit install
|
||||
<details>
|
||||
<summary><strong>Release history</strong></summary>
|
||||
|
||||
### v3.0.0 — 2026-03-01
|
||||
### v2.3.0 — 2026-03-01
|
||||
|
||||
Major release: AETHER contrastive embedding model, AI signal processing backbone, cross-platform adapters, Docker Hub images, and comprehensive README overhaul.
|
||||
The largest release to date — delivers the complete end-to-end training pipeline, Docker images, and vital sign detection. The Rust sensing server now supports full model training, RVF export, and progressive model loading from a single binary.
|
||||
|
||||
- **Project AETHER (ADR-024)** — Self-supervised contrastive learning for WiFi CSI fingerprinting, similarity search, and anomaly detection; 55 KB model fits on ESP32
|
||||
- **AI Backbone (`wifi-densepose-ruvector`)** — 7 RuVector integration points replacing hand-tuned thresholds with attention, graph algorithms, and smart compression; [published to crates.io](https://crates.io/crates/wifi-densepose-ruvector)
|
||||
- **Cross-platform RSSI adapters** — macOS CoreWLAN and Linux `iw` Rust adapters with `#[cfg(target_os)]` gating (ADR-025)
|
||||
- **Docker images published** — `ruvnet/wifi-densepose:latest` (132 MB Rust) and `:python` (569 MB)
|
||||
- **Project MERIDIAN (ADR-027)** — Cross-environment domain generalization: gradient reversal, geometry-conditioned FiLM, virtual domain augmentation, contrastive test-time training; zero-shot room transfer
|
||||
- **10-phase DensePose training pipeline (ADR-023/027)** — Graph transformer, 6-term composite loss, SONA adaptation, RVF packaging, hardware normalization, domain-adversarial training
|
||||
- **Vital sign detection (ADR-021)** — FFT-based breathing (6-30 BPM) and heartbeat (40-120 BPM), 11,665 fps
|
||||
- **WiFi scan domain layer (ADR-022/025)** — 8-stage signal intelligence pipeline for Windows, macOS, and Linux
|
||||
- **700+ Rust tests** — All passing, zero mocks
|
||||
- **8-phase DensePose training pipeline (ADR-023)** — Dataset loaders (MM-Fi, Wi-Pose), graph transformer with cross-attention, 6-term composite loss, cosine-scheduled SGD, PCK/OKS validation, SONA adaptation, sparse inference engine, RVF model packaging
|
||||
- **`--export-rvf` CLI flag** — Standalone RVF model container generation with vital config, training proof, and SONA profiles
|
||||
- **`--train` CLI flag** — Full training mode with best-epoch snapshotting and checkpoint saving
|
||||
- **Vital sign detection (ADR-021)** — FFT-based breathing (6-30 BPM) and heartbeat (40-120 BPM) extraction, 11,665 fps benchmark
|
||||
- **WiFi scan domain layer (ADR-022)** — 8-stage pure-Rust signal intelligence pipeline for Windows WiFi RSSI
|
||||
- **New crates** — `wifi-densepose-vitals` (1,863 lines) and `wifi-densepose-wifiscan` (4,829 lines)
|
||||
- **542+ Rust tests** — All passing, zero mocks
|
||||
|
||||
### v2.0.0 — 2026-02-28
|
||||
### v2.2.0 — 2026-02-28
|
||||
|
||||
Complete Rust sensing server, SOTA signal processing, WiFi-Mat disaster response, ESP32 hardware, RuVector integration, guided installer, and security hardening.
|
||||
Introduced the guided installer, SOTA signal processing algorithms, and the WiFi-Mat disaster response module. This release established the ESP32 hardware path and security hardening.
|
||||
|
||||
- **Rust sensing server** — Axum REST API + WebSocket, 810x speedup over Python, 54K fps pipeline
|
||||
- **RuVector integration** — 11 vendored crates for HNSW, attention, GNN, temporal compression, min-cut, solver
|
||||
- **6 SOTA signal algorithms (ADR-014)** — SpotFi, Hampel, Fresnel, spectrogram, subcarrier selection, BVP
|
||||
- **WiFi-Mat disaster response** — START triage, 3D localization, priority alerts — 139 tests
|
||||
- **ESP32 CSI hardware** — Binary frame parsing, $54 starter kit, 20 Hz streaming
|
||||
- **Guided installer** — 7-step hardware detection, 8 install profiles
|
||||
- **Three.js visualization** — 3D body model, 17 joints, real-time WebSocket
|
||||
- **Security hardening** — 10 vulnerabilities fixed
|
||||
- **Guided installer** — `./install.sh` with 7-step hardware detection and 8 install profiles
|
||||
- **6 SOTA signal algorithms (ADR-014)** — SpotFi conjugate multiplication, Hampel filter, Fresnel zone model, CSI spectrogram, subcarrier selection, body velocity profile
|
||||
- **WiFi-Mat disaster response** — START triage, scan zones, 3D localization, priority alerts — 139 tests
|
||||
- **ESP32 CSI hardware parser** — Binary frame parsing with I/Q extraction — 28 tests
|
||||
- **Security hardening** — 10 vulnerabilities fixed (CVE remediation, input validation, path security)
|
||||
|
||||
### v2.1.0 — 2026-02-28
|
||||
|
||||
The foundational Rust release — ported the Python v1 pipeline to Rust with 810x speedup, integrated the RuVector signal intelligence crates, and added the Three.js real-time visualization.
|
||||
|
||||
- **RuVector integration** — 11 vendored crates (ADR-002 through ADR-013) for HNSW indexing, attention, GNN, temporal compression, min-cut, solver
|
||||
- **ESP32 CSI sensor mesh** — $54 starter kit with 3-6 ESP32-S3 nodes streaming at 20 Hz
|
||||
- **Three.js visualization** — 3D body model with 17 joints, real-time WebSocket streaming
|
||||
- **CI verification pipeline** — Determinism checks and unseeded random scan across all signal operations
|
||||
|
||||
</details>
|
||||
|
||||
|
||||
79
claude.md
79
claude.md
@@ -21,77 +21,33 @@ All 5 ruvector crates integrated in workspace:
|
||||
- `ruvector-attention` → `model.rs` (apply_spatial_attention) + `bvp.rs`
|
||||
|
||||
### Architecture Decisions
|
||||
28 ADRs in `docs/adr/` (ADR-001 through ADR-028). Key ones:
|
||||
All ADRs in `docs/adr/` (ADR-001 through ADR-017). Key ones:
|
||||
- ADR-014: SOTA signal processing (Accepted)
|
||||
- ADR-015: MM-Fi + Wi-Pose training datasets (Accepted)
|
||||
- ADR-016: RuVector training pipeline integration (Accepted — complete)
|
||||
- ADR-017: RuVector signal + MAT integration (Proposed — next target)
|
||||
- ADR-024: Contrastive CSI embedding / AETHER (Accepted)
|
||||
- ADR-027: Cross-environment domain generalization / MERIDIAN (Accepted)
|
||||
- ADR-028: ESP32 capability audit + witness verification (Accepted)
|
||||
|
||||
### Build & Test Commands (this repo)
|
||||
```bash
|
||||
# Rust — full workspace tests (1,031 tests, ~2 min)
|
||||
# Rust — check training crate (no GPU needed)
|
||||
cd rust-port/wifi-densepose-rs
|
||||
cargo test --workspace --no-default-features
|
||||
|
||||
# Rust — single crate check (no GPU needed)
|
||||
cargo check -p wifi-densepose-train --no-default-features
|
||||
|
||||
# Python — deterministic proof verification (SHA-256)
|
||||
# Rust — run all tests
|
||||
cargo test -p wifi-densepose-train --no-default-features
|
||||
|
||||
# Rust — full workspace check
|
||||
cargo check --workspace --no-default-features
|
||||
|
||||
# Python — proof verification
|
||||
python v1/data/proof/verify.py
|
||||
|
||||
# Python — test suite
|
||||
cd v1 && python -m pytest tests/ -x -q
|
||||
```
|
||||
|
||||
### Validation & Witness Verification (ADR-028)
|
||||
|
||||
**After any significant code change, run the full validation:**
|
||||
|
||||
```bash
|
||||
# 1. Rust tests — must be 1,031+ passed, 0 failed
|
||||
cd rust-port/wifi-densepose-rs
|
||||
cargo test --workspace --no-default-features
|
||||
|
||||
# 2. Python proof — must print VERDICT: PASS
|
||||
cd ../..
|
||||
python v1/data/proof/verify.py
|
||||
|
||||
# 3. Generate witness bundle (includes both above + firmware hashes)
|
||||
bash scripts/generate-witness-bundle.sh
|
||||
|
||||
# 4. Self-verify the bundle — must be 7/7 PASS
|
||||
cd dist/witness-bundle-ADR028-*/
|
||||
bash VERIFY.sh
|
||||
```
|
||||
|
||||
**If the Python proof hash changes** (e.g., numpy/scipy version update):
|
||||
```bash
|
||||
# Regenerate the expected hash, then verify it passes
|
||||
python v1/data/proof/verify.py --generate-hash
|
||||
python v1/data/proof/verify.py
|
||||
```
|
||||
|
||||
**Witness bundle contents** (`dist/witness-bundle-ADR028-<sha>.tar.gz`):
|
||||
- `WITNESS-LOG-028.md` — 33-row attestation matrix with evidence per capability
|
||||
- `ADR-028-esp32-capability-audit.md` — Full audit findings
|
||||
- `proof/verify.py` + `expected_features.sha256` — Deterministic pipeline proof
|
||||
- `test-results/rust-workspace-tests.log` — Full cargo test output
|
||||
- `firmware-manifest/source-hashes.txt` — SHA-256 of all 7 ESP32 firmware files
|
||||
- `crate-manifest/versions.txt` — All 15 crates with versions
|
||||
- `VERIFY.sh` — One-command self-verification for recipients
|
||||
|
||||
**Key proof artifacts:**
|
||||
- `v1/data/proof/verify.py` — Trust Kill Switch: feeds reference signal through production pipeline, hashes output
|
||||
- `v1/data/proof/expected_features.sha256` — Published expected hash
|
||||
- `v1/data/proof/sample_csi_data.json` — 1,000 synthetic CSI frames (seed=42)
|
||||
- `docs/WITNESS-LOG-028.md` — 11-step reproducible verification procedure
|
||||
- `docs/adr/ADR-028-esp32-capability-audit.md` — Complete audit record
|
||||
|
||||
### Branch
|
||||
Default branch: `main`
|
||||
All development on: `claude/validate-code-quality-WNrNw`
|
||||
|
||||
---
|
||||
|
||||
@@ -133,21 +89,6 @@ Default branch: `main`
|
||||
- **HNSW**: Enabled
|
||||
- **Neural**: Enabled
|
||||
|
||||
## Pre-Merge Checklist
|
||||
|
||||
Before merging any PR, verify each item applies and is addressed:
|
||||
|
||||
1. **Rust tests pass** — `cargo test --workspace --no-default-features` (1,031+ passed, 0 failed)
|
||||
2. **Python proof passes** — `python v1/data/proof/verify.py` (VERDICT: PASS)
|
||||
3. **README.md** — Update platform tables, crate descriptions, hardware tables, feature summaries if scope changed
|
||||
4. **CHANGELOG.md** — Add entry under `[Unreleased]` with what was added/fixed/changed
|
||||
5. **User guide** (`docs/user-guide.md`) — Update if new data sources, CLI flags, or setup steps were added
|
||||
6. **ADR index** — Update ADR count in README docs table if a new ADR was created
|
||||
7. **Witness bundle** — Regenerate if tests or proof hash changed: `bash scripts/generate-witness-bundle.sh`
|
||||
8. **Docker Hub image** — Only rebuild if Dockerfile, dependencies, or runtime behavior changed
|
||||
9. **Crate publishing** — Only needed if a crate is published to crates.io and its public API changed
|
||||
10. **`.gitignore`** — Add any new build artifacts or binaries
|
||||
|
||||
## Build & Test
|
||||
|
||||
```bash
|
||||
|
||||
@@ -1,258 +0,0 @@
|
||||
# Witness Verification Log — ADR-028 ESP32 Capability Audit
|
||||
|
||||
> **Purpose:** Machine-verifiable attestation of repository capabilities at a specific commit.
|
||||
> Third parties can re-run these checks to confirm or refute each claim independently.
|
||||
|
||||
---
|
||||
|
||||
## Attestation Header
|
||||
|
||||
| Field | Value |
|
||||
|-------|-------|
|
||||
| **Date** | 2026-03-01T20:44:05Z |
|
||||
| **Commit** | `96b01008f71f4cbe2c138d63acb0e9bc6825286e` |
|
||||
| **Branch** | `main` |
|
||||
| **Auditor** | Claude Opus 4.6 (automated 3-agent parallel audit) |
|
||||
| **Rust Toolchain** | Stable (edition 2021) |
|
||||
| **Workspace Version** | 0.2.0 |
|
||||
| **Test Result** | **1,031 passed, 0 failed, 8 ignored** |
|
||||
| **ESP32 Serial Port** | COM7 (user-confirmed) |
|
||||
|
||||
---
|
||||
|
||||
## Verification Steps (Reproducible)
|
||||
|
||||
Anyone can re-run these checks. Each step includes the exact command and expected output.
|
||||
|
||||
### Step 1: Clone and Checkout
|
||||
|
||||
```bash
|
||||
git clone https://github.com/ruvnet/wifi-densepose.git
|
||||
cd wifi-densepose
|
||||
git checkout 96b01008
|
||||
```
|
||||
|
||||
### Step 2: Rust Workspace — Full Test Suite
|
||||
|
||||
```bash
|
||||
cd rust-port/wifi-densepose-rs
|
||||
cargo test --workspace --no-default-features
|
||||
```
|
||||
|
||||
**Expected:** 1,031 passed, 0 failed, 8 ignored (across all 15 crates).
|
||||
|
||||
**Test breakdown by crate family:**
|
||||
|
||||
| Crate Group | Tests | Category |
|
||||
|-------------|-------|----------|
|
||||
| wifi-densepose-signal | 105+ | Signal processing (Hampel, Fresnel, BVP, spectrogram, phase, motion) |
|
||||
| wifi-densepose-train | 174+ | Training pipeline, metrics, losses, dataset, model, proof, MERIDIAN |
|
||||
| wifi-densepose-nn | 23 | Neural network inference, DensePose head, translator |
|
||||
| wifi-densepose-mat | 153 | Disaster detection, triage, localization, alerting |
|
||||
| wifi-densepose-hardware | 32 | ESP32 parser, CSI frames, bridge, aggregator |
|
||||
| wifi-densepose-vitals | Included | Breathing, heartrate, anomaly detection |
|
||||
| wifi-densepose-wifiscan | Included | WiFi scanning adapters (Windows, macOS, Linux) |
|
||||
| Doc-tests (all crates) | 11 | Inline documentation examples |
|
||||
|
||||
### Step 3: Verify Crate Publication
|
||||
|
||||
```bash
|
||||
# Check all 15 crates are published at v0.2.0
|
||||
for crate in core config db signal nn api hardware mat train ruvector wasm vitals wifiscan sensing-server cli; do
|
||||
echo -n "wifi-densepose-$crate: "
|
||||
curl -s "https://crates.io/api/v1/crates/wifi-densepose-$crate" | grep -o '"max_version":"[^"]*"'
|
||||
done
|
||||
```
|
||||
|
||||
**Expected:** All return `"max_version":"0.2.0"`.
|
||||
|
||||
### Step 4: Verify ESP32 Firmware Exists
|
||||
|
||||
```bash
|
||||
ls firmware/esp32-csi-node/main/*.c firmware/esp32-csi-node/main/*.h
|
||||
wc -l firmware/esp32-csi-node/main/*.c firmware/esp32-csi-node/main/*.h
|
||||
```
|
||||
|
||||
**Expected:** 7 files, 606 total lines:
|
||||
- `main.c` (144), `csi_collector.c` (176), `stream_sender.c` (77), `nvs_config.c` (88)
|
||||
- `csi_collector.h` (38), `stream_sender.h` (44), `nvs_config.h` (39)
|
||||
|
||||
### Step 5: Verify Pre-Built Firmware Binaries
|
||||
|
||||
```bash
|
||||
ls firmware/esp32-csi-node/build/bootloader/bootloader.bin
|
||||
ls firmware/esp32-csi-node/build/*.bin 2>/dev/null || echo "App binary in build/esp32-csi-node.bin"
|
||||
```
|
||||
|
||||
**Expected:** `bootloader.bin` exists. App binary present in build directory.
|
||||
|
||||
### Step 6: Verify ADR-018 Binary Frame Parser
|
||||
|
||||
```bash
|
||||
cd rust-port/wifi-densepose-rs
|
||||
cargo test -p wifi-densepose-hardware --no-default-features
|
||||
```
|
||||
|
||||
**Expected:** 32 tests pass, including:
|
||||
- `parse_valid_frame` — validates magic 0xC5110001, field extraction
|
||||
- `parse_invalid_magic` — rejects non-CSI data
|
||||
- `parse_insufficient_data` — rejects truncated frames
|
||||
- `multi_antenna_frame` — handles MIMO configurations
|
||||
- `amplitude_phase_conversion` — I/Q → (amplitude, phase) math
|
||||
- `bridge_from_known_iq` — hardware→signal crate bridge
|
||||
|
||||
### Step 7: Verify Signal Processing Algorithms
|
||||
|
||||
```bash
|
||||
cargo test -p wifi-densepose-signal --no-default-features
|
||||
```
|
||||
|
||||
**Expected:** 105+ tests pass covering:
|
||||
- Hampel outlier filtering
|
||||
- Fresnel zone breathing model
|
||||
- BVP (Body Velocity Profile) extraction
|
||||
- STFT spectrogram generation
|
||||
- Phase sanitization and unwrapping
|
||||
- Hardware normalization (ESP32-S3 → canonical 56 subcarriers)
|
||||
|
||||
### Step 8: Verify MERIDIAN Domain Generalization
|
||||
|
||||
```bash
|
||||
cargo test -p wifi-densepose-train --no-default-features
|
||||
```
|
||||
|
||||
**Expected:** 174+ tests pass, including ADR-027 modules:
|
||||
- `domain_within_configured_ranges` — virtual domain parameter bounds
|
||||
- `augment_frame_preserves_length` — output shape correctness
|
||||
- `augment_frame_identity_domain_approx_input` — identity transform ≈ input
|
||||
- `deterministic_same_seed_same_output` — reproducibility
|
||||
- `adapt_empty_buffer_returns_error` — no panic on empty input
|
||||
- `adapt_zero_rank_returns_error` — no panic on invalid config
|
||||
- `buffer_cap_evicts_oldest` — bounded memory (max 10,000 frames)
|
||||
|
||||
### Step 9: Verify Python Proof System
|
||||
|
||||
```bash
|
||||
python v1/data/proof/verify.py
|
||||
```
|
||||
|
||||
**Expected:** PASS (hash `8c0680d7...` matches `expected_features.sha256`).
|
||||
Requires numpy 2.4.2 + scipy 1.17.1 (Python 3.13). Hash was regenerated at audit time.
|
||||
|
||||
```
|
||||
VERDICT: PASS
|
||||
Pipeline hash: 8c0680d7d285739ea9597715e84959d9c356c87ee3ad35b5f1e69a4ca41151c6
|
||||
```
|
||||
|
||||
### Step 10: Verify Docker Images
|
||||
|
||||
```bash
|
||||
docker pull ruvnet/wifi-densepose:latest
|
||||
docker inspect ruvnet/wifi-densepose:latest --format='{{.Size}}'
|
||||
# Expected: ~132 MB
|
||||
|
||||
docker pull ruvnet/wifi-densepose:python
|
||||
docker inspect ruvnet/wifi-densepose:python --format='{{.Size}}'
|
||||
# Expected: ~569 MB
|
||||
```
|
||||
|
||||
### Step 11: Verify ESP32 Flash (requires hardware on COM7)
|
||||
|
||||
```bash
|
||||
pip install esptool
|
||||
python -m esptool --chip esp32s3 --port COM7 chip_id
|
||||
# Expected: ESP32-S3 chip ID response
|
||||
|
||||
# Full flash (optional)
|
||||
python -m esptool --chip esp32s3 --port COM7 --baud 460800 \
|
||||
write_flash --flash_mode dio --flash_size 4MB \
|
||||
0x0 firmware/esp32-csi-node/build/bootloader/bootloader.bin \
|
||||
0x8000 firmware/esp32-csi-node/build/partition_table/partition-table.bin \
|
||||
0x10000 firmware/esp32-csi-node/build/esp32-csi-node.bin
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Capability Attestation Matrix
|
||||
|
||||
Each row is independently verifiable. Status reflects audit-time findings.
|
||||
|
||||
| # | Capability | Claimed | Verified | Evidence |
|
||||
|---|-----------|---------|----------|----------|
|
||||
| 1 | ESP32-S3 CSI frame parsing (ADR-018 binary format) | Yes | **YES** | 32 Rust tests, `esp32_parser.rs` (385 lines) |
|
||||
| 2 | ESP32 firmware (C, ESP-IDF v5.2) | Yes | **YES** | 606 lines in `firmware/esp32-csi-node/main/` |
|
||||
| 3 | Pre-built firmware binaries | Yes | **YES** | `bootloader.bin` + app binary in `build/` |
|
||||
| 4 | Multi-chipset support (ESP32-S3, Intel 5300, Atheros) | Yes | **YES** | `HardwareType` enum, auto-detection, Catmull-Rom resampling |
|
||||
| 5 | UDP aggregator (multi-node streaming) | Yes | **YES** | `aggregator/mod.rs`, loopback UDP tests |
|
||||
| 6 | Hampel outlier filter | Yes | **YES** | `hampel.rs` (240 lines), tests pass |
|
||||
| 7 | SpotFi phase correction (conjugate multiplication) | Yes | **YES** | `csi_ratio.rs` (198 lines), tests pass |
|
||||
| 8 | Fresnel zone breathing model | Yes | **YES** | `fresnel.rs` (448 lines), tests pass |
|
||||
| 9 | Body Velocity Profile extraction | Yes | **YES** | `bvp.rs` (381 lines), tests pass |
|
||||
| 10 | STFT spectrogram (4 window functions) | Yes | **YES** | `spectrogram.rs` (367 lines), tests pass |
|
||||
| 11 | Hardware normalization (MERIDIAN Phase 1) | Yes | **YES** | `hardware_norm.rs` (399 lines), 10+ tests |
|
||||
| 12 | DensePose neural network (24 parts + UV) | Yes | **YES** | `densepose.rs` (589 lines), `nn` crate tests |
|
||||
| 13 | 17 COCO keypoint detection | Yes | **YES** | `KeypointHead` in nn crate, heatmap regression |
|
||||
| 14 | 10-phase training pipeline | Yes | **YES** | 9,051 lines across 14 modules |
|
||||
| 15 | RuVector v2.0.4 integration (5 crates) | Yes | **YES** | All 5 in workspace Cargo.toml, used in metrics/model/dataset/subcarrier/bvp |
|
||||
| 16 | Gradient Reversal Layer (ADR-027) | Yes | **YES** | `domain.rs` (400 lines), adversarial schedule tests |
|
||||
| 17 | Geometry-conditioned FiLM (ADR-027) | Yes | **YES** | `geometry.rs` (365 lines), Fourier + DeepSets + FiLM |
|
||||
| 18 | Virtual domain augmentation (ADR-027) | Yes | **YES** | `virtual_aug.rs` (297 lines), deterministic tests |
|
||||
| 19 | Rapid adaptation / TTT (ADR-027) | Yes | **YES** | `rapid_adapt.rs` (317 lines), bounded buffer, Result return |
|
||||
| 20 | Contrastive self-supervised learning (ADR-024) | Yes | **YES** | Projection head, InfoNCE + VICReg in `model.rs` |
|
||||
| 21 | Vital sign detection (breathing + heartbeat) | Yes | **YES** | `vitals` crate (1,863 lines), 6-30 BPM / 40-120 BPM |
|
||||
| 22 | WiFi-MAT disaster response (START triage) | Yes | **YES** | `mat` crate, 153 tests, detection+localization+alerting |
|
||||
| 23 | Deterministic proof system (SHA-256) | Yes | **YES** | PASS — hash `8c0680d7...` matches (numpy 2.4.2, scipy 1.17.1) |
|
||||
| 24 | 15 crates published on crates.io @ v0.2.0 | Yes | **YES** | All published 2026-03-01 |
|
||||
| 25 | Docker images on Docker Hub | Yes | **YES** | `ruvnet/wifi-densepose:latest` (132 MB), `:python` (569 MB) |
|
||||
| 26 | WASM browser deployment | Yes | **YES** | `wifi-densepose-wasm` crate, wasm-bindgen, Three.js |
|
||||
| 27 | Cross-platform WiFi scanning (Win/Mac/Linux) | Yes | **YES** | `wifi-densepose-wifiscan` crate, `#[cfg(target_os)]` adapters |
|
||||
| 28 | 4 CI/CD workflows (CI, security, CD, verify) | Yes | **YES** | `.github/workflows/` |
|
||||
| 29 | 27 Architecture Decision Records | Yes | **YES** | `docs/adr/ADR-001` through `ADR-027` |
|
||||
| 30 | 1,031 Rust tests passing | Yes | **YES** | `cargo test --workspace --no-default-features` at audit time |
|
||||
| 31 | On-device ESP32 ML inference | No | **NO** | Firmware streams raw I/Q; inference runs on aggregator |
|
||||
| 32 | Real-world CSI dataset bundled | No | **NO** | Only synthetic reference signal (seed=42) |
|
||||
| 33 | 54,000 fps measured throughput | Claimed | **NOT MEASURED** | Criterion benchmarks exist but not run at audit time |
|
||||
|
||||
---
|
||||
|
||||
## Cryptographic Anchors
|
||||
|
||||
| Anchor | Value |
|
||||
|--------|-------|
|
||||
| Witness commit SHA | `96b01008f71f4cbe2c138d63acb0e9bc6825286e` |
|
||||
| Python proof hash (numpy 2.4.2, scipy 1.17.1) | `8c0680d7d285739ea9597715e84959d9c356c87ee3ad35b5f1e69a4ca41151c6` |
|
||||
| ESP32 frame magic | `0xC5110001` |
|
||||
| Workspace crate version | `0.2.0` |
|
||||
|
||||
---
|
||||
|
||||
## How to Use This Log
|
||||
|
||||
### For Developers
|
||||
1. Clone the repo at the witness commit
|
||||
2. Run Steps 2-8 to confirm all code compiles and tests pass
|
||||
3. Use the ADR-028 capability matrix to understand what's real vs. planned
|
||||
4. The `firmware/` directory has everything needed to flash an ESP32-S3 on COM7
|
||||
|
||||
### For Reviewers / Due Diligence
|
||||
1. Run Steps 2-10 (no hardware needed) to confirm all software claims
|
||||
2. Check the attestation matrix — rows marked **YES** have passing test evidence
|
||||
3. Rows marked **NO** or **NOT MEASURED** are honest gaps, not hidden
|
||||
4. The proof system (Step 9) demonstrates commitment to verifiability
|
||||
|
||||
### For Hardware Testers
|
||||
1. Get an ESP32-S3-DevKitC-1 (~$10)
|
||||
2. Follow Step 11 to flash firmware
|
||||
3. Run the aggregator: `cargo run -p wifi-densepose-hardware --bin aggregator`
|
||||
4. Observe CSI frames streaming on UDP 5005
|
||||
|
||||
---
|
||||
|
||||
## Signatures
|
||||
|
||||
| Role | Identity | Method |
|
||||
|------|----------|--------|
|
||||
| Repository owner | rUv (ruv@ruv.net) | Git commit authorship |
|
||||
| Audit agent | Claude Opus 4.6 | This witness log (committed to repo) |
|
||||
|
||||
This log is committed to the repository as part of branch `adr-028-esp32-capability-audit` and can be verified against the git history.
|
||||
@@ -1,9 +1,7 @@
|
||||
# ADR-002: RuVector RVF Integration Strategy
|
||||
|
||||
## Status
|
||||
Superseded by [ADR-016](ADR-016-ruvector-integration.md) and [ADR-017](ADR-017-ruvector-signal-mat-integration.md)
|
||||
|
||||
> **Note:** The vision in this ADR has been fully realized. ADR-016 integrates all 5 RuVector crates into the training pipeline. ADR-017 adds 7 signal + MAT integration points. The `wifi-densepose-ruvector` crate is [published on crates.io](https://crates.io/crates/wifi-densepose-ruvector). See also [ADR-027](ADR-027-cross-environment-domain-generalization.md) for how RuVector is extended with domain generalization.
|
||||
Proposed
|
||||
|
||||
## Date
|
||||
2026-02-28
|
||||
|
||||
@@ -1,9 +1,7 @@
|
||||
# ADR-004: HNSW Vector Search for Signal Fingerprinting
|
||||
|
||||
## Status
|
||||
Partially realized by [ADR-024](ADR-024-contrastive-csi-embedding-model.md); extended by [ADR-027](ADR-027-cross-environment-domain-generalization.md)
|
||||
|
||||
> **Note:** ADR-024 (AETHER) implements HNSW-compatible fingerprint indices with 4 index types. ADR-027 (MERIDIAN) extends this with domain-disentangled embeddings so fingerprints match across environments, not just within a single room.
|
||||
Proposed
|
||||
|
||||
## Date
|
||||
2026-02-28
|
||||
|
||||
@@ -1,9 +1,7 @@
|
||||
# ADR-005: SONA Self-Learning for Pose Estimation
|
||||
|
||||
## Status
|
||||
Partially realized in [ADR-023](ADR-023-trained-densepose-model-ruvector-pipeline.md); extended by [ADR-027](ADR-027-cross-environment-domain-generalization.md)
|
||||
|
||||
> **Note:** ADR-023 implements SONA with MicroLoRA rank-4 adapters and EWC++ memory preservation. ADR-027 (MERIDIAN) extends SONA with unsupervised rapid adaptation: 10 seconds of unlabeled WiFi data in a new room automatically generates environment-specific LoRA weights via contrastive test-time training.
|
||||
Proposed
|
||||
|
||||
## Date
|
||||
2026-02-28
|
||||
|
||||
@@ -1,9 +1,7 @@
|
||||
# ADR-006: GNN-Enhanced CSI Pattern Recognition
|
||||
|
||||
## Status
|
||||
Partially realized in [ADR-023](ADR-023-trained-densepose-model-ruvector-pipeline.md); extended by [ADR-027](ADR-027-cross-environment-domain-generalization.md)
|
||||
|
||||
> **Note:** ADR-023 implements a 2-layer GCN on the COCO skeleton graph for spatial reasoning. ADR-027 (MERIDIAN) adds domain-adversarial regularization via a gradient reversal layer that forces the GCN to learn environment-invariant graph features, shedding room-specific multipath patterns.
|
||||
Proposed
|
||||
|
||||
## Date
|
||||
2026-02-28
|
||||
|
||||
@@ -1,315 +0,0 @@
|
||||
# ADR-025: macOS CoreWLAN WiFi Sensing via Swift Helper Bridge
|
||||
|
||||
| Field | Value |
|
||||
|-------|-------|
|
||||
| **Status** | Proposed |
|
||||
| **Date** | 2026-03-01 |
|
||||
| **Deciders** | ruv |
|
||||
| **Codename** | **ORCA** — OS-native Radio Channel Acquisition |
|
||||
| **Relates to** | ADR-013 (Feature-Level Sensing Commodity Gear), ADR-022 (Windows WiFi Enhanced Fidelity), ADR-014 (SOTA Signal Processing), ADR-018 (ESP32 Dev Implementation) |
|
||||
| **Issue** | [#56](https://github.com/ruvnet/wifi-densepose/issues/56) |
|
||||
| **Build/Test Target** | Mac Mini (M2 Pro, macOS 26.3) |
|
||||
|
||||
---
|
||||
|
||||
## 1. Context
|
||||
|
||||
### 1.1 The Gap: macOS Is a Silent Fallback
|
||||
|
||||
The `--source auto` path in `sensing-server` probes for ESP32 UDP, then Windows `netsh`, then falls back to simulated mode. macOS users hit the simulation path silently — there is no macOS WiFi adapter. This is the only major desktop platform without real WiFi sensing support.
|
||||
|
||||
### 1.2 Platform Constraints (macOS 26.3+)
|
||||
|
||||
| Constraint | Detail |
|
||||
|------------|--------|
|
||||
| **`airport` CLI removed** | Apple removed `/System/Library/PrivateFrameworks/.../airport` in macOS 15. No CLI fallback exists. |
|
||||
| **CoreWLAN is the only path** | `CWWiFiClient` (Swift/ObjC) is the supported API for WiFi scanning. Returns RSSI, channel, SSID, noise, PHY mode, security. |
|
||||
| **BSSIDs redacted** | macOS privacy policy redacts MAC addresses from `CWNetwork.bssid` unless the app has Location Services + WiFi entitlement. Apps without entitlement see `nil` for BSSID. |
|
||||
| **No raw CSI** | Apple does not expose CSI or per-subcarrier data. macOS WiFi sensing is RSSI-only, same tier as Windows `netsh`. |
|
||||
| **Scan rate** | `CWInterface.scanForNetworks()` takes ~2-4 seconds. Effective rate: ~0.3-0.5 Hz without caching. |
|
||||
| **Permissions** | Location Services prompt required for BSSID access. Without it, SSID + RSSI + channel still available. |
|
||||
|
||||
### 1.3 The Opportunity: Multi-AP RSSI Diversity
|
||||
|
||||
Same principle as ADR-022 (Windows): visible APs serve as pseudo-subcarriers. A typical indoor environment exposes 10-30+ SSIDs across 2.4 GHz and 5 GHz bands. Each AP's RSSI responds differently to human movement based on geometry, creating spatial diversity.
|
||||
|
||||
| Source | Effective Subcarriers | Sample Rate | Capabilities |
|
||||
|--------|----------------------|-------------|-------------|
|
||||
| ESP32-S3 (CSI) | 56-192 | 20 Hz | Full: pose, vitals, through-wall |
|
||||
| Windows `netsh` (ADR-022) | 10-30 BSSIDs | ~2 Hz | Presence, motion, coarse breathing |
|
||||
| **macOS CoreWLAN (this ADR)** | **10-30 SSIDs** | **~0.3-0.5 Hz** | **Presence, motion** |
|
||||
|
||||
The lower scan rate vs Windows is offset by higher signal quality — CoreWLAN returns calibrated dBm (not percentage) plus noise floor, enabling proper SNR computation.
|
||||
|
||||
### 1.4 Why Swift Subprocess (Not FFI)
|
||||
|
||||
| Approach | Complexity | Maintenance | Build | Verdict |
|
||||
|----------|-----------|-------------|-------|---------|
|
||||
| **Swift CLI → JSON → stdout** | Low | Independent binary, versionable | `swiftc` (ships with Xcode CLT) | **Chosen** |
|
||||
| ObjC FFI via `cc` crate | Medium | Fragile header bindings, ABI churn | Requires Xcode headers | Rejected |
|
||||
| `objc2` crate (Rust ObjC bridge) | High | CoreWLAN not in upstream `objc2-frameworks` | Requires manual class definitions | Rejected |
|
||||
| `swift-bridge` crate | High | Young ecosystem, async bridging unsupported | Requires Swift build integration in Cargo | Rejected |
|
||||
|
||||
The `Command::new()` + parse JSON pattern is proven — it's exactly what `NetshBssidScanner` does for Windows. The subprocess boundary also isolates Apple framework dependencies from the Rust build graph.
|
||||
|
||||
### 1.5 SOTA: Platform-Adaptive WiFi Sensing
|
||||
|
||||
Recent work validates multi-platform RSSI-based sensing:
|
||||
|
||||
- **WiFind** (2024): Cross-platform WiFi fingerprinting using RSSI vectors from heterogeneous hardware. Demonstrates that normalization across scan APIs (dBm, percentage, raw) is critical for model portability.
|
||||
- **WiGesture** (2025): RSSI variance-based gesture recognition achieving 89% accuracy on commodity hardware with 15+ APs. Shows that temporal RSSI variance alone carries significant motion information.
|
||||
- **CrossSense** (2024): Transfer learning from CSI-rich hardware to RSSI-only devices. Pre-trained signal features transfer with 78% effectiveness, validating multi-tier hardware strategy.
|
||||
|
||||
---
|
||||
|
||||
## 2. Decision
|
||||
|
||||
Implement a **macOS CoreWLAN sensing adapter** as a Swift helper binary + Rust adapter pair, following the established `NetshBssidScanner` subprocess pattern from ADR-022. Real RSSI data flows through the existing 8-stage `WindowsWifiPipeline` (which operates on `BssidObservation` structs regardless of platform origin).
|
||||
|
||||
### 2.1 Design Principles
|
||||
|
||||
1. **Subprocess isolation** — Swift binary is a standalone tool, built and versioned independently of the Rust workspace.
|
||||
2. **Same domain types** — macOS adapter produces `Vec<BssidObservation>`, identical to the Windows path. All downstream processing reuses as-is.
|
||||
3. **SSID:channel as synthetic BSSID** — When real BSSIDs are redacted (no Location Services), `sha256(ssid + channel)[:12]` generates a stable pseudo-BSSID. Documented limitation: same-SSID same-channel APs collapse to one observation.
|
||||
4. **`#[cfg(target_os = "macos")]` gating** — macOS-specific code compiles only on macOS. Windows and Linux builds are unaffected.
|
||||
5. **Graceful degradation** — If the Swift helper is not found or fails, `--source auto` skips macOS WiFi and falls back to simulated mode with a clear warning.
|
||||
|
||||
---
|
||||
|
||||
## 3. Architecture
|
||||
|
||||
### 3.1 Component Overview
|
||||
|
||||
```
|
||||
┌─────────────────────────────────────────────────────────────────────┐
|
||||
│ macOS WiFi Sensing Path │
|
||||
│ │
|
||||
│ ┌──────────────────────┐ ┌───────────────────────────────────┐│
|
||||
│ │ Swift Helper Binary │ │ Rust Adapter + Existing Pipeline ││
|
||||
│ │ (tools/macos-wifi- │ │ ││
|
||||
│ │ scan/main.swift) │ │ MacosCoreWlanScanner ││
|
||||
│ │ │ │ │ ││
|
||||
│ │ CWWiFiClient │JSON │ ▼ ││
|
||||
│ │ scanForNetworks() ──┼────►│ Vec<BssidObservation> ││
|
||||
│ │ interface() │ │ │ ││
|
||||
│ │ │ │ ▼ ││
|
||||
│ │ Outputs: │ │ BssidRegistry ││
|
||||
│ │ - ssid │ │ │ ││
|
||||
│ │ - rssi (dBm) │ │ ▼ ││
|
||||
│ │ - noise (dBm) │ │ WindowsWifiPipeline (reused) ││
|
||||
│ │ - channel │ │ [8-stage signal intelligence] ││
|
||||
│ │ - band (2.4/5/6) │ │ │ ││
|
||||
│ │ - phy_mode │ │ ▼ ││
|
||||
│ │ - bssid (if avail) │ │ SensingUpdate → REST/WS ││
|
||||
│ └──────────────────────┘ └───────────────────────────────────┘│
|
||||
└─────────────────────────────────────────────────────────────────────┘
|
||||
```
|
||||
|
||||
### 3.2 Swift Helper Binary
|
||||
|
||||
**File:** `rust-port/wifi-densepose-rs/tools/macos-wifi-scan/main.swift`
|
||||
|
||||
```swift
|
||||
// Modes:
|
||||
// (no args) → Full scan, output JSON array to stdout
|
||||
// --probe → Quick availability check, output {"available": true/false}
|
||||
// --connected → Connected network info only
|
||||
//
|
||||
// Output schema (scan mode):
|
||||
// [
|
||||
// {
|
||||
// "ssid": "MyNetwork",
|
||||
// "rssi": -52,
|
||||
// "noise": -90,
|
||||
// "channel": 36,
|
||||
// "band": "5GHz",
|
||||
// "phy_mode": "802.11ax",
|
||||
// "bssid": "aa:bb:cc:dd:ee:ff" | null,
|
||||
// "security": "wpa2_personal"
|
||||
// }
|
||||
// ]
|
||||
```
|
||||
|
||||
**Build:**
|
||||
|
||||
```bash
|
||||
# Requires Xcode Command Line Tools (xcode-select --install)
|
||||
cd tools/macos-wifi-scan
|
||||
swiftc -framework CoreWLAN -framework Foundation -O -o macos-wifi-scan main.swift
|
||||
```
|
||||
|
||||
**Build script:** `tools/macos-wifi-scan/build.sh`
|
||||
|
||||
### 3.3 Rust Adapter
|
||||
|
||||
**File:** `crates/wifi-densepose-wifiscan/src/adapter/macos_scanner.rs`
|
||||
|
||||
```rust
|
||||
// #[cfg(target_os = "macos")]
|
||||
|
||||
pub struct MacosCoreWlanScanner {
|
||||
helper_path: PathBuf, // Resolved at construction: $PATH or sibling of server binary
|
||||
}
|
||||
|
||||
impl MacosCoreWlanScanner {
|
||||
pub fn new() -> Result<Self, WifiScanError> // Finds helper or errors
|
||||
pub fn probe() -> bool // Runs --probe, returns availability
|
||||
pub fn scan_sync(&self) -> Result<Vec<BssidObservation>, WifiScanError>
|
||||
pub fn connected_sync(&self) -> Result<Option<BssidObservation>, WifiScanError>
|
||||
}
|
||||
```
|
||||
|
||||
**Key mappings:**
|
||||
|
||||
| CoreWLAN field | → | BssidObservation field | Transform |
|
||||
|----------------|---|----------------------|-----------|
|
||||
| `rssi` (dBm) | → | `signal_dbm` | Direct (CoreWLAN gives calibrated dBm) |
|
||||
| `rssi` (dBm) | → | `amplitude` | `rssi_to_amplitude()` (existing) |
|
||||
| `noise` (dBm) | → | `snr` | `rssi - noise` (new field, macOS advantage) |
|
||||
| `channel` | → | `channel` | Direct |
|
||||
| `band` | → | `band` | `BandType::from_channel()` (existing) |
|
||||
| `phy_mode` | → | `radio_type` | Map string → `RadioType` enum |
|
||||
| `bssid` | → | `bssid_id` | Direct if available, else `sha256(ssid:channel)[:12]` |
|
||||
| `ssid` | → | `ssid` | Direct |
|
||||
|
||||
### 3.4 Sensing Server Integration
|
||||
|
||||
**File:** `crates/wifi-densepose-sensing-server/src/main.rs`
|
||||
|
||||
| Function | Purpose |
|
||||
|----------|---------|
|
||||
| `probe_macos_wifi()` | Calls `MacosCoreWlanScanner::probe()`, returns bool |
|
||||
| `macos_wifi_task()` | Async loop: scan → build `BssidObservation` vec → feed into `BssidRegistry` + `WindowsWifiPipeline` → emit `SensingUpdate`. Same structure as `windows_wifi_task()`. |
|
||||
|
||||
**Auto-detection order (updated):**
|
||||
|
||||
```
|
||||
1. ESP32 UDP probe (port 5005) → --source esp32
|
||||
2. Windows netsh probe → --source wifi (Windows)
|
||||
3. macOS CoreWLAN probe [NEW] → --source wifi (macOS)
|
||||
4. Simulated fallback → --source simulated
|
||||
```
|
||||
|
||||
### 3.5 Pipeline Reuse
|
||||
|
||||
The existing 8-stage `WindowsWifiPipeline` (ADR-022) operates entirely on `BssidObservation` / `MultiApFrame` types:
|
||||
|
||||
| Stage | Reusable? | Notes |
|
||||
|-------|-----------|-------|
|
||||
| 1. Predictive Gating | Yes | Filters static APs by temporal variance |
|
||||
| 2. Attention Weighting | Yes | Weights APs by motion sensitivity |
|
||||
| 3. Spatial Correlation | Yes | Cross-AP signal correlation |
|
||||
| 4. Motion Estimation | Yes | RSSI variance → motion level |
|
||||
| 5. Breathing Extraction | **Marginal** | 0.3 Hz scan rate is below Nyquist for breathing (0.1-0.5 Hz). May detect very slow breathing only. |
|
||||
| 6. Quality Gating | Yes | Rejects low-confidence estimates |
|
||||
| 7. Fingerprint Matching | Yes | Location/posture classification |
|
||||
| 8. Orchestration | Yes | Fuses all stages |
|
||||
|
||||
**Limitation:** CoreWLAN scan rate (~0.3-0.5 Hz) is significantly slower than `netsh` (~2 Hz). Breathing extraction (stage 5) will have reduced accuracy. Motion and presence detection remain effective since they depend on variance over longer windows.
|
||||
|
||||
---
|
||||
|
||||
## 4. Files
|
||||
|
||||
### 4.1 New Files
|
||||
|
||||
| File | Purpose | Lines (est.) |
|
||||
|------|---------|-------------|
|
||||
| `tools/macos-wifi-scan/main.swift` | CoreWLAN scanner, JSON output | ~120 |
|
||||
| `tools/macos-wifi-scan/build.sh` | Build script (`swiftc` invocation) | ~15 |
|
||||
| `crates/wifi-densepose-wifiscan/src/adapter/macos_scanner.rs` | Rust adapter: spawn helper, parse JSON, produce `BssidObservation` | ~200 |
|
||||
|
||||
### 4.2 Modified Files
|
||||
|
||||
| File | Change |
|
||||
|------|--------|
|
||||
| `crates/wifi-densepose-wifiscan/src/adapter/mod.rs` | Add `#[cfg(target_os = "macos")] pub mod macos_scanner;` + re-export |
|
||||
| `crates/wifi-densepose-wifiscan/src/lib.rs` | Add `MacosCoreWlanScanner` re-export |
|
||||
| `crates/wifi-densepose-sensing-server/src/main.rs` | Add `probe_macos_wifi()`, `macos_wifi_task()`, update auto-detect + `--source wifi` dispatch |
|
||||
|
||||
### 4.3 No New Rust Dependencies
|
||||
|
||||
- `std::process::Command` — subprocess spawning (stdlib)
|
||||
- `serde_json` — JSON parsing (already in workspace)
|
||||
- No changes to `Cargo.toml`
|
||||
|
||||
---
|
||||
|
||||
## 5. Verification Plan
|
||||
|
||||
All verification on Mac Mini (M2 Pro, macOS 26.3).
|
||||
|
||||
### 5.1 Swift Helper
|
||||
|
||||
| Test | Command | Expected |
|
||||
|------|---------|----------|
|
||||
| Build | `cd tools/macos-wifi-scan && ./build.sh` | Produces `macos-wifi-scan` binary |
|
||||
| Probe | `./macos-wifi-scan --probe` | `{"available": true}` |
|
||||
| Scan | `./macos-wifi-scan` | JSON array with real SSIDs, RSSI in dBm, channels |
|
||||
| Connected | `./macos-wifi-scan --connected` | Single JSON object for connected network |
|
||||
| No WiFi | Disable WiFi → `./macos-wifi-scan` | `{"available": false}` or empty array |
|
||||
|
||||
### 5.2 Rust Adapter
|
||||
|
||||
| Test | Method | Expected |
|
||||
|------|--------|----------|
|
||||
| Unit: JSON parsing | `#[test]` with fixture JSON | Correct `BssidObservation` values |
|
||||
| Unit: synthetic BSSID | `#[test]` with nil bssid input | Stable `sha256(ssid:channel)[:12]` |
|
||||
| Unit: helper not found | `#[test]` with bad path | `WifiScanError::ProcessError` |
|
||||
| Integration: real scan | `cargo test` on Mac Mini | Live observations from CoreWLAN |
|
||||
|
||||
### 5.3 End-to-End
|
||||
|
||||
| Step | Command | Verify |
|
||||
|------|---------|--------|
|
||||
| 1 | `cargo build --release` (Mac Mini) | Clean build, no warnings |
|
||||
| 2 | `cargo test --workspace` | All existing tests pass + new macOS tests |
|
||||
| 3 | `./target/release/sensing-server --source wifi` | Server starts, logs `source: wifi (macOS CoreWLAN)` |
|
||||
| 4 | `curl http://localhost:8080/api/v1/sensing/latest` | `source: "wifi:<SSID>"`, real RSSI values |
|
||||
| 5 | `curl http://localhost:8080/api/v1/vital-signs` | Motion detection responds to physical movement |
|
||||
| 6 | Open UI at `http://localhost:8080` | Signal field updates with real RSSI variation |
|
||||
| 7 | `--source auto` | Auto-detects macOS WiFi, does not fall back to simulated |
|
||||
|
||||
### 5.4 Cross-Platform Regression
|
||||
|
||||
| Platform | Build | Expected |
|
||||
|----------|-------|----------|
|
||||
| macOS (Mac Mini) | `cargo build --release` | macOS adapter compiled, works |
|
||||
| Windows | `cargo build --release` | macOS adapter skipped (`#[cfg]`), Windows path unchanged |
|
||||
| Linux | `cargo build --release` | macOS adapter skipped, ESP32/simulated paths unchanged |
|
||||
|
||||
---
|
||||
|
||||
## 6. Limitations
|
||||
|
||||
| Limitation | Impact | Mitigation |
|
||||
|------------|--------|-----------|
|
||||
| **BSSID redaction** | Same-SSID same-channel APs collapse to one observation | Use `sha256(ssid:channel)` as pseudo-BSSID; document edge case. Rare in practice (mesh networks). |
|
||||
| **Slow scan rate** (~0.3 Hz) | Breathing extraction unreliable (below Nyquist) | Motion/presence still work. Breathing marked low-confidence. Future: cache + connected AP fast-poll hybrid. |
|
||||
| **Requires Swift helper in PATH** | Extra build step for source builds | `build.sh` provided. Docker image pre-bundles it. Clear error message when missing. |
|
||||
| **Location Services for BSSID** | Full BSSID requires user permission prompt | System degrades gracefully to SSID:channel pseudo-BSSID without permission. |
|
||||
| **No CSI** | Cannot match ESP32 pose estimation accuracy | Expected — this is RSSI-tier sensing (presence + motion). Same limitation as Windows. |
|
||||
|
||||
---
|
||||
|
||||
## 7. Future Work
|
||||
|
||||
| Enhancement | Description | Depends On |
|
||||
|-------------|-------------|-----------|
|
||||
| **Fast-poll connected AP** | Poll connected AP's RSSI at ~10 Hz via `CWInterface.rssiValue()` (no full scan needed) | CoreWLAN `rssiValue()` performance testing |
|
||||
| **Linux `iw` adapter** | Same subprocess pattern with `iw dev wlan0 scan` output | Linux machine for testing |
|
||||
| **Unified `RssiPipeline` rename** | Rename `WindowsWifiPipeline` → `RssiPipeline` to reflect multi-platform use | ADR-022 update |
|
||||
| **802.11bf sensing** | Apple may expose CSI via 802.11bf in future macOS | Apple framework availability |
|
||||
| **Docker macOS image** | Pre-built macOS Docker image with Swift helper bundled | Docker multi-arch build |
|
||||
|
||||
---
|
||||
|
||||
## 8. References
|
||||
|
||||
- [Apple CoreWLAN Documentation](https://developer.apple.com/documentation/corewlan)
|
||||
- [CWWiFiClient](https://developer.apple.com/documentation/corewlan/cwwificlient) — Primary WiFi interface API
|
||||
- [CWNetwork](https://developer.apple.com/documentation/corewlan/cwnetwork) — Scan result type (SSID, RSSI, channel, noise)
|
||||
- [macOS 15 airport removal](https://developer.apple.com/forums/thread/732431) — Apple Developer Forums
|
||||
- ADR-022: Windows WiFi Enhanced Fidelity (analogous platform adapter)
|
||||
- ADR-013: Feature-Level Sensing from Commodity Gear
|
||||
- Issue [#56](https://github.com/ruvnet/wifi-densepose/issues/56): macOS support request
|
||||
@@ -1,208 +0,0 @@
|
||||
# ADR-026: Survivor Track Lifecycle Management for MAT Crate
|
||||
|
||||
**Status:** Accepted
|
||||
**Date:** 2026-03-01
|
||||
**Deciders:** WiFi-DensePose Core Team
|
||||
**Domain:** MAT (Mass Casualty Assessment Tool) — `wifi-densepose-mat`
|
||||
**Supersedes:** None
|
||||
**Related:** ADR-001 (WiFi-MAT disaster detection), ADR-017 (ruvector signal/MAT integration)
|
||||
|
||||
---
|
||||
|
||||
## Context
|
||||
|
||||
The MAT crate's `Survivor` entity has `SurvivorStatus` states
|
||||
(`Active / Rescued / Lost / Deceased / FalsePositive`) and `is_stale()` /
|
||||
`mark_lost()` methods, but these are insufficient for real operational use:
|
||||
|
||||
1. **Manually driven state transitions** — no controller automatically fires
|
||||
`mark_lost()` when signal drops for N consecutive frames, nor re-activates
|
||||
a survivor when signal reappears.
|
||||
|
||||
2. **Frame-local assignment only** — `DynamicPersonMatcher` (metrics.rs) solves
|
||||
bipartite matching per training frame; there is no equivalent for real-time
|
||||
tracking across time.
|
||||
|
||||
3. **No position continuity** — `update_location()` overwrites position directly.
|
||||
Multi-AP triangulation via `NeumannSolver` (ADR-017) produces a noisy point
|
||||
estimate each cycle; nothing smooths the trajectory.
|
||||
|
||||
4. **No re-identification** — when `SurvivorStatus::Lost`, reappearance of the
|
||||
same physical person creates a fresh `Survivor` with a new UUID. Vital-sign
|
||||
history is lost and survivor count is inflated.
|
||||
|
||||
### Operational Impact in Disaster SAR
|
||||
|
||||
| Gap | Consequence |
|
||||
|-----|-------------|
|
||||
| No auto `mark_lost()` | Stale `Active` survivors persist indefinitely |
|
||||
| No re-ID | Duplicate entries per signal dropout; incorrect triage workload |
|
||||
| No position filter | Rescue teams see jumpy, noisy location updates |
|
||||
| No birth gate | Single spurious CSI spike creates a permanent survivor record |
|
||||
|
||||
---
|
||||
|
||||
## Decision
|
||||
|
||||
Add a **`tracking` bounded context** within `wifi-densepose-mat` at
|
||||
`src/tracking/`, implementing three collaborating components:
|
||||
|
||||
### 1. Kalman Filter — Constant-Velocity 3-D Model (`kalman.rs`)
|
||||
|
||||
State vector `x = [px, py, pz, vx, vy, vz]` (position + velocity in metres / m·s⁻¹).
|
||||
|
||||
| Parameter | Value | Rationale |
|
||||
|-----------|-------|-----------|
|
||||
| Process noise σ_a | 0.1 m/s² | Survivors in rubble move slowly or not at all |
|
||||
| Measurement noise σ_obs | 1.5 m | Typical indoor multi-AP WiFi accuracy |
|
||||
| Initial covariance P₀ | 10·I₆ | Large uncertainty until first update |
|
||||
|
||||
Provides **Mahalanobis gating** (threshold χ²(3 d.o.f.) = 9.0 ≈ 3σ ellipsoid)
|
||||
before associating an observation with a track, rejecting physically impossible
|
||||
jumps caused by multipath or AP failure.
|
||||
|
||||
### 2. CSI Fingerprint Re-Identification (`fingerprint.rs`)
|
||||
|
||||
Features extracted from `VitalSignsReading` and last-known `Coordinates3D`:
|
||||
|
||||
| Feature | Weight | Notes |
|
||||
|---------|--------|-------|
|
||||
| `breathing_rate_bpm` | 0.40 | Most stable biometric across short gaps |
|
||||
| `breathing_amplitude` | 0.25 | Varies with debris depth |
|
||||
| `heartbeat_rate_bpm` | 0.20 | Optional; available from `HeartbeatDetector` |
|
||||
| `location_hint [x,y,z]` | 0.15 | Last known position before loss |
|
||||
|
||||
Normalized weighted Euclidean distance. Re-ID fires when distance < 0.35 and
|
||||
the `Lost` track has not exceeded `max_lost_age_secs` (default 30 s).
|
||||
|
||||
### 3. Track Lifecycle State Machine (`lifecycle.rs`)
|
||||
|
||||
```
|
||||
┌────────────── birth observation ──────────────┐
|
||||
│ │
|
||||
[Tentative] ──(hits ≥ 2)──► [Active] ──(misses ≥ 3)──► [Lost]
|
||||
│ │
|
||||
│ ├─(re-ID match + age ≤ 30s)──► [Active]
|
||||
│ │
|
||||
└── (manual) ──► [Rescued]└─(age > 30s)──► [Terminated]
|
||||
```
|
||||
|
||||
- **Tentative**: 2-hit confirmation gate prevents single-frame CSI spikes from
|
||||
generating survivor records.
|
||||
- **Active**: normal tracking; updated each cycle.
|
||||
- **Lost**: Kalman predicts position; re-ID window open.
|
||||
- **Terminated**: unrecoverable; new physical detection creates a fresh track.
|
||||
- **Rescued**: operator-confirmed; metrics only.
|
||||
|
||||
### 4. `SurvivorTracker` Aggregate Root (`tracker.rs`)
|
||||
|
||||
Per-tick algorithm:
|
||||
|
||||
```
|
||||
update(observations, dt_secs):
|
||||
1. Predict — advance Kalman state for all Active + Lost tracks
|
||||
2. Gate — compute Mahalanobis distance from each Active track to each observation
|
||||
3. Associate — greedy nearest-neighbour (gated); Hungarian for N ≤ 10
|
||||
4. Re-ID — unmatched observations vs Lost tracks via CsiFingerprint
|
||||
5. Birth — still-unmatched observations → new Tentative tracks
|
||||
6. Update — matched tracks: Kalman update + vitals update + lifecycle.hit()
|
||||
7. Lifecycle — unmatched tracks: lifecycle.miss(); transitions Lost→Terminated
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Domain-Driven Design
|
||||
|
||||
### Bounded Context: `tracking`
|
||||
|
||||
```
|
||||
tracking/
|
||||
├── mod.rs — public API re-exports
|
||||
├── kalman.rs — KalmanState value object
|
||||
├── fingerprint.rs — CsiFingerprint value object
|
||||
├── lifecycle.rs — TrackState enum, TrackLifecycle entity, TrackerConfig
|
||||
└── tracker.rs — SurvivorTracker aggregate root
|
||||
TrackedSurvivor entity (wraps Survivor + tracking state)
|
||||
DetectionObservation value object
|
||||
AssociationResult value object
|
||||
```
|
||||
|
||||
### Integration with `DisasterResponse`
|
||||
|
||||
`DisasterResponse` gains a `SurvivorTracker` field. In `scan_cycle()`:
|
||||
|
||||
1. Detections from `DetectionPipeline` become `DetectionObservation`s.
|
||||
2. `SurvivorTracker::update()` is called; `AssociationResult` drives domain events.
|
||||
3. `DisasterResponse::survivors()` returns `active_tracks()` from the tracker.
|
||||
|
||||
### New Domain Events
|
||||
|
||||
`DomainEvent::Tracking(TrackingEvent)` variant added to `events.rs`:
|
||||
|
||||
| Event | Trigger |
|
||||
|-------|---------|
|
||||
| `TrackBorn` | Tentative → Active (confirmed survivor) |
|
||||
| `TrackLost` | Active → Lost (signal dropout) |
|
||||
| `TrackReidentified` | Lost → Active (fingerprint match) |
|
||||
| `TrackTerminated` | Lost → Terminated (age exceeded) |
|
||||
| `TrackRescued` | Active → Rescued (operator action) |
|
||||
|
||||
---
|
||||
|
||||
## Consequences
|
||||
|
||||
### Positive
|
||||
|
||||
- **Eliminates duplicate survivor records** from signal dropout (estimated 60–80%
|
||||
reduction in field tests with similar WiFi sensing systems).
|
||||
- **Smooth 3-D position trajectory** improves rescue team navigation accuracy.
|
||||
- **Vital-sign history preserved** across signal gaps ≤ 30 s.
|
||||
- **Correct survivor count** for triage workload management (START protocol).
|
||||
- **Birth gate** eliminates spurious records from single-frame multipath artefacts.
|
||||
|
||||
### Negative
|
||||
|
||||
- Re-ID threshold (0.35) is tuned empirically; too low → missed re-links;
|
||||
too high → false merges (safety risk: two survivors counted as one).
|
||||
- Kalman velocity state is meaningless for truly stationary survivors;
|
||||
acceptable because σ_accel is small and position estimate remains correct.
|
||||
- Adds ~500 lines of tracking code to the MAT crate.
|
||||
|
||||
### Risk Mitigation
|
||||
|
||||
- **Conservative re-ID**: threshold 0.35 (not 0.5) — prefer new survivor record
|
||||
over incorrect merge. Operators can manually merge via the API if needed.
|
||||
- **Large initial uncertainty**: P₀ = 10·I₆ converges safely after first update.
|
||||
- **`Terminated` is unrecoverable**: prevents runaway re-linking.
|
||||
- All thresholds exposed in `TrackerConfig` for operational tuning.
|
||||
|
||||
---
|
||||
|
||||
## Alternatives Considered
|
||||
|
||||
| Alternative | Rejected Because |
|
||||
|-------------|-----------------|
|
||||
| **DeepSORT** (appearance embedding + Kalman) | Requires visual features; not applicable to WiFi CSI |
|
||||
| **Particle filter** | Better for nonlinear dynamics; overkill for slow-moving rubble survivors |
|
||||
| **Pure frame-local assignment** | Current state — insufficient; causes all described problems |
|
||||
| **IoU-based tracking** | Requires bounding boxes from camera; WiFi gives only positions |
|
||||
|
||||
---
|
||||
|
||||
## Implementation Notes
|
||||
|
||||
- No new Cargo dependencies required; `ndarray` (already in mat `Cargo.toml`)
|
||||
available if needed, but all Kalman math uses `[[f64; 6]; 6]` stack arrays.
|
||||
- Feature-gate not needed: tracking is always-on for the MAT crate.
|
||||
- `TrackerConfig` defaults are conservative and tuned for earthquake SAR
|
||||
(2 Hz update rate, 1.5 m position uncertainty, 0.1 m/s² process noise).
|
||||
|
||||
---
|
||||
|
||||
## References
|
||||
|
||||
- Welch, G. & Bishop, G. (2006). *An Introduction to the Kalman Filter*.
|
||||
- Bewley et al. (2016). *Simple Online and Realtime Tracking (SORT)*. ICIP.
|
||||
- Wojke et al. (2017). *Simple Online and Realtime Tracking with a Deep Association Metric (DeepSORT)*. ICIP.
|
||||
- ADR-001: WiFi-MAT Disaster Detection Architecture
|
||||
- ADR-017: RuVector Signal and MAT Integration
|
||||
@@ -1,548 +0,0 @@
|
||||
# ADR-027: Project MERIDIAN -- Cross-Environment Domain Generalization for WiFi Pose Estimation
|
||||
|
||||
| Field | Value |
|
||||
|-------|-------|
|
||||
| **Status** | Proposed |
|
||||
| **Date** | 2026-03-01 |
|
||||
| **Deciders** | ruv |
|
||||
| **Codename** | **MERIDIAN** -- Multi-Environment Robust Inference via Domain-Invariant Alignment Networks |
|
||||
| **Relates to** | ADR-005 (SONA Self-Learning), ADR-014 (SOTA Signal Processing), ADR-015 (Public Datasets), ADR-016 (RuVector Integration), ADR-023 (Trained DensePose Pipeline), ADR-024 (AETHER Contrastive Embeddings) |
|
||||
|
||||
---
|
||||
|
||||
## 1. Context
|
||||
|
||||
### 1.1 The Domain Gap Problem
|
||||
|
||||
WiFi-based pose estimation models exhibit severe performance degradation when deployed in environments different from their training setting. A model trained in Room A with a specific transceiver layout, wall material composition, and furniture arrangement can lose 40-70% accuracy when moved to Room B -- even in the same building. This brittleness is the single largest barrier to real-world WiFi sensing deployment.
|
||||
|
||||
The root cause is three-fold:
|
||||
|
||||
1. **Layout overfitting**: Models memorize the spatial relationship between transmitter, receiver, and the coordinate system, rather than learning environment-agnostic human motion features. PerceptAlign (Chen et al., 2026; arXiv:2601.12252) demonstrated that cross-layout error drops by >60% when geometry conditioning is introduced.
|
||||
|
||||
2. **Multipath memorization**: The multipath channel profile encodes room geometry (wall positions, furniture, materials) as a static fingerprint. Models learn this fingerprint as a shortcut, using room-specific multipath patterns to predict positions rather than extracting pose-relevant body reflections.
|
||||
|
||||
3. **Hardware heterogeneity**: Different WiFi chipsets (ESP32, Intel 5300, Atheros) produce CSI with different subcarrier counts, phase noise profiles, and sampling rates. A model trained on Intel 5300 (30 subcarriers, 3x3 MIMO) fails on ESP32-S3 (64 subcarriers, 1x1 SISO).
|
||||
|
||||
The current wifi-densepose system (ADR-023) trains and evaluates on a single environment from MM-Fi or Wi-Pose. There is no mechanism to disentangle human motion from environment, adapt to new rooms without full retraining, or handle mixed hardware deployments.
|
||||
|
||||
### 1.2 SOTA Landscape (2024-2026)
|
||||
|
||||
Five concurrent lines of research have converged on the domain generalization problem:
|
||||
|
||||
**Cross-Layout Pose Estimation:**
|
||||
- **PerceptAlign** (Chen et al., 2026; arXiv:2601.12252): First geometry-conditioned framework. Encodes transceiver positions into high-dimensional embeddings fused with CSI features, achieving 60%+ cross-domain error reduction. Constructed the largest cross-domain WiFi pose dataset: 21 subjects, 5 scenes, 18 actions, 7 layouts.
|
||||
- **AdaPose** (Zhou et al., 2024; IEEE IoT Journal, arXiv:2309.16964): Mapping Consistency Loss aligns domain discrepancy at the mapping level. First to address cross-domain WiFi pose estimation specifically.
|
||||
- **Person-in-WiFi 3D** (Yan et al., CVPR 2024): End-to-end multi-person 3D pose from WiFi, achieving 91.7mm single-person error, but generalization across layouts remains an open problem.
|
||||
|
||||
**Domain Generalization Frameworks:**
|
||||
- **DGSense** (Zhou et al., 2025; arXiv:2502.08155): Virtual data generator + episodic training for domain-invariant features. Generalizes to unseen domains without target data across WiFi, mmWave, and acoustic sensing.
|
||||
- **Context-Aware Predictive Coding (CAPC)** (2024; arXiv:2410.01825; IEEE OJCOMS): Self-supervised CPC + Barlow Twins for WiFi, with 24.7% accuracy improvement over supervised learning on unseen environments.
|
||||
|
||||
**Foundation Models:**
|
||||
- **X-Fi** (Chen & Yang, ICLR 2025; arXiv:2410.10167): First modality-invariant foundation model for human sensing. X-fusion mechanism preserves modality-specific features. 24.8% MPJPE improvement on MM-Fi.
|
||||
- **AM-FM** (2026; arXiv:2602.11200): First WiFi foundation model, pre-trained on 9.2M unlabeled CSI samples across 20 device types over 439 days. Contrastive learning + masked reconstruction + physics-informed objectives.
|
||||
|
||||
**Generative Approaches:**
|
||||
- **LatentCSI** (Ramesh et al., 2025; arXiv:2506.10605): Lightweight CSI encoder maps directly into Stable Diffusion 3 latent space, demonstrating that CSI contains enough spatial information to reconstruct room imagery.
|
||||
|
||||
### 1.3 What MERIDIAN Adds to the Existing System
|
||||
|
||||
| Current Capability | Gap | MERIDIAN Addition |
|
||||
|-------------------|-----|------------------|
|
||||
| AETHER embeddings (ADR-024) | Embeddings encode environment identity -- useful for fingerprinting but harmful for cross-environment transfer | Environment-disentangled embeddings with explicit factorization |
|
||||
| SONA LoRA adapters (ADR-005) | Adapters must be manually created per environment; no mechanism to generate them from few-shot data | Zero-shot environment adaptation via geometry-conditioned inference |
|
||||
| MM-Fi/Wi-Pose training (ADR-015) | Single-environment train/eval; no cross-domain protocol | Multi-domain training protocol with environment augmentation |
|
||||
| SpotFi phase correction (ADR-014) | Hardware-specific phase calibration | Hardware-invariant CSI normalization layer |
|
||||
| RuVector attention (ADR-016) | Attention weights learn environment-specific patterns | Domain-adversarial attention regularization |
|
||||
|
||||
---
|
||||
|
||||
## 2. Decision
|
||||
|
||||
### 2.1 Architecture: Environment-Disentangled Dual-Path Transformer
|
||||
|
||||
MERIDIAN adds a domain generalization layer between the CSI encoder and the pose/embedding heads. The core insight is explicit factorization: decompose the latent representation into a **pose-relevant** component (invariant across environments) and an **environment** component (captures room geometry, hardware, layout):
|
||||
|
||||
```
|
||||
CSI Frame(s) [n_pairs x n_subcarriers]
|
||||
|
|
||||
v
|
||||
HardwareNormalizer [NEW: chipset-invariant preprocessing]
|
||||
| - Resample to canonical 56 subcarriers
|
||||
| - Normalize amplitude distribution to N(0,1) per-frame
|
||||
| - Apply SanitizedPhaseTransform (hardware-agnostic)
|
||||
|
|
||||
v
|
||||
csi_embed (Linear 56 -> d_model=64) [EXISTING]
|
||||
|
|
||||
v
|
||||
CrossAttention (Q=keypoint_queries, [EXISTING]
|
||||
K,V=csi_embed)
|
||||
|
|
||||
v
|
||||
GnnStack (2-layer GCN) [EXISTING]
|
||||
|
|
||||
v
|
||||
body_part_features [17 x 64] [EXISTING]
|
||||
|
|
||||
+---> DomainFactorizer: [NEW]
|
||||
| |
|
||||
| +---> PoseEncoder: [NEW: domain-invariant path]
|
||||
| | fc1: Linear(64, 128) + LayerNorm + GELU
|
||||
| | fc2: Linear(128, 64)
|
||||
| | --> h_pose [17 x 64] (invariant to environment)
|
||||
| |
|
||||
| +---> EnvEncoder: [NEW: environment-specific path]
|
||||
| GlobalMeanPool [17 x 64] -> [64]
|
||||
| fc_env: Linear(64, 32)
|
||||
| --> h_env [32] (captures room/hardware identity)
|
||||
|
|
||||
+---> h_pose ---> xyz_head + conf_head [EXISTING: pose regression]
|
||||
| --> keypoints [17 x (x,y,z,conf)]
|
||||
|
|
||||
+---> h_pose ---> MeanPool -> ProjectionHead -> z_csi [128] [ADR-024 AETHER]
|
||||
|
|
||||
+---> h_env ---> (discarded at inference; used only for training signal)
|
||||
```
|
||||
|
||||
### 2.2 Domain-Adversarial Training with Gradient Reversal
|
||||
|
||||
To force `h_pose` to be environment-invariant, we employ domain-adversarial training (Ganin et al., 2016) with a gradient reversal layer (GRL):
|
||||
|
||||
```
|
||||
h_pose [17 x 64]
|
||||
|
|
||||
+---> [Normal gradient] --> xyz_head --> L_pose
|
||||
|
|
||||
+---> [GRL: multiply grad by -lambda_adv]
|
||||
|
|
||||
v
|
||||
DomainClassifier:
|
||||
MeanPool [17 x 64] -> [64]
|
||||
fc1: Linear(64, 32) + ReLU + Dropout(0.3)
|
||||
fc2: Linear(32, n_domains)
|
||||
--> domain_logits
|
||||
--> L_domain = CrossEntropy(domain_logits, domain_label)
|
||||
|
||||
Total loss:
|
||||
L = L_pose + lambda_c * L_contrastive + lambda_adv * L_domain
|
||||
+ lambda_env * L_env_recon
|
||||
```
|
||||
|
||||
The GRL reverses the gradient flowing from `L_domain` into `PoseEncoder`, meaning the PoseEncoder is trained to **maximize** domain classification error -- forcing `h_pose` to shed all environment-specific information.
|
||||
|
||||
**Key hyperparameters:**
|
||||
- `lambda_adv`: Adversarial weight, annealed from 0.0 to 1.0 over first 20 epochs using the schedule `lambda_adv(p) = 2 / (1 + exp(-10 * p)) - 1` where `p = epoch / max_epochs`
|
||||
- `lambda_env = 0.1`: Environment reconstruction weight (auxiliary task to ensure `h_env` captures what `h_pose` discards)
|
||||
- `lambda_c = 0.1`: Contrastive loss weight from AETHER (unchanged)
|
||||
|
||||
### 2.3 Geometry-Conditioned Inference (Zero-Shot Adaptation)
|
||||
|
||||
Inspired by PerceptAlign, MERIDIAN conditions the pose decoder on the physical transceiver geometry. At deployment time, the user provides AP/sensor positions (known from installation), and the model adjusts its coordinate frame accordingly:
|
||||
|
||||
```rust
|
||||
/// Encodes transceiver geometry into a conditioning vector.
|
||||
/// Positions are in meters relative to an arbitrary room origin.
|
||||
pub struct GeometryEncoder {
|
||||
/// Fourier positional encoding of 3D coordinates
|
||||
pos_embed: FourierPositionalEncoding, // 3 coords -> 64 dims per position
|
||||
/// Aggregates variable-count AP positions into fixed-dim vector
|
||||
set_encoder: DeepSets, // permutation-invariant {AP_1..AP_n} -> 64
|
||||
}
|
||||
|
||||
/// Fourier features: [sin(2^0 * pi * x), cos(2^0 * pi * x), ...,
|
||||
/// sin(2^(L-1) * pi * x), cos(2^(L-1) * pi * x)]
|
||||
/// L = 10 frequency bands, producing 60 dims per coordinate (+ 3 raw = 63, padded to 64)
|
||||
pub struct FourierPositionalEncoding {
|
||||
n_frequencies: usize, // default: 10
|
||||
scale: f32, // default: 1.0 (meters)
|
||||
}
|
||||
|
||||
/// DeepSets: phi(x) -> mean-pool -> rho(.) for permutation-invariant set encoding
|
||||
pub struct DeepSets {
|
||||
phi: Linear, // 64 -> 64
|
||||
rho: Linear, // 64 -> 64
|
||||
}
|
||||
```
|
||||
|
||||
The geometry embedding `g` (64-dim) is injected into the pose decoder via FiLM conditioning:
|
||||
|
||||
```
|
||||
g = GeometryEncoder(ap_positions) [64-dim]
|
||||
gamma = Linear(64, 64)(g) [per-feature scale]
|
||||
beta = Linear(64, 64)(g) [per-feature shift]
|
||||
|
||||
h_pose_conditioned = gamma * h_pose + beta [FiLM: Feature-wise Linear Modulation]
|
||||
|
|
||||
v
|
||||
xyz_head --> keypoints
|
||||
```
|
||||
|
||||
This enables zero-shot deployment: given the positions of WiFi APs in a new room, the model adapts its coordinate prediction without any retraining.
|
||||
|
||||
### 2.4 Hardware-Invariant CSI Normalization
|
||||
|
||||
```rust
|
||||
/// Normalizes CSI from heterogeneous hardware to a canonical representation.
|
||||
/// Handles ESP32-S3 (64 sub), Intel 5300 (30 sub), Atheros (56 sub).
|
||||
pub struct HardwareNormalizer {
|
||||
/// Target subcarrier count (project all hardware to this)
|
||||
canonical_subcarriers: usize, // default: 56 (matches MM-Fi)
|
||||
/// Per-hardware amplitude statistics for z-score normalization
|
||||
hw_stats: HashMap<HardwareType, AmplitudeStats>,
|
||||
}
|
||||
|
||||
pub enum HardwareType {
|
||||
Esp32S3 { subcarriers: usize, mimo: (u8, u8) },
|
||||
Intel5300 { subcarriers: usize, mimo: (u8, u8) },
|
||||
Atheros { subcarriers: usize, mimo: (u8, u8) },
|
||||
Generic { subcarriers: usize, mimo: (u8, u8) },
|
||||
}
|
||||
|
||||
impl HardwareNormalizer {
|
||||
/// Normalize a raw CSI frame to canonical form:
|
||||
/// 1. Resample subcarriers to canonical count via cubic interpolation
|
||||
/// 2. Z-score normalize amplitude per-frame
|
||||
/// 3. Sanitize phase: remove hardware-specific linear phase offset
|
||||
pub fn normalize(&self, frame: &CsiFrame) -> CanonicalCsiFrame { .. }
|
||||
}
|
||||
```
|
||||
|
||||
The resampling uses `ruvector-solver`'s sparse interpolation (already integrated per ADR-016) to project from any subcarrier count to the canonical 56.
|
||||
|
||||
### 2.5 Virtual Environment Augmentation
|
||||
|
||||
Following DGSense's virtual data generator concept, MERIDIAN augments training data with synthetic domain shifts:
|
||||
|
||||
```rust
|
||||
/// Generates virtual CSI domains by simulating environment variations.
|
||||
pub struct VirtualDomainAugmentor {
|
||||
/// Simulate different room sizes via multipath delay scaling
|
||||
room_scale_range: (f32, f32), // default: (0.5, 2.0)
|
||||
/// Simulate wall material via reflection coefficient perturbation
|
||||
reflection_coeff_range: (f32, f32), // default: (0.3, 0.9)
|
||||
/// Simulate furniture via random scatterer injection
|
||||
n_virtual_scatterers: (usize, usize), // default: (0, 5)
|
||||
/// Simulate hardware differences via subcarrier response shaping
|
||||
hw_response_filters: Vec<SubcarrierResponseFilter>,
|
||||
}
|
||||
|
||||
impl VirtualDomainAugmentor {
|
||||
/// Apply a random virtual domain shift to a CSI batch.
|
||||
/// Each call generates a new "virtual environment" for training diversity.
|
||||
pub fn augment(&self, batch: &CsiBatch, rng: &mut impl Rng) -> CsiBatch { .. }
|
||||
}
|
||||
```
|
||||
|
||||
During training, each mini-batch is augmented with K=3 virtual domain shifts, producing 4x the effective training environments. The domain classifier sees both real and virtual domain labels, improving its ability to force environment-invariant features.
|
||||
|
||||
### 2.6 Few-Shot Rapid Adaptation
|
||||
|
||||
For deployment scenarios where a brief calibration period is available (10-60 seconds of CSI data from the new environment, no pose labels needed):
|
||||
|
||||
```rust
|
||||
/// Rapid adaptation to a new environment using unlabeled CSI data.
|
||||
/// Combines SONA LoRA adapters (ADR-005) with MERIDIAN's domain factorization.
|
||||
pub struct RapidAdaptation {
|
||||
/// Number of unlabeled CSI frames needed for adaptation
|
||||
min_calibration_frames: usize, // default: 200 (10 sec @ 20 Hz)
|
||||
/// LoRA rank for environment-specific adaptation
|
||||
lora_rank: usize, // default: 4
|
||||
/// Self-supervised adaptation loss (AETHER contrastive + entropy min)
|
||||
adaptation_loss: AdaptationLoss,
|
||||
}
|
||||
|
||||
pub enum AdaptationLoss {
|
||||
/// Test-time training with AETHER contrastive loss on unlabeled data
|
||||
ContrastiveTTT { epochs: usize, lr: f32 },
|
||||
/// Entropy minimization on pose confidence outputs
|
||||
EntropyMin { epochs: usize, lr: f32 },
|
||||
/// Combined: contrastive + entropy minimization
|
||||
Combined { epochs: usize, lr: f32, lambda_ent: f32 },
|
||||
}
|
||||
```
|
||||
|
||||
This leverages the existing SONA infrastructure (ADR-005) to generate environment-specific LoRA weights from unlabeled CSI alone, bridging the gap between zero-shot geometry conditioning and full supervised fine-tuning.
|
||||
|
||||
---
|
||||
|
||||
## 3. Comparison: MERIDIAN vs Alternatives
|
||||
|
||||
| Approach | Cross-Layout | Cross-Hardware | Zero-Shot | Few-Shot | Edge-Compatible | Multi-Person |
|
||||
|----------|-------------|----------------|-----------|----------|-----------------|-------------|
|
||||
| **MERIDIAN (this ADR)** | Yes (GRL + geometry FiLM) | Yes (HardwareNormalizer) | Yes (geometry conditioning) | Yes (SONA + contrastive TTT) | Yes (adds ~12K params) | Yes (via ADR-023) |
|
||||
| PerceptAlign (2026) | Yes | No | Partial (needs layout) | No | Unknown (20M params) | No |
|
||||
| AdaPose (2024) | Partial (2 domains) | No | No | Yes (mapping consistency) | Unknown | No |
|
||||
| DGSense (2025) | Yes (virtual aug) | Yes (multi-modality) | Yes | No | No (ResNet backbone) | No |
|
||||
| X-Fi (ICLR 2025) | Yes (foundation model) | Yes (multi-modal) | Yes | Yes (pre-trained) | No (large transformer) | Yes |
|
||||
| AM-FM (2026) | Yes (439-day pretraining) | Yes (20 device types) | Yes | Yes | No (foundation scale) | Unknown |
|
||||
| CAPC (2024) | Partial (transfer learning) | No | No | Yes (SSL fine-tune) | Yes (lightweight) | No |
|
||||
| **Current wifi-densepose** | **No** | **No** | **No** | **Partial (SONA manual)** | **Yes** | **Yes** |
|
||||
|
||||
### MERIDIAN's Differentiators
|
||||
|
||||
1. **Additive, not replacement**: Unlike X-Fi or AM-FM which require new foundation model infrastructure, MERIDIAN adds 4 small modules to the existing ADR-023 pipeline.
|
||||
2. **Edge-compatible**: Total parameter overhead is ~12K (geometry encoder ~8K, domain factorizer ~4K), fitting within the ESP32 budget established in ADR-024.
|
||||
3. **Hardware-agnostic**: First approach to combine cross-layout AND cross-hardware generalization in a single framework, using the existing `ruvector-solver` sparse interpolation.
|
||||
4. **Continuum of adaptation**: Supports zero-shot (geometry only), few-shot (10-sec calibration), and full fine-tuning on the same architecture.
|
||||
|
||||
---
|
||||
|
||||
## 4. Implementation
|
||||
|
||||
### 4.1 Phase 1 -- Hardware Normalizer (Week 1)
|
||||
|
||||
**Goal**: Canonical CSI representation across ESP32, Intel 5300, and Atheros hardware.
|
||||
|
||||
**Files modified:**
|
||||
- `crates/wifi-densepose-signal/src/hardware_norm.rs` (new)
|
||||
- `crates/wifi-densepose-signal/src/lib.rs` (export new module)
|
||||
- `crates/wifi-densepose-train/src/dataset.rs` (apply normalizer in data pipeline)
|
||||
|
||||
**Dependencies**: `ruvector-solver` (sparse interpolation, already vendored)
|
||||
|
||||
**Acceptance criteria:**
|
||||
- [ ] Resample any subcarrier count to canonical 56 within 50us per frame
|
||||
- [ ] Z-score normalization produces mean=0, std=1 per-frame amplitude
|
||||
- [ ] Phase sanitization removes linear trend (validated against SpotFi output)
|
||||
- [ ] Unit tests with synthetic ESP32 (64 sub) and Intel 5300 (30 sub) frames
|
||||
|
||||
### 4.2 Phase 2 -- Domain Factorizer + GRL (Week 2-3)
|
||||
|
||||
**Goal**: Disentangle pose-relevant and environment-specific features during training.
|
||||
|
||||
**Files modified:**
|
||||
- `crates/wifi-densepose-train/src/domain.rs` (new: DomainFactorizer, GRL, DomainClassifier)
|
||||
- `crates/wifi-densepose-train/src/graph_transformer.rs` (wire factorizer after GNN)
|
||||
- `crates/wifi-densepose-train/src/trainer.rs` (add L_domain to composite loss, GRL annealing)
|
||||
- `crates/wifi-densepose-train/src/dataset.rs` (add domain labels to DataPipeline)
|
||||
|
||||
**Key implementation detail -- Gradient Reversal Layer:**
|
||||
|
||||
```rust
|
||||
/// Gradient Reversal Layer: identity in forward pass, negates gradient in backward.
|
||||
/// Used to train the PoseEncoder to produce domain-invariant features.
|
||||
pub struct GradientReversalLayer {
|
||||
lambda: f32,
|
||||
}
|
||||
|
||||
impl GradientReversalLayer {
|
||||
/// Forward: identity. Backward: multiply gradient by -lambda.
|
||||
/// In our pure-Rust autograd, this is implemented as:
|
||||
/// forward(x) = x
|
||||
/// backward(grad) = -lambda * grad
|
||||
pub fn forward(&self, x: &Tensor) -> Tensor {
|
||||
// Store lambda for backward pass in computation graph
|
||||
x.clone_with_grad_fn(GrlBackward { lambda: self.lambda })
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
**Acceptance criteria:**
|
||||
- [ ] Domain classifier achieves >90% accuracy on source domains (proves signal exists)
|
||||
- [ ] After GRL training, domain classifier accuracy drops to near-chance (proves disentanglement)
|
||||
- [ ] Pose accuracy on source domains degrades <5% vs non-adversarial baseline
|
||||
- [ ] Cross-domain pose accuracy improves >20% on held-out environment
|
||||
|
||||
### 4.3 Phase 3 -- Geometry Encoder + FiLM Conditioning (Week 3-4)
|
||||
|
||||
**Goal**: Enable zero-shot deployment given AP positions.
|
||||
|
||||
**Files modified:**
|
||||
- `crates/wifi-densepose-train/src/geometry.rs` (new: GeometryEncoder, FourierPositionalEncoding, DeepSets, FiLM)
|
||||
- `crates/wifi-densepose-train/src/graph_transformer.rs` (inject FiLM conditioning before xyz_head)
|
||||
- `crates/wifi-densepose-train/src/config.rs` (add geometry fields to TrainConfig)
|
||||
|
||||
**Acceptance criteria:**
|
||||
- [ ] FourierPositionalEncoding produces 64-dim vectors from 3D coordinates
|
||||
- [ ] DeepSets is permutation-invariant (same output regardless of AP ordering)
|
||||
- [ ] FiLM conditioning reduces cross-layout MPJPE by >30% vs unconditioned baseline
|
||||
- [ ] Inference overhead <100us per frame (geometry encoding is amortized per-session)
|
||||
|
||||
### 4.4 Phase 4 -- Virtual Domain Augmentation (Week 4-5)
|
||||
|
||||
**Goal**: Synthetic environment diversity to improve generalization.
|
||||
|
||||
**Files modified:**
|
||||
- `crates/wifi-densepose-train/src/virtual_aug.rs` (new: VirtualDomainAugmentor)
|
||||
- `crates/wifi-densepose-train/src/trainer.rs` (integrate augmentor into training loop)
|
||||
- `crates/wifi-densepose-signal/src/fresnel.rs` (reuse Fresnel zone model for scatterer simulation)
|
||||
|
||||
**Dependencies**: `ruvector-attn-mincut` (attention-weighted scatterer placement)
|
||||
|
||||
**Acceptance criteria:**
|
||||
- [ ] Generate K=3 virtual domains per batch with <1ms overhead
|
||||
- [ ] Virtual domains produce measurably different CSI statistics (KL divergence >0.1)
|
||||
- [ ] Training with virtual augmentation improves unseen-environment accuracy by >15%
|
||||
- [ ] No regression on seen-environment accuracy (within 2%)
|
||||
|
||||
### 4.5 Phase 5 -- Few-Shot Rapid Adaptation (Week 5-6)
|
||||
|
||||
**Goal**: 10-second calibration enables environment-specific fine-tuning without labels.
|
||||
|
||||
**Files modified:**
|
||||
- `crates/wifi-densepose-train/src/rapid_adapt.rs` (new: RapidAdaptation)
|
||||
- `crates/wifi-densepose-train/src/sona.rs` (extend SonaProfile with MERIDIAN fields)
|
||||
- `crates/wifi-densepose-sensing-server/src/main.rs` (add `--calibrate` CLI flag)
|
||||
|
||||
**Acceptance criteria:**
|
||||
- [ ] 200-frame (10 sec) calibration produces usable LoRA adapter
|
||||
- [ ] Adapted model MPJPE within 15% of fully-supervised in-domain baseline
|
||||
- [ ] Calibration completes in <5 seconds on x86 (including contrastive TTT)
|
||||
- [ ] Adapted LoRA weights serializable to RVF container (ADR-023 Segment type)
|
||||
|
||||
### 4.6 Phase 6 -- Cross-Domain Evaluation Protocol (Week 6-7)
|
||||
|
||||
**Goal**: Rigorous multi-domain evaluation using MM-Fi's scene/subject splits.
|
||||
|
||||
**Files modified:**
|
||||
- `crates/wifi-densepose-train/src/eval.rs` (new: CrossDomainEvaluator)
|
||||
- `crates/wifi-densepose-train/src/dataset.rs` (add domain-split loading for MM-Fi)
|
||||
|
||||
**Evaluation protocol (following PerceptAlign):**
|
||||
|
||||
| Metric | Description |
|
||||
|--------|-------------|
|
||||
| **In-domain MPJPE** | Mean Per Joint Position Error on training environment |
|
||||
| **Cross-domain MPJPE** | MPJPE on held-out environment (zero-shot) |
|
||||
| **Few-shot MPJPE** | MPJPE after 10-sec calibration in target environment |
|
||||
| **Cross-hardware MPJPE** | MPJPE when trained on one hardware, tested on another |
|
||||
| **Domain gap ratio** | cross-domain / in-domain MPJPE (lower = better; target <1.5) |
|
||||
| **Adaptation speedup** | Labeled samples saved vs training from scratch (target >5x) |
|
||||
|
||||
### 4.7 Phase 7 -- RVF Container + Deployment (Week 7-8)
|
||||
|
||||
**Goal**: Package MERIDIAN-enhanced models for edge deployment.
|
||||
|
||||
**Files modified:**
|
||||
- `crates/wifi-densepose-train/src/rvf_container.rs` (add GEOM and DOMAIN segment types)
|
||||
- `crates/wifi-densepose-sensing-server/src/inference.rs` (load geometry + domain weights)
|
||||
- `crates/wifi-densepose-sensing-server/src/main.rs` (add `--ap-positions` CLI flag)
|
||||
|
||||
**New RVF segments:**
|
||||
|
||||
| Segment | Type ID | Contents | Size |
|
||||
|---------|---------|----------|------|
|
||||
| `GEOM` | `0x47454F4D` | GeometryEncoder weights + FiLM layers | ~4 KB |
|
||||
| `DOMAIN` | `0x444F4D4E` | DomainFactorizer weights (PoseEncoder only; EnvEncoder and GRL discarded) | ~8 KB |
|
||||
| `HWSTATS` | `0x48575354` | Per-hardware amplitude statistics for HardwareNormalizer | ~1 KB |
|
||||
|
||||
**CLI usage:**
|
||||
|
||||
```bash
|
||||
# Train with MERIDIAN domain generalization
|
||||
cargo run -p wifi-densepose-sensing-server -- \
|
||||
--train --dataset data/mmfi/ --epochs 100 \
|
||||
--meridian --n-virtual-domains 3 \
|
||||
--save-rvf model-meridian.rvf
|
||||
|
||||
# Deploy with geometry conditioning (zero-shot)
|
||||
cargo run -p wifi-densepose-sensing-server -- \
|
||||
--model model-meridian.rvf \
|
||||
--ap-positions "0,0,2.5;3.5,0,2.5;1.75,4,2.5"
|
||||
|
||||
# Calibrate in new environment (few-shot, 10 seconds)
|
||||
cargo run -p wifi-densepose-sensing-server -- \
|
||||
--model model-meridian.rvf --calibrate --calibrate-duration 10
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 5. Consequences
|
||||
|
||||
### 5.1 Positive
|
||||
|
||||
- **Deploy once, work everywhere**: A single MERIDIAN-trained model generalizes across rooms, buildings, and hardware without per-environment retraining
|
||||
- **Reduced deployment cost**: Zero-shot mode requires only AP position input; few-shot mode needs 10 seconds of ambient WiFi data
|
||||
- **AETHER synergy**: Domain-invariant embeddings (ADR-024) become environment-agnostic fingerprints, enabling cross-building room identification
|
||||
- **Hardware freedom**: HardwareNormalizer unblocks mixed-fleet deployments (ESP32 in some rooms, Intel 5300 in others)
|
||||
- **Competitive positioning**: No existing open-source WiFi pose system offers cross-environment generalization; MERIDIAN would be the first
|
||||
|
||||
### 5.2 Negative
|
||||
|
||||
- **Training complexity**: Multi-domain training requires CSI data from multiple environments. MM-Fi provides multiple scenes but PerceptAlign's 7-layout dataset is not yet public.
|
||||
- **Hyperparameter sensitivity**: GRL lambda annealing schedule and adversarial balance require careful tuning; unstable training is possible if adversarial signal is too strong early.
|
||||
- **Geometry input requirement**: Zero-shot mode requires users to input AP positions, which may not always be precisely known. Degradation under inaccurate geometry input needs characterization.
|
||||
- **Parameter overhead**: +12K parameters increases total model from 55K to 67K (22% increase), still well within ESP32 budget but notable.
|
||||
|
||||
### 5.3 Risks and Mitigations
|
||||
|
||||
| Risk | Probability | Impact | Mitigation |
|
||||
|------|-------------|--------|------------|
|
||||
| GRL training instability | Medium | Training diverges | Lambda annealing schedule; gradient clipping at 1.0; fallback to non-adversarial training |
|
||||
| Virtual augmentation unrealistic | Low | No generalization improvement | Validate augmented CSI against real cross-domain data distributions |
|
||||
| Geometry encoder overfits to training layouts | Medium | Zero-shot fails on novel geometries | Augment geometry inputs during training (jitter AP positions by +/-0.5m) |
|
||||
| MM-Fi scenes insufficient diversity | High | Limited evaluation validity | Supplement with synthetic data; target PerceptAlign dataset when released |
|
||||
|
||||
---
|
||||
|
||||
## 6. Relationship to Proposed ADRs (Gap Closure)
|
||||
|
||||
ADRs 002-011 were proposed during the initial architecture phase. MERIDIAN directly addresses, subsumes, or enables several of these gaps. This section maps each proposed ADR to its current status and how ADR-027 interacts with it.
|
||||
|
||||
### 6.1 Directly Addressed by MERIDIAN
|
||||
|
||||
| Proposed ADR | Gap | How MERIDIAN Closes It |
|
||||
|-------------|-----|----------------------|
|
||||
| **ADR-004**: HNSW Vector Search Fingerprinting | CSI fingerprints are environment-specific — a fingerprint learned in Room A is useless in Room B | MERIDIAN's `DomainFactorizer` produces **environment-disentangled embeddings** (`h_pose`). When fed into ADR-024's `FingerprintIndex`, these embeddings match across rooms because environment information has been factored out. The `h_env` path captures room identity separately, enabling both cross-room matching AND room identification in a single model. |
|
||||
| **ADR-005**: SONA Self-Learning for Pose Estimation | SONA LoRA adapters must be manually created per environment with labeled data | MERIDIAN Phase 5 (`RapidAdaptation`) extends SONA with **unsupervised adapter generation**: 10 seconds of unlabeled WiFi data + contrastive test-time training automatically produces a per-room LoRA adapter. No labels, no manual intervention. The existing `SonaProfile` in `sona.rs` gains a `meridian_calibration` field for storing adaptation state. |
|
||||
| **ADR-006**: GNN-Enhanced CSI Pattern Recognition | GNN treats each environment's patterns independently; no cross-environment transfer | MERIDIAN's domain-adversarial training regularizes the GCN layers (ADR-023's `GnnStack`) to learn **structure-preserving, environment-invariant** graph features. The gradient reversal layer forces the GCN to shed room-specific multipath patterns while retaining body-pose-relevant spatial relationships between keypoints. |
|
||||
|
||||
### 6.2 Superseded (Already Implemented)
|
||||
|
||||
| Proposed ADR | Original Vision | Current Status |
|
||||
|-------------|----------------|---------------|
|
||||
| **ADR-002**: RuVector RVF Integration Strategy | Integrate RuVector crates into the WiFi-DensePose pipeline | **Fully implemented** by ADR-016 (training pipeline, 5 crates) and ADR-017 (signal + MAT, 7 integration points). The `wifi-densepose-ruvector` crate is published on crates.io. No further action needed. |
|
||||
|
||||
### 6.3 Enabled by MERIDIAN (Future Work)
|
||||
|
||||
These ADRs remain independent tracks but MERIDIAN creates enabling infrastructure for them:
|
||||
|
||||
| Proposed ADR | Gap | How MERIDIAN Enables It |
|
||||
|-------------|-----|------------------------|
|
||||
| **ADR-003**: RVF Cognitive Containers | CSI pipeline stages produce ephemeral data; no persistent cognitive state across sessions | MERIDIAN's RVF container extensions (Phase 7: `GEOM`, `DOMAIN`, `HWSTATS` segments) establish the pattern for **environment-aware model packaging**. A cognitive container could store per-room adaptation history, geometry profiles, and domain statistics — building on MERIDIAN's segment format. The `h_env` embeddings are natural candidates for persistent environment memory. |
|
||||
| **ADR-008**: Distributed Consensus for Multi-AP | Multiple APs need coordinated sensing; no agreement protocol for conflicting observations | MERIDIAN's `GeometryEncoder` already models variable-count AP positions via permutation-invariant `DeepSets`. This provides the **geometric foundation** for multi-AP fusion: each AP's CSI is geometry-conditioned independently, then fused. A consensus layer (Raft or BFT) would sit above MERIDIAN to reconcile conflicting pose estimates from different AP vantage points. The `HardwareNormalizer` ensures mixed hardware (ESP32 + Intel 5300 across APs) produces comparable features. |
|
||||
| **ADR-009**: RVF WASM Runtime for Edge | Self-contained WASM model execution without server dependency | MERIDIAN's +12K parameter overhead (67K total) remains within the WASM size budget. The `HardwareNormalizer` is critical for WASM deployment: browser-based inference must handle whatever CSI format the connected hardware provides. WASM builds should include the geometry conditioning path so users can specify AP layout in the browser UI. |
|
||||
|
||||
### 6.4 Independent Tracks (Not Addressed by MERIDIAN)
|
||||
|
||||
These ADRs address orthogonal concerns and should be pursued separately:
|
||||
|
||||
| Proposed ADR | Gap | Recommendation |
|
||||
|-------------|-----|----------------|
|
||||
| **ADR-007**: Post-Quantum Cryptography | WiFi sensing data reveals presence, health, and activity — quantum computers could break current encryption of sensing streams | **Pursue independently.** MERIDIAN does not address data-in-transit security. PQC should be applied to WebSocket streams (`/ws/sensing`, `/ws/mat/stream`) and RVF model containers (replace Ed25519 signing with ML-DSA/Dilithium). Priority: medium — no imminent quantum threat, but healthcare deployments may require PQC compliance for long-term data retention. |
|
||||
| **ADR-010**: Witness Chains for Audit Trail | Disaster triage decisions (ADR-001) need tamper-proof audit trails for legal/regulatory compliance | **Pursue independently.** MERIDIAN's domain adaptation improves triage accuracy in unfamiliar environments (rubble, collapsed buildings), which reduces the need for audit trail corrections. But the audit trail itself — hash chains, Merkle proofs, timestamped triage events — is a separate integrity concern. Priority: high for disaster response deployments. |
|
||||
| **ADR-011**: Python Proof-of-Reality (URGENT) | Python v1 contains mock/placeholder code that undermines credibility; `verify.py` exists but mock paths remain | **Pursue independently.** This is a Python v1 code quality issue, not an ML/architecture concern. The Rust port (v2+) has no mock code — all 542+ tests run against real algorithm implementations. Recommendation: either complete the mock elimination in Python v1 or formally deprecate Python v1 in favor of the Rust stack. Priority: high for credibility. |
|
||||
|
||||
### 6.5 Gap Closure Summary
|
||||
|
||||
```
|
||||
Proposed ADRs (002-011) Status After ADR-027
|
||||
───────────────────────── ─────────────────────
|
||||
ADR-002 RVF Integration ──→ ✅ Superseded (ADR-016/017 implemented)
|
||||
ADR-003 Cognitive Containers ─→ 🔜 Enabled (MERIDIAN RVF segments provide pattern)
|
||||
ADR-004 HNSW Fingerprinting ──→ ✅ Addressed (domain-disentangled embeddings)
|
||||
ADR-005 SONA Self-Learning ──→ ✅ Addressed (unsupervised rapid adaptation)
|
||||
ADR-006 GNN Patterns ──→ ✅ Addressed (adversarial GCN regularization)
|
||||
ADR-007 Post-Quantum Crypto ──→ ⏳ Independent (pursue separately, medium priority)
|
||||
ADR-008 Distributed Consensus → 🔜 Enabled (GeometryEncoder + HardwareNormalizer)
|
||||
ADR-009 WASM Runtime ──→ 🔜 Enabled (67K model fits WASM budget)
|
||||
ADR-010 Witness Chains ──→ ⏳ Independent (pursue separately, high priority)
|
||||
ADR-011 Proof-of-Reality ──→ ⏳ Independent (Python v1 issue, high priority)
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 7. References
|
||||
|
||||
1. Chen, L., et al. (2026). "Breaking Coordinate Overfitting: Geometry-Aware WiFi Sensing for Cross-Layout 3D Pose Estimation." arXiv:2601.12252. https://arxiv.org/abs/2601.12252
|
||||
2. Zhou, Y., et al. (2024). "AdaPose: Towards Cross-Site Device-Free Human Pose Estimation with Commodity WiFi." IEEE Internet of Things Journal. arXiv:2309.16964. https://arxiv.org/abs/2309.16964
|
||||
3. Yan, K., et al. (2024). "Person-in-WiFi 3D: End-to-End Multi-Person 3D Pose Estimation with Wi-Fi." CVPR 2024, pp. 969-978. https://openaccess.thecvf.com/content/CVPR2024/html/Yan_Person-in-WiFi_3D_End-to-End_Multi-Person_3D_Pose_Estimation_with_Wi-Fi_CVPR_2024_paper.html
|
||||
4. Zhou, R., et al. (2025). "DGSense: A Domain Generalization Framework for Wireless Sensing." arXiv:2502.08155. https://arxiv.org/abs/2502.08155
|
||||
5. CAPC (2024). "Context-Aware Predictive Coding: A Representation Learning Framework for WiFi Sensing." IEEE OJCOMS, Vol. 5, pp. 6119-6134. arXiv:2410.01825. https://arxiv.org/abs/2410.01825
|
||||
6. Chen, X. & Yang, J. (2025). "X-Fi: A Modality-Invariant Foundation Model for Multimodal Human Sensing." ICLR 2025. arXiv:2410.10167. https://arxiv.org/abs/2410.10167
|
||||
7. AM-FM (2026). "AM-FM: A Foundation Model for Ambient Intelligence Through WiFi." arXiv:2602.11200. https://arxiv.org/abs/2602.11200
|
||||
8. Ramesh, S. et al. (2025). "LatentCSI: High-resolution efficient image generation from WiFi CSI using a pretrained latent diffusion model." arXiv:2506.10605. https://arxiv.org/abs/2506.10605
|
||||
9. Ganin, Y. et al. (2016). "Domain-Adversarial Training of Neural Networks." JMLR 17(59):1-35. https://jmlr.org/papers/v17/15-239.html
|
||||
10. Perez, E. et al. (2018). "FiLM: Visual Reasoning with a General Conditioning Layer." AAAI 2018. arXiv:1709.07871. https://arxiv.org/abs/1709.07871
|
||||
@@ -1,308 +0,0 @@
|
||||
# ADR-028: ESP32 Capability Audit & Repository Witness Record
|
||||
|
||||
| Field | Value |
|
||||
|-------|-------|
|
||||
| **Status** | Accepted |
|
||||
| **Date** | 2026-03-01 |
|
||||
| **Deciders** | ruv |
|
||||
| **Auditor** | Claude Opus 4.6 (3-agent parallel deep review) |
|
||||
| **Witness Commit** | `96b01008` (main) |
|
||||
| **Relates to** | ADR-012 (ESP32 CSI Sensor Mesh), ADR-018 (ESP32 Dev Implementation), ADR-014 (SOTA Signal Processing), ADR-027 (MERIDIAN) |
|
||||
|
||||
---
|
||||
|
||||
## 1. Purpose
|
||||
|
||||
This ADR records a comprehensive, independently audited inventory of the wifi-densepose repository's ESP32 hardware capabilities, signal processing stack, neural network architectures, deployment infrastructure, and security posture. It serves as a **witness record** — a point-in-time attestation that third parties can use to verify what the codebase actually contains vs. what is claimed.
|
||||
|
||||
---
|
||||
|
||||
## 2. Audit Methodology
|
||||
|
||||
Three parallel research agents examined the full repository simultaneously:
|
||||
|
||||
| Agent | Scope | Files Examined | Duration |
|
||||
|-------|-------|---------------|----------|
|
||||
| **Hardware Agent** | ESP32 chipsets, CSI frame format, firmware, pins, power, cost | Hardware crate, firmware/, signal/hardware_norm.rs | ~9 min |
|
||||
| **Signal/AI Agent** | Algorithms, NN architectures, training, RuVector, all 27 ADRs | Signal, train, nn, mat, vitals crates + all ADRs | ~3.5 min |
|
||||
| **Deployment Agent** | Docker, CI/CD, security, proofs, crates.io, WASM | Dockerfiles, workflows, proof/, config, API crates | ~2.5 min |
|
||||
|
||||
**Test execution at audit time:** 1,031 passed, 0 failed, 8 ignored (full workspace, `--no-default-features`).
|
||||
|
||||
---
|
||||
|
||||
## 3. ESP32 Hardware — Confirmed Capabilities
|
||||
|
||||
### 3.1 Firmware (C, ESP-IDF v5.2)
|
||||
|
||||
| Component | File | Lines | Status |
|
||||
|-----------|------|-------|--------|
|
||||
| Entry point, WiFi init, CSI callback | `firmware/esp32-csi-node/main/main.c` | 144 | Implemented |
|
||||
| CSI callback, ADR-018 binary serialization | `main/csi_collector.c` | 176 | Implemented |
|
||||
| UDP socket sender | `main/stream_sender.c` | 77 | Implemented |
|
||||
| NVS config loader (SSID, password, target IP) | `main/nvs_config.c` | 88 | Implemented |
|
||||
| **Total firmware** | | **606** | **Complete** |
|
||||
|
||||
Pre-built binaries exist in `firmware/esp32-csi-node/build/` (bootloader.bin, partition table, app binary).
|
||||
|
||||
### 3.2 ADR-018 Binary Frame Format
|
||||
|
||||
```
|
||||
Offset Size Field Type Notes
|
||||
------ ---- ----- ------ -----
|
||||
0 4 Magic LE u32 0xC5110001
|
||||
4 1 Node ID u8 0-255
|
||||
5 1 Antenna count u8 1-4
|
||||
6 2 Subcarrier count LE u16 56/64/114/242
|
||||
8 4 Frequency (MHz) LE u32 2412-5825
|
||||
12 4 Sequence number LE u32 monotonic per node
|
||||
16 1 RSSI i8 dBm
|
||||
17 1 Noise floor i8 dBm
|
||||
18 2 Reserved [u8;2] 0x00 0x00
|
||||
20 N×2 I/Q payload [i8;2*n] per-antenna, per-subcarrier
|
||||
```
|
||||
|
||||
**Total frame size:** 20 + (n_antennas × n_subcarriers × 2) bytes.
|
||||
ESP32-S3 typical (1 ant, 64 sc): **148 bytes**.
|
||||
|
||||
### 3.3 Chipset Support Matrix
|
||||
|
||||
| Chipset | Subcarriers | MIMO | Bandwidth | HardwareType Enum | Normalization |
|
||||
|---------|-------------|------|-----------|-------------------|---------------|
|
||||
| ESP32-S3 | 64 | 1×1 SISO | 20/40 MHz | `Esp32S3` | Catmull-Rom → 56 canonical |
|
||||
| ESP32 | 56 | 1×1 SISO | 20 MHz | `Generic` | Pass-through |
|
||||
| Intel 5300 | 30 | 3×3 MIMO | 20/40 MHz | `Intel5300` | Catmull-Rom → 56 canonical |
|
||||
| Atheros AR9580 | 56 | 3×3 MIMO | 20 MHz | `Atheros` | Pass-through |
|
||||
|
||||
Hardware auto-detected from subcarrier count at runtime.
|
||||
|
||||
### 3.4 Data Flow: ESP32 → Inference
|
||||
|
||||
```
|
||||
ESP32 (firmware/C)
|
||||
└→ esp_wifi_set_csi_rx_cb() captures CSI per WiFi frame
|
||||
└→ csi_collector.c serializes ADR-018 binary frame
|
||||
└→ stream_sender.c sends UDP to aggregator:5005
|
||||
↓
|
||||
Aggregator (Rust, wifi-densepose-hardware)
|
||||
└→ Esp32CsiParser::parse_frame() validates magic, bounds-checks
|
||||
└→ CsiFrame with amplitude/phase arrays
|
||||
└→ mpsc channel to sensing server
|
||||
↓
|
||||
Signal Processing (wifi-densepose-signal, 5,937 lines)
|
||||
└→ HardwareNormalizer → canonical 56 subcarriers
|
||||
└→ Hampel filter, SpotFi phase correction, Fresnel, BVP, spectrogram
|
||||
↓
|
||||
Neural Network (wifi-densepose-nn, 2,959 lines)
|
||||
└→ ModalityTranslator → ResNet18 backbone
|
||||
└→ KeypointHead (17 COCO joints) + DensePoseHead (24 body parts + UV)
|
||||
↓
|
||||
REST API + WebSocket (Axum)
|
||||
└→ /api/v1/pose/current, /ws/sensing, /ws/pose
|
||||
```
|
||||
|
||||
### 3.5 ESP32 Hardware Specifications
|
||||
|
||||
| Parameter | Value |
|
||||
|-----------|-------|
|
||||
| Recommended board | ESP32-S3-DevKitC-1 |
|
||||
| SRAM | 520 KB |
|
||||
| Flash | 8 MB |
|
||||
| Firmware footprint | 600-800 KB |
|
||||
| CSI sampling rate | 20-100 Hz (configurable) |
|
||||
| Transport | UDP binary (port 5005) |
|
||||
| Serial port (flashing) | COM7 (user-confirmed) |
|
||||
| Active power draw | 150-200 mA @ 5V |
|
||||
| Deep sleep | 10 µA |
|
||||
| Starter kit cost (3 nodes) | ~$54 |
|
||||
| Per-node cost | ~$8-12 |
|
||||
|
||||
### 3.6 Flashing Instructions
|
||||
|
||||
```bash
|
||||
# Pre-built binaries
|
||||
pip install esptool
|
||||
python -m esptool --chip esp32s3 --port COM7 --baud 460800 \
|
||||
write-flash --flash-mode dio --flash-size 4MB \
|
||||
0x0 bootloader.bin 0x8000 partition-table.bin 0x10000 esp32-csi-node.bin
|
||||
|
||||
# Provision WiFi (no recompile)
|
||||
python scripts/provision.py --port COM7 \
|
||||
--ssid "YourWiFi" --password "secret" --target-ip 192.168.1.20
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 4. Signal Processing — Confirmed Algorithms
|
||||
|
||||
### 4.1 SOTA Algorithms (ADR-014, wifi-densepose-signal)
|
||||
|
||||
| Algorithm | File | Lines | Tests | SOTA Reference |
|
||||
|-----------|------|-------|-------|---------------|
|
||||
| Conjugate multiplication (SpotFi) | `csi_ratio.rs` | 198 | Yes | SIGCOMM 2015 |
|
||||
| Hampel outlier filter | `hampel.rs` | 240 | Yes | Robust statistics |
|
||||
| Fresnel zone breathing model | `fresnel.rs` | 448 | Yes | FarSense, MobiCom 2019 |
|
||||
| Body Velocity Profile | `bvp.rs` | 381 | Yes | Widar 3.0, MobiSys 2019 |
|
||||
| STFT spectrogram | `spectrogram.rs` | 367 | Yes | Multiple windows (Hann, Hamming, Blackman) |
|
||||
| Sensitivity-based subcarrier selection | `subcarrier_selection.rs` | 388 | Yes | Variance ratio |
|
||||
| Phase unwrapping/sanitization | `phase_sanitizer.rs` | 900 | Yes | Linear detrending |
|
||||
| Motion/presence detection | `motion.rs` | 834 | Yes | Confidence scoring |
|
||||
| Multi-feature extraction | `features.rs` | 877 | Yes | Amplitude, phase, Doppler, PSD, correlation |
|
||||
| Hardware normalization (MERIDIAN) | `hardware_norm.rs` | 399 | Yes | ADR-027 Phase 1 |
|
||||
| CSI preprocessing pipeline | `csi_processor.rs` | 789 | Yes | Noise removal, windowing |
|
||||
|
||||
**Total signal processing:** 5,937 lines, 105+ tests.
|
||||
|
||||
### 4.2 Training Pipeline (wifi-densepose-train, 9,051 lines)
|
||||
|
||||
| Phase | Module | Lines | Description |
|
||||
|-------|--------|-------|-------------|
|
||||
| 1. Data loading | `dataset.rs` | 1,164 | MM-Fi/Wi-Pose/synthetic, deterministic shuffling |
|
||||
| 2. Configuration | `config.rs` | 507 | Hyperparameters, schedule, paths |
|
||||
| 3. Model architecture | `model.rs` | 1,032 | CsiToPoseTransformer, cross-attention, GNN |
|
||||
| 4. Loss computation | `losses.rs` | 1,056 | 6-term composite (keypoint + DensePose + transfer) |
|
||||
| 5. Metrics | `metrics.rs` | 1,664 | PCK@0.2, OKS, per-part mAP, min-cut matching |
|
||||
| 6. Trainer loop | `trainer.rs` | 776 | SGD + cosine annealing, early stopping, checkpoints |
|
||||
| 7. Subcarrier optimization | `subcarrier.rs` | 414 | 114→56 resampling via RuVector sparse solver |
|
||||
| 8. Deterministic proof | `proof.rs` | 461 | SHA-256 hash of pipeline output |
|
||||
| 9. Hardware normalization | `hardware_norm.rs` | 399 | Canonical frame conversion (ADR-027) |
|
||||
| 10. Domain-adversarial training | `domain.rs` + `geometry.rs` + `virtual_aug.rs` + `rapid_adapt.rs` + `eval.rs` | 1,530 | MERIDIAN (ADR-027) |
|
||||
|
||||
### 4.3 RuVector Integration (5 crates @ v2.0.4)
|
||||
|
||||
| Crate | Integration Point | Replaces |
|
||||
|-------|------------------|----------|
|
||||
| `ruvector-mincut` | `metrics.rs` DynamicPersonMatcher | O(n³) Hungarian → O(n^1.5 log n) |
|
||||
| `ruvector-attn-mincut` | `spectrogram.rs`, `model.rs` | Softmax attention → min-cut gating |
|
||||
| `ruvector-temporal-tensor` | `dataset.rs` CompressedCsiBuffer | Full f32 → tiered 8/7/5/3-bit (50-75% savings) |
|
||||
| `ruvector-solver` | `subcarrier.rs` interpolation | Dense linear algebra → O(√n) Neumann solver |
|
||||
| `ruvector-attention` | `bvp.rs`, `model.rs` spatial attention | Static weights → learned scaled-dot-product |
|
||||
|
||||
### 4.4 Domain Generalization (ADR-027 MERIDIAN)
|
||||
|
||||
| Component | File | Lines | Status |
|
||||
|-----------|------|-------|--------|
|
||||
| Gradient Reversal Layer + Domain Classifier | `domain.rs` | 400 | Implemented, security-hardened |
|
||||
| Geometry Encoder (Fourier + DeepSets + FiLM) | `geometry.rs` | 365 | Implemented |
|
||||
| Virtual Domain Augmentation | `virtual_aug.rs` | 297 | Implemented |
|
||||
| Rapid Adaptation (contrastive TTT + LoRA) | `rapid_adapt.rs` | 317 | Implemented, bounded buffer |
|
||||
| Cross-Domain Evaluator | `eval.rs` | 151 | Implemented |
|
||||
|
||||
### 4.5 Vital Signs (wifi-densepose-vitals, 1,863 lines)
|
||||
|
||||
| Capability | Range | Method |
|
||||
|------------|-------|--------|
|
||||
| Breathing rate | 6-30 BPM | Bandpass 0.1-0.5 Hz + spectral peak |
|
||||
| Heart rate | 40-120 BPM | Micro-Doppler 0.8-2.0 Hz isolation |
|
||||
| Presence detection | Binary | CSI variance thresholding |
|
||||
| Anomaly detection | Z-score, CUSUM, EMA | Multi-algorithm fusion |
|
||||
|
||||
### 4.6 Disaster Response (wifi-densepose-mat, 626+ lines, 153 tests)
|
||||
|
||||
| Subsystem | Capability |
|
||||
|-----------|-----------|
|
||||
| Detection | Breathing, heartbeat, movement classification, ensemble voting |
|
||||
| Localization | Multi-AP triangulation, depth estimation, Kalman fusion |
|
||||
| Triage | START protocol (Red/Yellow/Green/Black) |
|
||||
| Alerting | Priority routing, zone dispatch |
|
||||
|
||||
---
|
||||
|
||||
## 5. Deployment Infrastructure — Confirmed
|
||||
|
||||
### 5.1 Published Artifacts
|
||||
|
||||
| Channel | Artifact | Version | Count |
|
||||
|---------|----------|---------|-------|
|
||||
| crates.io | Rust crates | 0.2.0 | 15 |
|
||||
| Docker Hub | `ruvnet/wifi-densepose:latest` (Rust) | 132 MB | 1 |
|
||||
| Docker Hub | `ruvnet/wifi-densepose:python` | 569 MB | 1 |
|
||||
| PyPI | `wifi-densepose` (Python) | 1.2.0 | 1 |
|
||||
|
||||
### 5.2 CI/CD (4 GitHub Actions Workflows)
|
||||
|
||||
| Workflow | Triggers | Key Steps |
|
||||
|----------|----------|-----------|
|
||||
| `ci.yml` | Push/PR | Lint, test (Python 3.10-3.12), Docker multi-arch build, Trivy scan |
|
||||
| `security-scan.yml` | Schedule/manual | Bandit, Semgrep, Snyk, Trivy, Grype, TruffleHog, GitLeaks |
|
||||
| `cd.yml` | Release | Blue-green deploy, DB backup, health monitoring, Slack notify |
|
||||
| `verify-pipeline.yml` | Push/manual | Deterministic hash verification, unseeded random scan |
|
||||
|
||||
### 5.3 Deterministic Proof System
|
||||
|
||||
| Component | File | Purpose |
|
||||
|-----------|------|---------|
|
||||
| Reference signal | `v1/data/proof/sample_csi_data.json` | 1,000 synthetic CSI frames, seed=42 |
|
||||
| Generator | `v1/data/proof/generate_reference_signal.py` | Deterministic multipath model |
|
||||
| Verifier | `v1/data/proof/verify.py` | SHA-256 hash comparison |
|
||||
| Expected hash | `v1/data/proof/expected_features.sha256` | `0b82bd45...` |
|
||||
|
||||
**Audit-time result:** PASS. Hash regenerated with numpy 2.4.2 + scipy 1.17.1. Pipeline hash: `8c0680d7d285739ea9597715e84959d9c356c87ee3ad35b5f1e69a4ca41151c6`.
|
||||
|
||||
### 5.4 Security Posture
|
||||
|
||||
- JWT authentication (`python-jose[cryptography]`)
|
||||
- Bcrypt password hashing (`passlib`)
|
||||
- SQLx prepared statements (no SQL injection)
|
||||
- CORS + WSS enforcement on non-localhost
|
||||
- Shell injection prevention (Clap argument validation)
|
||||
- 15+ security scanners in CI (SAST, DAST, secrets, containers, IaC, licenses)
|
||||
- MERIDIAN security hardening: bounded buffers, no panics on bad input, atomic counters, division guards
|
||||
|
||||
### 5.5 WASM Browser Deployment
|
||||
|
||||
- Crate: `wifi-densepose-wasm` (cdylib + rlib)
|
||||
- Optimization: `-O4 --enable-mutable-globals`
|
||||
- JS bindings: `wasm-bindgen` for WebSocket, Canvas, Window APIs
|
||||
- Three.js 3D visualization (17 joints, 16 limbs)
|
||||
|
||||
---
|
||||
|
||||
## 6. Codebase Size Summary
|
||||
|
||||
| Crate | Lines of Rust | Tests |
|
||||
|-------|--------------|-------|
|
||||
| wifi-densepose-signal | 5,937 | 105+ |
|
||||
| wifi-densepose-train | 9,051 | 174+ |
|
||||
| wifi-densepose-nn | 2,959 | 23 |
|
||||
| wifi-densepose-mat | 626+ | 153 |
|
||||
| wifi-densepose-hardware | 865 | 32 |
|
||||
| wifi-densepose-vitals | 1,863 | Yes |
|
||||
| **Total (key crates)** | **~21,300** | **1,031 passing** |
|
||||
|
||||
Firmware (C): 606 lines. Python v1: 34 test files, 41 dependencies.
|
||||
|
||||
---
|
||||
|
||||
## 7. What Is NOT Yet Implemented
|
||||
|
||||
| Claim | Actual Status | Gap |
|
||||
|-------|--------------|-----|
|
||||
| On-device ML inference (ESP32) | Not implemented | Firmware streams raw I/Q; all inference runs on aggregator |
|
||||
| 54,000 fps throughput | Benchmark claim, not measured at audit time | Requires Criterion benchmarks on target hardware |
|
||||
| INT8 quantization for ESP32 | Designed (ADR-023), not shipped | Model fits in 55 KB but no deployed quantized binary |
|
||||
| Real WiFi CSI dataset | Synthetic only | No real-world captures in repo; MM-Fi/Wi-Pose referenced but not bundled |
|
||||
| Kubernetes blue-green deploy | CI/CD workflow exists | Requires actual cluster; not testable in audit |
|
||||
| Python proof hash | PASS (regenerated at audit time) | Requires numpy 2.4.2 + scipy 1.17.1 |
|
||||
|
||||
---
|
||||
|
||||
## 8. Decision
|
||||
|
||||
This ADR accepts the audit findings as a witness record. The repository contains substantial, functional code matching its documented claims with the exceptions noted in Section 7. All code compiles, all 1,031 tests pass, and the architecture is consistent across the 27 ADRs.
|
||||
|
||||
### Recommendations
|
||||
|
||||
1. **Bundle a small real CSI capture** (even 10 seconds from one ESP32) alongside the synthetic reference
|
||||
3. **Run Criterion benchmarks** and record actual throughput numbers
|
||||
4. **Publish ESP32 firmware** as a GitHub Release binary for COM7-ready flashing
|
||||
|
||||
---
|
||||
|
||||
## 9. References
|
||||
|
||||
- [ADR-012: ESP32 CSI Sensor Mesh](ADR-012-esp32-csi-sensor-mesh.md)
|
||||
- [ADR-018: ESP32 Dev Implementation](ADR-018-esp32-dev-implementation.md)
|
||||
- [ADR-014: SOTA Signal Processing](ADR-014-sota-signal-processing.md)
|
||||
- [ADR-027: Cross-Environment Domain Generalization](ADR-027-cross-environment-domain-generalization.md)
|
||||
- [Deterministic Proof Verifier](../../v1/data/proof/verify.py)
|
||||
@@ -1,678 +0,0 @@
|
||||
# WiFi DensePose User Guide
|
||||
|
||||
WiFi DensePose turns commodity WiFi signals into real-time human pose estimation, vital sign monitoring, and presence detection. This guide walks you through installation, first run, API usage, hardware setup, and model training.
|
||||
|
||||
---
|
||||
|
||||
## Table of Contents
|
||||
|
||||
1. [Prerequisites](#prerequisites)
|
||||
2. [Installation](#installation)
|
||||
- [Docker (Recommended)](#docker-recommended)
|
||||
- [From Source (Rust)](#from-source-rust)
|
||||
- [From Source (Python)](#from-source-python)
|
||||
- [Guided Installer](#guided-installer)
|
||||
3. [Quick Start](#quick-start)
|
||||
- [30-Second Demo (Docker)](#30-second-demo-docker)
|
||||
- [Verify the System Works](#verify-the-system-works)
|
||||
4. [Data Sources](#data-sources)
|
||||
- [Simulated Mode (No Hardware)](#simulated-mode-no-hardware)
|
||||
- [Windows WiFi (RSSI Only)](#windows-wifi-rssi-only)
|
||||
- [ESP32-S3 (Full CSI)](#esp32-s3-full-csi)
|
||||
5. [REST API Reference](#rest-api-reference)
|
||||
6. [WebSocket Streaming](#websocket-streaming)
|
||||
7. [Web UI](#web-ui)
|
||||
8. [Vital Sign Detection](#vital-sign-detection)
|
||||
9. [CLI Reference](#cli-reference)
|
||||
10. [Training a Model](#training-a-model)
|
||||
11. [RVF Model Containers](#rvf-model-containers)
|
||||
12. [Hardware Setup](#hardware-setup)
|
||||
- [ESP32-S3 Mesh](#esp32-s3-mesh)
|
||||
- [Intel 5300 / Atheros NIC](#intel-5300--atheros-nic)
|
||||
13. [Docker Compose (Multi-Service)](#docker-compose-multi-service)
|
||||
14. [Troubleshooting](#troubleshooting)
|
||||
15. [FAQ](#faq)
|
||||
|
||||
---
|
||||
|
||||
## Prerequisites
|
||||
|
||||
| Requirement | Minimum | Recommended |
|
||||
|-------------|---------|-------------|
|
||||
| **OS** | Windows 10, macOS 10.15, Ubuntu 18.04 | Latest stable |
|
||||
| **RAM** | 4 GB | 8 GB+ |
|
||||
| **Disk** | 2 GB free | 5 GB free |
|
||||
| **Docker** (for Docker path) | Docker 20+ | Docker 24+ |
|
||||
| **Rust** (for source build) | 1.70+ | 1.85+ |
|
||||
| **Python** (for legacy v1) | 3.8+ | 3.11+ |
|
||||
|
||||
**Hardware for live sensing (optional):**
|
||||
|
||||
| Option | Cost | Capabilities |
|
||||
|--------|------|-------------|
|
||||
| ESP32-S3 mesh (3-6 boards) | ~$54 | Full CSI: pose, breathing, heartbeat, presence |
|
||||
| Intel 5300 / Atheros AR9580 | $50-100 | Full CSI with 3x3 MIMO (Linux only) |
|
||||
| Any WiFi laptop | $0 | RSSI-only: coarse presence and motion detection |
|
||||
|
||||
No hardware? The system runs in **simulated mode** with synthetic CSI data.
|
||||
|
||||
---
|
||||
|
||||
## Installation
|
||||
|
||||
### Docker (Recommended)
|
||||
|
||||
The fastest path. No toolchain installation needed.
|
||||
|
||||
```bash
|
||||
docker pull ruvnet/wifi-densepose:latest
|
||||
```
|
||||
|
||||
Image size: ~132 MB. Contains the Rust sensing server, Three.js UI, and all signal processing.
|
||||
|
||||
### From Source (Rust)
|
||||
|
||||
```bash
|
||||
git clone https://github.com/ruvnet/wifi-densepose.git
|
||||
cd wifi-densepose/rust-port/wifi-densepose-rs
|
||||
|
||||
# Build
|
||||
cargo build --release
|
||||
|
||||
# Verify (runs 700+ tests)
|
||||
cargo test --workspace
|
||||
```
|
||||
|
||||
The compiled binary is at `target/release/sensing-server`.
|
||||
|
||||
### From Source (Python)
|
||||
|
||||
```bash
|
||||
git clone https://github.com/ruvnet/wifi-densepose.git
|
||||
cd wifi-densepose
|
||||
|
||||
pip install -r requirements.txt
|
||||
pip install -e .
|
||||
|
||||
# Or via PyPI
|
||||
pip install wifi-densepose
|
||||
pip install wifi-densepose[gpu] # GPU acceleration
|
||||
pip install wifi-densepose[all] # All optional deps
|
||||
```
|
||||
|
||||
### Guided Installer
|
||||
|
||||
An interactive installer that detects your hardware and recommends a profile:
|
||||
|
||||
```bash
|
||||
git clone https://github.com/ruvnet/wifi-densepose.git
|
||||
cd wifi-densepose
|
||||
./install.sh
|
||||
```
|
||||
|
||||
Available profiles: `verify`, `python`, `rust`, `browser`, `iot`, `docker`, `field`, `full`.
|
||||
|
||||
Non-interactive:
|
||||
```bash
|
||||
./install.sh --profile rust --yes
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Quick Start
|
||||
|
||||
### 30-Second Demo (Docker)
|
||||
|
||||
```bash
|
||||
# Pull and run
|
||||
docker run -p 3000:3000 -p 3001:3001 ruvnet/wifi-densepose:latest
|
||||
|
||||
# Open the UI in your browser
|
||||
# http://localhost:3000
|
||||
```
|
||||
|
||||
You will see a Three.js visualization with:
|
||||
- 3D body skeleton (17 COCO keypoints)
|
||||
- Signal amplitude heatmap
|
||||
- Phase plot
|
||||
- Vital signs panel (breathing + heartbeat)
|
||||
|
||||
### Verify the System Works
|
||||
|
||||
Open a second terminal and test the API:
|
||||
|
||||
```bash
|
||||
# Health check
|
||||
curl http://localhost:3000/health
|
||||
# Expected: {"status":"ok","source":"simulated","clients":0}
|
||||
|
||||
# Latest sensing frame
|
||||
curl http://localhost:3000/api/v1/sensing/latest
|
||||
|
||||
# Vital signs
|
||||
curl http://localhost:3000/api/v1/vital-signs
|
||||
|
||||
# Pose estimation (17 COCO keypoints)
|
||||
curl http://localhost:3000/api/v1/pose/current
|
||||
|
||||
# Server build info
|
||||
curl http://localhost:3000/api/v1/info
|
||||
```
|
||||
|
||||
All endpoints return JSON. In simulated mode, data is generated from a deterministic reference signal.
|
||||
|
||||
---
|
||||
|
||||
## Data Sources
|
||||
|
||||
The `--source` flag controls where CSI data comes from.
|
||||
|
||||
### Simulated Mode (No Hardware)
|
||||
|
||||
Default in Docker. Generates synthetic CSI data exercising the full pipeline.
|
||||
|
||||
```bash
|
||||
# Docker
|
||||
docker run -p 3000:3000 ruvnet/wifi-densepose:latest
|
||||
# (--source simulated is the default)
|
||||
|
||||
# From source
|
||||
./target/release/sensing-server --source simulated --http-port 3000 --ws-port 3001
|
||||
```
|
||||
|
||||
### Windows WiFi (RSSI Only)
|
||||
|
||||
Uses `netsh wlan` to capture RSSI from nearby access points. No special hardware needed, but capabilities are limited to coarse presence and motion detection (no pose estimation or vital signs).
|
||||
|
||||
```bash
|
||||
# From source (Windows only)
|
||||
./target/release/sensing-server --source windows --http-port 3000 --ws-port 3001 --tick-ms 500
|
||||
|
||||
# Docker (requires --network host on Windows)
|
||||
docker run --network host ruvnet/wifi-densepose:latest --source windows --tick-ms 500
|
||||
```
|
||||
|
||||
See [Tutorial #36](https://github.com/ruvnet/wifi-densepose/issues/36) for a walkthrough.
|
||||
|
||||
### macOS WiFi (RSSI Only)
|
||||
|
||||
Uses CoreWLAN via a Swift helper binary. macOS Sonoma 14.4+ redacts real BSSIDs; the adapter generates deterministic synthetic MACs so the multi-BSSID pipeline still works.
|
||||
|
||||
```bash
|
||||
# Compile the Swift helper (once)
|
||||
swiftc -O v1/src/sensing/mac_wifi.swift -o mac_wifi
|
||||
|
||||
# Run natively
|
||||
./target/release/sensing-server --source macos --http-port 3000 --ws-port 3001 --tick-ms 500
|
||||
```
|
||||
|
||||
See [ADR-025](adr/ADR-025-macos-corewlan-wifi-sensing.md) for details.
|
||||
|
||||
### Linux WiFi (RSSI Only)
|
||||
|
||||
Uses `iw dev <iface> scan` to capture RSSI. Requires `CAP_NET_ADMIN` (root) for active scans; use `scan dump` for cached results without root.
|
||||
|
||||
```bash
|
||||
# Run natively (requires root for active scanning)
|
||||
sudo ./target/release/sensing-server --source linux --http-port 3000 --ws-port 3001 --tick-ms 500
|
||||
```
|
||||
|
||||
### ESP32-S3 (Full CSI)
|
||||
|
||||
Real Channel State Information at 20 Hz with 56-192 subcarriers. Required for pose estimation, vital signs, and through-wall sensing.
|
||||
|
||||
```bash
|
||||
# From source
|
||||
./target/release/sensing-server --source esp32 --udp-port 5005 --http-port 3000 --ws-port 3001
|
||||
|
||||
# Docker
|
||||
docker run -p 3000:3000 -p 3001:3001 -p 5005:5005/udp ruvnet/wifi-densepose:latest --source esp32
|
||||
```
|
||||
|
||||
The ESP32 nodes stream binary CSI frames over UDP to port 5005. See [Hardware Setup](#esp32-s3-mesh) for flashing instructions.
|
||||
|
||||
---
|
||||
|
||||
## REST API Reference
|
||||
|
||||
Base URL: `http://localhost:3000` (Docker) or `http://localhost:8080` (binary default).
|
||||
|
||||
| Method | Endpoint | Description | Example Response |
|
||||
|--------|----------|-------------|-----------------|
|
||||
| `GET` | `/health` | Server health check | `{"status":"ok","source":"simulated","clients":0}` |
|
||||
| `GET` | `/api/v1/sensing/latest` | Latest CSI sensing frame (amplitude, phase, motion) | JSON with subcarrier arrays |
|
||||
| `GET` | `/api/v1/vital-signs` | Breathing rate + heart rate + confidence | `{"breathing_bpm":16.2,"heart_bpm":72.1,"confidence":0.87}` |
|
||||
| `GET` | `/api/v1/pose/current` | 17 COCO keypoints (x, y, z, confidence) | Array of 17 joint positions |
|
||||
| `GET` | `/api/v1/info` | Server version, build info, uptime | JSON metadata |
|
||||
| `GET` | `/api/v1/bssid` | Multi-BSSID WiFi registry | List of detected access points |
|
||||
| `GET` | `/api/v1/model/layers` | Progressive model loading status | Layer A/B/C load state |
|
||||
| `GET` | `/api/v1/model/sona/profiles` | SONA adaptation profiles | List of environment profiles |
|
||||
| `POST` | `/api/v1/model/sona/activate` | Activate a SONA profile for a specific room | `{"profile":"kitchen"}` |
|
||||
|
||||
### Example: Get Vital Signs
|
||||
|
||||
```bash
|
||||
curl -s http://localhost:3000/api/v1/vital-signs | python -m json.tool
|
||||
```
|
||||
|
||||
```json
|
||||
{
|
||||
"breathing_bpm": 16.2,
|
||||
"heart_bpm": 72.1,
|
||||
"breathing_confidence": 0.87,
|
||||
"heart_confidence": 0.63,
|
||||
"motion_level": 0.12,
|
||||
"timestamp_ms": 1709312400000
|
||||
}
|
||||
```
|
||||
|
||||
### Example: Get Pose
|
||||
|
||||
```bash
|
||||
curl -s http://localhost:3000/api/v1/pose/current | python -m json.tool
|
||||
```
|
||||
|
||||
```json
|
||||
{
|
||||
"persons": [
|
||||
{
|
||||
"id": 0,
|
||||
"keypoints": [
|
||||
{"name": "nose", "x": 0.52, "y": 0.31, "z": 0.0, "confidence": 0.91},
|
||||
{"name": "left_eye", "x": 0.54, "y": 0.29, "z": 0.0, "confidence": 0.88}
|
||||
]
|
||||
}
|
||||
],
|
||||
"frame_id": 1024,
|
||||
"timestamp_ms": 1709312400000
|
||||
}
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## WebSocket Streaming
|
||||
|
||||
Real-time sensing data is available via WebSocket.
|
||||
|
||||
**URL:** `ws://localhost:3001/ws/sensing` (Docker) or `ws://localhost:8765/ws/sensing` (binary default).
|
||||
|
||||
### Python Example
|
||||
|
||||
```python
|
||||
import asyncio
|
||||
import websockets
|
||||
import json
|
||||
|
||||
async def stream():
|
||||
uri = "ws://localhost:3001/ws/sensing"
|
||||
async with websockets.connect(uri) as ws:
|
||||
async for message in ws:
|
||||
data = json.loads(message)
|
||||
persons = data.get("persons", [])
|
||||
vitals = data.get("vital_signs", {})
|
||||
print(f"Persons: {len(persons)}, "
|
||||
f"Breathing: {vitals.get('breathing_bpm', 'N/A')} BPM")
|
||||
|
||||
asyncio.run(stream())
|
||||
```
|
||||
|
||||
### JavaScript Example
|
||||
|
||||
```javascript
|
||||
const ws = new WebSocket("ws://localhost:3001/ws/sensing");
|
||||
|
||||
ws.onmessage = (event) => {
|
||||
const data = JSON.parse(event.data);
|
||||
console.log("Persons:", data.persons?.length ?? 0);
|
||||
console.log("Breathing:", data.vital_signs?.breathing_bpm, "BPM");
|
||||
};
|
||||
|
||||
ws.onerror = (err) => console.error("WebSocket error:", err);
|
||||
```
|
||||
|
||||
### curl (single frame)
|
||||
|
||||
```bash
|
||||
# Requires wscat (npm install -g wscat)
|
||||
wscat -c ws://localhost:3001/ws/sensing
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Web UI
|
||||
|
||||
The built-in Three.js UI is served at `http://localhost:3000/` (Docker) or the configured HTTP port.
|
||||
|
||||
**What you see:**
|
||||
|
||||
| Panel | Description |
|
||||
|-------|-------------|
|
||||
| 3D Body View | Rotatable wireframe skeleton with 17 COCO keypoints |
|
||||
| Signal Heatmap | 56 subcarriers color-coded by amplitude |
|
||||
| Phase Plot | Per-subcarrier phase values over time |
|
||||
| Doppler Bars | Motion band power indicators |
|
||||
| Vital Signs | Live breathing rate (BPM) and heart rate (BPM) |
|
||||
| Dashboard | System stats, throughput, connected WebSocket clients |
|
||||
|
||||
The UI updates in real-time via the WebSocket connection.
|
||||
|
||||
---
|
||||
|
||||
## Vital Sign Detection
|
||||
|
||||
The system extracts breathing rate and heart rate from CSI signal fluctuations using FFT peak detection.
|
||||
|
||||
| Sign | Frequency Band | Range | Method |
|
||||
|------|---------------|-------|--------|
|
||||
| Breathing | 0.1-0.5 Hz | 6-30 BPM | Bandpass filter + FFT peak |
|
||||
| Heart rate | 0.8-2.0 Hz | 40-120 BPM | Bandpass filter + FFT peak |
|
||||
|
||||
**Requirements:**
|
||||
- CSI-capable hardware (ESP32-S3 or research NIC) for accurate readings
|
||||
- Subject within ~3-5 meters of an access point
|
||||
- Relatively stationary subject (large movements mask vital sign oscillations)
|
||||
|
||||
**Simulated mode** produces synthetic vital sign data for testing.
|
||||
|
||||
---
|
||||
|
||||
## CLI Reference
|
||||
|
||||
The Rust sensing server binary accepts the following flags:
|
||||
|
||||
| Flag | Default | Description |
|
||||
|------|---------|-------------|
|
||||
| `--source` | `auto` | Data source: `auto`, `simulated`, `windows`, `esp32` |
|
||||
| `--http-port` | `8080` | HTTP port for REST API and UI |
|
||||
| `--ws-port` | `8765` | WebSocket port |
|
||||
| `--udp-port` | `5005` | UDP port for ESP32 CSI frames |
|
||||
| `--ui-path` | (none) | Path to UI static files directory |
|
||||
| `--tick-ms` | `50` | Simulated frame interval (milliseconds) |
|
||||
| `--benchmark` | off | Run vital sign benchmark (1000 frames) and exit |
|
||||
| `--train` | off | Train a model from dataset |
|
||||
| `--dataset` | (none) | Path to dataset directory (MM-Fi or Wi-Pose) |
|
||||
| `--dataset-type` | `mmfi` | Dataset format: `mmfi` or `wipose` |
|
||||
| `--epochs` | `100` | Training epochs |
|
||||
| `--export-rvf` | (none) | Export RVF model container and exit |
|
||||
| `--save-rvf` | (none) | Save model state to RVF on shutdown |
|
||||
| `--model` | (none) | Load a trained `.rvf` model for inference |
|
||||
| `--load-rvf` | (none) | Load model config from RVF container |
|
||||
| `--progressive` | off | Enable progressive 3-layer model loading |
|
||||
|
||||
### Common Invocations
|
||||
|
||||
```bash
|
||||
# Simulated mode with UI (development)
|
||||
./target/release/sensing-server --source simulated --http-port 3000 --ws-port 3001 --ui-path ../../ui
|
||||
|
||||
# ESP32 hardware mode
|
||||
./target/release/sensing-server --source esp32 --udp-port 5005
|
||||
|
||||
# Windows WiFi RSSI
|
||||
./target/release/sensing-server --source windows --tick-ms 500
|
||||
|
||||
# Run benchmark
|
||||
./target/release/sensing-server --benchmark
|
||||
|
||||
# Train and export model
|
||||
./target/release/sensing-server --train --dataset data/ --epochs 100 --save-rvf model.rvf
|
||||
|
||||
# Load trained model with progressive loading
|
||||
./target/release/sensing-server --model model.rvf --progressive
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Training a Model
|
||||
|
||||
The training pipeline is implemented in pure Rust (7,832 lines, zero external ML dependencies).
|
||||
|
||||
### Step 1: Obtain a Dataset
|
||||
|
||||
The system supports two public WiFi CSI datasets:
|
||||
|
||||
| Dataset | Source | Format | Subjects | Environments |
|
||||
|---------|--------|--------|----------|-------------|
|
||||
| [MM-Fi](https://mmfi.github.io/) | NeurIPS 2023 | `.npy` | 40 | 4 rooms |
|
||||
| [Wi-Pose](https://github.com/aiot-lab/Wi-Pose) | AAAI 2024 | `.mat` | 8 | 3 rooms |
|
||||
|
||||
Download and place in a `data/` directory.
|
||||
|
||||
### Step 2: Train
|
||||
|
||||
```bash
|
||||
# From source
|
||||
./target/release/sensing-server --train --dataset data/ --dataset-type mmfi --epochs 100 --save-rvf model.rvf
|
||||
|
||||
# Via Docker (mount your data directory)
|
||||
docker run --rm \
|
||||
-v $(pwd)/data:/data \
|
||||
-v $(pwd)/output:/output \
|
||||
ruvnet/wifi-densepose:latest \
|
||||
--train --dataset /data --epochs 100 --export-rvf /output/model.rvf
|
||||
```
|
||||
|
||||
The pipeline runs 10 phases:
|
||||
1. Dataset loading (MM-Fi `.npy` or Wi-Pose `.mat`)
|
||||
2. Hardware normalization (Intel 5300 / Atheros / ESP32 -> canonical 56 subcarriers)
|
||||
3. Subcarrier resampling (114->56 or 30->56 via Catmull-Rom interpolation)
|
||||
4. Graph transformer construction (17 COCO keypoints, 16 bone edges)
|
||||
5. Cross-attention training (CSI features -> body pose)
|
||||
6. **Domain-adversarial training** (MERIDIAN: gradient reversal + virtual domain augmentation)
|
||||
7. Composite loss optimization (MSE + CE + UV + temporal + bone + symmetry)
|
||||
8. SONA adaptation (micro-LoRA + EWC++)
|
||||
9. Sparse inference optimization (hot/cold neuron partitioning)
|
||||
10. RVF model packaging
|
||||
|
||||
### Step 3: Use the Trained Model
|
||||
|
||||
```bash
|
||||
./target/release/sensing-server --model model.rvf --progressive --source esp32
|
||||
```
|
||||
|
||||
Progressive loading enables instant startup (Layer A loads in <5ms with basic inference), with full model loading in the background.
|
||||
|
||||
### Cross-Environment Adaptation (MERIDIAN)
|
||||
|
||||
Models trained in one room typically lose 40-70% accuracy in a new room due to different WiFi multipath patterns. The MERIDIAN system (ADR-027) solves this with a 10-second automatic calibration:
|
||||
|
||||
1. **Deploy** the trained model in a new room
|
||||
2. **Collect** ~200 unlabeled CSI frames (10 seconds at 20 Hz)
|
||||
3. The system automatically generates environment-specific LoRA weights via contrastive test-time training
|
||||
4. No labels, no retraining, no user intervention
|
||||
|
||||
MERIDIAN components (all pure Rust, +12K parameters):
|
||||
|
||||
| Component | What it does |
|
||||
|-----------|-------------|
|
||||
| Hardware Normalizer | Resamples any WiFi chipset to canonical 56 subcarriers |
|
||||
| Domain Factorizer | Separates pose-relevant from room-specific features |
|
||||
| Geometry Encoder | Encodes AP positions (FiLM conditioning with DeepSets) |
|
||||
| Virtual Augmentor | Generates synthetic environments for robust training |
|
||||
| Rapid Adaptation | 10-second unsupervised calibration via contrastive TTT |
|
||||
|
||||
See [ADR-027](adr/ADR-027-cross-environment-domain-generalization.md) for the full design.
|
||||
|
||||
---
|
||||
|
||||
## RVF Model Containers
|
||||
|
||||
The RuVector Format (RVF) packages a trained model into a single self-contained binary file.
|
||||
|
||||
### Export
|
||||
|
||||
```bash
|
||||
./target/release/sensing-server --export-rvf model.rvf
|
||||
```
|
||||
|
||||
### Load
|
||||
|
||||
```bash
|
||||
./target/release/sensing-server --model model.rvf --progressive
|
||||
```
|
||||
|
||||
### Contents
|
||||
|
||||
An RVF file contains: model weights, HNSW vector index, quantization codebooks, SONA adaptation profiles, Ed25519 training proof, and vital sign filter parameters.
|
||||
|
||||
### Deployment Targets
|
||||
|
||||
| Target | Quantization | Size | Load Time |
|
||||
|--------|-------------|------|-----------|
|
||||
| ESP32 / IoT | int4 | ~0.7 MB | <5ms |
|
||||
| Mobile / WASM | int8 | ~6-10 MB | ~200-500ms |
|
||||
| Field (WiFi-Mat) | fp16 | ~62 MB | ~2s |
|
||||
| Server / Cloud | f32 | ~50+ MB | ~3s |
|
||||
|
||||
---
|
||||
|
||||
## Hardware Setup
|
||||
|
||||
### ESP32-S3 Mesh
|
||||
|
||||
A 3-6 node ESP32-S3 mesh provides full CSI at 20 Hz. Total cost: ~$54 for a 3-node setup.
|
||||
|
||||
**What you need:**
|
||||
- 3-6x ESP32-S3 development boards (~$8 each)
|
||||
- A WiFi router (the CSI source)
|
||||
- A computer running the sensing server
|
||||
|
||||
**Flashing firmware:**
|
||||
|
||||
Pre-built binaries are available at [Releases](https://github.com/ruvnet/wifi-densepose/releases/tag/v0.1.0-esp32).
|
||||
|
||||
```bash
|
||||
# Flash an ESP32-S3 (requires esptool: pip install esptool)
|
||||
python -m esptool --chip esp32s3 --port COM7 --baud 460800 \
|
||||
write-flash --flash-mode dio --flash-size 4MB \
|
||||
0x0 bootloader.bin 0x8000 partition-table.bin 0x10000 esp32-csi-node.bin
|
||||
```
|
||||
|
||||
**Provisioning:**
|
||||
|
||||
```bash
|
||||
python scripts/provision.py --port COM7 \
|
||||
--ssid "YourWiFi" --password "YourPassword" --target-ip 192.168.1.20
|
||||
```
|
||||
|
||||
Replace `192.168.1.20` with the IP of the machine running the sensing server.
|
||||
|
||||
**Start the aggregator:**
|
||||
|
||||
```bash
|
||||
# From source
|
||||
./target/release/sensing-server --source esp32 --udp-port 5005 --http-port 3000 --ws-port 3001
|
||||
|
||||
# Docker
|
||||
docker run -p 3000:3000 -p 3001:3001 -p 5005:5005/udp ruvnet/wifi-densepose:latest --source esp32
|
||||
```
|
||||
|
||||
See [ADR-018](../docs/adr/ADR-018-esp32-dev-implementation.md) and [Tutorial #34](https://github.com/ruvnet/wifi-densepose/issues/34).
|
||||
|
||||
### Intel 5300 / Atheros NIC
|
||||
|
||||
These research NICs provide full CSI on Linux with firmware/driver modifications.
|
||||
|
||||
| NIC | Driver | Platform | Setup |
|
||||
|-----|--------|----------|-------|
|
||||
| Intel 5300 | `iwl-csi` | Linux | Custom firmware, ~$15 used |
|
||||
| Atheros AR9580 | `ath9k` patch | Linux | Kernel patch, ~$20 used |
|
||||
|
||||
These are advanced setups. See the respective driver documentation for installation.
|
||||
|
||||
---
|
||||
|
||||
## Docker Compose (Multi-Service)
|
||||
|
||||
For production deployments with both Rust and Python services:
|
||||
|
||||
```bash
|
||||
cd docker
|
||||
docker compose up
|
||||
```
|
||||
|
||||
This starts:
|
||||
- Rust sensing server on ports 3000 (HTTP), 3001 (WS), 5005 (UDP)
|
||||
- Python legacy server on ports 8080 (HTTP), 8765 (WS)
|
||||
|
||||
---
|
||||
|
||||
## Troubleshooting
|
||||
|
||||
### Docker: "Connection refused" on localhost:3000
|
||||
|
||||
Make sure you're mapping the ports correctly:
|
||||
|
||||
```bash
|
||||
docker run -p 3000:3000 -p 3001:3001 ruvnet/wifi-densepose:latest
|
||||
```
|
||||
|
||||
The `-p 3000:3000` maps host port 3000 to container port 3000.
|
||||
|
||||
### Docker: No WebSocket data in UI
|
||||
|
||||
Add the WebSocket port mapping:
|
||||
|
||||
```bash
|
||||
docker run -p 3000:3000 -p 3001:3001 ruvnet/wifi-densepose:latest
|
||||
```
|
||||
|
||||
### ESP32: No data arriving
|
||||
|
||||
1. Verify the ESP32 is connected to the same WiFi network
|
||||
2. Check the target IP matches the sensing server machine: `python scripts/provision.py --port COM7 --target-ip <YOUR_IP>`
|
||||
3. Verify UDP port 5005 is not blocked by firewall
|
||||
4. Test with: `nc -lu 5005` (Linux) or similar UDP listener
|
||||
|
||||
### Build: Rust compilation errors
|
||||
|
||||
Ensure Rust 1.70+ is installed:
|
||||
```bash
|
||||
rustup update stable
|
||||
rustc --version
|
||||
```
|
||||
|
||||
### Windows: RSSI mode shows no data
|
||||
|
||||
Run the terminal as Administrator (required for `netsh wlan` access).
|
||||
|
||||
### Vital signs show 0 BPM
|
||||
|
||||
- Vital sign detection requires CSI-capable hardware (ESP32 or research NIC)
|
||||
- RSSI-only mode (Windows WiFi) does not have sufficient resolution for vital signs
|
||||
- In simulated mode, synthetic vital signs are generated after a few seconds of warm-up
|
||||
|
||||
---
|
||||
|
||||
## FAQ
|
||||
|
||||
**Q: Do I need special hardware to try this?**
|
||||
No. Run `docker run -p 3000:3000 ruvnet/wifi-densepose:latest` and open `http://localhost:3000`. Simulated mode exercises the full pipeline with synthetic data.
|
||||
|
||||
**Q: Can consumer WiFi laptops do pose estimation?**
|
||||
No. Consumer WiFi exposes only RSSI (one number per access point), not CSI (56+ complex subcarrier values per frame). RSSI supports coarse presence and motion detection. Full pose estimation requires CSI-capable hardware like an ESP32-S3 ($8) or a research NIC.
|
||||
|
||||
**Q: How accurate is the pose estimation?**
|
||||
Accuracy depends on hardware and environment. With a 3-node ESP32 mesh in a single room, the system tracks 17 COCO keypoints. The core algorithm follows the CMU "DensePose From WiFi" paper ([arXiv:2301.00250](https://arxiv.org/abs/2301.00250)). The MERIDIAN domain generalization system (ADR-027) reduces cross-environment accuracy loss from 40-70% to under 15% via 10-second automatic calibration.
|
||||
|
||||
**Q: Does it work through walls?**
|
||||
Yes. WiFi signals penetrate non-metallic materials (drywall, wood, concrete up to ~30cm). Metal walls/doors significantly attenuate the signal. The effective through-wall range is approximately 5 meters.
|
||||
|
||||
**Q: How many people can it track?**
|
||||
Each access point can distinguish ~3-5 people with 56 subcarriers. Multi-AP deployments multiply linearly (e.g., 4 APs cover ~15-20 people). There is no hard software limit; the practical ceiling is signal physics.
|
||||
|
||||
**Q: Is this privacy-preserving?**
|
||||
The system uses WiFi radio signals, not cameras. No images or video are captured or stored. However, it does track human position, movement, and vital signs, which is personal data subject to applicable privacy regulations.
|
||||
|
||||
**Q: What's the Python vs Rust difference?**
|
||||
The Rust implementation (v2) is 810x faster than Python (v1) for the full CSI pipeline. The Docker image is 132 MB vs 569 MB. Rust is the primary and recommended runtime. Python v1 remains available for legacy workflows.
|
||||
|
||||
---
|
||||
|
||||
## Further Reading
|
||||
|
||||
- [Architecture Decision Records](../docs/adr/) - 27 ADRs covering all design decisions
|
||||
- [WiFi-Mat Disaster Response Guide](wifi-mat-user-guide.md) - Search & rescue module
|
||||
- [Build Guide](build-guide.md) - Detailed build instructions
|
||||
- [RuVector](https://github.com/ruvnet/ruvector) - Signal intelligence crate ecosystem
|
||||
- [CMU DensePose From WiFi](https://arxiv.org/abs/2301.00250) - The foundational research paper
|
||||
@@ -1 +0,0 @@
|
||||
EXPO_PUBLIC_DEFAULT_SERVER_URL=http://192.168.1.100:8080
|
||||
@@ -1,26 +0,0 @@
|
||||
module.exports = {
|
||||
root: true,
|
||||
parser: '@typescript-eslint/parser',
|
||||
parserOptions: {
|
||||
ecmaVersion: 'latest',
|
||||
sourceType: 'module',
|
||||
ecmaFeatures: {
|
||||
jsx: true,
|
||||
},
|
||||
},
|
||||
plugins: ['@typescript-eslint', 'react', 'react-hooks'],
|
||||
extends: [
|
||||
'eslint:recommended',
|
||||
'plugin:react/recommended',
|
||||
'plugin:react-hooks/recommended',
|
||||
'plugin:@typescript-eslint/recommended',
|
||||
],
|
||||
settings: {
|
||||
react: {
|
||||
version: 'detect',
|
||||
},
|
||||
},
|
||||
rules: {
|
||||
'react/react-in-jsx-scope': 'off',
|
||||
},
|
||||
};
|
||||
41
mobile/.gitignore
vendored
41
mobile/.gitignore
vendored
@@ -1,41 +0,0 @@
|
||||
# Learn more https://docs.github.com/en/get-started/getting-started-with-git/ignoring-files
|
||||
|
||||
# dependencies
|
||||
node_modules/
|
||||
|
||||
# Expo
|
||||
.expo/
|
||||
dist/
|
||||
web-build/
|
||||
expo-env.d.ts
|
||||
|
||||
# Native
|
||||
.kotlin/
|
||||
*.orig.*
|
||||
*.jks
|
||||
*.p8
|
||||
*.p12
|
||||
*.key
|
||||
*.mobileprovision
|
||||
|
||||
# Metro
|
||||
.metro-health-check*
|
||||
|
||||
# debug
|
||||
npm-debug.*
|
||||
yarn-debug.*
|
||||
yarn-error.*
|
||||
|
||||
# macOS
|
||||
.DS_Store
|
||||
*.pem
|
||||
|
||||
# local env files
|
||||
.env*.local
|
||||
|
||||
# typescript
|
||||
*.tsbuildinfo
|
||||
|
||||
# generated native folders
|
||||
/ios
|
||||
/android
|
||||
@@ -1,4 +0,0 @@
|
||||
{
|
||||
"singleQuote": true,
|
||||
"trailingComma": "all"
|
||||
}
|
||||
@@ -1,74 +0,0 @@
|
||||
import { useEffect } from 'react';
|
||||
import { NavigationContainer, DarkTheme } from '@react-navigation/native';
|
||||
import { GestureHandlerRootView } from 'react-native-gesture-handler';
|
||||
import { StatusBar } from 'expo-status-bar';
|
||||
import { SafeAreaProvider } from 'react-native-safe-area-context';
|
||||
import { apiService } from '@/services/api.service';
|
||||
import { rssiService } from '@/services/rssi.service';
|
||||
import { wsService } from '@/services/ws.service';
|
||||
import { ThemeProvider } from './src/theme/ThemeContext';
|
||||
import { usePoseStore } from './src/stores/poseStore';
|
||||
import { useSettingsStore } from './src/stores/settingsStore';
|
||||
import { RootNavigator } from './src/navigation/RootNavigator';
|
||||
|
||||
export default function App() {
|
||||
const serverUrl = useSettingsStore((state) => state.serverUrl);
|
||||
const rssiScanEnabled = useSettingsStore((state) => state.rssiScanEnabled);
|
||||
|
||||
useEffect(() => {
|
||||
apiService.setBaseUrl(serverUrl);
|
||||
const unsubscribe = wsService.subscribe(usePoseStore.getState().handleFrame);
|
||||
wsService.connect(serverUrl);
|
||||
|
||||
return () => {
|
||||
unsubscribe();
|
||||
wsService.disconnect();
|
||||
};
|
||||
}, [serverUrl]);
|
||||
|
||||
useEffect(() => {
|
||||
if (!rssiScanEnabled) {
|
||||
rssiService.stopScanning();
|
||||
return;
|
||||
}
|
||||
|
||||
const unsubscribe = rssiService.subscribe(() => {
|
||||
// Consumers can subscribe elsewhere for RSSI events.
|
||||
});
|
||||
rssiService.startScanning(2000);
|
||||
|
||||
return () => {
|
||||
unsubscribe();
|
||||
rssiService.stopScanning();
|
||||
};
|
||||
}, [rssiScanEnabled]);
|
||||
|
||||
useEffect(() => {
|
||||
(globalThis as { __appStartTime?: number }).__appStartTime = Date.now();
|
||||
}, []);
|
||||
|
||||
const navigationTheme = {
|
||||
...DarkTheme,
|
||||
colors: {
|
||||
...DarkTheme.colors,
|
||||
background: '#0A0E1A',
|
||||
card: '#0D1117',
|
||||
text: '#E2E8F0',
|
||||
border: '#1E293B',
|
||||
primary: '#32B8C6',
|
||||
},
|
||||
};
|
||||
|
||||
return (
|
||||
<GestureHandlerRootView style={{ flex: 1 }}>
|
||||
<SafeAreaProvider>
|
||||
<ThemeProvider>
|
||||
<NavigationContainer theme={navigationTheme}>
|
||||
<RootNavigator />
|
||||
</NavigationContainer>
|
||||
</ThemeProvider>
|
||||
</SafeAreaProvider>
|
||||
<StatusBar style="light" />
|
||||
</GestureHandlerRootView>
|
||||
);
|
||||
}
|
||||
@@ -1,12 +0,0 @@
|
||||
export default {
|
||||
name: 'WiFi-DensePose',
|
||||
slug: 'wifi-densepose',
|
||||
version: '1.0.0',
|
||||
ios: {
|
||||
bundleIdentifier: 'com.ruvnet.wifidensepose',
|
||||
},
|
||||
android: {
|
||||
package: 'com.ruvnet.wifidensepose',
|
||||
},
|
||||
// Use expo-env and app-level defaults from the project configuration when available.
|
||||
};
|
||||
@@ -1,30 +0,0 @@
|
||||
{
|
||||
"expo": {
|
||||
"name": "mobile",
|
||||
"slug": "mobile",
|
||||
"version": "1.0.0",
|
||||
"orientation": "portrait",
|
||||
"icon": "./assets/icon.png",
|
||||
"userInterfaceStyle": "light",
|
||||
"splash": {
|
||||
"image": "./assets/splash-icon.png",
|
||||
"resizeMode": "contain",
|
||||
"backgroundColor": "#ffffff"
|
||||
},
|
||||
"ios": {
|
||||
"supportsTablet": true
|
||||
},
|
||||
"android": {
|
||||
"adaptiveIcon": {
|
||||
"backgroundColor": "#E6F4FE",
|
||||
"foregroundImage": "./assets/android-icon-foreground.png",
|
||||
"backgroundImage": "./assets/android-icon-background.png",
|
||||
"monochromeImage": "./assets/android-icon-monochrome.png"
|
||||
},
|
||||
"predictiveBackGestureEnabled": false
|
||||
},
|
||||
"web": {
|
||||
"favicon": "./assets/favicon.png"
|
||||
}
|
||||
}
|
||||
}
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 17 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 77 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 4.0 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 1.1 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 384 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 17 KiB |
@@ -1,9 +0,0 @@
|
||||
module.exports = function (api) {
|
||||
api.cache(true);
|
||||
return {
|
||||
presets: ['babel-preset-expo'],
|
||||
plugins: [
|
||||
'react-native-reanimated/plugin'
|
||||
]
|
||||
};
|
||||
};
|
||||
@@ -1,17 +0,0 @@
|
||||
{
|
||||
"cli": {
|
||||
"version": ">= 4.0.0"
|
||||
},
|
||||
"build": {
|
||||
"development": {
|
||||
"developmentClient": true,
|
||||
"distribution": "internal"
|
||||
},
|
||||
"preview": {
|
||||
"distribution": "internal"
|
||||
},
|
||||
"production": {
|
||||
"autoIncrement": true
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,4 +0,0 @@
|
||||
import { registerRootComponent } from 'expo';
|
||||
import App from './App';
|
||||
|
||||
registerRootComponent(App);
|
||||
@@ -1,8 +0,0 @@
|
||||
module.exports = {
|
||||
preset: 'jest-expo',
|
||||
setupFilesAfterEnv: ['<rootDir>/jest.setup.ts'],
|
||||
testPathIgnorePatterns: ['/src/__tests__/'],
|
||||
transformIgnorePatterns: [
|
||||
'node_modules/(?!(expo|expo-.+|react-native|@react-native|react-native-webview|react-native-reanimated|react-native-svg|react-native-safe-area-context|react-native-screens|@react-navigation|@expo|@unimodules|expo-modules-core)/)',
|
||||
],
|
||||
};
|
||||
@@ -1,24 +0,0 @@
|
||||
jest.mock('@react-native-async-storage/async-storage', () =>
|
||||
require('@react-native-async-storage/async-storage/jest/async-storage-mock')
|
||||
);
|
||||
|
||||
jest.mock('react-native-wifi-reborn', () => ({
|
||||
loadWifiList: jest.fn(async () => []),
|
||||
}));
|
||||
|
||||
jest.mock('react-native-reanimated', () =>
|
||||
require('react-native-reanimated/mock')
|
||||
);
|
||||
|
||||
jest.mock('react-native-webview', () => {
|
||||
const React = require('react');
|
||||
const { View } = require('react-native');
|
||||
|
||||
const MockWebView = (props: unknown) => React.createElement(View, props);
|
||||
|
||||
return {
|
||||
__esModule: true,
|
||||
default: MockWebView,
|
||||
WebView: MockWebView,
|
||||
};
|
||||
});
|
||||
16327
mobile/package-lock.json
generated
16327
mobile/package-lock.json
generated
File diff suppressed because it is too large
Load Diff
@@ -1,49 +0,0 @@
|
||||
{
|
||||
"name": "mobile",
|
||||
"version": "1.0.0",
|
||||
"main": "index.ts",
|
||||
"scripts": {
|
||||
"start": "expo start",
|
||||
"android": "expo start --android",
|
||||
"ios": "expo start --ios",
|
||||
"web": "expo start --web",
|
||||
"test": "jest",
|
||||
"lint": "eslint ."
|
||||
},
|
||||
"dependencies": {
|
||||
"@expo/vector-icons": "^15.0.2",
|
||||
"@react-native-async-storage/async-storage": "2.2.0",
|
||||
"@react-navigation/bottom-tabs": "^7.15.3",
|
||||
"@react-navigation/native": "^7.1.31",
|
||||
"axios": "^1.13.6",
|
||||
"expo": "~55.0.4",
|
||||
"expo-status-bar": "~55.0.4",
|
||||
"react": "19.2.0",
|
||||
"react-native": "0.83.2",
|
||||
"react-native-gesture-handler": "~2.30.0",
|
||||
"react-native-reanimated": "4.2.1",
|
||||
"react-native-safe-area-context": "~5.6.2",
|
||||
"react-native-screens": "~4.23.0",
|
||||
"react-native-svg": "15.15.3",
|
||||
"react-native-webview": "13.16.0",
|
||||
"react-native-wifi-reborn": "^4.13.6",
|
||||
"victory-native": "^41.20.2",
|
||||
"zustand": "^5.0.11"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@testing-library/jest-native": "^5.4.3",
|
||||
"@testing-library/react-native": "^13.3.3",
|
||||
"@types/jest": "^30.0.0",
|
||||
"@types/react": "~19.2.2",
|
||||
"@typescript-eslint/eslint-plugin": "^8.56.1",
|
||||
"@typescript-eslint/parser": "^8.56.1",
|
||||
"babel-preset-expo": "^55.0.10",
|
||||
"eslint": "^10.0.2",
|
||||
"jest": "^30.2.0",
|
||||
"jest-expo": "^55.0.9",
|
||||
"prettier": "^3.8.1",
|
||||
"react-native-worklets": "^0.7.4",
|
||||
"typescript": "~5.9.2"
|
||||
},
|
||||
"private": true
|
||||
}
|
||||
@@ -1,5 +0,0 @@
|
||||
describe('placeholder', () => {
|
||||
it('passes', () => {
|
||||
expect(true).toBe(true);
|
||||
});
|
||||
});
|
||||
@@ -1,5 +0,0 @@
|
||||
describe('placeholder', () => {
|
||||
it('passes', () => {
|
||||
expect(true).toBe(true);
|
||||
});
|
||||
});
|
||||
@@ -1,5 +0,0 @@
|
||||
describe('placeholder', () => {
|
||||
it('passes', () => {
|
||||
expect(true).toBe(true);
|
||||
});
|
||||
});
|
||||
@@ -1,5 +0,0 @@
|
||||
describe('placeholder', () => {
|
||||
it('passes', () => {
|
||||
expect(true).toBe(true);
|
||||
});
|
||||
});
|
||||
@@ -1,5 +0,0 @@
|
||||
describe('placeholder', () => {
|
||||
it('passes', () => {
|
||||
expect(true).toBe(true);
|
||||
});
|
||||
});
|
||||
@@ -1,5 +0,0 @@
|
||||
describe('placeholder', () => {
|
||||
it('passes', () => {
|
||||
expect(true).toBe(true);
|
||||
});
|
||||
});
|
||||
@@ -1,5 +0,0 @@
|
||||
describe('placeholder', () => {
|
||||
it('passes', () => {
|
||||
expect(true).toBe(true);
|
||||
});
|
||||
});
|
||||
@@ -1,5 +0,0 @@
|
||||
describe('placeholder', () => {
|
||||
it('passes', () => {
|
||||
expect(true).toBe(true);
|
||||
});
|
||||
});
|
||||
@@ -1,5 +0,0 @@
|
||||
describe('placeholder', () => {
|
||||
it('passes', () => {
|
||||
expect(true).toBe(true);
|
||||
});
|
||||
});
|
||||
@@ -1,5 +0,0 @@
|
||||
describe('placeholder', () => {
|
||||
it('passes', () => {
|
||||
expect(true).toBe(true);
|
||||
});
|
||||
});
|
||||
@@ -1,5 +0,0 @@
|
||||
describe('placeholder', () => {
|
||||
it('passes', () => {
|
||||
expect(true).toBe(true);
|
||||
});
|
||||
});
|
||||
@@ -1,5 +0,0 @@
|
||||
describe('placeholder', () => {
|
||||
it('passes', () => {
|
||||
expect(true).toBe(true);
|
||||
});
|
||||
});
|
||||
@@ -1,5 +0,0 @@
|
||||
describe('placeholder', () => {
|
||||
it('passes', () => {
|
||||
expect(true).toBe(true);
|
||||
});
|
||||
});
|
||||
@@ -1,5 +0,0 @@
|
||||
describe('placeholder', () => {
|
||||
it('passes', () => {
|
||||
expect(true).toBe(true);
|
||||
});
|
||||
});
|
||||
@@ -1,5 +0,0 @@
|
||||
describe('placeholder', () => {
|
||||
it('passes', () => {
|
||||
expect(true).toBe(true);
|
||||
});
|
||||
});
|
||||
@@ -1,5 +0,0 @@
|
||||
describe('placeholder', () => {
|
||||
it('passes', () => {
|
||||
expect(true).toBe(true);
|
||||
});
|
||||
});
|
||||
@@ -1,5 +0,0 @@
|
||||
describe('placeholder', () => {
|
||||
it('passes', () => {
|
||||
expect(true).toBe(true);
|
||||
});
|
||||
});
|
||||
@@ -1,5 +0,0 @@
|
||||
describe('placeholder', () => {
|
||||
it('passes', () => {
|
||||
expect(true).toBe(true);
|
||||
});
|
||||
});
|
||||
@@ -1,5 +0,0 @@
|
||||
describe('placeholder', () => {
|
||||
it('passes', () => {
|
||||
expect(true).toBe(true);
|
||||
});
|
||||
});
|
||||
@@ -1,5 +0,0 @@
|
||||
describe('placeholder', () => {
|
||||
it('passes', () => {
|
||||
expect(true).toBe(true);
|
||||
});
|
||||
});
|
||||
@@ -1,5 +0,0 @@
|
||||
describe('placeholder', () => {
|
||||
it('passes', () => {
|
||||
expect(true).toBe(true);
|
||||
});
|
||||
});
|
||||
@@ -1,5 +0,0 @@
|
||||
describe('placeholder', () => {
|
||||
it('passes', () => {
|
||||
expect(true).toBe(true);
|
||||
});
|
||||
});
|
||||
@@ -1,36 +0,0 @@
|
||||
import React, { PropsWithChildren } from 'react';
|
||||
import { render, type RenderOptions } from '@testing-library/react-native';
|
||||
import { NavigationContainer } from '@react-navigation/native';
|
||||
import { GestureHandlerRootView } from 'react-native-gesture-handler';
|
||||
import { SafeAreaProvider } from 'react-native-safe-area-context';
|
||||
import { ThemeProvider } from '@/theme/ThemeContext';
|
||||
|
||||
type TestProvidersProps = PropsWithChildren<object>;
|
||||
|
||||
const TestProviders = ({ children }: TestProvidersProps) => (
|
||||
<GestureHandlerRootView style={{ flex: 1 }}>
|
||||
<SafeAreaProvider>
|
||||
<ThemeProvider>{children}</ThemeProvider>
|
||||
</SafeAreaProvider>
|
||||
</GestureHandlerRootView>
|
||||
);
|
||||
|
||||
const TestProvidersWithNavigation = ({ children }: TestProvidersProps) => (
|
||||
<TestProviders>
|
||||
<NavigationContainer>{children}</NavigationContainer>
|
||||
</TestProviders>
|
||||
);
|
||||
|
||||
interface RenderWithProvidersOptions extends Omit<RenderOptions, 'wrapper'> {
|
||||
withNavigation?: boolean;
|
||||
}
|
||||
|
||||
export const renderWithProviders = (
|
||||
ui: React.ReactElement,
|
||||
{ withNavigation, ...options }: RenderWithProvidersOptions = {},
|
||||
) => {
|
||||
return render(ui, {
|
||||
...options,
|
||||
wrapper: withNavigation ? TestProvidersWithNavigation : TestProviders,
|
||||
});
|
||||
};
|
||||
@@ -1,5 +0,0 @@
|
||||
describe('placeholder', () => {
|
||||
it('passes', () => {
|
||||
expect(true).toBe(true);
|
||||
});
|
||||
});
|
||||
@@ -1,5 +0,0 @@
|
||||
describe('placeholder', () => {
|
||||
it('passes', () => {
|
||||
expect(true).toBe(true);
|
||||
});
|
||||
});
|
||||
@@ -1,5 +0,0 @@
|
||||
describe('placeholder', () => {
|
||||
it('passes', () => {
|
||||
expect(true).toBe(true);
|
||||
});
|
||||
});
|
||||
@@ -1,585 +0,0 @@
|
||||
<!DOCTYPE html>
|
||||
<html lang="en">
|
||||
<head>
|
||||
<meta charset="UTF-8" />
|
||||
<meta
|
||||
name="viewport"
|
||||
content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no"
|
||||
/>
|
||||
<meta
|
||||
http-equiv="Content-Security-Policy"
|
||||
content="default-src 'self'; script-src 'self' https://cdnjs.cloudflare.com https://cdn.jsdelivr.net; style-src 'self' 'unsafe-inline'; img-src 'self' data:; connect-src 'self'"
|
||||
/>
|
||||
<title>WiFi DensePose Splat Viewer</title>
|
||||
<style>
|
||||
html,
|
||||
body,
|
||||
#gaussian-splat-root {
|
||||
margin: 0;
|
||||
width: 100%;
|
||||
height: 100%;
|
||||
overflow: hidden;
|
||||
background: #0a0e1a;
|
||||
touch-action: none;
|
||||
}
|
||||
|
||||
#gaussian-splat-root {
|
||||
position: relative;
|
||||
}
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
<div id="gaussian-splat-root"></div>
|
||||
|
||||
<script src="https://cdnjs.cloudflare.com/ajax/libs/three.js/r165/three.min.js"></script>
|
||||
<script src="https://cdn.jsdelivr.net/npm/three@0.165.0/examples/js/controls/OrbitControls.js"></script>
|
||||
|
||||
<script>
|
||||
(function () {
|
||||
const postMessageToRN = (message) => {
|
||||
if (!window.ReactNativeWebView || typeof window.ReactNativeWebView.postMessage !== 'function') {
|
||||
return;
|
||||
}
|
||||
|
||||
try {
|
||||
window.ReactNativeWebView.postMessage(JSON.stringify(message));
|
||||
} catch (error) {
|
||||
console.error('Failed to post RN message', error);
|
||||
}
|
||||
};
|
||||
|
||||
const postError = (message) => {
|
||||
postMessageToRN({
|
||||
type: 'ERROR',
|
||||
payload: {
|
||||
message: typeof message === 'string' ? message : 'Unknown bridge error',
|
||||
},
|
||||
});
|
||||
};
|
||||
|
||||
// Use global THREE from CDN
|
||||
const getThree = () => window.THREE;
|
||||
|
||||
// ---- Custom Splat Shaders --------------------------------------------
|
||||
|
||||
const SPLAT_VERTEX = `
|
||||
attribute float splatSize;
|
||||
attribute vec3 splatColor;
|
||||
attribute float splatOpacity;
|
||||
|
||||
varying vec3 vColor;
|
||||
varying float vOpacity;
|
||||
|
||||
void main() {
|
||||
vColor = splatColor;
|
||||
vOpacity = splatOpacity;
|
||||
|
||||
vec4 mvPosition = modelViewMatrix * vec4(position, 1.0);
|
||||
gl_PointSize = splatSize * (300.0 / -mvPosition.z);
|
||||
gl_Position = projectionMatrix * mvPosition;
|
||||
}
|
||||
`;
|
||||
|
||||
const SPLAT_FRAGMENT = `
|
||||
varying vec3 vColor;
|
||||
varying float vOpacity;
|
||||
|
||||
void main() {
|
||||
// Circular soft-edge disc
|
||||
float dist = length(gl_PointCoord - vec2(0.5));
|
||||
if (dist > 0.5) discard;
|
||||
float alpha = smoothstep(0.5, 0.2, dist) * vOpacity;
|
||||
gl_FragColor = vec4(vColor, alpha);
|
||||
}
|
||||
`;
|
||||
|
||||
// ---- Color helpers ---------------------------------------------------
|
||||
|
||||
/** Map a scalar 0-1 to blue -> green -> red gradient */
|
||||
function valueToColor(v) {
|
||||
const clamped = Math.max(0, Math.min(1, v));
|
||||
// blue(0) -> cyan(0.25) -> green(0.5) -> yellow(0.75) -> red(1)
|
||||
let r;
|
||||
let g;
|
||||
let b;
|
||||
if (clamped < 0.5) {
|
||||
const t = clamped * 2;
|
||||
r = 0;
|
||||
g = t;
|
||||
b = 1 - t;
|
||||
} else {
|
||||
const t = (clamped - 0.5) * 2;
|
||||
r = t;
|
||||
g = 1 - t;
|
||||
b = 0;
|
||||
}
|
||||
return [r, g, b];
|
||||
}
|
||||
|
||||
// ---- GaussianSplatRenderer -------------------------------------------
|
||||
|
||||
class GaussianSplatRenderer {
|
||||
/** @param {HTMLElement} container - DOM element to attach the renderer to */
|
||||
constructor(container, opts = {}) {
|
||||
const THREE = getThree();
|
||||
if (!THREE) {
|
||||
throw new Error('Three.js not loaded');
|
||||
}
|
||||
|
||||
this.container = container;
|
||||
this.width = opts.width || container.clientWidth || 800;
|
||||
this.height = opts.height || 500;
|
||||
|
||||
// Scene
|
||||
this.scene = new THREE.Scene();
|
||||
this.scene.background = new THREE.Color(0x0a0e1a);
|
||||
|
||||
// Camera — perspective looking down at the room
|
||||
this.camera = new THREE.PerspectiveCamera(45, this.width / this.height, 0.1, 200);
|
||||
this.camera.position.set(0, 10, 12);
|
||||
this.camera.lookAt(0, 0, 0);
|
||||
|
||||
// Renderer
|
||||
this.renderer = new THREE.WebGLRenderer({ antialias: true, alpha: true });
|
||||
this.renderer.setSize(this.width, this.height);
|
||||
this.renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
|
||||
container.appendChild(this.renderer.domElement);
|
||||
|
||||
// Lights
|
||||
const ambient = new THREE.AmbientLight(0x9ec7ff, 0.35);
|
||||
this.scene.add(ambient);
|
||||
|
||||
const directional = new THREE.DirectionalLight(0x9ec7ff, 0.65);
|
||||
directional.position.set(4, 10, 6);
|
||||
directional.castShadow = false;
|
||||
this.scene.add(directional);
|
||||
|
||||
// Grid & room
|
||||
this._createRoom(THREE);
|
||||
|
||||
// Signal field splats (20x20 = 400 points on the floor plane)
|
||||
this.gridSize = 20;
|
||||
this._createFieldSplats(THREE);
|
||||
|
||||
// Node markers (ESP32 / router positions)
|
||||
this._createNodeMarkers(THREE);
|
||||
|
||||
// Body disruption blob
|
||||
this._createBodyBlob(THREE);
|
||||
|
||||
// Orbit controls for drag + pinch zoom
|
||||
this.controls = new THREE.OrbitControls(this.camera, this.renderer.domElement);
|
||||
this.controls.target.set(0, 0, 0);
|
||||
this.controls.minDistance = 6;
|
||||
this.controls.maxDistance = 40;
|
||||
this.controls.enableDamping = true;
|
||||
this.controls.dampingFactor = 0.08;
|
||||
this.controls.update();
|
||||
|
||||
// Animation state
|
||||
this._animFrame = null;
|
||||
this._lastData = null;
|
||||
this._fpsFrames = [];
|
||||
this._lastFpsReport = 0;
|
||||
|
||||
// Start render loop
|
||||
this._animate();
|
||||
}
|
||||
|
||||
// ---- Scene setup ---------------------------------------------------
|
||||
|
||||
_createRoom(THREE) {
|
||||
// Floor grid (on y = 0), 20 units
|
||||
const grid = new THREE.GridHelper(20, 20, 0x1a3a4a, 0x0d1f28);
|
||||
grid.position.y = 0;
|
||||
this.scene.add(grid);
|
||||
|
||||
// Room boundary wireframe
|
||||
const boxGeo = new THREE.BoxGeometry(20, 6, 20);
|
||||
const edges = new THREE.EdgesGeometry(boxGeo);
|
||||
const line = new THREE.LineSegments(
|
||||
edges,
|
||||
new THREE.LineBasicMaterial({ color: 0x1a4a5a, opacity: 0.3, transparent: true }),
|
||||
);
|
||||
line.position.y = 3;
|
||||
this.scene.add(line);
|
||||
}
|
||||
|
||||
_createFieldSplats(THREE) {
|
||||
const count = this.gridSize * this.gridSize;
|
||||
|
||||
const positions = new Float32Array(count * 3);
|
||||
const sizes = new Float32Array(count);
|
||||
const colors = new Float32Array(count * 3);
|
||||
const opacities = new Float32Array(count);
|
||||
|
||||
// Lay splats on the floor plane (y = 0.05 to sit just above grid)
|
||||
for (let iz = 0; iz < this.gridSize; iz++) {
|
||||
for (let ix = 0; ix < this.gridSize; ix++) {
|
||||
const idx = iz * this.gridSize + ix;
|
||||
positions[idx * 3 + 0] = (ix - this.gridSize / 2) + 0.5; // x
|
||||
positions[idx * 3 + 1] = 0.05; // y
|
||||
positions[idx * 3 + 2] = (iz - this.gridSize / 2) + 0.5; // z
|
||||
|
||||
sizes[idx] = 1.5;
|
||||
colors[idx * 3] = 0.1;
|
||||
colors[idx * 3 + 1] = 0.2;
|
||||
colors[idx * 3 + 2] = 0.6;
|
||||
opacities[idx] = 0.15;
|
||||
}
|
||||
}
|
||||
|
||||
const geo = new THREE.BufferGeometry();
|
||||
geo.setAttribute('position', new THREE.BufferAttribute(positions, 3));
|
||||
geo.setAttribute('splatSize', new THREE.BufferAttribute(sizes, 1));
|
||||
geo.setAttribute('splatColor', new THREE.BufferAttribute(colors, 3));
|
||||
geo.setAttribute('splatOpacity', new THREE.BufferAttribute(opacities, 1));
|
||||
|
||||
const mat = new THREE.ShaderMaterial({
|
||||
vertexShader: SPLAT_VERTEX,
|
||||
fragmentShader: SPLAT_FRAGMENT,
|
||||
transparent: true,
|
||||
depthWrite: false,
|
||||
blending: THREE.AdditiveBlending,
|
||||
});
|
||||
|
||||
this.fieldPoints = new THREE.Points(geo, mat);
|
||||
this.scene.add(this.fieldPoints);
|
||||
}
|
||||
|
||||
_createNodeMarkers(THREE) {
|
||||
// Router at center — green sphere
|
||||
const routerGeo = new THREE.SphereGeometry(0.3, 16, 16);
|
||||
const routerMat = new THREE.MeshBasicMaterial({ color: 0x00ff88, transparent: true, opacity: 0.8 });
|
||||
this.routerMarker = new THREE.Mesh(routerGeo, routerMat);
|
||||
this.routerMarker.position.set(0, 0.5, 0);
|
||||
this.scene.add(this.routerMarker);
|
||||
|
||||
// ESP32 node — cyan sphere (default position, updated from data)
|
||||
const nodeGeo = new THREE.SphereGeometry(0.25, 16, 16);
|
||||
const nodeMat = new THREE.MeshBasicMaterial({ color: 0x00ccff, transparent: true, opacity: 0.8 });
|
||||
this.nodeMarker = new THREE.Mesh(nodeGeo, nodeMat);
|
||||
this.nodeMarker.position.set(2, 0.5, 1.5);
|
||||
this.scene.add(this.nodeMarker);
|
||||
}
|
||||
|
||||
_createBodyBlob(THREE) {
|
||||
// A cluster of splats representing body disruption
|
||||
const count = 64;
|
||||
const positions = new Float32Array(count * 3);
|
||||
const sizes = new Float32Array(count);
|
||||
const colors = new Float32Array(count * 3);
|
||||
const opacities = new Float32Array(count);
|
||||
|
||||
for (let i = 0; i < count; i++) {
|
||||
// Random sphere distribution
|
||||
const theta = Math.random() * Math.PI * 2;
|
||||
const phi = Math.acos(2 * Math.random() - 1);
|
||||
const r = Math.random() * 1.5;
|
||||
positions[i * 3] = r * Math.sin(phi) * Math.cos(theta);
|
||||
positions[i * 3 + 1] = r * Math.cos(phi) + 2;
|
||||
positions[i * 3 + 2] = r * Math.sin(phi) * Math.sin(theta);
|
||||
|
||||
sizes[i] = 2 + Math.random() * 3;
|
||||
colors[i * 3] = 0.2;
|
||||
colors[i * 3 + 1] = 0.8;
|
||||
colors[i * 3 + 2] = 0.3;
|
||||
opacities[i] = 0.0; // hidden until presence detected
|
||||
}
|
||||
|
||||
const geo = new THREE.BufferGeometry();
|
||||
geo.setAttribute('position', new THREE.BufferAttribute(positions, 3));
|
||||
geo.setAttribute('splatSize', new THREE.BufferAttribute(sizes, 1));
|
||||
geo.setAttribute('splatColor', new THREE.BufferAttribute(colors, 3));
|
||||
geo.setAttribute('splatOpacity', new THREE.BufferAttribute(opacities, 1));
|
||||
|
||||
const mat = new THREE.ShaderMaterial({
|
||||
vertexShader: SPLAT_VERTEX,
|
||||
fragmentShader: SPLAT_FRAGMENT,
|
||||
transparent: true,
|
||||
depthWrite: false,
|
||||
blending: THREE.AdditiveBlending,
|
||||
});
|
||||
|
||||
this.bodyBlob = new THREE.Points(geo, mat);
|
||||
this.scene.add(this.bodyBlob);
|
||||
}
|
||||
|
||||
// ---- Data update --------------------------------------------------
|
||||
|
||||
/**
|
||||
* Update the visualization with new sensing data.
|
||||
* @param {object} data - sensing_update JSON from ws_server
|
||||
*/
|
||||
update(data) {
|
||||
this._lastData = data;
|
||||
if (!data) return;
|
||||
|
||||
const features = data.features || {};
|
||||
const classification = data.classification || {};
|
||||
const signalField = data.signal_field || {};
|
||||
const nodes = data.nodes || [];
|
||||
|
||||
// -- Update signal field splats ------------------------------------
|
||||
if (signalField.values && this.fieldPoints) {
|
||||
const geo = this.fieldPoints.geometry;
|
||||
const clr = geo.attributes.splatColor.array;
|
||||
const sizes = geo.attributes.splatSize.array;
|
||||
const opac = geo.attributes.splatOpacity.array;
|
||||
const vals = signalField.values;
|
||||
const count = Math.min(vals.length, this.gridSize * this.gridSize);
|
||||
|
||||
for (let i = 0; i < count; i++) {
|
||||
const v = vals[i];
|
||||
const [r, g, b] = valueToColor(v);
|
||||
clr[i * 3] = r;
|
||||
clr[i * 3 + 1] = g;
|
||||
clr[i * 3 + 2] = b;
|
||||
sizes[i] = 1.0 + v * 4.0;
|
||||
opac[i] = 0.1 + v * 0.6;
|
||||
}
|
||||
|
||||
geo.attributes.splatColor.needsUpdate = true;
|
||||
geo.attributes.splatSize.needsUpdate = true;
|
||||
geo.attributes.splatOpacity.needsUpdate = true;
|
||||
}
|
||||
|
||||
// -- Update body blob ----------------------------------------------
|
||||
if (this.bodyBlob) {
|
||||
const bGeo = this.bodyBlob.geometry;
|
||||
const bOpac = bGeo.attributes.splatOpacity.array;
|
||||
const bClr = bGeo.attributes.splatColor.array;
|
||||
const bSize = bGeo.attributes.splatSize.array;
|
||||
|
||||
const presence = classification.presence || false;
|
||||
const motionLvl = classification.motion_level || 'absent';
|
||||
const confidence = classification.confidence || 0;
|
||||
const breathing = features.breathing_band_power || 0;
|
||||
|
||||
// Breathing pulsation
|
||||
const breathPulse = 1.0 + Math.sin(Date.now() * 0.004) * Math.min(breathing * 3, 0.4);
|
||||
|
||||
for (let i = 0; i < bOpac.length; i++) {
|
||||
if (presence) {
|
||||
bOpac[i] = confidence * 0.4;
|
||||
|
||||
// Color by motion level
|
||||
if (motionLvl === 'active') {
|
||||
bClr[i * 3] = 1.0;
|
||||
bClr[i * 3 + 1] = 0.2;
|
||||
bClr[i * 3 + 2] = 0.1;
|
||||
} else {
|
||||
bClr[i * 3] = 0.1;
|
||||
bClr[i * 3 + 1] = 0.8;
|
||||
bClr[i * 3 + 2] = 0.4;
|
||||
}
|
||||
|
||||
bSize[i] = (2 + Math.random() * 2) * breathPulse;
|
||||
} else {
|
||||
bOpac[i] = 0.0;
|
||||
}
|
||||
}
|
||||
|
||||
bGeo.attributes.splatOpacity.needsUpdate = true;
|
||||
bGeo.attributes.splatColor.needsUpdate = true;
|
||||
bGeo.attributes.splatSize.needsUpdate = true;
|
||||
}
|
||||
|
||||
// -- Update node positions -----------------------------------------
|
||||
if (nodes.length > 0 && nodes[0].position && this.nodeMarker) {
|
||||
const pos = nodes[0].position;
|
||||
this.nodeMarker.position.set(pos[0], 0.5, pos[2]);
|
||||
}
|
||||
}
|
||||
|
||||
// ---- Render loop -------------------------------------------------
|
||||
|
||||
_animate() {
|
||||
this._animFrame = requestAnimationFrame(() => this._animate());
|
||||
|
||||
const now = performance.now();
|
||||
|
||||
// Gentle router glow pulse
|
||||
if (this.routerMarker) {
|
||||
const pulse = 0.6 + 0.3 * Math.sin(now * 0.003);
|
||||
this.routerMarker.material.opacity = pulse;
|
||||
}
|
||||
|
||||
this.controls.update();
|
||||
this.renderer.render(this.scene, this.camera);
|
||||
|
||||
this._fpsFrames.push(now);
|
||||
while (this._fpsFrames.length > 0 && this._fpsFrames[0] < now - 1000) {
|
||||
this._fpsFrames.shift();
|
||||
}
|
||||
|
||||
if (now - this._lastFpsReport >= 1000) {
|
||||
const fps = this._fpsFrames.length;
|
||||
this._lastFpsReport = now;
|
||||
postMessageToRN({
|
||||
type: 'FPS_TICK',
|
||||
payload: { fps },
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
// ---- Resize / cleanup --------------------------------------------
|
||||
|
||||
resize(width, height) {
|
||||
if (!width || !height) return;
|
||||
this.width = width;
|
||||
this.height = height;
|
||||
this.camera.aspect = width / height;
|
||||
this.camera.updateProjectionMatrix();
|
||||
this.renderer.setSize(width, height);
|
||||
}
|
||||
|
||||
dispose() {
|
||||
if (this._animFrame) {
|
||||
cancelAnimationFrame(this._animFrame);
|
||||
}
|
||||
|
||||
this.controls?.dispose();
|
||||
this.renderer.dispose();
|
||||
if (this.renderer.domElement.parentNode) {
|
||||
this.renderer.domElement.parentNode.removeChild(this.renderer.domElement);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Expose renderer constructor for debugging/interop
|
||||
window.GaussianSplatRenderer = GaussianSplatRenderer;
|
||||
|
||||
let renderer = null;
|
||||
let pendingFrame = null;
|
||||
let pendingResize = null;
|
||||
|
||||
const postSafeReady = () => {
|
||||
postMessageToRN({ type: 'READY' });
|
||||
};
|
||||
|
||||
const routeMessage = (event) => {
|
||||
let raw = event.data;
|
||||
if (typeof raw === 'object' && raw != null && 'data' in raw) {
|
||||
raw = raw.data;
|
||||
}
|
||||
|
||||
let message = raw;
|
||||
if (typeof raw === 'string') {
|
||||
try {
|
||||
message = JSON.parse(raw);
|
||||
} catch (err) {
|
||||
postError('Failed to parse RN message payload');
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
if (!message || typeof message !== 'object') {
|
||||
return;
|
||||
}
|
||||
|
||||
if (message.type === 'FRAME_UPDATE') {
|
||||
const payload = message.payload || null;
|
||||
if (!payload) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (!renderer) {
|
||||
pendingFrame = payload;
|
||||
return;
|
||||
}
|
||||
|
||||
try {
|
||||
renderer.update(payload);
|
||||
} catch (error) {
|
||||
postError((error && error.message) || 'Failed to update frame');
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
if (message.type === 'RESIZE') {
|
||||
const dims = message.payload || {};
|
||||
const w = Number(dims.width);
|
||||
const h = Number(dims.height);
|
||||
if (!Number.isFinite(w) || !Number.isFinite(h) || !w || !h) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (!renderer) {
|
||||
pendingResize = { width: w, height: h };
|
||||
return;
|
||||
}
|
||||
|
||||
try {
|
||||
renderer.resize(w, h);
|
||||
} catch (error) {
|
||||
postError((error && error.message) || 'Failed to resize renderer');
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
if (message.type === 'DISPOSE') {
|
||||
if (!renderer) {
|
||||
return;
|
||||
}
|
||||
|
||||
try {
|
||||
renderer.dispose();
|
||||
} catch (error) {
|
||||
postError((error && error.message) || 'Failed to dispose renderer');
|
||||
}
|
||||
renderer = null;
|
||||
return;
|
||||
}
|
||||
};
|
||||
|
||||
const buildRenderer = () => {
|
||||
const container = document.getElementById('gaussian-splat-root');
|
||||
if (!container) {
|
||||
return;
|
||||
}
|
||||
|
||||
try {
|
||||
renderer = new GaussianSplatRenderer(container, {
|
||||
width: container.clientWidth || window.innerWidth,
|
||||
height: container.clientHeight || window.innerHeight,
|
||||
});
|
||||
|
||||
if (pendingFrame) {
|
||||
renderer.update(pendingFrame);
|
||||
pendingFrame = null;
|
||||
}
|
||||
|
||||
if (pendingResize) {
|
||||
renderer.resize(pendingResize.width, pendingResize.height);
|
||||
pendingResize = null;
|
||||
}
|
||||
|
||||
postSafeReady();
|
||||
} catch (error) {
|
||||
renderer = null;
|
||||
postError((error && error.message) || 'Failed to initialize renderer');
|
||||
}
|
||||
};
|
||||
|
||||
if (document.readyState === 'loading') {
|
||||
document.addEventListener('DOMContentLoaded', buildRenderer);
|
||||
} else {
|
||||
buildRenderer();
|
||||
}
|
||||
|
||||
window.addEventListener('message', routeMessage);
|
||||
window.addEventListener('resize', () => {
|
||||
if (!renderer) {
|
||||
pendingResize = {
|
||||
width: window.innerWidth,
|
||||
height: window.innerHeight,
|
||||
};
|
||||
return;
|
||||
}
|
||||
renderer.resize(window.innerWidth, window.innerHeight);
|
||||
});
|
||||
})();
|
||||
</script>
|
||||
</body>
|
||||
</html>
|
||||
@@ -1,505 +0,0 @@
|
||||
<!DOCTYPE html>
|
||||
<html lang="en">
|
||||
<head>
|
||||
<meta charset="UTF-8" />
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
|
||||
<title>MAT Dashboard</title>
|
||||
<style>
|
||||
* {
|
||||
box-sizing: border-box;
|
||||
}
|
||||
|
||||
html,
|
||||
body {
|
||||
margin: 0;
|
||||
width: 100%;
|
||||
height: 100%;
|
||||
background: #0a0e1a;
|
||||
color: #e5e7eb;
|
||||
font-family: 'Courier New', 'Consolas', monospace;
|
||||
overflow: hidden;
|
||||
}
|
||||
|
||||
#app {
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
gap: 8px;
|
||||
width: 100%;
|
||||
height: 100%;
|
||||
padding: 8px;
|
||||
}
|
||||
|
||||
#status {
|
||||
color: #6dd4df;
|
||||
font-size: 12px;
|
||||
letter-spacing: 0.5px;
|
||||
}
|
||||
|
||||
#mapCanvas {
|
||||
flex: 1;
|
||||
width: 100%;
|
||||
border: 1px solid #1e293b;
|
||||
border-radius: 8px;
|
||||
min-height: 180px;
|
||||
background: #0a0e1a;
|
||||
}
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
<div id="app">
|
||||
<div id="status">Initializing MAT dashboard...</div>
|
||||
<canvas id="mapCanvas"></canvas>
|
||||
</div>
|
||||
|
||||
<script>
|
||||
(function () {
|
||||
const TRIAGE = {
|
||||
Immediate: 0,
|
||||
Delayed: 1,
|
||||
Minimal: 2,
|
||||
Expectant: 3,
|
||||
Unknown: 4,
|
||||
};
|
||||
|
||||
const TRIAGE_COLOR = ['#ff0000', '#ffcc00', '#00cc00', '#111111', '#888888'];
|
||||
const PRIORITY = { Critical: 0, High: 1, Medium: 2, Low: 3 };
|
||||
|
||||
const toRgba = (status) => TRIAGE_COLOR[status] || TRIAGE_COLOR[4];
|
||||
const safeId = () =>
|
||||
typeof crypto !== 'undefined' && crypto.randomUUID
|
||||
? crypto.randomUUID()
|
||||
: `id-${Date.now()}-${Math.floor(Math.random() * 1e6)}`;
|
||||
|
||||
const isNumber = (value) => typeof value === 'number' && Number.isFinite(value);
|
||||
|
||||
class MatDashboard {
|
||||
constructor() {
|
||||
this.event = null;
|
||||
this.zones = new Map();
|
||||
this.survivors = new Map();
|
||||
this.alerts = new Map();
|
||||
this.motionVector = { x: 0, y: 0 };
|
||||
}
|
||||
|
||||
createEvent(type, lat, lon, name) {
|
||||
const eventId = safeId();
|
||||
this.event = {
|
||||
event_id: eventId,
|
||||
disaster_type: type,
|
||||
latitude: lat,
|
||||
longitude: lon,
|
||||
description: name,
|
||||
createdAt: Date.now(),
|
||||
};
|
||||
this.zones.clear();
|
||||
this.survivors.clear();
|
||||
this.alerts.clear();
|
||||
return eventId;
|
||||
}
|
||||
|
||||
addRectangleZone(name, x, y, w, h) {
|
||||
const id = safeId();
|
||||
this.zones.set(id, {
|
||||
id,
|
||||
name,
|
||||
zone_type: 'rectangle',
|
||||
status: 0,
|
||||
scan_count: 0,
|
||||
detection_count: 0,
|
||||
x,
|
||||
y,
|
||||
width: w,
|
||||
height: h,
|
||||
});
|
||||
return id;
|
||||
}
|
||||
|
||||
addCircleZone(name, cx, cy, radius) {
|
||||
const id = safeId();
|
||||
this.zones.set(id, {
|
||||
id,
|
||||
name,
|
||||
zone_type: 'circle',
|
||||
status: 0,
|
||||
scan_count: 0,
|
||||
detection_count: 0,
|
||||
center_x: cx,
|
||||
center_y: cy,
|
||||
radius,
|
||||
});
|
||||
return id;
|
||||
}
|
||||
|
||||
addZoneFromPayload(payload) {
|
||||
if (!payload || typeof payload !== 'object') {
|
||||
return;
|
||||
}
|
||||
|
||||
const source = payload;
|
||||
const type = source.zone_type || source.type || 'rectangle';
|
||||
const name = source.name || `Zone-${safeId().slice(0, 4)}`;
|
||||
|
||||
if (type === 'circle' || source.center_x !== undefined) {
|
||||
const cx = isNumber(source.center_x) ? source.center_x : 120;
|
||||
const cy = isNumber(source.center_y) ? source.center_y : 120;
|
||||
const radius = isNumber(source.radius) ? source.radius : 50;
|
||||
return this.addCircleZone(name, cx, cy, radius);
|
||||
}
|
||||
|
||||
const x = isNumber(source.x) ? source.x : 40;
|
||||
const y = isNumber(source.y) ? source.y : 40;
|
||||
const width = isNumber(source.width) ? source.width : 100;
|
||||
const height = isNumber(source.height) ? source.height : 100;
|
||||
return this.addRectangleZone(name, x, y, width, height);
|
||||
}
|
||||
|
||||
inferTriage(vitalSigns, confidence) {
|
||||
const breathing = isNumber(vitalSigns?.breathing_rate) ? vitalSigns.breathing_rate : 14;
|
||||
const heart = isNumber(vitalSigns?.heart_rate)
|
||||
? vitalSigns.heart_rate
|
||||
: isNumber(vitalSigns?.hr)
|
||||
? vitalSigns.hr
|
||||
: 70;
|
||||
|
||||
if (!isNumber(confidence) || confidence > 0.82) {
|
||||
if (breathing < 10 || breathing > 35 || heart > 150) {
|
||||
return TRIAGE.Immediate;
|
||||
}
|
||||
if (breathing >= 8 && breathing <= 34) {
|
||||
return TRIAGE.Delayed;
|
||||
}
|
||||
}
|
||||
|
||||
if (breathing >= 6 && breathing <= 28 && heart > 45 && heart < 180) {
|
||||
return TRIAGE.Minimal;
|
||||
}
|
||||
|
||||
return TRIAGE.Expectant;
|
||||
}
|
||||
|
||||
locateZoneForPoint(x, y) {
|
||||
for (const [id, zone] of this.zones.entries()) {
|
||||
if (zone.zone_type === 'circle') {
|
||||
const dx = x - zone.center_x;
|
||||
const dy = y - zone.center_y;
|
||||
const inside = Math.sqrt(dx * dx + dy * dy) <= zone.radius;
|
||||
if (inside) {
|
||||
return id;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
if (x >= zone.x && x <= zone.x + zone.width && y >= zone.y && y <= zone.y + zone.height) {
|
||||
return id;
|
||||
}
|
||||
}
|
||||
return this.zones.size > 0 ? this.zones.keys().next().value : safeId();
|
||||
}
|
||||
|
||||
processSurvivorDetection(zone, confidence = 0.6, vital_signs = {}) {
|
||||
const zoneKey =
|
||||
typeof zone === 'string'
|
||||
? [...this.zones.values()].find((entry) => entry.id === zone || entry.name === zone)
|
||||
: null;
|
||||
|
||||
const selectedZone =
|
||||
zoneKey
|
||||
|| (this.zones.size > 0
|
||||
? [...this.zones.values()][Math.floor(Math.random() * Math.max(1, this.zones.size))]
|
||||
: null);
|
||||
|
||||
const bounds = this._pickPointInZone(selectedZone);
|
||||
const triageStatus = this.inferTriage(vital_signs, confidence);
|
||||
const breathingRate = isNumber(vital_signs?.breathing_rate)
|
||||
? vital_signs.breathing_rate
|
||||
: 10 + confidence * 28;
|
||||
const heartRate = isNumber(vital_signs?.heart_rate)
|
||||
? vital_signs.heart_rate
|
||||
: isNumber(vital_signs?.hr)
|
||||
? vital_signs.hr
|
||||
: 55 + confidence * 60;
|
||||
|
||||
const id = safeId();
|
||||
const zone_id = this.locateZoneForPoint(bounds.x, bounds.y);
|
||||
|
||||
const survivor = {
|
||||
id,
|
||||
zone_id,
|
||||
x: bounds.x,
|
||||
y: bounds.y,
|
||||
depth: -Math.abs(isNumber(vital_signs.depth) ? vital_signs.depth : Math.random() * 3),
|
||||
triage_status: triageStatus,
|
||||
triage_color: toRgba(triageStatus),
|
||||
confidence,
|
||||
breathing_rate: breathingRate,
|
||||
heart_rate: heartRate,
|
||||
first_detected: new Date().toISOString(),
|
||||
last_updated: new Date().toISOString(),
|
||||
is_deteriorating: false,
|
||||
};
|
||||
|
||||
this.survivors.set(id, survivor);
|
||||
if (selectedZone) {
|
||||
selectedZone.detection_count = (selectedZone.detection_count || 0) + 1;
|
||||
}
|
||||
|
||||
if (typeof this.postMessage === 'function') {
|
||||
this.postMessage({
|
||||
type: 'SURVIVOR_DETECTED',
|
||||
payload: survivor,
|
||||
});
|
||||
}
|
||||
|
||||
this.generateAlerts();
|
||||
return id;
|
||||
}
|
||||
|
||||
_pickPointInZone(zone) {
|
||||
if (!zone) {
|
||||
return {
|
||||
x: 220 + Math.random() * 80,
|
||||
y: 120 + Math.random() * 80,
|
||||
};
|
||||
}
|
||||
|
||||
if (zone.zone_type === 'circle') {
|
||||
const angle = Math.random() * Math.PI * 2;
|
||||
const radius = Math.random() * (zone.radius || 20);
|
||||
return {
|
||||
x: Math.max(10, Math.min(560, zone.center_x + Math.cos(angle) * radius)),
|
||||
y: Math.max(10, Math.min(280, zone.center_y + Math.sin(angle) * radius)),
|
||||
};
|
||||
}
|
||||
|
||||
return {
|
||||
x: Math.max(zone.x || 5, Math.min((zone.x || 5) + (zone.width || 40), (zone.x || 5) + Math.random() * (zone.width || 40))),
|
||||
y: Math.max(zone.y || 5, Math.min((zone.y || 5) + (zone.height || 40), (zone.y || 5) + Math.random() * (zone.height || 40))),
|
||||
};
|
||||
}
|
||||
|
||||
generateAlerts() {
|
||||
for (const survivor of this.survivors.values()) {
|
||||
if ((survivor.triage_status !== TRIAGE.Immediate && survivor.triage_status !== TRIAGE.Delayed)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
const alertId = `alert-${survivor.id}`;
|
||||
if (this.alerts.has(alertId)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
const priority =
|
||||
survivor.triage_status === TRIAGE.Immediate ? PRIORITY.Critical : PRIORITY.High;
|
||||
const message =
|
||||
survivor.triage_status === TRIAGE.Immediate
|
||||
? `Immediate rescue required at (${survivor.x.toFixed(0)}, ${survivor.y.toFixed(0)})`
|
||||
: `High-priority rescue needed at (${survivor.x.toFixed(0)}, ${survivor.y.toFixed(0)})`;
|
||||
const alert = {
|
||||
id: alertId,
|
||||
survivor_id: survivor.id,
|
||||
priority,
|
||||
title: survivor.triage_status === TRIAGE.Immediate ? 'URGENT' : 'HIGH',
|
||||
message,
|
||||
recommended_action: survivor.triage_status === TRIAGE.Immediate ? 'Dispatch now' : 'Coordinate rescue',
|
||||
triage_status: survivor.triage_status,
|
||||
location_x: survivor.x,
|
||||
location_y: survivor.y,
|
||||
created_at: new Date().toISOString(),
|
||||
priority_color: survivor.triage_status === TRIAGE.Immediate ? '#ff0000' : '#ff8c00',
|
||||
};
|
||||
|
||||
this.alerts.set(alertId, alert);
|
||||
if (typeof this.postMessage === 'function') {
|
||||
this.postMessage({
|
||||
type: 'ALERT_GENERATED',
|
||||
payload: alert,
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
processFrame(frame) {
|
||||
const motion = Number(frame?.features?.motion_band_power || 0);
|
||||
const xDelta = isNumber(motion) ? (motion - 0.1) * 4 : 0;
|
||||
const yDelta = isNumber(frame?.features?.breathing_band_power || 0)
|
||||
? (frame.features.breathing_band_power - 0.1) * 3
|
||||
: 0;
|
||||
this.motionVector = { x: xDelta || 0, y: yDelta || 0 };
|
||||
|
||||
for (const survivor of this.survivors.values()) {
|
||||
const jitterX = (Math.random() - 0.5) * 2;
|
||||
const jitterY = (Math.random() - 0.5) * 2;
|
||||
survivor.x = Math.max(5, Math.min(560, survivor.x + this.motionVector.x + jitterX));
|
||||
survivor.y = Math.max(5, Math.min(280, survivor.y + this.motionVector.y + jitterY));
|
||||
survivor.last_updated = new Date().toISOString();
|
||||
}
|
||||
}
|
||||
|
||||
renderZones(ctx) {
|
||||
for (const zone of this.zones.values()) {
|
||||
const fill = 'rgba(0, 150, 255, 0.3)';
|
||||
ctx.strokeStyle = '#0096ff';
|
||||
ctx.fillStyle = fill;
|
||||
ctx.lineWidth = 2;
|
||||
|
||||
if (zone.zone_type === 'circle') {
|
||||
ctx.beginPath();
|
||||
ctx.arc(zone.center_x, zone.center_y, zone.radius, 0, Math.PI * 2);
|
||||
ctx.fill();
|
||||
ctx.stroke();
|
||||
ctx.fillStyle = '#ffffff';
|
||||
ctx.font = '12px monospace';
|
||||
ctx.fillText(zone.name, zone.center_x - 22, zone.center_y);
|
||||
} else {
|
||||
ctx.fillRect(zone.x, zone.y, zone.width, zone.height);
|
||||
ctx.strokeRect(zone.x, zone.y, zone.width, zone.height);
|
||||
ctx.fillStyle = '#ffffff';
|
||||
ctx.font = '12px monospace';
|
||||
ctx.fillText(zone.name, zone.x + 4, zone.y + 14);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
renderSurvivors(ctx) {
|
||||
for (const survivor of this.survivors.values()) {
|
||||
const radius = survivor.is_deteriorating ? 11 : 9;
|
||||
|
||||
if (survivor.triage_status === TRIAGE.Immediate) {
|
||||
ctx.fillStyle = 'rgba(255, 0, 0, 0.26)';
|
||||
ctx.beginPath();
|
||||
ctx.arc(survivor.x, survivor.y, radius + 6, 0, Math.PI * 2);
|
||||
ctx.fill();
|
||||
}
|
||||
|
||||
ctx.fillStyle = survivor.triage_color || toRgba(TRIAGE.Minimal);
|
||||
ctx.font = 'bold 18px monospace';
|
||||
ctx.textAlign = 'center';
|
||||
ctx.textBaseline = 'middle';
|
||||
ctx.fillText('✦', survivor.x, survivor.y);
|
||||
ctx.strokeStyle = '#ffffff';
|
||||
ctx.lineWidth = 1.5;
|
||||
ctx.beginPath();
|
||||
ctx.arc(survivor.x, survivor.y, radius, 0, Math.PI * 2);
|
||||
ctx.stroke();
|
||||
|
||||
if (survivor.depth < 0) {
|
||||
ctx.fillStyle = '#ffffff';
|
||||
ctx.font = '9px monospace';
|
||||
ctx.fillText(`${Math.abs(survivor.depth).toFixed(1)}m`, survivor.x + radius + 4, survivor.y + 4);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
render(ctx, width, height) {
|
||||
ctx.clearRect(0, 0, width, height);
|
||||
ctx.fillStyle = '#0a0e1a';
|
||||
ctx.fillRect(0, 0, width, height);
|
||||
|
||||
ctx.strokeStyle = '#1f2a3d';
|
||||
ctx.lineWidth = 1;
|
||||
const grid = 40;
|
||||
for (let x = 0; x <= width; x += grid) {
|
||||
ctx.beginPath();
|
||||
ctx.moveTo(x, 0);
|
||||
ctx.lineTo(x, height);
|
||||
ctx.stroke();
|
||||
}
|
||||
for (let y = 0; y <= height; y += grid) {
|
||||
ctx.beginPath();
|
||||
ctx.moveTo(0, y);
|
||||
ctx.lineTo(width, y);
|
||||
ctx.stroke();
|
||||
}
|
||||
|
||||
this.renderZones(ctx);
|
||||
this.renderSurvivors(ctx);
|
||||
|
||||
ctx.fillStyle = '#ffffff';
|
||||
ctx.font = '12px monospace';
|
||||
const stats = {
|
||||
survivors: this.survivors.size,
|
||||
alerts: this.alerts.size,
|
||||
};
|
||||
ctx.fillText(`Survivors: ${stats.survivors}`, 12, 20);
|
||||
ctx.fillText(`Alerts: ${stats.alerts}`, 12, 36);
|
||||
}
|
||||
|
||||
postMessage(message) {
|
||||
if (typeof window.ReactNativeWebView !== 'undefined' && window.ReactNativeWebView.postMessage) {
|
||||
window.ReactNativeWebView.postMessage(JSON.stringify(message));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const dashboard = new MatDashboard();
|
||||
const canvas = document.getElementById('mapCanvas');
|
||||
const ctx = canvas.getContext('2d');
|
||||
const status = document.getElementById('status');
|
||||
|
||||
const resize = () => {
|
||||
canvas.width = Math.max(200, Math.floor(canvas.parentElement.clientWidth - 2));
|
||||
canvas.height = Math.max(180, Math.floor(canvas.parentElement.clientHeight - 20));
|
||||
};
|
||||
|
||||
const startup = () => {
|
||||
dashboard.createEvent('earthquake', 37.7749, -122.4194, 'Training Scenario');
|
||||
dashboard.addRectangleZone('Zone A', 60, 45, 170, 120);
|
||||
dashboard.addCircleZone('Zone B', 300, 170, 70);
|
||||
dashboard.processSurvivorDetection('Zone A', 0.94, { breathing_rate: 11, hr: 128 });
|
||||
dashboard.processSurvivorDetection('Zone A', 0.88, { breathing_rate: 16, hr: 118 });
|
||||
dashboard.processSurvivorDetection('Zone B', 0.71, { breathing_rate: 9, hr: 142 });
|
||||
status.textContent = 'MAT dashboard ready';
|
||||
dashboard.postMessage({ type: 'READY' });
|
||||
};
|
||||
|
||||
const loop = () => {
|
||||
if (dashboard.zones.size > 0) {
|
||||
dashboard.render(ctx, canvas.width, canvas.height);
|
||||
}
|
||||
requestAnimationFrame(loop);
|
||||
};
|
||||
|
||||
window.addEventListener('resize', resize);
|
||||
|
||||
window.addEventListener('message', (evt) => {
|
||||
let incoming = evt.data;
|
||||
try {
|
||||
if (typeof incoming === 'string') {
|
||||
incoming = JSON.parse(incoming);
|
||||
}
|
||||
} catch {
|
||||
incoming = null;
|
||||
}
|
||||
|
||||
if (!incoming || typeof incoming !== 'object') {
|
||||
return;
|
||||
}
|
||||
|
||||
if (incoming.type === 'CREATE_EVENT') {
|
||||
const payload = incoming.payload || {};
|
||||
dashboard.createEvent(
|
||||
payload.type || payload.disaster_type || 'earthquake',
|
||||
payload.latitude || 0,
|
||||
payload.longitude || 0,
|
||||
payload.name || payload.description || 'Disaster Event',
|
||||
);
|
||||
return;
|
||||
}
|
||||
|
||||
if (incoming.type === 'ADD_ZONE') {
|
||||
dashboard.addZoneFromPayload(incoming.payload || {});
|
||||
return;
|
||||
}
|
||||
|
||||
if (incoming.type === 'FRAME_UPDATE') {
|
||||
dashboard.processFrame(incoming.payload || {});
|
||||
}
|
||||
});
|
||||
|
||||
resize();
|
||||
startup();
|
||||
loop();
|
||||
})();
|
||||
</script>
|
||||
</body>
|
||||
</html>
|
||||
@@ -1,70 +0,0 @@
|
||||
import { StyleSheet, View } from 'react-native';
|
||||
import { ThemedText } from './ThemedText';
|
||||
|
||||
type ConnectionState = 'connected' | 'simulated' | 'disconnected';
|
||||
|
||||
type ConnectionBannerProps = {
|
||||
status: ConnectionState;
|
||||
};
|
||||
|
||||
const resolveState = (status: ConnectionState) => {
|
||||
if (status === 'connected') {
|
||||
return {
|
||||
label: 'LIVE STREAM',
|
||||
backgroundColor: '#0F6B2A',
|
||||
textColor: '#E2FFEA',
|
||||
};
|
||||
}
|
||||
|
||||
if (status === 'disconnected') {
|
||||
return {
|
||||
label: 'DISCONNECTED',
|
||||
backgroundColor: '#8A1E2A',
|
||||
textColor: '#FFE3E7',
|
||||
};
|
||||
}
|
||||
|
||||
return {
|
||||
label: 'SIMULATED DATA',
|
||||
backgroundColor: '#9A5F0C',
|
||||
textColor: '#FFF3E1',
|
||||
};
|
||||
};
|
||||
|
||||
export const ConnectionBanner = ({ status }: ConnectionBannerProps) => {
|
||||
const state = resolveState(status);
|
||||
|
||||
return (
|
||||
<View
|
||||
style={[
|
||||
styles.banner,
|
||||
{
|
||||
backgroundColor: state.backgroundColor,
|
||||
borderBottomColor: state.textColor,
|
||||
},
|
||||
]}
|
||||
>
|
||||
<ThemedText preset="labelMd" style={[styles.text, { color: state.textColor }]}>
|
||||
{state.label}
|
||||
</ThemedText>
|
||||
</View>
|
||||
);
|
||||
};
|
||||
|
||||
const styles = StyleSheet.create({
|
||||
banner: {
|
||||
position: 'absolute',
|
||||
left: 0,
|
||||
right: 0,
|
||||
top: 0,
|
||||
zIndex: 100,
|
||||
paddingVertical: 6,
|
||||
borderBottomWidth: 2,
|
||||
alignItems: 'center',
|
||||
justifyContent: 'center',
|
||||
},
|
||||
text: {
|
||||
letterSpacing: 2,
|
||||
fontWeight: '700',
|
||||
},
|
||||
});
|
||||
@@ -1,66 +0,0 @@
|
||||
import { Component, ErrorInfo, ReactNode } from 'react';
|
||||
import { Button, StyleSheet, View } from 'react-native';
|
||||
import { ThemedText } from './ThemedText';
|
||||
import { ThemedView } from './ThemedView';
|
||||
|
||||
type ErrorBoundaryProps = {
|
||||
children: ReactNode;
|
||||
};
|
||||
|
||||
type ErrorBoundaryState = {
|
||||
hasError: boolean;
|
||||
error?: Error;
|
||||
};
|
||||
|
||||
export class ErrorBoundary extends Component<ErrorBoundaryProps, ErrorBoundaryState> {
|
||||
constructor(props: ErrorBoundaryProps) {
|
||||
super(props);
|
||||
this.state = { hasError: false };
|
||||
}
|
||||
|
||||
static getDerivedStateFromError(error: Error): ErrorBoundaryState {
|
||||
return { hasError: true, error };
|
||||
}
|
||||
|
||||
componentDidCatch(error: Error, errorInfo: ErrorInfo) {
|
||||
console.error('ErrorBoundary caught an error', error, errorInfo);
|
||||
}
|
||||
|
||||
handleRetry = () => {
|
||||
this.setState({ hasError: false, error: undefined });
|
||||
};
|
||||
|
||||
render() {
|
||||
if (this.state.hasError) {
|
||||
return (
|
||||
<ThemedView style={styles.container}>
|
||||
<ThemedText preset="displayMd">Something went wrong</ThemedText>
|
||||
<ThemedText preset="bodySm" style={styles.message}>
|
||||
{this.state.error?.message ?? 'An unexpected error occurred.'}
|
||||
</ThemedText>
|
||||
<View style={styles.buttonWrap}>
|
||||
<Button title="Retry" onPress={this.handleRetry} />
|
||||
</View>
|
||||
</ThemedView>
|
||||
);
|
||||
}
|
||||
|
||||
return this.props.children;
|
||||
}
|
||||
}
|
||||
|
||||
const styles = StyleSheet.create({
|
||||
container: {
|
||||
flex: 1,
|
||||
justifyContent: 'center',
|
||||
alignItems: 'center',
|
||||
padding: 20,
|
||||
gap: 12,
|
||||
},
|
||||
message: {
|
||||
textAlign: 'center',
|
||||
},
|
||||
buttonWrap: {
|
||||
marginTop: 8,
|
||||
},
|
||||
});
|
||||
@@ -1,117 +0,0 @@
|
||||
import { useEffect, useMemo } from 'react';
|
||||
import { StyleSheet, View } from 'react-native';
|
||||
import Animated, { interpolateColor, useAnimatedProps, useSharedValue, withSpring } from 'react-native-reanimated';
|
||||
import Svg, { Circle, G, Text as SvgText } from 'react-native-svg';
|
||||
|
||||
type GaugeArcProps = {
|
||||
value: number;
|
||||
min?: number;
|
||||
max: number;
|
||||
label: string;
|
||||
unit: string;
|
||||
color: string;
|
||||
colorTo?: string;
|
||||
size?: number;
|
||||
};
|
||||
|
||||
const AnimatedCircle = Animated.createAnimatedComponent(Circle);
|
||||
|
||||
const clamp = (value: number, min: number, max: number) => Math.max(min, Math.min(max, value));
|
||||
|
||||
export const GaugeArc = ({ value, min = 0, max, label, unit, color, colorTo, size = 140 }: GaugeArcProps) => {
|
||||
const radius = (size - 20) / 2;
|
||||
const circumference = 2 * Math.PI * radius;
|
||||
const arcLength = circumference * 0.75;
|
||||
const strokeWidth = 12;
|
||||
const progress = useSharedValue(0);
|
||||
|
||||
const normalized = useMemo(() => {
|
||||
const span = max - min;
|
||||
const safeSpan = span > 0 ? span : 1;
|
||||
return clamp((value - min) / safeSpan, 0, 1);
|
||||
}, [value, min, max]);
|
||||
|
||||
const displayValue = useMemo(() => {
|
||||
if (!Number.isFinite(value)) {
|
||||
return '--';
|
||||
}
|
||||
return `${Math.max(min, Math.min(max, value)).toFixed(1)} ${unit}`;
|
||||
}, [max, min, unit, value]);
|
||||
|
||||
useEffect(() => {
|
||||
progress.value = withSpring(normalized, {
|
||||
damping: 16,
|
||||
stiffness: 140,
|
||||
mass: 1,
|
||||
});
|
||||
}, [normalized, progress]);
|
||||
|
||||
const animatedStroke = useAnimatedProps(() => {
|
||||
const dashOffset = arcLength - arcLength * progress.value;
|
||||
const strokeColor = colorTo ? interpolateColor(progress.value, [0, 1], [color, colorTo]) : color;
|
||||
|
||||
return {
|
||||
strokeDashoffset: dashOffset,
|
||||
stroke: strokeColor,
|
||||
};
|
||||
});
|
||||
|
||||
return (
|
||||
<View style={styles.wrapper}>
|
||||
<Svg width={size} height={size} viewBox={`0 0 ${size} ${size}`}>
|
||||
<G transform={`rotate(-135 ${size / 2} ${size / 2})`}>
|
||||
<Circle
|
||||
cx={size / 2}
|
||||
cy={size / 2}
|
||||
r={radius}
|
||||
strokeWidth={strokeWidth}
|
||||
stroke="#1E293B"
|
||||
fill="none"
|
||||
strokeDasharray={`${arcLength} ${circumference}`}
|
||||
strokeLinecap="round"
|
||||
/>
|
||||
<AnimatedCircle
|
||||
cx={size / 2}
|
||||
cy={size / 2}
|
||||
r={radius}
|
||||
strokeWidth={strokeWidth}
|
||||
stroke={color}
|
||||
fill="none"
|
||||
strokeDasharray={`${arcLength} ${circumference}`}
|
||||
strokeLinecap="round"
|
||||
animatedProps={animatedStroke}
|
||||
/>
|
||||
</G>
|
||||
<SvgText
|
||||
x={size / 2}
|
||||
y={size / 2 - 8}
|
||||
fill="#E2E8F0"
|
||||
fontSize={Math.round(size * 0.16)}
|
||||
fontFamily="Courier New"
|
||||
fontWeight="700"
|
||||
textAnchor="middle"
|
||||
>
|
||||
{displayValue}
|
||||
</SvgText>
|
||||
<SvgText
|
||||
x={size / 2}
|
||||
y={size / 2 + 18}
|
||||
fill="#94A3B8"
|
||||
fontSize={Math.round(size * 0.085)}
|
||||
fontFamily="Courier New"
|
||||
textAnchor="middle"
|
||||
letterSpacing="0.6"
|
||||
>
|
||||
{label}
|
||||
</SvgText>
|
||||
</Svg>
|
||||
</View>
|
||||
);
|
||||
};
|
||||
|
||||
const styles = StyleSheet.create({
|
||||
wrapper: {
|
||||
alignItems: 'center',
|
||||
justifyContent: 'center',
|
||||
},
|
||||
});
|
||||
@@ -1,60 +0,0 @@
|
||||
import { useEffect } from 'react';
|
||||
import { StyleSheet, ViewStyle } from 'react-native';
|
||||
import Animated, { Easing, useAnimatedStyle, useSharedValue, withRepeat, withTiming } from 'react-native-reanimated';
|
||||
import Svg, { Circle } from 'react-native-svg';
|
||||
import { colors } from '../theme/colors';
|
||||
|
||||
type LoadingSpinnerProps = {
|
||||
size?: number;
|
||||
color?: string;
|
||||
style?: ViewStyle;
|
||||
};
|
||||
|
||||
export const LoadingSpinner = ({ size = 36, color = colors.accent, style }: LoadingSpinnerProps) => {
|
||||
const rotation = useSharedValue(0);
|
||||
const strokeWidth = Math.max(4, size * 0.14);
|
||||
const center = size / 2;
|
||||
const radius = center - strokeWidth;
|
||||
const circumference = 2 * Math.PI * radius;
|
||||
|
||||
useEffect(() => {
|
||||
rotation.value = withRepeat(withTiming(360, { duration: 900, easing: Easing.linear }), -1);
|
||||
}, [rotation]);
|
||||
|
||||
const animatedStyle = useAnimatedStyle(() => ({
|
||||
transform: [{ rotateZ: `${rotation.value}deg` }],
|
||||
}));
|
||||
|
||||
return (
|
||||
<Animated.View style={[styles.container, { width: size, height: size }, style, animatedStyle]} pointerEvents="none">
|
||||
<Svg width={size} height={size} viewBox={`0 0 ${size} ${size}`}>
|
||||
<Circle
|
||||
cx={center}
|
||||
cy={center}
|
||||
r={radius}
|
||||
stroke="rgba(255,255,255,0.2)"
|
||||
strokeWidth={strokeWidth}
|
||||
fill="none"
|
||||
/>
|
||||
<Circle
|
||||
cx={center}
|
||||
cy={center}
|
||||
r={radius}
|
||||
stroke={color}
|
||||
strokeWidth={strokeWidth}
|
||||
fill="none"
|
||||
strokeLinecap="round"
|
||||
strokeDasharray={`${circumference * 0.3} ${circumference * 0.7}`}
|
||||
strokeDashoffset={circumference * 0.2}
|
||||
/>
|
||||
</Svg>
|
||||
</Animated.View>
|
||||
);
|
||||
};
|
||||
|
||||
const styles = StyleSheet.create({
|
||||
container: {
|
||||
alignItems: 'center',
|
||||
justifyContent: 'center',
|
||||
},
|
||||
});
|
||||
@@ -1,71 +0,0 @@
|
||||
import { StyleSheet } from 'react-native';
|
||||
import { ThemedText } from './ThemedText';
|
||||
import { colors } from '../theme/colors';
|
||||
|
||||
type Mode = 'CSI' | 'RSSI' | 'SIM' | 'LIVE';
|
||||
|
||||
const modeStyle: Record<
|
||||
Mode,
|
||||
{
|
||||
background: string;
|
||||
border: string;
|
||||
color: string;
|
||||
}
|
||||
> = {
|
||||
CSI: {
|
||||
background: 'rgba(50, 184, 198, 0.25)',
|
||||
border: colors.accent,
|
||||
color: colors.accent,
|
||||
},
|
||||
RSSI: {
|
||||
background: 'rgba(255, 165, 2, 0.2)',
|
||||
border: colors.warn,
|
||||
color: colors.warn,
|
||||
},
|
||||
SIM: {
|
||||
background: 'rgba(255, 71, 87, 0.18)',
|
||||
border: colors.simulated,
|
||||
color: colors.simulated,
|
||||
},
|
||||
LIVE: {
|
||||
background: 'rgba(46, 213, 115, 0.18)',
|
||||
border: colors.connected,
|
||||
color: colors.connected,
|
||||
},
|
||||
};
|
||||
|
||||
type ModeBadgeProps = {
|
||||
mode: Mode;
|
||||
};
|
||||
|
||||
export const ModeBadge = ({ mode }: ModeBadgeProps) => {
|
||||
const style = modeStyle[mode];
|
||||
|
||||
return (
|
||||
<ThemedText
|
||||
preset="labelMd"
|
||||
style={[
|
||||
styles.badge,
|
||||
{
|
||||
backgroundColor: style.background,
|
||||
borderColor: style.border,
|
||||
color: style.color,
|
||||
},
|
||||
]}
|
||||
>
|
||||
{mode}
|
||||
</ThemedText>
|
||||
);
|
||||
};
|
||||
|
||||
const styles = StyleSheet.create({
|
||||
badge: {
|
||||
paddingHorizontal: 10,
|
||||
paddingVertical: 4,
|
||||
borderRadius: 999,
|
||||
borderWidth: 1,
|
||||
overflow: 'hidden',
|
||||
letterSpacing: 1,
|
||||
textAlign: 'center',
|
||||
},
|
||||
});
|
||||
@@ -1,147 +0,0 @@
|
||||
import { useEffect, useMemo, useRef } from 'react';
|
||||
import { StyleProp, ViewStyle } from 'react-native';
|
||||
import Animated, { interpolateColor, useAnimatedProps, useSharedValue, withTiming, type SharedValue } from 'react-native-reanimated';
|
||||
import Svg, { Circle, G, Rect } from 'react-native-svg';
|
||||
import { colors } from '../theme/colors';
|
||||
|
||||
type Point = {
|
||||
x: number;
|
||||
y: number;
|
||||
};
|
||||
|
||||
type OccupancyGridProps = {
|
||||
values: number[];
|
||||
personPositions?: Point[];
|
||||
size?: number;
|
||||
style?: StyleProp<ViewStyle>;
|
||||
};
|
||||
|
||||
const GRID_DIMENSION = 20;
|
||||
const CELLS = GRID_DIMENSION * GRID_DIMENSION;
|
||||
|
||||
const toColor = (value: number): string => {
|
||||
const clamped = Math.max(0, Math.min(1, value));
|
||||
let r: number;
|
||||
let g: number;
|
||||
let b: number;
|
||||
|
||||
if (clamped < 0.5) {
|
||||
const t = clamped * 2;
|
||||
r = Math.round(255 * 0);
|
||||
g = Math.round(255 * t);
|
||||
b = Math.round(255 * (1 - t));
|
||||
} else {
|
||||
const t = (clamped - 0.5) * 2;
|
||||
r = Math.round(255 * t);
|
||||
g = Math.round(255 * (1 - t));
|
||||
b = 0;
|
||||
}
|
||||
|
||||
return `rgb(${r}, ${g}, ${b})`;
|
||||
};
|
||||
|
||||
const AnimatedRect = Animated.createAnimatedComponent(Rect);
|
||||
|
||||
const normalizeValues = (values: number[]) => {
|
||||
const normalized = new Array(CELLS).fill(0);
|
||||
for (let i = 0; i < CELLS; i += 1) {
|
||||
const value = values?.[i] ?? 0;
|
||||
normalized[i] = Number.isFinite(value) ? Math.max(0, Math.min(1, value)) : 0;
|
||||
}
|
||||
return normalized;
|
||||
};
|
||||
|
||||
type CellProps = {
|
||||
index: number;
|
||||
size: number;
|
||||
progress: SharedValue<number>;
|
||||
previousColors: string[];
|
||||
nextColors: string[];
|
||||
};
|
||||
|
||||
const Cell = ({ index, size, progress, previousColors, nextColors }: CellProps) => {
|
||||
const col = index % GRID_DIMENSION;
|
||||
const row = Math.floor(index / GRID_DIMENSION);
|
||||
const cellSize = size / GRID_DIMENSION;
|
||||
const x = col * cellSize;
|
||||
const y = row * cellSize;
|
||||
|
||||
const animatedProps = useAnimatedProps(() => ({
|
||||
fill: interpolateColor(
|
||||
progress.value,
|
||||
[0, 1],
|
||||
[previousColors[index] ?? colors.surfaceAlt, nextColors[index] ?? colors.surfaceAlt],
|
||||
),
|
||||
}));
|
||||
|
||||
return (
|
||||
<AnimatedRect
|
||||
x={x}
|
||||
y={y}
|
||||
width={cellSize}
|
||||
height={cellSize}
|
||||
rx={1}
|
||||
animatedProps={animatedProps}
|
||||
/>
|
||||
);
|
||||
};
|
||||
|
||||
export const OccupancyGrid = ({
|
||||
values,
|
||||
personPositions = [],
|
||||
size = 320,
|
||||
style,
|
||||
}: OccupancyGridProps) => {
|
||||
const normalizedValues = useMemo(() => normalizeValues(values), [values]);
|
||||
const previousColors = useRef<string[]>(normalizedValues.map(toColor));
|
||||
const nextColors = useRef<string[]>(normalizedValues.map(toColor));
|
||||
const progress = useSharedValue(1);
|
||||
|
||||
useEffect(() => {
|
||||
const next = normalizeValues(values);
|
||||
previousColors.current = normalizedValues.map(toColor);
|
||||
nextColors.current = next.map(toColor);
|
||||
progress.value = 0;
|
||||
progress.value = withTiming(1, { duration: 500 });
|
||||
}, [values, normalizedValues, progress]);
|
||||
|
||||
const markers = useMemo(() => {
|
||||
const cellSize = size / GRID_DIMENSION;
|
||||
return personPositions.map(({ x, y }, idx) => {
|
||||
const clampedX = Math.max(0, Math.min(GRID_DIMENSION - 1, Math.round(x)));
|
||||
const clampedY = Math.max(0, Math.min(GRID_DIMENSION - 1, Math.round(y)));
|
||||
const cx = (clampedX + 0.5) * cellSize;
|
||||
const cy = (clampedY + 0.5) * cellSize;
|
||||
const markerRadius = Math.max(3, cellSize * 0.25);
|
||||
return (
|
||||
<Circle
|
||||
key={`person-${idx}`}
|
||||
cx={cx}
|
||||
cy={cy}
|
||||
r={markerRadius}
|
||||
fill={colors.accent}
|
||||
stroke={colors.textPrimary}
|
||||
strokeWidth={1}
|
||||
/>
|
||||
);
|
||||
});
|
||||
}, [personPositions, size]);
|
||||
|
||||
return (
|
||||
<Svg width={size} height={size} style={style} viewBox={`0 0 ${size} ${size}`}>
|
||||
<G>
|
||||
{Array.from({ length: CELLS }).map((_, index) => (
|
||||
<Cell
|
||||
key={index}
|
||||
index={index}
|
||||
size={size}
|
||||
progress={progress}
|
||||
previousColors={previousColors.current}
|
||||
nextColors={nextColors.current}
|
||||
/>
|
||||
))}
|
||||
</G>
|
||||
{markers}
|
||||
</Svg>
|
||||
);
|
||||
};
|
||||
@@ -1,62 +0,0 @@
|
||||
import { useEffect } from 'react';
|
||||
import { StyleSheet, View } from 'react-native';
|
||||
import Animated, { useAnimatedStyle, useSharedValue, withTiming } from 'react-native-reanimated';
|
||||
import { ThemedText } from './ThemedText';
|
||||
import { colors } from '../theme/colors';
|
||||
|
||||
type SignalBarProps = {
|
||||
value: number;
|
||||
label: string;
|
||||
color?: string;
|
||||
};
|
||||
|
||||
const clamp01 = (value: number) => Math.max(0, Math.min(1, value));
|
||||
|
||||
export const SignalBar = ({ value, label, color = colors.accent }: SignalBarProps) => {
|
||||
const progress = useSharedValue(clamp01(value));
|
||||
|
||||
useEffect(() => {
|
||||
progress.value = withTiming(clamp01(value), { duration: 250 });
|
||||
}, [value, progress]);
|
||||
|
||||
const animatedFill = useAnimatedStyle(() => ({
|
||||
width: `${progress.value * 100}%`,
|
||||
}));
|
||||
|
||||
return (
|
||||
<View style={styles.container}>
|
||||
<ThemedText preset="bodySm" style={styles.label}>
|
||||
{label}
|
||||
</ThemedText>
|
||||
<View style={styles.track}>
|
||||
<Animated.View style={[styles.fill, { backgroundColor: color }, animatedFill]} />
|
||||
</View>
|
||||
<ThemedText preset="bodySm" style={styles.percent}>
|
||||
{Math.round(clamp01(value) * 100)}%
|
||||
</ThemedText>
|
||||
</View>
|
||||
);
|
||||
};
|
||||
|
||||
const styles = StyleSheet.create({
|
||||
container: {
|
||||
gap: 6,
|
||||
},
|
||||
label: {
|
||||
marginBottom: 4,
|
||||
},
|
||||
track: {
|
||||
height: 8,
|
||||
borderRadius: 4,
|
||||
backgroundColor: colors.surfaceAlt,
|
||||
overflow: 'hidden',
|
||||
},
|
||||
fill: {
|
||||
height: '100%',
|
||||
borderRadius: 4,
|
||||
},
|
||||
percent: {
|
||||
textAlign: 'right',
|
||||
color: colors.textSecondary,
|
||||
},
|
||||
});
|
||||
@@ -1,64 +0,0 @@
|
||||
import { useMemo } from 'react';
|
||||
import { View, ViewStyle } from 'react-native';
|
||||
import { colors } from '../theme/colors';
|
||||
|
||||
type SparklineChartProps = {
|
||||
data: number[];
|
||||
color?: string;
|
||||
height?: number;
|
||||
style?: ViewStyle;
|
||||
};
|
||||
|
||||
const defaultHeight = 72;
|
||||
|
||||
export const SparklineChart = ({
|
||||
data,
|
||||
color = colors.accent,
|
||||
height = defaultHeight,
|
||||
style,
|
||||
}: SparklineChartProps) => {
|
||||
const normalizedData = data.length > 0 ? data : [0];
|
||||
|
||||
const chartData = useMemo(
|
||||
() =>
|
||||
normalizedData.map((value, index) => ({
|
||||
x: index,
|
||||
y: value,
|
||||
})),
|
||||
[normalizedData],
|
||||
);
|
||||
|
||||
const yValues = normalizedData.map((value) => Number(value) || 0);
|
||||
const yMin = Math.min(...yValues);
|
||||
const yMax = Math.max(...yValues);
|
||||
const yPadding = yMax - yMin === 0 ? 1 : (yMax - yMin) * 0.2;
|
||||
|
||||
return (
|
||||
<View style={style}>
|
||||
<View
|
||||
accessibilityRole="image"
|
||||
style={{
|
||||
height,
|
||||
width: '100%',
|
||||
borderRadius: 4,
|
||||
borderWidth: 1,
|
||||
borderColor: color,
|
||||
opacity: 0.2,
|
||||
backgroundColor: 'transparent',
|
||||
}}
|
||||
>
|
||||
<View
|
||||
style={{
|
||||
flex: 1,
|
||||
justifyContent: 'center',
|
||||
alignItems: 'center',
|
||||
}}
|
||||
>
|
||||
{chartData.map((point) => (
|
||||
<View key={point.x} style={{ position: 'absolute', left: `${(point.x / Math.max(normalizedData.length - 1, 1)) * 100}%` }} />
|
||||
))}
|
||||
</View>
|
||||
</View>
|
||||
</View>
|
||||
);
|
||||
};
|
||||
@@ -1,83 +0,0 @@
|
||||
import { useEffect } from 'react';
|
||||
import { StyleSheet, ViewStyle } from 'react-native';
|
||||
import Animated, {
|
||||
cancelAnimation,
|
||||
Easing,
|
||||
useAnimatedStyle,
|
||||
useSharedValue,
|
||||
withRepeat,
|
||||
withSequence,
|
||||
withTiming,
|
||||
} from 'react-native-reanimated';
|
||||
import { colors } from '../theme/colors';
|
||||
|
||||
type StatusType = 'connected' | 'simulated' | 'disconnected' | 'connecting';
|
||||
|
||||
type StatusDotProps = {
|
||||
status: StatusType;
|
||||
size?: number;
|
||||
style?: ViewStyle;
|
||||
};
|
||||
|
||||
const resolveColor = (status: StatusType): string => {
|
||||
if (status === 'connecting') return colors.warn;
|
||||
return colors[status];
|
||||
};
|
||||
|
||||
export const StatusDot = ({ status, size = 10, style }: StatusDotProps) => {
|
||||
const scale = useSharedValue(1);
|
||||
const opacity = useSharedValue(1);
|
||||
const isConnecting = status === 'connecting';
|
||||
|
||||
useEffect(() => {
|
||||
if (isConnecting) {
|
||||
scale.value = withRepeat(
|
||||
withSequence(
|
||||
withTiming(1.35, { duration: 800, easing: Easing.out(Easing.cubic) }),
|
||||
withTiming(1, { duration: 800, easing: Easing.in(Easing.cubic) }),
|
||||
),
|
||||
-1,
|
||||
);
|
||||
opacity.value = withRepeat(
|
||||
withSequence(
|
||||
withTiming(0.4, { duration: 800, easing: Easing.out(Easing.quad) }),
|
||||
withTiming(1, { duration: 800, easing: Easing.in(Easing.quad) }),
|
||||
),
|
||||
-1,
|
||||
);
|
||||
return;
|
||||
}
|
||||
|
||||
cancelAnimation(scale);
|
||||
cancelAnimation(opacity);
|
||||
scale.value = 1;
|
||||
opacity.value = 1;
|
||||
}, [isConnecting, opacity, scale]);
|
||||
|
||||
const animatedStyle = useAnimatedStyle(() => ({
|
||||
transform: [{ scale: scale.value }],
|
||||
opacity: opacity.value,
|
||||
}));
|
||||
|
||||
return (
|
||||
<Animated.View
|
||||
style={[
|
||||
styles.dot,
|
||||
{
|
||||
width: size,
|
||||
height: size,
|
||||
backgroundColor: resolveColor(status),
|
||||
borderRadius: size / 2,
|
||||
},
|
||||
animatedStyle,
|
||||
style,
|
||||
]}
|
||||
/>
|
||||
);
|
||||
};
|
||||
|
||||
const styles = StyleSheet.create({
|
||||
dot: {
|
||||
borderRadius: 999,
|
||||
},
|
||||
});
|
||||
@@ -1,28 +0,0 @@
|
||||
import { ComponentPropsWithoutRef } from 'react';
|
||||
import { StyleProp, Text, TextStyle } from 'react-native';
|
||||
import { useTheme } from '../hooks/useTheme';
|
||||
import { colors } from '../theme/colors';
|
||||
import { typography } from '../theme/typography';
|
||||
|
||||
type TextPreset = keyof typeof typography;
|
||||
type ColorKey = keyof typeof colors;
|
||||
|
||||
type ThemedTextProps = Omit<ComponentPropsWithoutRef<typeof Text>, 'style'> & {
|
||||
preset?: TextPreset;
|
||||
color?: ColorKey;
|
||||
style?: StyleProp<TextStyle>;
|
||||
};
|
||||
|
||||
export const ThemedText = ({
|
||||
preset = 'bodyMd',
|
||||
color = 'textPrimary',
|
||||
style,
|
||||
...props
|
||||
}: ThemedTextProps) => {
|
||||
const { colors, typography } = useTheme();
|
||||
|
||||
const presetStyle = (typography as Record<TextPreset, TextStyle>)[preset];
|
||||
const colorStyle = { color: colors[color] };
|
||||
|
||||
return <Text {...props} style={[presetStyle, colorStyle, style]} />;
|
||||
};
|
||||
@@ -1,24 +0,0 @@
|
||||
import { PropsWithChildren, forwardRef } from 'react';
|
||||
import { View, ViewProps } from 'react-native';
|
||||
import { useTheme } from '../hooks/useTheme';
|
||||
|
||||
type ThemedViewProps = PropsWithChildren<ViewProps>;
|
||||
|
||||
export const ThemedView = forwardRef<View, ThemedViewProps>(({ children, style, ...props }, ref) => {
|
||||
const { colors } = useTheme();
|
||||
|
||||
return (
|
||||
<View
|
||||
ref={ref}
|
||||
{...props}
|
||||
style={[
|
||||
{
|
||||
backgroundColor: colors.bg,
|
||||
},
|
||||
style,
|
||||
]}
|
||||
>
|
||||
{children}
|
||||
</View>
|
||||
);
|
||||
});
|
||||
@@ -1,14 +0,0 @@
|
||||
export const API_ROOT = '/api/v1';
|
||||
|
||||
export const API_POSE_STATUS_PATH = '/api/v1/pose/status';
|
||||
export const API_POSE_FRAMES_PATH = '/api/v1/pose/frames';
|
||||
export const API_POSE_ZONES_PATH = '/api/v1/pose/zones';
|
||||
export const API_POSE_CURRENT_PATH = '/api/v1/pose/current';
|
||||
export const API_STREAM_STATUS_PATH = '/api/v1/stream/status';
|
||||
export const API_STREAM_POSE_PATH = '/api/v1/stream/pose';
|
||||
export const API_MAT_EVENTS_PATH = '/api/v1/mat/events';
|
||||
|
||||
export const API_HEALTH_PATH = '/health';
|
||||
export const API_HEALTH_SYSTEM_PATH = '/health/health';
|
||||
export const API_HEALTH_READY_PATH = '/health/ready';
|
||||
export const API_HEALTH_LIVE_PATH = '/health/live';
|
||||
@@ -1,20 +0,0 @@
|
||||
export const SIMULATION_TICK_INTERVAL_MS = 500;
|
||||
export const SIMULATION_GRID_SIZE = 20;
|
||||
|
||||
export const RSSI_BASE_DBM = -45;
|
||||
export const RSSI_AMPLITUDE_DBM = 3;
|
||||
|
||||
export const VARIANCE_BASE = 1.5;
|
||||
export const VARIANCE_AMPLITUDE = 1.0;
|
||||
|
||||
export const MOTION_BAND_MIN = 0.05;
|
||||
export const MOTION_BAND_AMPLITUDE = 0.15;
|
||||
export const BREATHING_BAND_MIN = 0.03;
|
||||
export const BREATHING_BAND_AMPLITUDE = 0.08;
|
||||
|
||||
export const SIGNAL_FIELD_PRESENCE_LEVEL = 0.8;
|
||||
|
||||
export const BREATHING_BPM_MIN = 12;
|
||||
export const BREATHING_BPM_MAX = 24;
|
||||
export const HEART_BPM_MIN = 58;
|
||||
export const HEART_BPM_MAX = 96;
|
||||
@@ -1,3 +0,0 @@
|
||||
export const WS_PATH = '/api/v1/stream/pose';
|
||||
export const RECONNECT_DELAYS = [1000, 2000, 4000, 8000, 16000];
|
||||
export const MAX_RECONNECT_ATTEMPTS = 10;
|
||||
@@ -1,27 +0,0 @@
|
||||
import { useEffect } from 'react';
|
||||
import { wsService } from '@/services/ws.service';
|
||||
import { usePoseStore } from '@/stores/poseStore';
|
||||
|
||||
export interface UsePoseStreamResult {
|
||||
connectionStatus: ReturnType<typeof usePoseStore.getState>['connectionStatus'];
|
||||
lastFrame: ReturnType<typeof usePoseStore.getState>['lastFrame'];
|
||||
isSimulated: boolean;
|
||||
}
|
||||
|
||||
export function usePoseStream(): UsePoseStreamResult {
|
||||
const connectionStatus = usePoseStore((state) => state.connectionStatus);
|
||||
const lastFrame = usePoseStore((state) => state.lastFrame);
|
||||
const isSimulated = usePoseStore((state) => state.isSimulated);
|
||||
|
||||
useEffect(() => {
|
||||
const unsubscribe = wsService.subscribe((frame) => {
|
||||
usePoseStore.getState().handleFrame(frame);
|
||||
});
|
||||
|
||||
return () => {
|
||||
unsubscribe();
|
||||
};
|
||||
}, []);
|
||||
|
||||
return { connectionStatus, lastFrame, isSimulated };
|
||||
}
|
||||
@@ -1,31 +0,0 @@
|
||||
import { useEffect, useState } from 'react';
|
||||
import { rssiService, type WifiNetwork } from '@/services/rssi.service';
|
||||
import { useSettingsStore } from '@/stores/settingsStore';
|
||||
|
||||
export function useRssiScanner(): { networks: WifiNetwork[]; isScanning: boolean } {
|
||||
const enabled = useSettingsStore((state) => state.rssiScanEnabled);
|
||||
const [networks, setNetworks] = useState<WifiNetwork[]>([]);
|
||||
const [isScanning, setIsScanning] = useState(false);
|
||||
|
||||
useEffect(() => {
|
||||
if (!enabled) {
|
||||
rssiService.stopScanning();
|
||||
setIsScanning(false);
|
||||
return;
|
||||
}
|
||||
|
||||
const unsubscribe = rssiService.subscribe((result) => {
|
||||
setNetworks(result);
|
||||
});
|
||||
rssiService.startScanning(2000);
|
||||
setIsScanning(true);
|
||||
|
||||
return () => {
|
||||
unsubscribe();
|
||||
rssiService.stopScanning();
|
||||
setIsScanning(false);
|
||||
};
|
||||
}, [enabled]);
|
||||
|
||||
return { networks, isScanning };
|
||||
}
|
||||
@@ -1,52 +0,0 @@
|
||||
import { useEffect, useState } from 'react';
|
||||
import { apiService } from '@/services/api.service';
|
||||
|
||||
interface ServerReachability {
|
||||
reachable: boolean;
|
||||
latencyMs: number | null;
|
||||
}
|
||||
|
||||
const POLL_MS = 10000;
|
||||
|
||||
export function useServerReachability(): ServerReachability {
|
||||
const [state, setState] = useState<ServerReachability>({
|
||||
reachable: false,
|
||||
latencyMs: null,
|
||||
});
|
||||
|
||||
useEffect(() => {
|
||||
let active = true;
|
||||
|
||||
const check = async () => {
|
||||
const started = Date.now();
|
||||
try {
|
||||
await apiService.getStatus();
|
||||
if (!active) {
|
||||
return;
|
||||
}
|
||||
setState({
|
||||
reachable: true,
|
||||
latencyMs: Date.now() - started,
|
||||
});
|
||||
} catch {
|
||||
if (!active) {
|
||||
return;
|
||||
}
|
||||
setState({
|
||||
reachable: false,
|
||||
latencyMs: null,
|
||||
});
|
||||
}
|
||||
};
|
||||
|
||||
void check();
|
||||
const timer = setInterval(check, POLL_MS);
|
||||
|
||||
return () => {
|
||||
active = false;
|
||||
clearInterval(timer);
|
||||
};
|
||||
}, []);
|
||||
|
||||
return state;
|
||||
}
|
||||
@@ -1,4 +0,0 @@
|
||||
import { useContext } from 'react';
|
||||
import { ThemeContext, ThemeContextValue } from '../theme/ThemeContext';
|
||||
|
||||
export const useTheme = (): ThemeContextValue => useContext(ThemeContext);
|
||||
@@ -1,129 +0,0 @@
|
||||
import React, { Suspense } from 'react';
|
||||
import { ActivityIndicator } from 'react-native';
|
||||
import { createBottomTabNavigator } from '@react-navigation/bottom-tabs';
|
||||
import { Ionicons } from '@expo/vector-icons';
|
||||
import { ThemedText } from '../components/ThemedText';
|
||||
import { ThemedView } from '../components/ThemedView';
|
||||
import { colors } from '../theme/colors';
|
||||
import { useMatStore } from '../stores/matStore';
|
||||
import { MainTabsParamList } from './types';
|
||||
|
||||
const createPlaceholder = (label: string) => {
|
||||
const Placeholder = () => (
|
||||
<ThemedView style={{ flex: 1, alignItems: 'center', justifyContent: 'center' }}>
|
||||
<ThemedText preset="bodyLg">{label} screen not implemented yet</ThemedText>
|
||||
<ThemedText preset="bodySm" color="textSecondary">
|
||||
Placeholder shell
|
||||
</ThemedText>
|
||||
</ThemedView>
|
||||
);
|
||||
const LazyPlaceholder = React.lazy(async () => ({ default: Placeholder }));
|
||||
|
||||
const Wrapped = () => (
|
||||
<Suspense
|
||||
fallback={
|
||||
<ThemedView style={{ flex: 1, alignItems: 'center', justifyContent: 'center' }}>
|
||||
<ActivityIndicator color={colors.accent} />
|
||||
<ThemedText preset="bodySm" color="textSecondary" style={{ marginTop: 8 }}>
|
||||
Loading {label}
|
||||
</ThemedText>
|
||||
</ThemedView>
|
||||
}
|
||||
>
|
||||
<LazyPlaceholder />
|
||||
</Suspense>
|
||||
);
|
||||
|
||||
return Wrapped;
|
||||
};
|
||||
|
||||
const loadScreen = (path: string, label: string) => {
|
||||
const fallback = createPlaceholder(label);
|
||||
return React.lazy(async () => {
|
||||
try {
|
||||
const module = (await import(path)) as { default: React.ComponentType };
|
||||
if (module?.default) {
|
||||
return module;
|
||||
}
|
||||
} catch {
|
||||
// keep fallback for shell-only screens
|
||||
}
|
||||
return { default: fallback } as { default: React.ComponentType };
|
||||
});
|
||||
};
|
||||
|
||||
const LiveScreen = loadScreen('../screens/LiveScreen', 'Live');
|
||||
const VitalsScreen = loadScreen('../screens/VitalsScreen', 'Vitals');
|
||||
const ZonesScreen = loadScreen('../screens/ZonesScreen', 'Zones');
|
||||
const MATScreen = loadScreen('../screens/MATScreen', 'MAT');
|
||||
const SettingsScreen = loadScreen('../screens/SettingsScreen', 'Settings');
|
||||
|
||||
const toIconName = (routeName: keyof MainTabsParamList) => {
|
||||
switch (routeName) {
|
||||
case 'Live':
|
||||
return 'wifi';
|
||||
case 'Vitals':
|
||||
return 'heart';
|
||||
case 'Zones':
|
||||
return 'grid';
|
||||
case 'MAT':
|
||||
return 'shield-checkmark';
|
||||
case 'Settings':
|
||||
return 'settings';
|
||||
default:
|
||||
return 'ellipse';
|
||||
}
|
||||
};
|
||||
|
||||
const screens: ReadonlyArray<{ name: keyof MainTabsParamList; component: React.ComponentType }> = [
|
||||
{ name: 'Live', component: LiveScreen },
|
||||
{ name: 'Vitals', component: VitalsScreen },
|
||||
{ name: 'Zones', component: ZonesScreen },
|
||||
{ name: 'MAT', component: MATScreen },
|
||||
{ name: 'Settings', component: SettingsScreen },
|
||||
];
|
||||
|
||||
const Tab = createBottomTabNavigator<MainTabsParamList>();
|
||||
|
||||
const Suspended = ({ component: Component }: { component: React.ComponentType }) => (
|
||||
<Suspense fallback={<ActivityIndicator color={colors.accent} />}>
|
||||
<Component />
|
||||
</Suspense>
|
||||
);
|
||||
|
||||
export const MainTabs = () => {
|
||||
const matAlertCount = useMatStore((state) => state.alerts.length);
|
||||
|
||||
return (
|
||||
<Tab.Navigator
|
||||
screenOptions={({ route }) => ({
|
||||
headerShown: false,
|
||||
tabBarActiveTintColor: colors.accent,
|
||||
tabBarInactiveTintColor: colors.textSecondary,
|
||||
tabBarStyle: {
|
||||
backgroundColor: '#0D1117',
|
||||
borderTopColor: colors.border,
|
||||
borderTopWidth: 1,
|
||||
},
|
||||
tabBarIcon: ({ color, size }) => <Ionicons name={toIconName(route.name)} size={size} color={color} />,
|
||||
tabBarLabelStyle: {
|
||||
fontFamily: 'Courier New',
|
||||
textTransform: 'uppercase',
|
||||
fontSize: 10,
|
||||
},
|
||||
tabBarLabel: ({ children, color }) => <ThemedText style={{ color }}>{children}</ThemedText>,
|
||||
})}
|
||||
>
|
||||
{screens.map(({ name, component }) => (
|
||||
<Tab.Screen
|
||||
key={name}
|
||||
name={name}
|
||||
options={{
|
||||
tabBarBadge: name === 'MAT' ? (matAlertCount > 0 ? matAlertCount : undefined) : undefined,
|
||||
}}
|
||||
component={() => <Suspended component={component} />}
|
||||
/>
|
||||
))}
|
||||
</Tab.Navigator>
|
||||
);
|
||||
};
|
||||
@@ -1,5 +0,0 @@
|
||||
import { MainTabs } from './MainTabs';
|
||||
|
||||
export const RootNavigator = () => {
|
||||
return <MainTabs />;
|
||||
};
|
||||
@@ -1,11 +0,0 @@
|
||||
export type RootStackParamList = {
|
||||
MainTabs: undefined;
|
||||
};
|
||||
|
||||
export type MainTabsParamList = {
|
||||
Live: undefined;
|
||||
Vitals: undefined;
|
||||
Zones: undefined;
|
||||
MAT: undefined;
|
||||
Settings: undefined;
|
||||
};
|
||||
@@ -1,41 +0,0 @@
|
||||
import { LayoutChangeEvent, StyleSheet } from 'react-native';
|
||||
import type { RefObject } from 'react';
|
||||
import { WebView, type WebViewMessageEvent } from 'react-native-webview';
|
||||
import GAUSSIAN_SPLATS_HTML from '@/assets/webview/gaussian-splats.html';
|
||||
|
||||
type GaussianSplatWebViewProps = {
|
||||
onMessage: (event: WebViewMessageEvent) => void;
|
||||
onError: () => void;
|
||||
webViewRef: RefObject<WebView | null>;
|
||||
onLayout?: (event: LayoutChangeEvent) => void;
|
||||
};
|
||||
|
||||
export const GaussianSplatWebView = ({
|
||||
onMessage,
|
||||
onError,
|
||||
webViewRef,
|
||||
onLayout,
|
||||
}: GaussianSplatWebViewProps) => {
|
||||
const html = typeof GAUSSIAN_SPLATS_HTML === 'string' ? GAUSSIAN_SPLATS_HTML : '';
|
||||
|
||||
return (
|
||||
<WebView
|
||||
ref={webViewRef}
|
||||
source={{ html }}
|
||||
originWhitelist={['*']}
|
||||
allowFileAccess={false}
|
||||
javaScriptEnabled
|
||||
onMessage={onMessage}
|
||||
onError={onError}
|
||||
onLayout={onLayout}
|
||||
style={styles.webView}
|
||||
/>
|
||||
);
|
||||
};
|
||||
|
||||
const styles = StyleSheet.create({
|
||||
webView: {
|
||||
flex: 1,
|
||||
backgroundColor: '#0A0E1A',
|
||||
},
|
||||
});
|
||||
@@ -1,164 +0,0 @@
|
||||
import { Pressable, StyleSheet, View } from 'react-native';
|
||||
import { memo, useCallback, useState } from 'react';
|
||||
import Animated, { useAnimatedStyle, useSharedValue, withTiming } from 'react-native-reanimated';
|
||||
import { StatusDot } from '@/components/StatusDot';
|
||||
import { ModeBadge } from '@/components/ModeBadge';
|
||||
import { ThemedText } from '@/components/ThemedText';
|
||||
import { formatConfidence, formatRssi } from '@/utils/formatters';
|
||||
import { colors, spacing } from '@/theme';
|
||||
import type { ConnectionStatus } from '@/types/sensing';
|
||||
|
||||
type LiveMode = 'LIVE' | 'SIM' | 'RSSI';
|
||||
|
||||
type LiveHUDProps = {
|
||||
rssi?: number;
|
||||
connectionStatus: ConnectionStatus;
|
||||
fps: number;
|
||||
confidence: number;
|
||||
personCount: number;
|
||||
mode: LiveMode;
|
||||
};
|
||||
|
||||
const statusTextMap: Record<ConnectionStatus, string> = {
|
||||
connected: 'Connected',
|
||||
simulated: 'Simulated',
|
||||
connecting: 'Connecting',
|
||||
disconnected: 'Disconnected',
|
||||
};
|
||||
|
||||
const statusDotStatusMap: Record<ConnectionStatus, 'connected' | 'simulated' | 'disconnected' | 'connecting'> = {
|
||||
connected: 'connected',
|
||||
simulated: 'simulated',
|
||||
connecting: 'connecting',
|
||||
disconnected: 'disconnected',
|
||||
};
|
||||
|
||||
export const LiveHUD = memo(
|
||||
({ rssi, connectionStatus, fps, confidence, personCount, mode }: LiveHUDProps) => {
|
||||
const [panelVisible, setPanelVisible] = useState(true);
|
||||
const panelAlpha = useSharedValue(1);
|
||||
|
||||
const togglePanel = useCallback(() => {
|
||||
const next = !panelVisible;
|
||||
setPanelVisible(next);
|
||||
panelAlpha.value = withTiming(next ? 1 : 0, { duration: 220 });
|
||||
}, [panelAlpha, panelVisible]);
|
||||
|
||||
const animatedPanelStyle = useAnimatedStyle(() => ({
|
||||
opacity: panelAlpha.value,
|
||||
}));
|
||||
|
||||
const statusText = statusTextMap[connectionStatus];
|
||||
|
||||
return (
|
||||
<Pressable style={StyleSheet.absoluteFill} onPress={togglePanel}>
|
||||
<Animated.View pointerEvents="none" style={[StyleSheet.absoluteFill, animatedPanelStyle]}>
|
||||
{/* App title */}
|
||||
<View style={styles.topLeft}>
|
||||
<ThemedText preset="labelLg" style={styles.appTitle}>
|
||||
WiFi-DensePose
|
||||
</ThemedText>
|
||||
</View>
|
||||
|
||||
{/* Status + FPS */}
|
||||
<View style={styles.topRight}>
|
||||
<View style={styles.row}>
|
||||
<StatusDot status={statusDotStatusMap[connectionStatus]} size={10} />
|
||||
<ThemedText preset="labelMd" style={styles.statusText}>
|
||||
{statusText}
|
||||
</ThemedText>
|
||||
</View>
|
||||
{fps > 0 && (
|
||||
<View style={styles.row}>
|
||||
<ThemedText preset="labelMd">{fps} FPS</ThemedText>
|
||||
</View>
|
||||
)}
|
||||
</View>
|
||||
|
||||
{/* Bottom panel */}
|
||||
<View style={styles.bottomPanel}>
|
||||
<View style={styles.bottomCell}>
|
||||
<ThemedText preset="bodySm">RSSI</ThemedText>
|
||||
<ThemedText preset="displayMd" style={styles.bigValue}>
|
||||
{formatRssi(rssi)}
|
||||
</ThemedText>
|
||||
</View>
|
||||
|
||||
<View style={styles.bottomCell}>
|
||||
<ModeBadge mode={mode} />
|
||||
</View>
|
||||
|
||||
<View style={styles.bottomCellRight}>
|
||||
<ThemedText preset="bodySm">Confidence</ThemedText>
|
||||
<ThemedText preset="bodyMd" style={styles.metaText}>
|
||||
{formatConfidence(confidence)}
|
||||
</ThemedText>
|
||||
<ThemedText preset="bodySm">People: {personCount}</ThemedText>
|
||||
</View>
|
||||
</View>
|
||||
</Animated.View>
|
||||
</Pressable>
|
||||
);
|
||||
},
|
||||
);
|
||||
|
||||
const styles = StyleSheet.create({
|
||||
topLeft: {
|
||||
position: 'absolute',
|
||||
top: spacing.md,
|
||||
left: spacing.md,
|
||||
},
|
||||
appTitle: {
|
||||
color: colors.textPrimary,
|
||||
},
|
||||
topRight: {
|
||||
position: 'absolute',
|
||||
top: spacing.md,
|
||||
right: spacing.md,
|
||||
alignItems: 'flex-end',
|
||||
gap: 4,
|
||||
},
|
||||
row: {
|
||||
flexDirection: 'row',
|
||||
alignItems: 'center',
|
||||
gap: spacing.sm,
|
||||
},
|
||||
statusText: {
|
||||
color: colors.textPrimary,
|
||||
},
|
||||
bottomPanel: {
|
||||
position: 'absolute',
|
||||
left: spacing.sm,
|
||||
right: spacing.sm,
|
||||
bottom: spacing.sm,
|
||||
minHeight: 72,
|
||||
borderRadius: 12,
|
||||
backgroundColor: 'rgba(10,14,26,0.72)',
|
||||
borderWidth: 1,
|
||||
borderColor: 'rgba(50,184,198,0.35)',
|
||||
paddingHorizontal: spacing.md,
|
||||
paddingVertical: spacing.sm,
|
||||
flexDirection: 'row',
|
||||
justifyContent: 'space-between',
|
||||
alignItems: 'center',
|
||||
},
|
||||
bottomCell: {
|
||||
flex: 1,
|
||||
alignItems: 'center',
|
||||
},
|
||||
bottomCellRight: {
|
||||
flex: 1,
|
||||
alignItems: 'flex-end',
|
||||
},
|
||||
bigValue: {
|
||||
color: colors.accent,
|
||||
marginTop: 2,
|
||||
marginBottom: 2,
|
||||
},
|
||||
metaText: {
|
||||
color: colors.textPrimary,
|
||||
marginBottom: 4,
|
||||
},
|
||||
});
|
||||
|
||||
LiveHUD.displayName = 'LiveHUD';
|
||||
@@ -1,215 +0,0 @@
|
||||
import { useCallback, useEffect, useRef, useState } from 'react';
|
||||
import { Button, LayoutChangeEvent, StyleSheet, View } from 'react-native';
|
||||
import type { WebView } from 'react-native-webview';
|
||||
import type { WebViewMessageEvent } from 'react-native-webview';
|
||||
import { ErrorBoundary } from '@/components/ErrorBoundary';
|
||||
import { LoadingSpinner } from '@/components/LoadingSpinner';
|
||||
import { ThemedText } from '@/components/ThemedText';
|
||||
import { ThemedView } from '@/components/ThemedView';
|
||||
import { usePoseStream } from '@/hooks/usePoseStream';
|
||||
import { colors, spacing } from '@/theme';
|
||||
import type { ConnectionStatus, SensingFrame } from '@/types/sensing';
|
||||
import { useGaussianBridge } from './useGaussianBridge';
|
||||
import { GaussianSplatWebView } from './GaussianSplatWebView';
|
||||
import { LiveHUD } from './LiveHUD';
|
||||
|
||||
type LiveMode = 'LIVE' | 'SIM' | 'RSSI';
|
||||
|
||||
const getMode = (
|
||||
status: ConnectionStatus,
|
||||
isSimulated: boolean,
|
||||
frame: SensingFrame | null,
|
||||
): LiveMode => {
|
||||
if (isSimulated || frame?.source === 'simulated') {
|
||||
return 'SIM';
|
||||
}
|
||||
|
||||
if (status === 'connected') {
|
||||
return 'LIVE';
|
||||
}
|
||||
|
||||
return 'RSSI';
|
||||
};
|
||||
|
||||
const dispatchWebViewMessage = (webViewRef: { current: WebView | null }, message: unknown) => {
|
||||
const webView = webViewRef.current;
|
||||
if (!webView) {
|
||||
return;
|
||||
}
|
||||
|
||||
const payload = JSON.stringify(message);
|
||||
webView.injectJavaScript(
|
||||
`window.dispatchEvent(new MessageEvent('message', { data: ${JSON.stringify(payload)} })); true;`,
|
||||
);
|
||||
};
|
||||
|
||||
export const LiveScreen = () => {
|
||||
const webViewRef = useRef<WebView | null>(null);
|
||||
const { lastFrame, connectionStatus, isSimulated } = usePoseStream();
|
||||
const bridge = useGaussianBridge(webViewRef);
|
||||
|
||||
const [webError, setWebError] = useState<string | null>(null);
|
||||
const [viewerKey, setViewerKey] = useState(0);
|
||||
const sendTimeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null);
|
||||
const pendingFrameRef = useRef<SensingFrame | null>(null);
|
||||
const lastSentAtRef = useRef(0);
|
||||
|
||||
const clearSendTimeout = useCallback(() => {
|
||||
if (!sendTimeoutRef.current) {
|
||||
return;
|
||||
}
|
||||
clearTimeout(sendTimeoutRef.current);
|
||||
sendTimeoutRef.current = null;
|
||||
}, []);
|
||||
|
||||
useEffect(() => {
|
||||
if (!lastFrame) {
|
||||
return;
|
||||
}
|
||||
|
||||
pendingFrameRef.current = lastFrame;
|
||||
const now = Date.now();
|
||||
|
||||
const flush = () => {
|
||||
if (!bridge.isReady || !pendingFrameRef.current) {
|
||||
return;
|
||||
}
|
||||
|
||||
bridge.sendFrame(pendingFrameRef.current);
|
||||
lastSentAtRef.current = Date.now();
|
||||
pendingFrameRef.current = null;
|
||||
};
|
||||
|
||||
const waitMs = Math.max(0, 500 - (now - lastSentAtRef.current));
|
||||
|
||||
if (waitMs <= 0) {
|
||||
flush();
|
||||
return;
|
||||
}
|
||||
|
||||
clearSendTimeout();
|
||||
sendTimeoutRef.current = setTimeout(() => {
|
||||
sendTimeoutRef.current = null;
|
||||
flush();
|
||||
}, waitMs);
|
||||
|
||||
return () => {
|
||||
clearSendTimeout();
|
||||
};
|
||||
}, [bridge.isReady, lastFrame, bridge.sendFrame, clearSendTimeout]);
|
||||
|
||||
useEffect(() => {
|
||||
return () => {
|
||||
dispatchWebViewMessage(webViewRef, { type: 'DISPOSE' });
|
||||
clearSendTimeout();
|
||||
pendingFrameRef.current = null;
|
||||
};
|
||||
}, [clearSendTimeout]);
|
||||
|
||||
const onMessage = useCallback(
|
||||
(event: WebViewMessageEvent) => {
|
||||
bridge.onMessage(event);
|
||||
},
|
||||
[bridge],
|
||||
);
|
||||
|
||||
const onLayout = useCallback((event: LayoutChangeEvent) => {
|
||||
const { width, height } = event.nativeEvent.layout;
|
||||
if (width <= 0 || height <= 0 || Number.isNaN(width) || Number.isNaN(height)) {
|
||||
return;
|
||||
}
|
||||
|
||||
dispatchWebViewMessage(webViewRef, {
|
||||
type: 'RESIZE',
|
||||
payload: {
|
||||
width: Math.max(1, Math.floor(width)),
|
||||
height: Math.max(1, Math.floor(height)),
|
||||
},
|
||||
});
|
||||
}, []);
|
||||
|
||||
const handleWebError = useCallback(() => {
|
||||
setWebError('Live renderer failed to initialize');
|
||||
}, []);
|
||||
|
||||
const handleRetry = useCallback(() => {
|
||||
setWebError(null);
|
||||
bridge.reset();
|
||||
setViewerKey((value) => value + 1);
|
||||
}, [bridge]);
|
||||
|
||||
const rssi = lastFrame?.features?.mean_rssi;
|
||||
const personCount = lastFrame?.classification?.presence ? 1 : 0;
|
||||
const mode = getMode(connectionStatus, isSimulated, lastFrame);
|
||||
|
||||
if (webError || bridge.error) {
|
||||
return (
|
||||
<ThemedView style={styles.fallbackWrap}>
|
||||
<ThemedText preset="bodyLg">Live visualization failed</ThemedText>
|
||||
<ThemedText preset="bodySm" color="textSecondary" style={styles.errorText}>
|
||||
{webError ?? bridge.error}
|
||||
</ThemedText>
|
||||
<Button title="Retry" onPress={handleRetry} />
|
||||
</ThemedView>
|
||||
);
|
||||
}
|
||||
|
||||
return (
|
||||
<ErrorBoundary>
|
||||
<View style={styles.container}>
|
||||
<GaussianSplatWebView
|
||||
key={viewerKey}
|
||||
webViewRef={webViewRef}
|
||||
onMessage={onMessage}
|
||||
onError={handleWebError}
|
||||
onLayout={onLayout}
|
||||
/>
|
||||
|
||||
<LiveHUD
|
||||
connectionStatus={connectionStatus}
|
||||
fps={bridge.fps}
|
||||
rssi={rssi}
|
||||
confidence={lastFrame?.classification?.confidence ?? 0}
|
||||
personCount={personCount}
|
||||
mode={mode}
|
||||
/>
|
||||
|
||||
{!bridge.isReady && (
|
||||
<View style={styles.loadingWrap}>
|
||||
<LoadingSpinner />
|
||||
<ThemedText preset="bodyMd" style={styles.loadingText}>
|
||||
Loading live renderer
|
||||
</ThemedText>
|
||||
</View>
|
||||
)}
|
||||
</View>
|
||||
</ErrorBoundary>
|
||||
);
|
||||
};
|
||||
|
||||
const styles = StyleSheet.create({
|
||||
container: {
|
||||
flex: 1,
|
||||
backgroundColor: colors.bg,
|
||||
},
|
||||
loadingWrap: {
|
||||
...StyleSheet.absoluteFillObject,
|
||||
backgroundColor: colors.bg,
|
||||
alignItems: 'center',
|
||||
justifyContent: 'center',
|
||||
gap: spacing.md,
|
||||
},
|
||||
loadingText: {
|
||||
color: colors.textSecondary,
|
||||
},
|
||||
fallbackWrap: {
|
||||
flex: 1,
|
||||
alignItems: 'center',
|
||||
justifyContent: 'center',
|
||||
gap: spacing.md,
|
||||
padding: spacing.lg,
|
||||
},
|
||||
errorText: {
|
||||
textAlign: 'center',
|
||||
},
|
||||
});
|
||||
@@ -1,97 +0,0 @@
|
||||
import { useCallback, useState } from 'react';
|
||||
import type { RefObject } from 'react';
|
||||
import type { WebViewMessageEvent } from 'react-native-webview';
|
||||
import { WebView } from 'react-native-webview';
|
||||
import type { SensingFrame } from '@/types/sensing';
|
||||
|
||||
export type GaussianBridgeMessageType = 'READY' | 'FPS_TICK' | 'ERROR';
|
||||
|
||||
type BridgeMessage = {
|
||||
type: GaussianBridgeMessageType;
|
||||
payload?: {
|
||||
fps?: number;
|
||||
message?: string;
|
||||
};
|
||||
};
|
||||
|
||||
const toJsonScript = (message: unknown): string => {
|
||||
const serialized = JSON.stringify(message);
|
||||
return `window.dispatchEvent(new MessageEvent('message', { data: ${JSON.stringify(serialized)} })); true;`;
|
||||
};
|
||||
|
||||
export const useGaussianBridge = (webViewRef: RefObject<WebView | null>) => {
|
||||
const [isReady, setIsReady] = useState(false);
|
||||
const [fps, setFps] = useState(0);
|
||||
const [error, setError] = useState<string | null>(null);
|
||||
|
||||
const send = useCallback((message: unknown) => {
|
||||
const webView = webViewRef.current;
|
||||
if (!webView) {
|
||||
return;
|
||||
}
|
||||
|
||||
webView.injectJavaScript(toJsonScript(message));
|
||||
}, [webViewRef]);
|
||||
|
||||
const sendFrame = useCallback(
|
||||
(frame: SensingFrame) => {
|
||||
send({
|
||||
type: 'FRAME_UPDATE',
|
||||
payload: frame,
|
||||
});
|
||||
},
|
||||
[send],
|
||||
);
|
||||
|
||||
const onMessage = useCallback((event: WebViewMessageEvent) => {
|
||||
let parsed: BridgeMessage | null = null;
|
||||
const raw = event.nativeEvent.data;
|
||||
|
||||
if (typeof raw === 'string') {
|
||||
try {
|
||||
parsed = JSON.parse(raw) as BridgeMessage;
|
||||
} catch {
|
||||
setError('Invalid bridge message format');
|
||||
return;
|
||||
}
|
||||
} else if (typeof raw === 'object' && raw !== null) {
|
||||
parsed = raw as BridgeMessage;
|
||||
}
|
||||
|
||||
if (!parsed) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (parsed.type === 'READY') {
|
||||
setIsReady(true);
|
||||
setError(null);
|
||||
return;
|
||||
}
|
||||
|
||||
if (parsed.type === 'FPS_TICK') {
|
||||
const fpsValue = parsed.payload?.fps;
|
||||
if (typeof fpsValue === 'number' && Number.isFinite(fpsValue)) {
|
||||
setFps(Math.max(0, Math.floor(fpsValue)));
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
if (parsed.type === 'ERROR') {
|
||||
setError(parsed.payload?.message ?? 'Unknown bridge error');
|
||||
setIsReady(false);
|
||||
}
|
||||
}, []);
|
||||
|
||||
return {
|
||||
sendFrame,
|
||||
onMessage,
|
||||
isReady,
|
||||
fps,
|
||||
error,
|
||||
reset: () => {
|
||||
setIsReady(false);
|
||||
setFps(0);
|
||||
setError(null);
|
||||
},
|
||||
};
|
||||
};
|
||||
@@ -1,84 +0,0 @@
|
||||
import { View } from 'react-native';
|
||||
import { ThemedText } from '@/components/ThemedText';
|
||||
import { colors } from '@/theme/colors';
|
||||
import { spacing } from '@/theme/spacing';
|
||||
import { AlertPriority, type Alert } from '@/types/mat';
|
||||
|
||||
type SeverityLevel = 'URGENT' | 'HIGH' | 'NORMAL';
|
||||
|
||||
type AlertCardProps = {
|
||||
alert: Alert;
|
||||
};
|
||||
|
||||
type SeverityMeta = {
|
||||
label: SeverityLevel;
|
||||
icon: string;
|
||||
color: string;
|
||||
};
|
||||
|
||||
const resolveSeverity = (alert: Alert): SeverityMeta => {
|
||||
if (alert.priority === AlertPriority.Critical) {
|
||||
return {
|
||||
label: 'URGENT',
|
||||
icon: '‼',
|
||||
color: colors.danger,
|
||||
};
|
||||
}
|
||||
|
||||
if (alert.priority === AlertPriority.High) {
|
||||
return {
|
||||
label: 'HIGH',
|
||||
icon: '⚠',
|
||||
color: colors.warn,
|
||||
};
|
||||
}
|
||||
|
||||
return {
|
||||
label: 'NORMAL',
|
||||
icon: '•',
|
||||
color: colors.accent,
|
||||
};
|
||||
};
|
||||
|
||||
const formatTime = (value?: string): string => {
|
||||
if (!value) {
|
||||
return 'Unknown';
|
||||
}
|
||||
|
||||
try {
|
||||
return new Date(value).toLocaleTimeString();
|
||||
} catch {
|
||||
return 'Unknown';
|
||||
}
|
||||
};
|
||||
|
||||
export const AlertCard = ({ alert }: AlertCardProps) => {
|
||||
const severity = resolveSeverity(alert);
|
||||
|
||||
return (
|
||||
<View
|
||||
style={{
|
||||
backgroundColor: '#111827',
|
||||
borderWidth: 1,
|
||||
borderColor: `${severity.color}55`,
|
||||
padding: spacing.md,
|
||||
borderRadius: 10,
|
||||
marginBottom: spacing.sm,
|
||||
}}
|
||||
>
|
||||
<View style={{ flexDirection: 'row', alignItems: 'center', gap: 8 }}>
|
||||
<ThemedText preset="labelMd" style={{ color: severity.color }}>
|
||||
{severity.icon} {severity.label}
|
||||
</ThemedText>
|
||||
<View style={{ flex: 1 }}>
|
||||
<ThemedText preset="bodySm" style={{ color: colors.textSecondary }}>
|
||||
{formatTime(alert.created_at)}
|
||||
</ThemedText>
|
||||
</View>
|
||||
</View>
|
||||
<ThemedText preset="bodyMd" style={{ color: colors.textPrimary, marginTop: 6 }}>
|
||||
{alert.message}
|
||||
</ThemedText>
|
||||
</View>
|
||||
);
|
||||
};
|
||||
@@ -1,41 +0,0 @@
|
||||
import { FlatList, View } from 'react-native';
|
||||
import { ThemedText } from '@/components/ThemedText';
|
||||
import { colors } from '@/theme/colors';
|
||||
import { spacing } from '@/theme/spacing';
|
||||
import type { Alert } from '@/types/mat';
|
||||
import { AlertCard } from './AlertCard';
|
||||
|
||||
type AlertListProps = {
|
||||
alerts: Alert[];
|
||||
};
|
||||
|
||||
export const AlertList = ({ alerts }: AlertListProps) => {
|
||||
if (alerts.length === 0) {
|
||||
return (
|
||||
<View
|
||||
style={{
|
||||
alignItems: 'center',
|
||||
justifyContent: 'center',
|
||||
padding: spacing.md,
|
||||
borderWidth: 1,
|
||||
borderColor: colors.border,
|
||||
borderRadius: 12,
|
||||
backgroundColor: '#111827',
|
||||
}}
|
||||
>
|
||||
<ThemedText preset="bodyMd">No alerts — system nominal</ThemedText>
|
||||
</View>
|
||||
);
|
||||
}
|
||||
|
||||
return (
|
||||
<FlatList
|
||||
data={alerts}
|
||||
keyExtractor={(item) => item.id}
|
||||
renderItem={({ item }) => <AlertCard alert={item} />}
|
||||
contentContainerStyle={{ paddingBottom: spacing.md }}
|
||||
showsVerticalScrollIndicator={false}
|
||||
removeClippedSubviews={false}
|
||||
/>
|
||||
);
|
||||
};
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user