6e0e539443
- densepose.rs: forward() returns NnError when no weights loaded instead of zeros - translator.rs: forward/encode/decode require loaded weights, error otherwise - fusion.rs: remove rand_range() RNG, RSSI reads return empty with warning log - hardware_adapter.rs: ESP32/Intel/Atheros/UDP/PCAP adapters return AdapterError explaining hardware not connected instead of silent empty readings - csi_receiver.rs: PicoScenes parser returns error instead of empty amplitudes - README.md: add v2.1.0 changelog with all recent changes https://claude.ai/code/session_01Ki7pvEZtJDvqJkmyn6B714
1341 lines
38 KiB
Markdown
1341 lines
38 KiB
Markdown
# WiFi DensePose
|
||
|
||
> **Hardware Required:** This system processes real WiFi Channel State Information (CSI) data. To capture live CSI you need one of:
|
||
>
|
||
> | Option | Hardware | Cost | Capabilities |
|
||
> |--------|----------|------|-------------|
|
||
> | **ESP32 Mesh** (recommended) | 3-6x ESP32-S3 boards + consumer WiFi router | ~$54 | Presence, motion, respiration detection |
|
||
> | **Research NIC** | Intel 5300 or Atheros AR9580 (discontinued) | ~$50-100 | Full CSI with 3x3 MIMO |
|
||
> | **Commodity WiFi** | Any Linux laptop with WiFi | $0 | Presence and coarse motion only (RSSI-based) |
|
||
>
|
||
> Without CSI-capable hardware, you can verify the signal processing pipeline using the included deterministic reference signal: `python v1/data/proof/verify.py`
|
||
>
|
||
> See [docs/adr/ADR-012-esp32-csi-sensor-mesh.md](docs/adr/ADR-012-esp32-csi-sensor-mesh.md) for the ESP32 setup guide and [docs/adr/ADR-013-feature-level-sensing-commodity-gear.md](docs/adr/ADR-013-feature-level-sensing-commodity-gear.md) for the zero-cost RSSI path.
|
||
|
||
[](https://www.python.org/downloads/)
|
||
[](https://fastapi.tiangolo.com/)
|
||
[](https://opensource.org/licenses/MIT)
|
||
[](https://pypi.org/project/wifi-densepose/)
|
||
[](https://pypi.org/project/wifi-densepose/)
|
||
[](https://github.com/ruvnet/wifi-densepose)
|
||
[](https://hub.docker.com/r/ruvnet/wifi-densepose)
|
||
|
||
A cutting-edge WiFi-based human pose estimation system that leverages Channel State Information (CSI) data and advanced machine learning to provide real-time, privacy-preserving pose detection without cameras.
|
||
|
||
## 🚀 Key Features
|
||
|
||
- **Privacy-First**: No cameras required - uses WiFi signals for pose detection
|
||
- **Real-Time Processing**: Sub-50ms latency with 30 FPS pose estimation
|
||
- **Multi-Person Tracking**: Simultaneous tracking of up to 10 individuals
|
||
- **Domain-Specific Optimization**: Healthcare, fitness, smart home, and security applications
|
||
- **Enterprise-Ready**: Production-grade API with authentication, rate limiting, and monitoring
|
||
- **Hardware Agnostic**: Works with standard WiFi routers and access points
|
||
- **Comprehensive Analytics**: Fall detection, activity recognition, and occupancy monitoring
|
||
- **WebSocket Streaming**: Real-time pose data streaming for live applications
|
||
- **100% Test Coverage**: Thoroughly tested with comprehensive test suite
|
||
|
||
## 🦀 Rust Implementation (v2)
|
||
|
||
A high-performance Rust port is available in `/rust-port/wifi-densepose-rs/`:
|
||
|
||
### Performance Benchmarks (Validated)
|
||
|
||
| Operation | Python (v1) | Rust (v2) | Speedup |
|
||
|-----------|-------------|-----------|---------|
|
||
| CSI Preprocessing (4x64) | ~5ms | **5.19 µs** | ~1000x |
|
||
| Phase Sanitization (4x64) | ~3ms | **3.84 µs** | ~780x |
|
||
| Feature Extraction (4x64) | ~8ms | **9.03 µs** | ~890x |
|
||
| Motion Detection | ~1ms | **186 ns** | ~5400x |
|
||
| **Full Pipeline** | ~15ms | **18.47 µs** | ~810x |
|
||
|
||
### Throughput Metrics
|
||
|
||
| Component | Throughput |
|
||
|-----------|------------|
|
||
| CSI Preprocessing | 49-66 Melem/s |
|
||
| Phase Sanitization | 67-85 Melem/s |
|
||
| Feature Extraction | 7-11 Melem/s |
|
||
| Full Pipeline | **~54,000 fps** |
|
||
|
||
### Resource Comparison
|
||
|
||
| Feature | Python (v1) | Rust (v2) |
|
||
|---------|-------------|-----------|
|
||
| Memory Usage | ~500MB | ~100MB |
|
||
| WASM Support | ❌ | ✅ |
|
||
| Binary Size | N/A | ~10MB |
|
||
| Test Coverage | 100% | 107 tests |
|
||
|
||
**Quick Start (Rust):**
|
||
```bash
|
||
cd rust-port/wifi-densepose-rs
|
||
cargo build --release
|
||
cargo test --workspace
|
||
cargo bench --package wifi-densepose-signal
|
||
```
|
||
|
||
### Validation Tests
|
||
|
||
Mathematical correctness validated:
|
||
- ✅ Phase unwrapping: 0.000000 radians max error
|
||
- ✅ Amplitude RMS: Exact match
|
||
- ✅ Doppler shift: 33.33 Hz (exact)
|
||
- ✅ Correlation: 1.0 for identical signals
|
||
- ✅ Phase coherence: 1.0 for coherent signals
|
||
|
||
See [Rust Port Documentation](/rust-port/wifi-densepose-rs/docs/) for ADRs and DDD patterns.
|
||
|
||
## 🚨 WiFi-Mat: Disaster Response Module
|
||
|
||
A specialized extension for **search and rescue operations** - detecting and localizing survivors trapped in rubble, earthquakes, and natural disasters.
|
||
|
||
### Key Capabilities
|
||
|
||
| Feature | Description |
|
||
|---------|-------------|
|
||
| **Vital Signs Detection** | Breathing (4-60 BPM), heartbeat via micro-Doppler |
|
||
| **3D Localization** | Position estimation through debris up to 5m depth |
|
||
| **START Triage** | Automatic Immediate/Delayed/Minor/Deceased classification |
|
||
| **Real-time Alerts** | Priority-based notifications with escalation |
|
||
|
||
### Use Cases
|
||
|
||
- Earthquake search and rescue
|
||
- Building collapse response
|
||
- Avalanche victim location
|
||
- Mine collapse detection
|
||
- Flood rescue operations
|
||
|
||
### Quick Example
|
||
|
||
```rust
|
||
use wifi_densepose_mat::{DisasterResponse, DisasterConfig, DisasterType, ScanZone, ZoneBounds};
|
||
|
||
let config = DisasterConfig::builder()
|
||
.disaster_type(DisasterType::Earthquake)
|
||
.sensitivity(0.85)
|
||
.max_depth(5.0)
|
||
.build();
|
||
|
||
let mut response = DisasterResponse::new(config);
|
||
response.initialize_event(location, "Building collapse")?;
|
||
response.add_zone(ScanZone::new("North Wing", ZoneBounds::rectangle(0.0, 0.0, 30.0, 20.0)))?;
|
||
response.start_scanning().await?;
|
||
|
||
// Get survivors prioritized by triage status
|
||
let immediate = response.survivors_by_triage(TriageStatus::Immediate);
|
||
println!("{} survivors require immediate rescue", immediate.len());
|
||
```
|
||
|
||
### Documentation
|
||
|
||
- **[WiFi-Mat User Guide](docs/wifi-mat-user-guide.md)** - Complete setup, configuration, and field deployment
|
||
- **[Architecture Decision Record](docs/adr/ADR-001-wifi-mat-disaster-detection.md)** - Design decisions and rationale
|
||
- **[Domain Model](docs/ddd/wifi-mat-domain-model.md)** - DDD bounded contexts and entities
|
||
|
||
**Build:**
|
||
```bash
|
||
cd rust-port/wifi-densepose-rs
|
||
cargo build --release --package wifi-densepose-mat
|
||
cargo test --package wifi-densepose-mat
|
||
```
|
||
|
||
## 📋 Table of Contents
|
||
|
||
<table>
|
||
<tr>
|
||
<td width="50%">
|
||
|
||
**🚀 Getting Started**
|
||
- [Key Features](#-key-features)
|
||
- [Rust Implementation (v2)](#-rust-implementation-v2)
|
||
- [WiFi-Mat Disaster Response](#-wifi-mat-disaster-response-module)
|
||
- [System Architecture](#️-system-architecture)
|
||
- [Installation](#-installation)
|
||
- [Using pip (Recommended)](#using-pip-recommended)
|
||
- [From Source](#from-source)
|
||
- [Using Docker](#using-docker)
|
||
- [System Requirements](#system-requirements)
|
||
- [Quick Start](#-quick-start)
|
||
- [Basic Setup](#1-basic-setup)
|
||
- [Start the System](#2-start-the-system)
|
||
- [Using the REST API](#3-using-the-rest-api)
|
||
- [Real-time Streaming](#4-real-time-streaming)
|
||
|
||
**🖥️ Usage & Configuration**
|
||
- [CLI Usage](#️-cli-usage)
|
||
- [Installation](#cli-installation)
|
||
- [Basic Commands](#basic-commands)
|
||
- [Configuration Commands](#configuration-commands)
|
||
- [Examples](#cli-examples)
|
||
- [Documentation](#-documentation)
|
||
- [Core Documentation](#-core-documentation)
|
||
- [Quick Links](#-quick-links)
|
||
- [API Overview](#-api-overview)
|
||
- [Hardware Setup](#-hardware-setup)
|
||
- [Supported Hardware](#supported-hardware)
|
||
- [Physical Setup](#physical-setup)
|
||
- [Network Configuration](#network-configuration)
|
||
- [Environment Calibration](#environment-calibration)
|
||
|
||
</td>
|
||
<td width="50%">
|
||
|
||
**⚙️ Advanced Topics**
|
||
- [Configuration](#️-configuration)
|
||
- [Environment Variables](#environment-variables)
|
||
- [Domain-Specific Configurations](#domain-specific-configurations)
|
||
- [Advanced Configuration](#advanced-configuration)
|
||
- [Testing](#-testing)
|
||
- [Running Tests](#running-tests)
|
||
- [Test Categories](#test-categories)
|
||
- [Mock Testing](#mock-testing)
|
||
- [Continuous Integration](#continuous-integration)
|
||
- [Deployment](#-deployment)
|
||
- [Production Deployment](#production-deployment)
|
||
- [Infrastructure as Code](#infrastructure-as-code)
|
||
- [Monitoring and Logging](#monitoring-and-logging)
|
||
|
||
**📊 Performance & Community**
|
||
- [Performance Metrics](#-performance-metrics)
|
||
- [Benchmark Results](#benchmark-results)
|
||
- [Performance Optimization](#performance-optimization)
|
||
- [Load Testing](#load-testing)
|
||
- [Contributing](#-contributing)
|
||
- [Development Setup](#development-setup)
|
||
- [Code Standards](#code-standards)
|
||
- [Contribution Process](#contribution-process)
|
||
- [Code Review Checklist](#code-review-checklist)
|
||
- [License](#-license)
|
||
- [Acknowledgments](#-acknowledgments)
|
||
- [Support](#-support)
|
||
|
||
</td>
|
||
</tr>
|
||
</table>
|
||
|
||
## 🏗️ System Architecture
|
||
|
||
WiFi DensePose consists of several key components working together:
|
||
|
||
```
|
||
┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐
|
||
│ WiFi Router │ │ WiFi Router │ │ WiFi Router │
|
||
│ (CSI Source) │ │ (CSI Source) │ │ (CSI Source) │
|
||
└─────────┬───────┘ └─────────┬───────┘ └─────────┬───────┘
|
||
│ │ │
|
||
└──────────────────────┼──────────────────────┘
|
||
│
|
||
┌─────────────▼─────────────┐
|
||
│ CSI Data Collector │
|
||
│ (Hardware Interface) │
|
||
└─────────────┬─────────────┘
|
||
│
|
||
┌─────────────▼─────────────┐
|
||
│ Signal Processor │
|
||
│ (Phase Sanitization) │
|
||
└─────────────┬─────────────┘
|
||
│
|
||
┌─────────────▼─────────────┐
|
||
│ Neural Network Model │
|
||
│ (DensePose Head) │
|
||
└─────────────┬─────────────┘
|
||
│
|
||
┌─────────────▼─────────────┐
|
||
│ Person Tracker │
|
||
│ (Multi-Object Tracking) │
|
||
└─────────────┬─────────────┘
|
||
│
|
||
┌───────────────────────┼───────────────────────┐
|
||
│ │ │
|
||
┌─────────▼─────────┐ ┌─────────▼─────────┐ ┌─────────▼─────────┐
|
||
│ REST API │ │ WebSocket API │ │ Analytics │
|
||
│ (CRUD Operations)│ │ (Real-time Stream)│ │ (Fall Detection) │
|
||
└───────────────────┘ └───────────────────┘ └───────────────────┘
|
||
```
|
||
|
||
### Core Components
|
||
|
||
- **CSI Processor**: Extracts and processes Channel State Information from WiFi signals
|
||
- **Phase Sanitizer**: Removes hardware-specific phase offsets and noise
|
||
- **DensePose Neural Network**: Converts CSI data to human pose keypoints
|
||
- **Multi-Person Tracker**: Maintains consistent person identities across frames
|
||
- **REST API**: Comprehensive API for data access and system control
|
||
- **WebSocket Streaming**: Real-time pose data broadcasting
|
||
- **Analytics Engine**: Advanced analytics including fall detection and activity recognition
|
||
|
||
## 📦 Installation
|
||
|
||
### Using pip (Recommended)
|
||
|
||
WiFi-DensePose is now available on PyPI for easy installation:
|
||
|
||
```bash
|
||
# Install the latest stable version
|
||
pip install wifi-densepose
|
||
|
||
# Install with specific version
|
||
pip install wifi-densepose==1.0.0
|
||
|
||
# Install with optional dependencies
|
||
pip install wifi-densepose[gpu] # For GPU acceleration
|
||
pip install wifi-densepose[dev] # For development
|
||
pip install wifi-densepose[all] # All optional dependencies
|
||
```
|
||
|
||
### From Source
|
||
|
||
```bash
|
||
git clone https://github.com/ruvnet/wifi-densepose.git
|
||
cd wifi-densepose
|
||
pip install -r requirements.txt
|
||
pip install -e .
|
||
```
|
||
|
||
### Using Docker
|
||
|
||
```bash
|
||
docker pull ruvnet/wifi-densepose:latest
|
||
docker run -p 8000:8000 ruvnet/wifi-densepose:latest
|
||
```
|
||
|
||
### System Requirements
|
||
|
||
- **Python**: 3.8 or higher
|
||
- **Operating System**: Linux (Ubuntu 18.04+), macOS (10.15+), Windows 10+
|
||
- **Memory**: Minimum 4GB RAM, Recommended 8GB+
|
||
- **Storage**: 2GB free space for models and data
|
||
- **Network**: WiFi interface with CSI capability
|
||
- **GPU**: Optional but recommended (NVIDIA GPU with CUDA support)
|
||
|
||
## 🚀 Quick Start
|
||
|
||
### 1. Basic Setup
|
||
|
||
```bash
|
||
# Install the package
|
||
pip install wifi-densepose
|
||
|
||
# Copy example configuration
|
||
cp example.env .env
|
||
|
||
# Edit configuration (set your WiFi interface)
|
||
nano .env
|
||
```
|
||
|
||
### 2. Start the System
|
||
|
||
```python
|
||
from wifi_densepose import WiFiDensePose
|
||
|
||
# Initialize with default configuration
|
||
system = WiFiDensePose()
|
||
|
||
# Start pose estimation
|
||
system.start()
|
||
|
||
# Get latest pose data
|
||
poses = system.get_latest_poses()
|
||
print(f"Detected {len(poses)} persons")
|
||
|
||
# Stop the system
|
||
system.stop()
|
||
```
|
||
|
||
### 3. Using the REST API
|
||
|
||
```bash
|
||
# Start the API server
|
||
wifi-densepose start
|
||
|
||
# Start with custom configuration
|
||
wifi-densepose -c /path/to/config.yaml start
|
||
|
||
# Start with verbose logging
|
||
wifi-densepose -v start
|
||
|
||
# Check server status
|
||
wifi-densepose status
|
||
```
|
||
|
||
The API will be available at `http://localhost:8000`
|
||
|
||
- **API Documentation**: http://localhost:8000/docs
|
||
- **Health Check**: http://localhost:8000/api/v1/health
|
||
- **Latest Poses**: http://localhost:8000/api/v1/pose/latest
|
||
|
||
### 4. Real-time Streaming
|
||
|
||
```python
|
||
import asyncio
|
||
import websockets
|
||
import json
|
||
|
||
async def stream_poses():
|
||
uri = "ws://localhost:8000/ws/pose/stream"
|
||
async with websockets.connect(uri) as websocket:
|
||
while True:
|
||
data = await websocket.recv()
|
||
poses = json.loads(data)
|
||
print(f"Received poses: {len(poses['persons'])} persons detected")
|
||
|
||
# Run the streaming client
|
||
asyncio.run(stream_poses())
|
||
```
|
||
|
||
## 🖥️ CLI Usage
|
||
|
||
WiFi DensePose provides a comprehensive command-line interface for easy system management, configuration, and monitoring.
|
||
|
||
### CLI Installation
|
||
|
||
The CLI is automatically installed with the package:
|
||
|
||
```bash
|
||
# Install WiFi DensePose with CLI
|
||
pip install wifi-densepose
|
||
|
||
# Verify CLI installation
|
||
wifi-densepose --help
|
||
wifi-densepose version
|
||
```
|
||
|
||
### Basic Commands
|
||
|
||
The WiFi-DensePose CLI provides the following commands:
|
||
|
||
```bash
|
||
wifi-densepose [OPTIONS] COMMAND [ARGS]...
|
||
|
||
Options:
|
||
-c, --config PATH Path to configuration file
|
||
-v, --verbose Enable verbose logging
|
||
--debug Enable debug mode
|
||
--help Show this message and exit.
|
||
|
||
Commands:
|
||
config Configuration management commands.
|
||
db Database management commands.
|
||
start Start the WiFi-DensePose API server.
|
||
status Show the status of the WiFi-DensePose API server.
|
||
stop Stop the WiFi-DensePose API server.
|
||
tasks Background task management commands.
|
||
version Show version information.
|
||
```
|
||
|
||
#### Server Management
|
||
```bash
|
||
# Start the WiFi-DensePose API server
|
||
wifi-densepose start
|
||
|
||
# Start with custom configuration
|
||
wifi-densepose -c /path/to/config.yaml start
|
||
|
||
# Start with verbose logging
|
||
wifi-densepose -v start
|
||
|
||
# Start with debug mode
|
||
wifi-densepose --debug start
|
||
|
||
# Check server status
|
||
wifi-densepose status
|
||
|
||
# Stop the server
|
||
wifi-densepose stop
|
||
|
||
# Show version information
|
||
wifi-densepose version
|
||
```
|
||
|
||
### Configuration Commands
|
||
|
||
#### Configuration Management
|
||
```bash
|
||
# Configuration management commands
|
||
wifi-densepose config [SUBCOMMAND]
|
||
|
||
# Examples:
|
||
# Show current configuration
|
||
wifi-densepose config show
|
||
|
||
# Validate configuration file
|
||
wifi-densepose config validate
|
||
|
||
# Create default configuration
|
||
wifi-densepose config init
|
||
|
||
# Edit configuration
|
||
wifi-densepose config edit
|
||
```
|
||
|
||
#### Database Management
|
||
```bash
|
||
# Database management commands
|
||
wifi-densepose db [SUBCOMMAND]
|
||
|
||
# Examples:
|
||
# Initialize database
|
||
wifi-densepose db init
|
||
|
||
# Run database migrations
|
||
wifi-densepose db migrate
|
||
|
||
# Check database status
|
||
wifi-densepose db status
|
||
|
||
# Backup database
|
||
wifi-densepose db backup
|
||
|
||
# Restore database
|
||
wifi-densepose db restore
|
||
```
|
||
|
||
#### Background Tasks
|
||
```bash
|
||
# Background task management commands
|
||
wifi-densepose tasks [SUBCOMMAND]
|
||
|
||
# Examples:
|
||
# List running tasks
|
||
wifi-densepose tasks list
|
||
|
||
# Start background tasks
|
||
wifi-densepose tasks start
|
||
|
||
# Stop background tasks
|
||
wifi-densepose tasks stop
|
||
|
||
# Check task status
|
||
wifi-densepose tasks status
|
||
```
|
||
|
||
### Command Examples
|
||
|
||
#### Complete CLI Reference
|
||
```bash
|
||
# Show help for main command
|
||
wifi-densepose --help
|
||
|
||
# Show help for specific command
|
||
wifi-densepose start --help
|
||
wifi-densepose config --help
|
||
wifi-densepose db --help
|
||
|
||
# Use global options with commands
|
||
wifi-densepose -v status # Verbose status check
|
||
wifi-densepose --debug start # Start with debug logging
|
||
wifi-densepose -c custom.yaml start # Start with custom config
|
||
```
|
||
|
||
#### Common Usage Patterns
|
||
```bash
|
||
# Basic server lifecycle
|
||
wifi-densepose start # Start the server
|
||
wifi-densepose status # Check if running
|
||
wifi-densepose stop # Stop the server
|
||
|
||
# Configuration management
|
||
wifi-densepose config show # View current config
|
||
wifi-densepose config validate # Check config validity
|
||
|
||
# Database operations
|
||
wifi-densepose db init # Initialize database
|
||
wifi-densepose db migrate # Run migrations
|
||
wifi-densepose db status # Check database health
|
||
|
||
# Task management
|
||
wifi-densepose tasks list # List background tasks
|
||
wifi-densepose tasks status # Check task status
|
||
|
||
# Version and help
|
||
wifi-densepose version # Show version info
|
||
wifi-densepose --help # Show help message
|
||
```
|
||
|
||
### CLI Examples
|
||
|
||
#### Complete Setup Workflow
|
||
```bash
|
||
# 1. Check version and help
|
||
wifi-densepose version
|
||
wifi-densepose --help
|
||
|
||
# 2. Initialize configuration
|
||
wifi-densepose config init
|
||
|
||
# 3. Initialize database
|
||
wifi-densepose db init
|
||
|
||
# 4. Start the server
|
||
wifi-densepose start
|
||
|
||
# 5. Check status
|
||
wifi-densepose status
|
||
```
|
||
|
||
#### Development Workflow
|
||
```bash
|
||
# Start with debug logging
|
||
wifi-densepose --debug start
|
||
|
||
# Use custom configuration
|
||
wifi-densepose -c dev-config.yaml start
|
||
|
||
# Check database status
|
||
wifi-densepose db status
|
||
|
||
# Manage background tasks
|
||
wifi-densepose tasks start
|
||
wifi-densepose tasks list
|
||
```
|
||
|
||
#### Production Workflow
|
||
```bash
|
||
# Start with production config
|
||
wifi-densepose -c production.yaml start
|
||
|
||
# Check system status
|
||
wifi-densepose status
|
||
|
||
# Manage database
|
||
wifi-densepose db migrate
|
||
wifi-densepose db backup
|
||
|
||
# Monitor tasks
|
||
wifi-densepose tasks status
|
||
```
|
||
|
||
#### Troubleshooting
|
||
```bash
|
||
# Enable verbose logging
|
||
wifi-densepose -v status
|
||
|
||
# Check configuration
|
||
wifi-densepose config validate
|
||
|
||
# Check database health
|
||
wifi-densepose db status
|
||
|
||
# Restart services
|
||
wifi-densepose stop
|
||
wifi-densepose start
|
||
```
|
||
|
||
## 📚 Documentation
|
||
|
||
Comprehensive documentation is available to help you get started and make the most of WiFi-DensePose:
|
||
|
||
### 📖 Core Documentation
|
||
|
||
- **[User Guide](docs/user_guide.md)** - Complete guide covering installation, setup, basic usage, and examples
|
||
- **[API Reference](docs/api_reference.md)** - Detailed documentation of all public classes, methods, and endpoints
|
||
- **[Deployment Guide](docs/deployment.md)** - Production deployment, Docker setup, Kubernetes, and scaling strategies
|
||
- **[Troubleshooting Guide](docs/troubleshooting.md)** - Common issues, solutions, and diagnostic procedures
|
||
|
||
### 🚀 Quick Links
|
||
|
||
- **Interactive API Docs**: http://localhost:8000/docs (when running)
|
||
- **Health Check**: http://localhost:8000/api/v1/health
|
||
- **Latest Poses**: http://localhost:8000/api/v1/pose/latest
|
||
- **System Status**: http://localhost:8000/api/v1/system/status
|
||
|
||
### 📋 API Overview
|
||
|
||
The system provides a comprehensive REST API and WebSocket streaming:
|
||
|
||
#### Key REST Endpoints
|
||
```bash
|
||
# Pose estimation
|
||
GET /api/v1/pose/latest # Get latest pose data
|
||
GET /api/v1/pose/history # Get historical data
|
||
GET /api/v1/pose/zones/{zone_id} # Get zone-specific data
|
||
|
||
# System management
|
||
GET /api/v1/system/status # System health and status
|
||
POST /api/v1/system/calibrate # Calibrate environment
|
||
GET /api/v1/analytics/summary # Analytics dashboard data
|
||
```
|
||
|
||
#### WebSocket Streaming
|
||
```javascript
|
||
// Real-time pose data
|
||
ws://localhost:8000/ws/pose/stream
|
||
|
||
// Analytics events (falls, alerts)
|
||
ws://localhost:8000/ws/analytics/events
|
||
|
||
// System status updates
|
||
ws://localhost:8000/ws/system/status
|
||
```
|
||
|
||
#### Python SDK Quick Example
|
||
```python
|
||
from wifi_densepose import WiFiDensePoseClient
|
||
|
||
# Initialize client
|
||
client = WiFiDensePoseClient(base_url="http://localhost:8000")
|
||
|
||
# Get latest poses with confidence filtering
|
||
poses = client.get_latest_poses(min_confidence=0.7)
|
||
print(f"Detected {len(poses)} persons")
|
||
|
||
# Get zone occupancy
|
||
occupancy = client.get_zone_occupancy("living_room")
|
||
print(f"Living room occupancy: {occupancy.person_count}")
|
||
```
|
||
|
||
For complete API documentation with examples, see the [API Reference Guide](docs/api_reference.md).
|
||
|
||
## 🔧 Hardware Setup
|
||
|
||
### Supported Hardware
|
||
|
||
WiFi DensePose works with standard WiFi equipment that supports CSI extraction:
|
||
|
||
#### Recommended Routers
|
||
- **ASUS AX6000** (RT-AX88U) - Excellent CSI quality
|
||
- **Netgear Nighthawk AX12** - High performance
|
||
- **TP-Link Archer AX73** - Budget-friendly option
|
||
- **Ubiquiti UniFi 6 Pro** - Enterprise grade
|
||
|
||
#### CSI-Capable Devices
|
||
- Intel WiFi cards (5300, 7260, 8260, 9260)
|
||
- Atheros AR9300 series
|
||
- Broadcom BCM4366 series
|
||
- Qualcomm QCA9984 series
|
||
|
||
### Physical Setup
|
||
|
||
1. **Router Placement**: Position routers to create overlapping coverage areas
|
||
2. **Height**: Mount routers 2-3 meters high for optimal coverage
|
||
3. **Spacing**: 5-10 meter spacing between routers depending on environment
|
||
4. **Orientation**: Ensure antennas are positioned for maximum signal diversity
|
||
|
||
### Network Configuration
|
||
|
||
```bash
|
||
# Configure WiFi interface for CSI extraction
|
||
sudo iwconfig wlan0 mode monitor
|
||
sudo iwconfig wlan0 channel 6
|
||
|
||
# Set up CSI extraction (Intel 5300 example)
|
||
echo 0x4101 | sudo tee /sys/kernel/debug/ieee80211/phy0/iwlwifi/iwldvm/debug/monitor_tx_rate
|
||
```
|
||
|
||
### Environment Calibration
|
||
|
||
```python
|
||
from wifi_densepose import Calibrator
|
||
|
||
# Run environment calibration
|
||
calibrator = Calibrator()
|
||
calibrator.calibrate_environment(
|
||
duration_minutes=10,
|
||
environment_id="room_001"
|
||
)
|
||
|
||
# Apply calibration
|
||
calibrator.apply_calibration()
|
||
```
|
||
|
||
## ⚙️ Configuration
|
||
|
||
### Environment Variables
|
||
|
||
Copy `example.env` to `.env` and configure:
|
||
|
||
```bash
|
||
# Application Settings
|
||
APP_NAME=WiFi-DensePose API
|
||
VERSION=1.0.0
|
||
ENVIRONMENT=production # development, staging, production
|
||
DEBUG=false
|
||
|
||
# Server Settings
|
||
HOST=0.0.0.0
|
||
PORT=8000
|
||
WORKERS=4
|
||
|
||
# Security Settings
|
||
SECRET_KEY=your-secure-secret-key-here
|
||
JWT_ALGORITHM=HS256
|
||
JWT_EXPIRE_HOURS=24
|
||
|
||
# Hardware Settings
|
||
WIFI_INTERFACE=wlan0
|
||
CSI_BUFFER_SIZE=1000
|
||
HARDWARE_POLLING_INTERVAL=0.1
|
||
|
||
# Pose Estimation Settings
|
||
POSE_CONFIDENCE_THRESHOLD=0.7
|
||
POSE_PROCESSING_BATCH_SIZE=32
|
||
POSE_MAX_PERSONS=10
|
||
|
||
# Feature Flags
|
||
ENABLE_AUTHENTICATION=true
|
||
ENABLE_RATE_LIMITING=true
|
||
ENABLE_WEBSOCKETS=true
|
||
ENABLE_REAL_TIME_PROCESSING=true
|
||
ENABLE_HISTORICAL_DATA=true
|
||
```
|
||
|
||
### Domain-Specific Configurations
|
||
|
||
#### Healthcare Configuration
|
||
```python
|
||
config = {
|
||
"domain": "healthcare",
|
||
"detection": {
|
||
"confidence_threshold": 0.8,
|
||
"max_persons": 5,
|
||
"enable_tracking": True
|
||
},
|
||
"analytics": {
|
||
"enable_fall_detection": True,
|
||
"enable_activity_recognition": True,
|
||
"alert_thresholds": {
|
||
"fall_confidence": 0.9,
|
||
"inactivity_timeout": 300
|
||
}
|
||
},
|
||
"privacy": {
|
||
"data_retention_days": 30,
|
||
"anonymize_data": True,
|
||
"enable_encryption": True
|
||
}
|
||
}
|
||
```
|
||
|
||
#### Fitness Configuration
|
||
```python
|
||
config = {
|
||
"domain": "fitness",
|
||
"detection": {
|
||
"confidence_threshold": 0.6,
|
||
"max_persons": 20,
|
||
"enable_tracking": True
|
||
},
|
||
"analytics": {
|
||
"enable_activity_recognition": True,
|
||
"enable_form_analysis": True,
|
||
"metrics": ["rep_count", "form_score", "intensity"]
|
||
}
|
||
}
|
||
```
|
||
|
||
### Advanced Configuration
|
||
|
||
```python
|
||
from wifi_densepose.config import Settings
|
||
|
||
# Load custom configuration
|
||
settings = Settings(
|
||
pose_model_path="/path/to/custom/model.pth",
|
||
neural_network={
|
||
"batch_size": 64,
|
||
"enable_gpu": True,
|
||
"inference_timeout": 500
|
||
},
|
||
tracking={
|
||
"max_age": 30,
|
||
"min_hits": 3,
|
||
"iou_threshold": 0.3
|
||
}
|
||
)
|
||
```
|
||
|
||
## 🧪 Testing
|
||
|
||
WiFi DensePose maintains 100% test coverage with comprehensive testing:
|
||
|
||
### Running Tests
|
||
|
||
```bash
|
||
# Run all tests
|
||
pytest
|
||
|
||
# Run with coverage report
|
||
pytest --cov=wifi_densepose --cov-report=html
|
||
|
||
# Run specific test categories
|
||
pytest tests/unit/ # Unit tests
|
||
pytest tests/integration/ # Integration tests
|
||
pytest tests/e2e/ # End-to-end tests
|
||
pytest tests/performance/ # Performance tests
|
||
```
|
||
|
||
### Test Categories
|
||
|
||
#### Unit Tests (95% coverage)
|
||
- CSI processing algorithms
|
||
- Neural network components
|
||
- Tracking algorithms
|
||
- API endpoints
|
||
- Configuration validation
|
||
|
||
#### Integration Tests
|
||
- Hardware interface integration
|
||
- Database operations
|
||
- WebSocket connections
|
||
- Authentication flows
|
||
|
||
#### End-to-End Tests
|
||
- Complete pose estimation pipeline
|
||
- Multi-person tracking scenarios
|
||
- Real-time streaming
|
||
- Analytics generation
|
||
|
||
#### Performance Tests
|
||
- Latency benchmarks
|
||
- Throughput testing
|
||
- Memory usage profiling
|
||
- Stress testing
|
||
|
||
### Mock Testing
|
||
|
||
For development without hardware:
|
||
|
||
```bash
|
||
# Enable mock mode
|
||
export MOCK_HARDWARE=true
|
||
export MOCK_POSE_DATA=true
|
||
|
||
# Run tests with mocked hardware
|
||
pytest tests/ --mock-hardware
|
||
```
|
||
|
||
### Continuous Integration
|
||
|
||
```yaml
|
||
# .github/workflows/test.yml
|
||
name: Test Suite
|
||
on: [push, pull_request]
|
||
jobs:
|
||
test:
|
||
runs-on: ubuntu-latest
|
||
steps:
|
||
- uses: actions/checkout@v2
|
||
- name: Set up Python
|
||
uses: actions/setup-python@v2
|
||
with:
|
||
python-version: 3.8
|
||
- name: Install dependencies
|
||
run: |
|
||
pip install -r requirements.txt
|
||
pip install -e .
|
||
- name: Run tests
|
||
run: pytest --cov=wifi_densepose --cov-report=xml
|
||
- name: Upload coverage
|
||
uses: codecov/codecov-action@v1
|
||
```
|
||
|
||
## 🚀 Deployment
|
||
|
||
### Production Deployment
|
||
|
||
#### Using Docker
|
||
|
||
```bash
|
||
# Build production image
|
||
docker build -t wifi-densepose:latest .
|
||
|
||
# Run with production configuration
|
||
docker run -d \
|
||
--name wifi-densepose \
|
||
-p 8000:8000 \
|
||
-v /path/to/data:/app/data \
|
||
-v /path/to/models:/app/models \
|
||
-e ENVIRONMENT=production \
|
||
-e SECRET_KEY=your-secure-key \
|
||
wifi-densepose:latest
|
||
```
|
||
|
||
#### Using Docker Compose
|
||
|
||
```yaml
|
||
# docker-compose.yml
|
||
version: '3.8'
|
||
services:
|
||
wifi-densepose:
|
||
image: wifi-densepose:latest
|
||
ports:
|
||
- "8000:8000"
|
||
environment:
|
||
- ENVIRONMENT=production
|
||
- DATABASE_URL=postgresql://user:pass@db:5432/wifi_densepose
|
||
- REDIS_URL=redis://redis:6379/0
|
||
volumes:
|
||
- ./data:/app/data
|
||
- ./models:/app/models
|
||
depends_on:
|
||
- db
|
||
- redis
|
||
|
||
db:
|
||
image: postgres:13
|
||
environment:
|
||
POSTGRES_DB: wifi_densepose
|
||
POSTGRES_USER: user
|
||
POSTGRES_PASSWORD: password
|
||
volumes:
|
||
- postgres_data:/var/lib/postgresql/data
|
||
|
||
redis:
|
||
image: redis:6-alpine
|
||
volumes:
|
||
- redis_data:/data
|
||
|
||
volumes:
|
||
postgres_data:
|
||
redis_data:
|
||
```
|
||
|
||
#### Kubernetes Deployment
|
||
|
||
```yaml
|
||
# k8s/deployment.yaml
|
||
apiVersion: apps/v1
|
||
kind: Deployment
|
||
metadata:
|
||
name: wifi-densepose
|
||
spec:
|
||
replicas: 3
|
||
selector:
|
||
matchLabels:
|
||
app: wifi-densepose
|
||
template:
|
||
metadata:
|
||
labels:
|
||
app: wifi-densepose
|
||
spec:
|
||
containers:
|
||
- name: wifi-densepose
|
||
image: wifi-densepose:latest
|
||
ports:
|
||
- containerPort: 8000
|
||
env:
|
||
- name: ENVIRONMENT
|
||
value: "production"
|
||
- name: DATABASE_URL
|
||
valueFrom:
|
||
secretKeyRef:
|
||
name: wifi-densepose-secrets
|
||
key: database-url
|
||
resources:
|
||
requests:
|
||
memory: "2Gi"
|
||
cpu: "1000m"
|
||
limits:
|
||
memory: "4Gi"
|
||
cpu: "2000m"
|
||
```
|
||
|
||
### Infrastructure as Code
|
||
|
||
#### Terraform (AWS)
|
||
|
||
```hcl
|
||
# terraform/main.tf
|
||
resource "aws_ecs_cluster" "wifi_densepose" {
|
||
name = "wifi-densepose"
|
||
}
|
||
|
||
resource "aws_ecs_service" "wifi_densepose" {
|
||
name = "wifi-densepose"
|
||
cluster = aws_ecs_cluster.wifi_densepose.id
|
||
task_definition = aws_ecs_task_definition.wifi_densepose.arn
|
||
desired_count = 3
|
||
|
||
load_balancer {
|
||
target_group_arn = aws_lb_target_group.wifi_densepose.arn
|
||
container_name = "wifi-densepose"
|
||
container_port = 8000
|
||
}
|
||
}
|
||
```
|
||
|
||
#### Ansible Playbook
|
||
|
||
```yaml
|
||
# ansible/playbook.yml
|
||
- hosts: servers
|
||
become: yes
|
||
tasks:
|
||
- name: Install Docker
|
||
apt:
|
||
name: docker.io
|
||
state: present
|
||
|
||
- name: Deploy WiFi DensePose
|
||
docker_container:
|
||
name: wifi-densepose
|
||
image: wifi-densepose:latest
|
||
ports:
|
||
- "8000:8000"
|
||
env:
|
||
ENVIRONMENT: production
|
||
DATABASE_URL: "{{ database_url }}"
|
||
restart_policy: always
|
||
```
|
||
|
||
### Monitoring and Logging
|
||
|
||
#### Prometheus Metrics
|
||
|
||
```yaml
|
||
# monitoring/prometheus.yml
|
||
global:
|
||
scrape_interval: 15s
|
||
|
||
scrape_configs:
|
||
- job_name: 'wifi-densepose'
|
||
static_configs:
|
||
- targets: ['localhost:8000']
|
||
metrics_path: '/metrics'
|
||
```
|
||
|
||
#### Grafana Dashboard
|
||
|
||
```json
|
||
{
|
||
"dashboard": {
|
||
"title": "WiFi DensePose Monitoring",
|
||
"panels": [
|
||
{
|
||
"title": "Pose Detection Rate",
|
||
"type": "graph",
|
||
"targets": [
|
||
{
|
||
"expr": "rate(pose_detections_total[5m])"
|
||
}
|
||
]
|
||
},
|
||
{
|
||
"title": "Processing Latency",
|
||
"type": "graph",
|
||
"targets": [
|
||
{
|
||
"expr": "histogram_quantile(0.95, pose_processing_duration_seconds_bucket)"
|
||
}
|
||
]
|
||
}
|
||
]
|
||
}
|
||
}
|
||
```
|
||
|
||
## 📊 Performance Metrics
|
||
|
||
### Benchmark Results
|
||
|
||
#### Latency Performance
|
||
- **Average Processing Time**: 45.2ms per frame
|
||
- **95th Percentile**: 67ms
|
||
- **99th Percentile**: 89ms
|
||
- **Real-time Capability**: 30 FPS sustained
|
||
|
||
#### Accuracy Metrics
|
||
- **Pose Detection Accuracy**: 94.2% (compared to camera-based systems)
|
||
- **Person Tracking Accuracy**: 91.8%
|
||
- **Fall Detection Sensitivity**: 96.5%
|
||
- **Fall Detection Specificity**: 94.1%
|
||
|
||
#### Resource Usage
|
||
- **CPU Usage**: 65% (4-core system)
|
||
- **Memory Usage**: 2.1GB RAM
|
||
- **GPU Usage**: 78% (NVIDIA RTX 3080)
|
||
- **Network Bandwidth**: 15 Mbps (CSI data)
|
||
|
||
#### Scalability
|
||
- **Maximum Concurrent Users**: 1000+ WebSocket connections
|
||
- **API Throughput**: 10,000 requests/minute
|
||
- **Data Storage**: 50GB/month (with compression)
|
||
- **Multi-Environment Support**: Up to 50 simultaneous environments
|
||
|
||
### Performance Optimization
|
||
|
||
#### Hardware Optimization
|
||
```python
|
||
# Enable GPU acceleration
|
||
config = {
|
||
"neural_network": {
|
||
"enable_gpu": True,
|
||
"batch_size": 64,
|
||
"mixed_precision": True
|
||
},
|
||
"processing": {
|
||
"num_workers": 4,
|
||
"prefetch_factor": 2
|
||
}
|
||
}
|
||
```
|
||
|
||
#### Software Optimization
|
||
```python
|
||
# Enable performance optimizations
|
||
config = {
|
||
"caching": {
|
||
"enable_redis": True,
|
||
"cache_ttl": 300
|
||
},
|
||
"database": {
|
||
"connection_pool_size": 20,
|
||
"enable_query_cache": True
|
||
}
|
||
}
|
||
```
|
||
|
||
### Load Testing
|
||
|
||
```bash
|
||
# API load testing with Apache Bench
|
||
ab -n 10000 -c 100 http://localhost:8000/api/v1/pose/latest
|
||
|
||
# WebSocket load testing
|
||
python scripts/websocket_load_test.py --connections 1000 --duration 300
|
||
```
|
||
|
||
## 🤝 Contributing
|
||
|
||
We welcome contributions to WiFi DensePose! Please follow these guidelines:
|
||
|
||
### Development Setup
|
||
|
||
```bash
|
||
# Clone the repository
|
||
git clone https://github.com/ruvnet/wifi-densepose.git
|
||
cd wifi-densepose
|
||
|
||
# Create virtual environment
|
||
python -m venv venv
|
||
source venv/bin/activate # On Windows: venv\Scripts\activate
|
||
|
||
# Install development dependencies
|
||
pip install -r requirements-dev.txt
|
||
pip install -e .
|
||
|
||
# Install pre-commit hooks
|
||
pre-commit install
|
||
```
|
||
|
||
### Code Standards
|
||
|
||
- **Python Style**: Follow PEP 8, enforced by Black and Flake8
|
||
- **Type Hints**: Use type hints for all functions and methods
|
||
- **Documentation**: Comprehensive docstrings for all public APIs
|
||
- **Testing**: Maintain 100% test coverage for new code
|
||
- **Security**: Follow OWASP guidelines for security
|
||
|
||
### Contribution Process
|
||
|
||
1. **Fork** the repository
|
||
2. **Create** a feature branch (`git checkout -b feature/amazing-feature`)
|
||
3. **Commit** your changes (`git commit -m 'Add amazing feature'`)
|
||
4. **Push** to the branch (`git push origin feature/amazing-feature`)
|
||
5. **Open** a Pull Request
|
||
|
||
### Code Review Checklist
|
||
|
||
- [ ] Code follows style guidelines
|
||
- [ ] Tests pass and coverage is maintained
|
||
- [ ] Documentation is updated
|
||
- [ ] Security considerations addressed
|
||
- [ ] Performance impact assessed
|
||
- [ ] Backward compatibility maintained
|
||
|
||
### Issue Templates
|
||
|
||
#### Bug Report
|
||
```markdown
|
||
**Describe the bug**
|
||
A clear description of the bug.
|
||
|
||
**To Reproduce**
|
||
Steps to reproduce the behavior.
|
||
|
||
**Expected behavior**
|
||
What you expected to happen.
|
||
|
||
**Environment**
|
||
- OS: [e.g., Ubuntu 20.04]
|
||
- Python version: [e.g., 3.8.10]
|
||
- WiFi DensePose version: [e.g., 1.0.0]
|
||
```
|
||
|
||
#### Feature Request
|
||
```markdown
|
||
**Feature Description**
|
||
A clear description of the feature.
|
||
|
||
**Use Case**
|
||
Describe the use case and benefits.
|
||
|
||
**Implementation Ideas**
|
||
Any ideas on how to implement this feature.
|
||
```
|
||
|
||
## 📄 License
|
||
|
||
This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
|
||
|
||
```
|
||
MIT License
|
||
|
||
Copyright (c) 2025 WiFi DensePose Contributors
|
||
|
||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||
of this software and associated documentation files (the "Software"), to deal
|
||
in the Software without restriction, including without limitation the rights
|
||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||
copies of the Software, and to permit persons to whom the Software is
|
||
furnished to do so, subject to the following conditions:
|
||
|
||
The above copyright notice and this permission notice shall be included in all
|
||
copies or substantial portions of the Software.
|
||
|
||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||
SOFTWARE.
|
||
```
|
||
|
||
## Changelog
|
||
|
||
### v2.1.0 — 2026-02-28
|
||
|
||
- **RuVector RVF integration** — Architecture Decision Records (ADR-002 through ADR-013) defining integration of RVF cognitive containers, HNSW vector search, SONA self-learning, GNN pattern recognition, post-quantum cryptography, distributed consensus, WASM edge runtime, and witness chains
|
||
- **ESP32 CSI sensor mesh** — Firmware specification for $54 starter kit with 3-6 ESP32-S3 nodes, feature-level fusion aggregator, and UDP streaming (ADR-012)
|
||
- **Commodity WiFi sensing** — Zero-cost presence/motion detection via RSSI from any Linux WiFi adapter using `/proc/net/wireless` and `iw` (ADR-013)
|
||
- **Deterministic proof bundle** — One-command pipeline verification (`./verify`) with SHA-256 hash matching against a published reference signal
|
||
- **Real Doppler extraction** — Temporal phase-difference FFT across CSI history frames for true Doppler spectrum computation
|
||
- **Three.js visualization** — 3D body model with 24 DensePose body parts, signal visualization, environment rendering, and WebSocket streaming
|
||
- **Commodity sensing module** — `RssiFeatureExtractor` with FFT spectral analysis, CUSUM change detection, and `PresenceClassifier` with rule-based logic
|
||
- **CI verification pipeline** — GitHub Actions workflow that verifies pipeline determinism and scans for unseeded random calls in production code
|
||
- **Rust hardware adapters** — ESP32, Intel 5300, Atheros, UDP, and PCAP adapters now return explicit errors when no hardware is connected instead of silent empty data
|
||
|
||
## 🙏 Acknowledgments
|
||
|
||
- **Research Foundation**: Based on groundbreaking research in WiFi-based human sensing
|
||
- **Open Source Libraries**: Built on PyTorch, FastAPI, and other excellent open source projects
|
||
- **Community**: Thanks to all contributors and users who make this project possible
|
||
- **Hardware Partners**: Special thanks to router manufacturers for CSI support
|
||
|
||
## 📞 Support
|
||
|
||
- **Documentation**:
|
||
- [User Guide](docs/user_guide.md) - Complete setup and usage guide
|
||
- [API Reference](docs/api_reference.md) - Detailed API documentation
|
||
- [Deployment Guide](docs/deployment.md) - Production deployment instructions
|
||
- [Troubleshooting Guide](docs/troubleshooting.md) - Common issues and solutions
|
||
- **Issues**: [GitHub Issues](https://github.com/ruvnet/wifi-densepose/issues)
|
||
- **Discussions**: [GitHub Discussions](https://github.com/ruvnet/wifi-densepose/discussions)
|
||
- **PyPI Package**: [https://pypi.org/project/wifi-densepose/](https://pypi.org/project/wifi-densepose/)
|
||
- **Email**: support@wifi-densepose.com
|
||
- **Discord**: [Join our community](https://discord.gg/wifi-densepose)
|
||
|
||
---
|
||
|
||
**WiFi DensePose** - Revolutionizing human pose estimation through privacy-preserving WiFi technology. |