import numpy as np
from scipy.signal import butter, filtfilt

def extract_breathing(csi_data, sample_rate=1000):
    """从 CSI 数据中提取呼吸频率"""
    # 1. 提取相位
    phase = np.angle(csi_data)
    
    # 2. 去除载波相位偏移
    phase_unwrapped = np.unwrap(phase)
    
    # 3. 带通滤波（0.1-0.5 Hz 对应 6-30 BPM）
    b, a = butter(2, [0.1/30, 0.5/30], btype='band')
    breathing_signal = filtfilt(b, a, phase_unwrapped)
    
    # 4. FFT 计算呼吸频率
    freqs = np.fft.rfftfreq(len(breathing_signal), 1/sample_rate)
    power = np.abs(np.fft.rfft(breathing_signal))**2
    
    # 5. 找峰值频率
    peak_idx = np.argmax(power)
    breathing_rate = freqs[peak_idx] * 60  # 转换为 BPM
    return breathing_rate

class RuVector:
    """
    RuView 的自学习向量记忆系统
    核心：对比学习（Contrastive Learning）+ 记忆增强
    """
    
    def __init__(self, embedding_dim=256):
        self.encoder = CSIEncoder(embedding_dim)
        self.memory = VectorMemory(capacity=10000)
        self.prototype_bank = PrototypeBank()
    
    def learn(self, csi_batch, labels=None):
        """
        从 CSI 数据中学习表示
        如果有标签（呼吸频率，心率等），使用监督学习
        如果没有标签，使用对比学习
        """
        embeddings = self.encoder(csi_batch)
        
        if labels is not None:
            # 监督学习
            loss = self.supervised_loss(embeddings, labels)
        else:
            # 对比自监督学习
            loss = self.contrastive_loss(embeddings)
        
        # 更新记忆
        self.memory.add(embeddings)
        return loss
    
    def retrieve(self, query):
        """从记忆中检索相似样本"""
        return self.memory.search(query, k=5)

import requests

# 获取当前姿态
response = requests.get("http://localhost:8000/api/v1/pose/latest")
pose_data = response.json()

print(f"检测到 {len(pose_data['persons'])} 人")
for person in pose_data['persons']:
    print(f"  ID: {person['id']}")
    print(f"  位置: ({person['x']:.2f}, {person['y']:.2f})")
    print(f"  骨架: {person['keypoints']}")

import asyncio
import websockets
import json

async def subscribe_pose():
    uri = "ws://localhost:8000/ws/pose"
    async with websockets.connect(uri) as ws:
        await ws.send('{"action": "subscribe", "room": "living_room"}')
        
        async for message in ws:
            data = json.loads(message)
            if data['type'] == 'pose_update':
                print(f"姿态更新: {data['person_count']} 人")

asyncio.run(subscribe_pose())

# 获取所有追踪目标
response = requests.get("http://localhost:8000/api/v1/tracking/all")
tracking_data = response.json()

print(f"当前追踪 {tracking_data['active_count']} / {tracking_data['max_count']} 个目标")

for target in tracking_data['targets']:
    print(f"\n目标 {target['id']}:")
    print(f"  轨迹长度: {len(target['trajectory'])} 点")
    print(f"  当前速度: {target['velocity']:.2f} m/s")
    print(f"  在场时长: {target['dwell_time']:.1f} 秒")

# 克隆仓库
git clone https://github.com/ruvnet/RuView.git
cd RuView/firmware

# 配置 WiFi
idf.py menuconfig
# 设置 WiFi SSID 和密码

# 编译
idf.py build

# 烧录
idf.py flash monitor

# 查看服务状态
curl http://localhost:8000/api/v1/health

# 获取 CSI 统计
curl http://localhost:8000/api/v1/csi/stats

# 获取设备列表
curl http://localhost:8000/api/v1/devices

# 重启服务
docker-compose restart server

// my_processor.rs
use wifi_densepose_rs::prelude::*;

pub struct MyProcessor {
    threshold: f32,
}

impl Processor for MyProcessor {
    fn process(&self, csi: &CSIFrame) -> Result<ProcessingOutput> {
        let filtered = self.apply_filter(&csi.data);
        let peaks = self.detect_peaks(&filtered);
        
        Ok(ProcessingOutput {
            detections: peaks,
            metadata: ProcessingMetadata::new(),
        })
    }
}

// 注册处理器
register_processor!("my_processor", MyProcessor::new);

use wifi_densepose_rs::ml::AdaptiveClassifier;

// 创建分类器
let mut classifier = AdaptiveClassifier::new(15);  // 15 特征

// 配置特征
classifier.set_features(vec![
    "amplitude_mean", "amplitude_std",
    "phase_jitter", "doppler_shift",
    "fresnel_zone_1", "fresnel_zone_2",
]);

// 记录训练数据
classifier.record("sitting", &csi_session_sitting)?;
classifier.record("walking", &csi_session_walking)?;
classifier.record("falling", &csi_session_falling)?;

// 训练模型
classifier.train()?;

// 推理
let activity = classifier.predict(&current_csi)?;
println!("检测到活动: {:?}", activity);

# Home Assistant configuration.yaml
sensor:
  - platform: rest
    name: RuView Breathing Rate
    resource: http://localhost:8000/api/v1/vitals/breathing
    value_template: "{{ value_json.rate }}"
    unit_of_measurement: "BPM"
    scan_interval: 5

automation:
  - alias: "呼吸率异常告警"
    trigger:
      platform: numeric_state
      entity_id: sensor.ruview_breathing_rate
      above: 25
    action:
      service: notify.mobile_app
      data:
        message: "检测到呼吸率异常"