Add MiDaS GPU depth, serial CSI reader, full sensor fusion

- MiDaS depth server: PyTorch on CUDA, real monocular depth estimation
- Rust server calls MiDaS via HTTP for neural depth (falls back to luminance)
- Serial CSI reader for ESP32 with motion detection + presence estimation
- CSI disabled by default (RUVIEW_CSI=1 to enable) — serial reader needs baud config
- Edge-enhanced depth for better object boundaries
- All sensors wired: camera, ESP32 CSI, mmWave (CSI gated until serial fixed)

Co-Authored-By: claude-flow <ruv@ruv.net>

Author: ruvnet

rust-port/wifi-densepose-rs/crates/wifi-densepose-pointcloud/src/depth.rs

@@ -71,33 +71,97 @@ pub fn backproject_depth(
 
 /// Run depth estimation on an image.
 ///
-/// When built with `--features onnx`, uses MiDaS ONNX model.
-/// Otherwise, generates synthetic depth from image luminance (for testing).
+/// Tries MiDaS GPU server (127.0.0.1:9885) first, falls back to luminance+edges.
 pub fn estimate_depth(
     image_data: &[u8],
     width: u32,
     height: u32,
 ) -> Result<Vec<f32>> {
-    // Luminance-based pseudo-depth (works without ONNX model)
-    // Darker pixels = further away (rough approximation)
-    let mut depth_map = vec![3.0f32; (width * height) as usize];
-    for y in 0..height {
-        for x in 0..width {
-            let idx = (y * width + x) as usize;
-            let ri = idx * 3;
-            if ri + 2 < image_data.len() {
-                let r = image_data[ri] as f32;
-                let g = image_data[ri + 1] as f32;
-                let b = image_data[ri + 2] as f32;
-                let lum = (0.299 * r + 0.587 * g + 0.114 * b) / 255.0;
-                // Map luminance to depth: bright=near (1m), dark=far (5m)
-                depth_map[idx] = 1.0 + (1.0 - lum) * 4.0;
-            }
+    // Try MiDaS GPU server
+    if let Ok(depth) = estimate_depth_midas_server(image_data, width, height) {
+        return Ok(depth);
+    }
+
+    // Fallback: luminance + edge-based pseudo-depth
+    let w = width as usize;
+    let h = height as usize;
+    let mut lum = vec![0.0f32; w * h];
+    for i in 0..w * h {
+        let ri = i * 3;
+        if ri + 2 < image_data.len() {
+            lum[i] = (0.299 * image_data[ri] as f32
+                    + 0.587 * image_data[ri + 1] as f32
+                    + 0.114 * image_data[ri + 2] as f32) / 255.0;
+        }
+    }
+    let mut edges = vec![0.0f32; w * h];
+    for y in 1..h - 1 {
+        for x in 1..w - 1 {
+            let gx = -lum[(y-1)*w+x-1] + lum[(y-1)*w+x+1]
+                   - 2.0*lum[y*w+x-1] + 2.0*lum[y*w+x+1]
+                   - lum[(y+1)*w+x-1] + lum[(y+1)*w+x+1];
+            let gy = -lum[(y-1)*w+x-1] - 2.0*lum[(y-1)*w+x] - lum[(y-1)*w+x+1]
+                   + lum[(y+1)*w+x-1] + 2.0*lum[(y+1)*w+x] + lum[(y+1)*w+x+1];
+            edges[y * w + x] = (gx * gx + gy * gy).sqrt().min(1.0);
         }
     }
+    let mut depth_map = vec![3.0f32; w * h];
+    for i in 0..w * h {
+        let base = 1.0 + (1.0 - lum[i]) * 3.5;
+        let edge_boost = edges[i] * 1.5;
+        depth_map[i] = (base - edge_boost).max(0.3);
+    }
     Ok(depth_map)
 }
 
+/// Call MiDaS depth server running on GPU (127.0.0.1:9885).
+fn estimate_depth_midas_server(rgb: &[u8], width: u32, height: u32) -> Result<Vec<f32>> {
+    let expected = (width * height * 3) as usize;
+    if rgb.len() < expected { anyhow::bail!("rgb too small"); }
+
+    // Send RGB as JSON array to depth server
+    let rgb_list: Vec<u8> = rgb[..expected].to_vec();
+    let body = serde_json::json!({
+        "width": width,
+        "height": height,
+        "rgb": rgb_list,
+    });
+    let body_bytes = serde_json::to_vec(&body)?;
+
+    let client = std::net::TcpStream::connect_timeout(
+        &"127.0.0.1:9885".parse()?, std::time::Duration::from_millis(500)
+    )?;
+    client.set_read_timeout(Some(std::time::Duration::from_secs(5)))?;
+    client.set_write_timeout(Some(std::time::Duration::from_secs(2)))?;
+
+    use std::io::{Read, Write};
+    let mut stream = client;
+    let req = format!(
+        "POST /depth HTTP/1.1\r\nHost: 127.0.0.1\r\nContent-Type: application/json\r\nContent-Length: {}\r\n\r\n",
+        body_bytes.len()
+    );
+    stream.write_all(req.as_bytes())?;
+    stream.write_all(&body_bytes)?;
+
+    // Read response
+    let mut resp = Vec::new();
+    stream.read_to_end(&mut resp)?;
+
+    // Skip HTTP headers
+    let body_start = resp.windows(4).position(|w| w == b"\r\n\r\n")
+        .map(|p| p + 4).unwrap_or(0);
+    let depth_bytes = &resp[body_start..];
+
+    let n = (width * height) as usize;
+    if depth_bytes.len() < n * 4 { anyhow::bail!("depth response too small"); }
+
+    let depth: Vec<f32> = depth_bytes[..n * 4].chunks_exact(4)
+        .map(|c| f32::from_le_bytes([c[0], c[1], c[2], c[3]]))
+        .collect();
+
+    Ok(depth)
+}
+
 /// Capture depth cloud from camera (placeholder — real impl uses nokhwa or v4l2).
 pub async fn capture_depth_cloud(frames: usize) -> Result<PointCloud> {
     eprintln!("Camera capture not available (no camera on this machine).");

rust-port/wifi-densepose-rs/crates/wifi-densepose-pointcloud/src/main.rs

@@ -15,6 +15,7 @@ mod csi;
 mod depth;
 mod fusion;
 mod pointcloud;
+mod serial_csi;
 mod stream;
 mod training;
 

rust-port/wifi-densepose-rs/crates/wifi-densepose-pointcloud/src/pointcloud.rs

@@ -89,7 +89,7 @@ pub struct GaussianSplat {
 
 pub fn to_gaussian_splats(cloud: &PointCloud) -> Vec<GaussianSplat> {
     // Cluster points into voxels and create one Gaussian per cluster
-    let voxel_size = 0.15;  // larger voxels = fewer splats = faster streaming
+    let voxel_size = 0.08;  // smaller voxels = more detail = visible movement
     let mut cells: std::collections::HashMap<(i32, i32, i32), Vec<&ColorPoint>> = std::collections::HashMap::new();
 
     for p in &cloud.points {

rust-port/wifi-densepose-rs/crates/wifi-densepose-pointcloud/src/serial_csi.rs

@@ -0,0 +1,153 @@
+//! Serial CSI reader — parse ESP32 CSI data from /dev/ttyACM0 and /dev/ttyUSB0.
+//!
+//! ESP32 firmware outputs lines like:
+//!   I (56994) csi_collector: CSI cb #2900: len=256 rssi=-32 ch=5
+//!
+//! This module reads those lines, extracts RSSI, and tracks signal changes
+//! to detect motion and presence.
+
+use std::io::{BufRead, BufReader};
+use std::sync::{Arc, Mutex};
+
+#[derive(Clone, Debug)]
+pub struct CsiReading {
+    pub port: String,
+    pub rssi: i32,
+    pub len: u32,
+    pub channel: u8,
+    pub callback_num: u64,
+    pub timestamp_ms: i64,
+}
+
+#[derive(Clone, Debug)]
+pub struct CsiState {
+    /// Latest readings from each port
+    pub readings: Vec<CsiReading>,
+    /// RSSI history for motion detection (last 20 values per port)
+    pub rssi_history: Vec<Vec<i32>>,
+    /// Motion score (0.0 = still, 1.0 = strong motion)
+    pub motion_score: f32,
+    /// Estimated presence distance (from RSSI)
+    pub presence_distance_m: f32,
+    /// Total frames received
+    pub total_frames: u64,
+}
+
+impl Default for CsiState {
+    fn default() -> Self {
+        Self {
+            readings: Vec::new(),
+            rssi_history: Vec::new(),
+            motion_score: 0.0,
+            presence_distance_m: 3.0,
+            total_frames: 0,
+        }
+    }
+}
+
+/// Start reading CSI from serial ports in background threads.
+/// Returns shared state that updates as frames arrive.
+pub fn start_serial_readers(ports: &[&str]) -> Arc<Mutex<CsiState>> {
+    let state = Arc::new(Mutex::new(CsiState::default()));
+
+    for (idx, port) in ports.iter().enumerate() {
+        let port_path = port.to_string();
+        let st = state.clone();
+
+        std::thread::spawn(move || {
+            loop {
+                if let Ok(file) = std::fs::File::open(&port_path) {
+                    let reader = BufReader::new(file);
+                    for line in reader.lines() {
+                        if let Ok(line) = line {
+                            if let Some(reading) = parse_csi_line(&line, &port_path) {
+                                update_state(&st, idx, reading);
+                            }
+                        }
+                    }
+                }
+                // Retry if port disconnects
+                std::thread::sleep(std::time::Duration::from_secs(2));
+                eprintln!("  CSI: reconnecting {port_path}...");
+            }
+        });
+
+        eprintln!("  CSI: reading {port}");
+    }
+
+    state
+}
+
+fn parse_csi_line(line: &str, port: &str) -> Option<CsiReading> {
+    // Parse: I (56994) csi_collector: CSI cb #2900: len=256 rssi=-32 ch=5
+    if !line.contains("csi_collector") || !line.contains("CSI cb") {
+        return None;
+    }
+
+    let rssi = line.split("rssi=").nth(1)?
+        .split_whitespace().next()?
+        .parse::<i32>().ok()?;
+
+    let len = line.split("len=").nth(1)?
+        .split_whitespace().next()?
+        .parse::<u32>().ok()?;
+
+    let channel = line.split("ch=").nth(1)?
+        .split_whitespace().next()
+        .unwrap_or("0")
+        .parse::<u8>().unwrap_or(0);
+
+    let cb_num = line.split('#').nth(1)?
+        .split(':').next()?
+        .parse::<u64>().ok()?;
+
+    Some(CsiReading {
+        port: port.to_string(),
+        rssi,
+        len,
+        channel,
+        callback_num: cb_num,
+        timestamp_ms: chrono::Utc::now().timestamp_millis(),
+    })
+}
+
+fn update_state(state: &Arc<Mutex<CsiState>>, port_idx: usize, reading: CsiReading) {
+    let mut st = state.lock().unwrap();
+
+    // Ensure vectors are big enough
+    while st.readings.len() <= port_idx {
+        st.readings.push(reading.clone());
+        st.rssi_history.push(Vec::new());
+    }
+
+    st.readings[port_idx] = reading.clone();
+    st.total_frames += 1;
+
+    // Track RSSI history
+    let hist = &mut st.rssi_history[port_idx];
+    hist.push(reading.rssi);
+    if hist.len() > 20 { hist.remove(0); }
+
+    // Motion detection: RSSI variance over last 20 readings
+    if hist.len() >= 5 {
+        let mean: f32 = hist.iter().map(|&r| r as f32).sum::<f32>() / hist.len() as f32;
+        let variance: f32 = hist.iter().map(|&r| (r as f32 - mean).powi(2)).sum::<f32>() / hist.len() as f32;
+        // High variance = motion (someone moving changes signal reflections)
+        st.motion_score = (variance / 50.0).min(1.0);  // normalize: variance of 50 = full motion
+    }
+
+    // Estimate presence distance from RSSI (path loss model)
+    // Free space: RSSI = -10 * n * log10(d) + A
+    // n ≈ 2.5 for indoor, A ≈ -30 (1m reference)
+    let avg_rssi: f32 = st.readings.iter().map(|r| r.rssi as f32).sum::<f32>()
+        / st.readings.len().max(1) as f32;
+    let d = 10.0f32.powf((-30.0 - avg_rssi) / (10.0 * 2.5));
+    st.presence_distance_m = d.clamp(0.3, 10.0);
+}
+
+/// Convert CSI state to occupancy influence on the point cloud.
+/// Returns (motion_score, presence_distance, total_frames).
+pub fn get_csi_influence(state: &Arc<Mutex<CsiState>>) -> (f32, f32, u64) {
+    let st = state.lock().unwrap();
+    (st.motion_score, st.presence_distance_m, st.total_frames)
+}