50Hz_NOTCH_FILTER_FIX_README.md

@@ -1,113 +0,0 @@
-# 50Hz陷波滤波器问题修复说明
-
-## 问题描述
-
-在使用50Hz自适应陷波滤波器时，数据出现丢失或过度衰减的问题。主要原因是：
-
-1. **采样率不匹配**：PPG数据的采样率是50Hz，但50Hz陷波滤波器的中心频率正好是50Hz
-2. **奈奎斯特频率限制**：50Hz采样率的奈奎斯特频率是25Hz，50Hz已经超出了这个范围
-3. **滤波器参数不当**：带宽设置过窄（1Hz），导致滤波器不稳定
-
-## 问题分析
-
-### 原始代码问题
-```cpp
-// 问题代码：对于50Hz采样率，50Hz陷波滤波会导致信号丢失
-channels[0] = filter(channels[0], SAMPLE_RATE, 49.5, 50.5, filtertype::notchpass);
-```
-
-### 问题根源
-- **采样率50Hz**：奈奎斯特频率 = 25Hz
-- **目标频率50Hz**：超出奈奎斯特频率，理论上无法被正确采样
-- **陷波滤波**：会过度衰减接近50Hz的所有频率成分
-
-## 修复方案
-
-### 1. 智能采样率检测
-根据采样率自动选择合适的滤波策略：
-
-```cpp
-if (SAMPLE_RATE > 100) {
-    // 高采样率：使用标准陷波滤波
-    channels[0] = filter(channels[0], SAMPLE_RATE, 49.5, 50.5, filtertype::notchpass);
-} else {
-    // 低采样率：使用带阻滤波，避免过度衰减
-    channels[0] = bandstop_filter(channels[0], SAMPLE_RATE, 45.0, 55.0);
-}
-```
-
-### 2. 自适应陷波滤波器保护
-在`adaptive_notch_filter`函数中添加多重保护：
-
-```cpp
-// 检查目标频率是否接近奈奎斯特频率
-const double nyquist_freq = sample_rate / 2.0;
-if (target_freq >= nyquist_freq * 0.8) {
-    std::cerr << "警告: 目标频率接近奈奎斯特频率，跳过陷波滤波" << std::endl;
-    return input;
-}
-```
-
-### 3. 陷波滤波类型自动切换
-在`filter`函数中自动检测并切换滤波类型：
-
-```cpp
-case filtertype::notchpass:
-    double center_freq = 0.5*(high_cutoff+low_cutoff);
-    if (center_freq >= sample_rate * 0.4) {
-        // 频率过高时改用带阻滤波
-        return bandstop_filter(input, sample_rate, low_cutoff, high_cutoff);
-    }
-    return adaptive_notch_filter(input, sample_rate, center_freq, high_cutoff-low_cutoff);
-```
-
-## 修复效果
-
-### 修复前
-- 50Hz采样率数据经过50Hz陷波滤波后信号丢失
-- 滤波器不稳定，可能导致程序崩溃
-- 无法正确处理低采样率数据
-
-### 修复后
-- 自动检测采样率并选择合适的滤波策略
-- 低采样率数据使用温和的带阻滤波
-- 高采样率数据使用精确的陷波滤波
-- 添加多重保护机制，提高系统稳定性
-
-## 使用建议
-
-### 1. 采样率选择
-- **PPG信号**：建议使用100Hz或更高采样率
-- **ECG信号**：建议使用250Hz或更高采样率
-- **EEG信号**：建议使用250Hz或更高采样率
-
-### 2. 滤波器参数
-- **高采样率（>100Hz）**：使用标准陷波滤波，带宽1Hz
-- **低采样率（≤100Hz）**：使用带阻滤波，带宽10Hz
-
-### 3. 监控和调试
-- 启用详细日志输出
-- 监控信号质量指数（SQI）
-- 定期检查滤波后的信号统计信息
-
-## 测试验证
-
-运行测试程序验证修复效果：
-
-```bash
-g++ -o test_notch_filter test_notch_filter.cpp
-./test_notch_filter
-```
-
-测试程序会生成不同采样率下的原始信号和滤波后信号的CSV文件，用于验证滤波效果。
-
-## 总结
-
-通过智能采样率检测和自适应滤波策略，成功解决了50Hz陷波滤波器导致数据丢失的问题。修复后的系统能够：
-
-1. 自动识别采样率限制
-2. 选择合适的滤波策略
-3. 保护信号完整性
-4. 提高系统稳定性
-
-建议在实际应用中根据具体需求调整滤波参数，并定期监控滤波效果。

ENHANCED_MOTION_ARTIFACT_DETECTION_README.md

@@ -1,224 +0,0 @@
-# 增强版运动伪迹检测和去除算法
-
-## 概述
-
-本文档描述了增强版运动伪迹检测和去除算法的实现，该算法显著提高了运动伪迹检测的准确度和处理上限。
-
-## 算法改进对比
-
-### 原始算法（简单版本）
-- **检测方法**：单一窗口统计检测
-- **窗口大小**：固定0.5秒
-- **检测条件**：Z-score > 3.0
-- **修复策略**：简单中值替换
-- **局限性**：误检率高，漏检率高
-
-### 增强版算法
-- **检测方法**：多尺度多特征融合检测
-- **窗口大小**：0.1秒、0.5秒、1.0秒、2.0秒
-- **检测条件**：多条件联合判断
-- **修复策略**：智能自适应修复
-- **优势**：高准确度，低误检率
-
-## 核心算法特性
-
-### 1. 多尺度检测框架
-```
-检测窗口配置：
-- 0.1秒：快速运动伪迹检测
-- 0.5秒：中等运动伪迹检测  
-- 1.0秒：慢速运动伪迹检测
-- 2.0秒：长期漂移检测
-```
-
-### 2. 多特征融合检测
-
-#### 2.1 统计特征检测
-- **均值**：局部信号中心趋势
-- **方差**：信号波动程度
-- **偏度**：信号分布不对称性
-- **峰度**：信号分布尖锐程度
-
-#### 2.2 梯度特征检测
-- **局部梯度**：相邻样本变化率
-- **平均梯度**：窗口内平均变化率
-- **梯度异常**：异常变化检测
-
-#### 2.3 形态学特征检测
-- **尖峰检测**：突发尖峰识别
-- **突变检测**：信号突变识别
-- **基线跳跃**：基线漂移检测
-
-### 3. 频域特征检测
-- **FFT分析**：1024点FFT变换
-- **功率谱密度**：频率成分分析
-- **高频成分检测**：异常高频识别
-- **窗函数应用**：Hanning窗减少泄漏
-
-### 4. 智能修复策略
-
-#### 4.1 多策略修复
-```
-修复策略优先级：
-1. 中值插值（推荐）
-2. 均值插值（备选）
-3. 线性插值（最后选择）
-```
-
-#### 4.2 自适应修复
-- **邻域搜索**：动态邻域范围
-- **质量评估**：修复质量验证
-- **平滑处理**：后处理优化
-
-## 算法参数配置
-
-### 检测阈值
-```cpp
-// 统计检测阈值
-const float Z_SCORE_THRESHOLD = 4.0f;        // Z-score阈值
-const float SKEWNESS_THRESHOLD = 2.0f;       // 偏度阈值
-const float KURTOSIS_THRESHOLD = 8.0f;       // 峰度阈值
-const float VARIANCE_THRESHOLD = 0.5f;       // 方差阈值
-const float GRADIENT_THRESHOLD = 3.0f;       // 梯度阈值
-
-// 频域检测阈值
-const float HIGH_FREQ_RATIO_THRESHOLD = 0.3f; // 高频比例阈值
-```
-
-### 窗口参数
-```cpp
-// 检测窗口配置
-const size_t MIN_WINDOW_SIZE = 0.1 * sample_rate;  // 最小窗口
-const size_t MAX_WINDOW_SIZE = 2.0 * sample_rate;  // 最大窗口
-const size_t FFT_SIZE = 1024;                      // FFT大小
-const size_t SMOOTH_WINDOW = 0.05 * sample_rate;   // 平滑窗口
-```
-
-## 性能指标
-
-### 检测准确度
-- **真阳性率（TPR）**：> 95%
-- **假阳性率（FPR）**：< 5%
-- **漏检率（FNR）**：< 3%
-
-### 处理能力
-- **最大信号长度**：无限制
-- **实时处理能力**：支持
-- **内存占用**：O(n) 线性复杂度
-
-### 质量改善
-- **SNR改善**：平均提升 8-15 dB
-- **方差减少**：平均减少 30-50%
-- **伪迹去除率**：> 90%
-
-## 使用示例
-
-### 基本用法
-```cpp
-#include "signal_processor.h"
-
-SignalProcessor processor;
-std::vector<float> signal = load_signal_data();
-double sample_rate = 100.0; // 100Hz
-
-// 应用增强版运动伪迹检测和去除
-std::vector<float> cleaned_signal = processor.remove_motion_artifacts(signal, sample_rate);
-```
-
-### 参数调优
-```cpp
-// 可以根据具体应用调整检测阈值
-// 例如：对于噪声较大的信号，可以降低Z-score阈值
-// 对于运动伪迹较少的信号，可以提高检测阈值
-```
-
-## 测试验证
-
-### 测试程序
-运行测试程序验证算法效果：
-```bash
-g++ -o test_motion_artifact test_motion_artifact.cpp
-./test_motion_artifact
-```
-
-### 测试结果
-测试程序会生成：
-- `original_with_artifacts.csv`：包含运动伪迹的原始信号
-- `cleaned_signal.csv`：处理后的清洁信号
-- 控制台输出：检测统计信息
-
-## 算法优势
-
-### 1. 高准确度
-- 多特征融合检测
-- 自适应阈值调整
-- 误检率显著降低
-
-### 2. 强鲁棒性
-- 多尺度检测框架
-- 频域时域联合分析
-- 适应不同信号类型
-
-### 3. 智能修复
-- 多策略修复选择
-- 自适应修复参数
-- 质量保持优化
-
-### 4. 高效处理
-- 线性时间复杂度
-- 内存占用优化
-- 实时处理支持
-
-## 应用场景
-
-### 1. 医疗设备
-- **PPG信号处理**：血氧监测
-- **ECG信号处理**：心电监测
-- **EEG信号处理**：脑电监测
-
-### 2. 可穿戴设备
-- **运动监测**：步数、心率
-- **健康监测**：睡眠质量、压力水平
-- **运动伪迹去除**：提高数据质量
-
-### 3. 工业应用
-- **振动监测**：设备状态监测
-- **噪声分析**：环境噪声评估
-- **信号质量提升**：传感器数据优化
-
-## 未来改进方向
-
-### 1. 机器学习集成
-- **深度学习检测**：CNN/LSTM模型
-- **自适应阈值**：在线学习调整
-- **特征自动选择**：最优特征组合
-
-### 2. 实时优化
-- **并行处理**：多线程加速
-- **GPU加速**：CUDA实现
-- **流式处理**：在线实时处理
-
-### 3. 算法扩展
-- **多通道处理**：同步多信号处理
-- **自适应窗口**：动态窗口大小
-- **质量评估**：在线质量监控
-
-## 总结
-
-增强版运动伪迹检测和去除算法通过多尺度检测、多特征融合、智能修复等技术创新，显著提高了算法的准确度和处理上限。该算法适用于各种生物医学信号处理场景，为高质量信号获取提供了强有力的技术支撑。
-
-### 关键改进点
-1. **多尺度检测框架**：提高检测覆盖范围
-2. **多特征融合**：降低误检率和漏检率
-3. **智能修复策略**：保持信号质量
-4. **频域分析**：增强检测能力
-5. **自适应参数**：提高算法鲁棒性
-
-### 性能提升
-- 检测准确度：从70%提升到95%+
-- 处理上限：支持任意长度信号
-- 实时性能：支持在线处理
-- 质量改善：SNR提升8-15dB
-
-
-

data_generated/ppg_a50_metrics.csv

@@ -1,12 +0,0 @@
-指标名称,数值,单位
-心率,54.0188,bpm
-血氧饱和度,93.6356,%
-灌注指数,692.188,%
-脉搏波宽度,15,ms
-红光红外光比值,0.606105,无单位
-信号质量评分,89.8093,%
-均值,2.17968,mV
-标准差,237.063,mV
-最小值,-3367.09,mV
-最大值,4504.26,mV
-峰峰值,7871.35,mV

include/headfile.h

@@ -14,7 +14,7 @@
 #include <numeric>
 #include "device_praser.h"
 #include "data_mapper.h"
-
+#include <windows.h>  // 引入 Windows API 头文件
 #include <cstring>
 #include <random>
 #include<fstream>

include/signal_processor.h

@@ -64,6 +64,11 @@ public:
     // 预处理信号
     SensorData preprocess_signals(const SensorData& raw_data);  // 使用DataType枚举
     SensorData preprocess_generic(const SensorData& data);
+    
+    // 新增：通道级滤波处理
+    std::vector<SensorData> process_channel_based_filtering(
+        const std::vector<SensorData>& data_packets);
+    
     // 新增：简化版通道级滤波处理（测试版本）
     std::vector<SensorData> process_channel_based_filtering_simple(
         const std::vector<SensorData>& data_packets);

log/PPG_A50_PROCESSING_README.md

@@ -1,196 +0,0 @@
-# PPG数据处理功能说明 (A50伤后6h-1.txt)
-
-## 📋 功能概述
-
-专门为处理 `A50伤后6h-1.txt` 文件而设计的PPG数据处理功能，可以读取txt格式的光电容积脉搏波数据，进行信号预处理和生理指标计算。
-
-## 📁 数据文件说明
-
-### 文件位置
-- **文件路径**: `raw_data/A50伤后6h-1.txt`
-- **文件大小**: 28KB
-- **数据行数**: 约3934行
-
-### 数据格式
-- **文件类型**: 纯文本文件 (.txt)
-- **数据格式**: 每行两个数值，用逗号分隔
-- **第一列**: 红光光电容积数据
-- **第二列**: 红外光光电容积数据
-- **示例**:
-```
--8,-10
--10,-11
--12,-10
--17,-9
--17,-9
--21,-8
--20,-7
--20,-8
--21,-6
-```
-
-### 数据特征
-- **数据长度**: 约3934个数据点
-- **数值范围**: 负值，表示光电容积变化
-- **采样率**: 默认设置为50Hz（可在代码中调整）
-- **数据类型**: 光电容积脉搏波 (PPG)
-
-## 🚀 使用方法
-
-### 1. 运行程序
-选择选项3: "处理PPG数据 (A50伤后6h-1.txt)"
-
-### 2. 自动处理流程
-程序会自动执行以下步骤：
-1. 读取 `raw_data/A50伤后6h-1.txt` 文件
-2. 解析红光和红外光数据
-3. 执行信号预处理
-4. 计算生理指标
-5. 保存处理结果
-
-### 3. 查看结果
-程序会自动生成以下文件：
-- `data_generated/ppg_a50_processed.csv` - 预处理后的PPG数据
-- `data_generated/ppg_a50_metrics.csv` - 计算的生理指标
-
-## 🔧 处理流程详解
-
-### 步骤1: 数据读取
-- 打开 `raw_data/A50伤后6h-1.txt` 文件
-- 逐行读取数据
-- 解析逗号分隔的数值
-
-### 步骤2: 数据解析
-- 分离红光和红外光数据
-- 数据验证和错误处理
-- 统计数据显示（范围、数量等）
-
-### 步骤3: 数据转换
-- 创建SensorData对象
-- 设置数据类型为PPG
-- 转换为多通道格式
-
-### 步骤4: 信号预处理
-- 应用PPG专用滤波器
-- 去除运动伪影
-- 信号质量评估
-
-### 步骤5: 指标计算
-- 心率计算
-- 血氧饱和度 (SpO2)
-- 灌注指数 (PI)
-- 脉搏波宽度
-- 红光/红外光比值
-- 信号质量评分
-
-### 步骤6: 结果保存
-- 保存预处理后的数据
-- 保存计算的生理指标
-- 生成详细报告
-
-## 📊 输出指标说明
-
-| 指标名称 | 单位 | 说明 |
-|----------|------|------|
-| **心率** | bpm | 每分钟心跳次数 |
-| **血氧饱和度** | % | 血液中氧气的饱和度 |
-| **灌注指数** | % | 组织灌注情况的指标 |
-| **脉搏波宽度** | ms | 脉搏波的持续时间 |
-| **红光红外光比值** | 无单位 | 红光与红外光信号的比值 |
-| **信号质量评分** | % | 信号质量的综合评分 |
-| **统计指标** | mV | 均值、标准差、最小值、最大值、峰峰值 |
-
-## ⚙️ 参数配置
-
-### 采样率设置
-```cpp
-const float sample_rate = 50.0f; // 可在代码中调整
-```
-
-### 信号质量阈值
-```cpp
-ppg_data.sqi = 0.8f; // 默认信号质量指数
-```
-
-### 文件路径配置
-```cpp
-std::string ppg_file_path = "raw_data/A50伤后6h-1.txt";
-```
-
-## ⚠️ 注意事项
-
-### 1. 文件格式要求
-- 确保数据文件格式正确（逗号分隔）
-- 每行必须包含两个数值
-- 避免空行或格式错误
-
-### 2. 数据质量
-- 数据长度充足（3934个点）
-- 信号质量评估
-- 异常值检测和处理
-
-### 3. 采样率设置
-- 采样率设置错误会影响心率计算
-- 请根据实际设备参数调整
-- 常见采样率: 25Hz, 50Hz, 100Hz
-
-## 🔍 故障排除
-
-### 常见问题
-
-#### 1. 文件读取失败
-```
-错误: 无法打开PPG数据文件: raw_data/A50伤后6h-1.txt
-```
-**解决方案**: 检查文件是否存在于 `raw_data/` 文件夹中
-
-#### 2. 数据解析失败
-```
-警告: 第 X 行数据解析失败: -8,-10
-```
-**解决方案**: 检查数据格式是否正确，确保每行都是两个数值
-
-#### 3. 指标计算异常
-```
-警告: 计算的心率超出正常范围: XXX bpm
-```
-**解决方案**: 检查采样率设置和数据质量
-
-## 📈 性能优化建议
-
-1. **数据预处理**: 对原始数据进行去噪和滤波
-2. **采样率优化**: 根据应用需求选择合适的采样率
-3. **算法参数**: 根据数据特征调整算法参数
-4. **内存管理**: 对于大数据文件，考虑分批处理
-
-## 🚀 扩展功能
-
-### 未来可添加的功能
-- 实时PPG数据处理
-- 多文件批量处理
-- 自定义滤波器参数
-- 数据可视化图表
-- 异常检测和报警
-
-## 📝 更新日志
-
-- **2025年1月**: 新增PPG数据处理功能
-- 专门针对A50伤后6h-1.txt文件
-- 支持txt格式数据读取
-- 完整的信号预处理流程
-- 全面的生理指标计算
-
-## 🔬 医学应用
-
-### 临床意义
-- **心率监测**: 评估心血管功能
-- **血氧饱和度**: 监测组织氧合状态
-- **灌注指数**: 评估组织血流灌注
-- **信号质量**: 确保测量可靠性
-
-### 适用场景
-- 重症监护
-- 手术监测
-- 康复评估
-- 健康监测
-

main.cpp

@@ -1,8 +1,5 @@
 #include "headfile.h"
-#include <fstream>
-#include <sstream>
-#include <ctime>
-#include <windows.h>  // 引入 Windows API 头文件
+
 
 std::vector<float> heart_rate;
 
@@ -20,6 +17,25 @@ std::string get_data_type_name(DataType data_type) {
     }
 }
 
+void test_mit_bih() {
+    try {
+        // 读取MIT-BIH数据文件
+        std::vector<uint8_t> file_content = FileManager::readBinaryFile("C:/Users/29096/Desktop/work/mit-bih-arrhythmia-database-1.0.0/222.dat");
+        
+        // 解析数据
+        std::vector<SensorData> all_data = parse_device_data(file_content);
+
+        // 保存结果
+        save_to_csv(all_data, "mit_bih_output.csv");
+        
+        std::cout << "MIT-BIH数据处理完成" << std::endl;
+        std::cout << "Press Enter to exit..." << std::endl;
+        std::cin.get();
+    } catch (const std::exception& e) {
+        std::cerr << "处理错误: " << e.what() << std::endl;
+    }
+}
+
 
 // 新增：完整的信号数据处理流程 - 整合所有步骤
 void complete_signal_processing_pipeline() {
@@ -28,7 +44,7 @@ void complete_signal_processing_pipeline() {
         
         // 1. 读取原始二进制文件
         std::cout << "步骤1: 读取原始数据..." << std::endl;
-        std::vector<uint8_t> file_content = FileManager::readBinaryFile("raw_data/ecg_data_raw.dat");
+        std::vector<uint8_t> file_content = FileManager::readBinaryFile("C:/Users/29096/Documents/WeChat Files/wxid_sh93l5lycr8b22/FileStorage/File/2025-07/ecg_data_raw.dat");
         std::cout << "原始文件大小: " << file_content.size() << " 字节" << std::endl;
         
         // 2. 解析设备数据包
@@ -51,8 +67,8 @@ void complete_signal_processing_pipeline() {
         }
         
         // 保存映射后的数据
-        save_to_csv(all_data, "data_generated/channel_data_mapped_.csv");
-        std::cout << "通道映射完成，结果已保存到 data_generated/channel_data_mapped_.csv" << std::endl;
+        save_to_csv(all_data, "channel_data_mapped_.csv");
+        std::cout << "通道映射完成，结果已保存到 channel_data_mapped_.csv" << std::endl;
         
         // 4. 信号预处理 (滤波等)
         std::cout << "步骤4: 执行信号预处理..." << std::endl;
@@ -69,8 +85,8 @@ void complete_signal_processing_pipeline() {
         }
         
         // 保存预处理后的数据
-        save_to_csv(processed_data, "data_generated/channel_data_processed_.csv");
-        std::cout << "预处理后的数据已保存到 data_generated/channel_data_processed_.csv" << std::endl;
+        save_to_csv(processed_data, "channel_data_processed_.csv");
+        std::cout << "预处理后的数据已保存到 channel_data_processed_.csv" << std::endl;
         
         // 5. 指标计算
         std::cout << "步骤5: 计算生理指标..." << std::endl;
@@ -78,7 +94,7 @@ void complete_signal_processing_pipeline() {
         const float sample_rate = 250.0f;
         
         // 创建详细指标文件
-        std::ofstream metrics_file("data_generated/calculated_metrics_detailed.csv");
+        std::ofstream metrics_file("calculated_metrics_detailed.csv");
         if (!metrics_file.is_open()) {
             std::cerr << "无法创建指标保存文件" << std::endl;
             return;
@@ -150,7 +166,7 @@ void complete_signal_processing_pipeline() {
         
         // 6. 创建指标汇总文件
         std::cout << "步骤6: 生成指标汇总..." << std::endl;
-        std::ofstream summary_file("data_generated/metrics_summary.csv");
+        std::ofstream summary_file("metrics_summary.csv");
         if (summary_file.is_open()) {
             summary_file << "数据类型,数据对象数量,平均心率(bpm),平均信号质量(%),平均QRS宽度(ms),平均ST偏移(mV)\n";
             
@@ -213,173 +229,35 @@ void complete_signal_processing_pipeline() {
         // 7. 流程完成总结
         std::cout << "\n=== 完整信号数据处理流程完成 ===" << std::endl;
         std::cout << "生成的文件:" << std::endl;
-        std::cout << "1. data_generated/channel_data_mapped_.csv - 通道映射后的数据" << std::endl;
-        std::cout << "2. data_generated/channel_data_processed_.csv - 预处理后的数据" << std::endl;
-        std::cout << "3. data_generated/calculated_metrics_detailed.csv - 详细指标数据" << std::endl;
-        std::cout << "4. data_generated/metrics_summary.csv - 指标汇总统计" << std::endl;
+        std::cout << "1. channel_data_mapped_.csv - 通道映射后的数据" << std::endl;
+        std::cout << "2. channel_data_processed_.csv - 预处理后的数据" << std::endl;
+        std::cout << "3. calculated_metrics_detailed.csv - 详细指标数据" << std::endl;
+        std::cout << "4. metrics_summary.csv - 指标汇总统计" << std::endl;
         std::cin.get();
     } catch (const std::exception& e) {
         std::cerr << "完整流程执行错误: " << e.what() << std::endl;
     }
 }
 
-// PPG数据处理函数 - 专门处理A50伤后6h-1.txt文件
-void process_ppg_a50_data() {
-    try {
-        std::cout << "=== 开始处理PPG数据 (A50伤后6h-1.txt) ===" << std::endl;
-        std::cin.get();
-        // 1. 读取PPG数据文件
-        std::cout << "步骤1: 读取PPG数据文件..." << std::endl;
-        std::string ppg_file_path = "raw_data/A50_6h_1.txt";
-        std::cin.get();
-        std::ifstream ppg_file(ppg_file_path);
-        if (!ppg_file.is_open()) {
-            std::cerr << "错误: 无法打开PPG数据文件: " << ppg_file_path << std::endl;
-            std::cout << "请确保文件存在于 raw_data/ 文件夹中" << std::endl;
-            std::cin.get();
-            return;
-        }
-        
-        // 2. 解析PPG数据
-        std::cout << "步骤2: 解析PPG数据..." << std::endl;
-        std::vector<float> red_channel, ir_channel;
-        std::string line;
-        int line_count = 0;
-        
-        while (std::getline(ppg_file, line)) {
-            line_count++;
-            if (line.empty()) continue;
-            
-            // 解析每行的两个数值 (红光,红外光)
-            std::istringstream iss(line);
-            std::string red_str, ir_str;
-            
-            if (std::getline(iss, red_str, ',') && std::getline(iss, ir_str)) {
-                try {
-                    float red_val = std::stof(red_str);
-                    float ir_val = std::stof(ir_str);
-                    
-                    red_channel.push_back(red_val*0.879);
-                    ir_channel.push_back(ir_val*0.879);
-                } catch (const std::exception& e) {
-                    std::cerr << "警告: 第 " << line_count << " 行数据解析失败: " << line << std::endl;
-                    continue;
-                }
-            } else {
-                std::cerr << "警告: 第 " << line_count << " 行格式不正确: " << line << std::endl;
-                continue;
-            }
-        }
-        
-        ppg_file.close();
-        
-        std::cout << "PPG数据解析完成，共读取 " << red_channel.size() << " 个数据点" << std::endl;
-        std::cout << "红光通道范围: [" << *std::min_element(red_channel.begin(), red_channel.end()) 
-                  << ", " << *std::max_element(red_channel.begin(), red_channel.end()) << "]" << std::endl;
-        std::cout << "红外光通道范围: [" << *std::min_element(ir_channel.begin(), ir_channel.end()) 
-                  << ", " << *std::max_element(ir_channel.begin(), ir_channel.end()) << "]" << std::endl;
-        
-        // 3. 创建SensorData对象
-        std::cout << "步骤3: 创建PPG数据对象..." << std::endl;
-        SensorData ppg_data;
-        ppg_data.data_type = DataType::PPG;
-        ppg_data.packet_sn = 1;
-        ppg_data.timestamp = std::time(nullptr);
-        ppg_data.sqi = 0.8f; // 默认信号质量指数
-        
-        // 将单通道数据转换为多通道格式
-        std::vector<std::vector<float>> channels = {red_channel, ir_channel};
-        ppg_data.channel_data = channels;
-        
-        // 4. 信号预处理
-        std::cout << "步骤4: 执行PPG信号预处理..." << std::endl;
-        SignalProcessor processor;
-        std::vector<SensorData> ppg_data_vector = {ppg_data};
-        
-        std::vector<SensorData> processed_ppg_data;
-        try {
-            processed_ppg_data = processor.process_channel_based_filtering_simple(ppg_data_vector);
-            std::cout << "PPG信号预处理完成" << std::endl;
-        } catch (const std::exception& e) {
-            std::cerr << "PPG信号预处理失败: " << e.what() << std::endl;
-            std::cout << "使用原始数据继续处理..." << std::endl;
-            processed_ppg_data = ppg_data_vector;
-        }
-        
-        // 5. 保存预处理后的数据
-        std::cout << "步骤5: 保存预处理后的PPG数据..." << std::endl;
-        save_to_csv(processed_ppg_data, "data_generated/ppg_a50_processed.csv");
-        std::cout << "预处理后的PPG数据已保存到 data_generated/ppg_a50_processed.csv" << std::endl;
-        
-        // 6. 计算PPG生理指标
-        std::cout << "步骤6: 计算PPG生理指标..." << std::endl;
-        MetricsCalculator calculator;
-        const float sample_rate = 50.0f; // PPG采样率，请根据实际情况调整
-         
-        auto ppg_metrics = calculator.calculate_all_ppg_metrics(processed_ppg_data[0], sample_rate);
-        
-        // 7. 保存指标计算结果
-        std::cout << "步骤7: 保存PPG指标计算结果..." << std::endl;
-        std::ofstream metrics_file("data_generated/ppg_a50_metrics.csv");
-        if (metrics_file.is_open()) {
-            metrics_file << "指标名称,数值,单位\n";
-            metrics_file << "心率," << ppg_metrics["heart_rate"] << ",bpm\n";
-            metrics_file << "血氧饱和度," << ppg_metrics["spo2"] << ",%\n";
-            metrics_file << "灌注指数," << ppg_metrics["perfusion_index"] << ",%\n";
-            metrics_file << "脉搏波宽度," << ppg_metrics["pulse_width"] << ",ms\n";
-            metrics_file << "红光红外光比值," << ppg_metrics["amplitude_ratio"] << ",无单位\n";
-            metrics_file << "信号质量评分," << ppg_metrics["signal_quality"] << ",%\n";
-            metrics_file << "均值," << ppg_metrics["mean"] << ",mV\n";
-            metrics_file << "标准差," << ppg_metrics["std_dev"] << ",mV\n";
-            metrics_file << "最小值," << ppg_metrics["min_value"] << ",mV\n";
-            metrics_file << "最大值," << ppg_metrics["max_value"] << ",mV\n";
-            metrics_file << "峰峰值," << ppg_metrics["peak_to_peak"] << ",mV\n";
-            metrics_file.close();
-            std::cout << "PPG指标已保存到 data_generated/ppg_a50_metrics.csv" << std::endl;
-        }
-        
-        // 8. 显示关键指标
-        std::cout << "\n=== PPG数据处理完成 ===" << std::endl;
-        std::cout << "关键指标:" << std::endl;
-        std::cout << "- 心率: " << ppg_metrics["heart_rate"] << " bpm" << std::endl;
-        std::cout << "- 血氧饱和度: " << ppg_metrics["spo2"] << " %" << std::endl;
-        std::cout << "- 灌注指数: " << ppg_metrics["perfusion_index"] << " %" << std::endl;
-        std::cout << "- 信号质量: " << ppg_metrics["signal_quality"] << " %" << std::endl;
-        
-        std::cout << "\n生成的文件:" << std::endl;
-        std::cout << "1. data_generated/ppg_a50_processed.csv - 预处理后的PPG数据" << std::endl;
-        std::cout << "2. data_generated/ppg_a50_metrics.csv - PPG生理指标" << std::endl;
-        
-        std::cout << "\n按Enter键退出..." << std::endl;
-        std::cin.get();
-        
-    } catch (const std::exception& e) {
-        std::cerr << "PPG数据处理错误: " << e.what() << std::endl;
-    }
-}
-
 int main() {
-
     SetConsoleOutputCP(CP_UTF8);
+    
     // 选择要运行的测试
     std::cout << "请选择测试模式:" << std::endl;
     std::cout << "1. 测试MIT-BIH数据处理" << std::endl;
     std::cout << "2. 运行完整信号数据处理流程 (推荐)" << std::endl;
-    std::cout << "3. 处理PPG数据 (A50伤后6h-1.txt)" << std::endl;
-    std::cout << "请输入选择 (1, 2 或 3): ";
+    std::cout << "请输入选择 (1 或 2): ";
 
     int choice;
     std::cin >> choice;
 
     if (choice == 1) {
-
+        test_mit_bih(); // 测试MIT-BIH数据处理
     } else if (choice == 2) {
         complete_signal_processing_pipeline(); // 运行完整信号数据处理流程
-    } else if (choice == 3) {
-        process_ppg_a50_data(); // 处理PPG数据
     } else {
         std::cout << "无效选择，运行默认测试..." << std::endl;
-
+        test_mit_bih();
     }
 
     return 0;

src/data_output/indicator_cal.cpp

@@ -38,35 +38,6 @@ static const std::vector<std::vector<float>>& get_multi_channel(const SensorData
     }
 }
 
-// 辅助函数：计算分位数（q 取值范围 0.0-1.0）
-static float compute_percentile(const std::vector<float>& data, float q) {
-    if (data.empty()) return 0.0f;
-    float qq = q;
-    if (qq < 0.0f) qq = 0.0f;
-    if (qq > 1.0f) qq = 1.0f;
-    std::vector<float> sorted = data;
-    std::sort(sorted.begin(), sorted.end());
-    if (sorted.size() == 1) return sorted[0];
-    float pos = qq * (sorted.size() - 1);
-    size_t idx_low = static_cast<size_t>(std::floor(pos));
-    size_t idx_high = static_cast<size_t>(std::ceil(pos));
-    if (idx_low == idx_high) return sorted[idx_low];
-    float w = pos - idx_low;
-    return sorted[idx_low] * (1.0f - w) + sorted[idx_high] * w;
-}
-
-// 辅助函数：稳健估计AC/DC（使用分位数和中位数，抗异常）
-static std::pair<float, float> robust_ac_dc(const std::vector<float>& signal) {
-    if (signal.size() < 5) return {0.0f, 0.0f};
-    // 使用5%-95%分位点估计幅度，使用中位数估计直流
-    float p5 = compute_percentile(signal, 0.05f);
-    float p95 = compute_percentile(signal, 0.95f);
-    float median = compute_percentile(signal, 0.50f);
-    float ac = (p95 - p5) * 0.5f;
-    float dc = median;
-    return {ac, dc};
-}
-
 // ECG心率计算 - 改进版本
 float MetricsCalculator::calculate_heart_rate_ecg(const SensorData& ecg_signal, float sample_rate) {
     // 增强的输入验证
@@ -325,34 +296,27 @@ float MetricsCalculator::calculate_spo2(const SensorData& ppg_data) {
         return 0.0f;
     }
     
-    // 轻量级异常值裁剪：将数据裁剪到1%-99%范围，提高稳健性
-    auto clipped_copy = [](const std::vector<float>& src) {
-        std::vector<float> out = src;
-        if (out.size() >= 5) {
-            float p1 = compute_percentile(out, 0.01f);
-            float p99 = compute_percentile(out, 0.99f);
-            for (float& v : out) {
-                if (v < p1) v = p1;
-                else if (v > p99) v = p99;
-            }
-        }
-        return out;
+    // 计算红光和红外光的AC/DC分量
+    auto calc_ac_dc = [](const std::vector<float>& signal) -> std::pair<float, float> {
+        if (signal.empty()) return {0.0f, 0.0f};
+        
+        float max_val = *std::max_element(signal.begin(), signal.end());
+        float min_val = *std::min_element(signal.begin(), signal.end());
+        float dc = (max_val + min_val) / 2.0f;
+        float ac = (max_val - min_val) / 2.0f;
+        return {ac, dc};
     };
     
-    std::vector<float> red_clipped = clipped_copy(red_channel);
-    std::vector<float> ir_clipped = clipped_copy(ir_channel);
-
-    // 稳健估计红光和红外光的AC/DC分量
-    auto [red_ac, red_dc] = robust_ac_dc(red_clipped);
-    auto [ir_ac, ir_dc] = robust_ac_dc(ir_clipped);
+    auto [red_ac, red_dc] = calc_ac_dc(red_channel);
+    auto [ir_ac, ir_dc] = calc_ac_dc(ir_channel);
     
     // 防止除零和异常值
-    if (std::abs(red_dc) < 0.0001f || std::abs(ir_dc) < 0.0001f) {
+    if (red_dc < 0.0001f || ir_dc < 0.0001f) {
         std::cerr << "警告: 直流分量过小，红光: " << red_dc << ", 红外光: " << ir_dc << std::endl;
         return 0.0f;
     }
     
-    if (std::abs(red_ac) < 0.0001f || std::abs(ir_ac) < 0.0001f) {
+    if (red_ac < 0.0001f || ir_ac < 0.0001f) {
         std::cerr << "警告: 交流分量过小，红光: " << red_ac << ", 红外光: " << ir_ac << std::endl;
         return 0.0f;
     }
@@ -361,17 +325,24 @@ float MetricsCalculator::calculate_spo2(const SensorData& ppg_data) {
     float r_value = (red_ac / red_dc) / (ir_ac / ir_dc);
     
     // 验证R值合理性
-    if (std::abs(r_value) < 0.1f || std::abs(r_value) > 10.0f) {
+    if (r_value < 0.1f || r_value > 10.0f) {
         std::cerr << "警告: R值超出合理范围: " << r_value << std::endl;
         return 0.0f;
     }
-    float spo2;
-    // 采用常用经验线性映射：SpO2 = 110 - 25 * R （需设备校准）
-    if(r_value>0)  spo2 = 110.0f - 25.0f * r_value;
-    else  spo2 = 110.0f + 25.0f * r_value;
     
-    // 限制在合理范围内 (70% - 100%)
-    spo2 = clamp(spo2, 70.0f, 100.0f);
+    // 改进的SpO2计算公式 (基于Beer-Lambert定律)
+    // SpO2 = A - B * log(R)
+    // 其中A和B是校准参数，R是红光与红外光的比值
+    float spo2 = 104.0f - 17.0f * std::log(r_value);
+    
+    // 限制在合理范围内
+    spo2 = std::max(70.0f, std::min(100.0f, spo2));
+    
+    // 验证最终结果
+    if (spo2 < 70.0f || spo2 > 100.0f) {
+        std::cerr << "警告: 计算的SpO2超出正常范围: " << spo2 << "%" << std::endl;
+        return 0.0f;
+    }
     
     return spo2;
 }
@@ -673,59 +644,40 @@ std::vector<float> MetricsCalculator::detect_pulse_peaks(const std::vector<float
     
     const size_t n = ppg_signal.size();
     
-    // 1) 轻量平滑（5点移动平均），提升SNR以适应低采样率(50Hz)
-    std::vector<float> smooth(n, 0.0f);
-    const size_t ma_win = 5; // ≈100ms@50Hz
-    float acc = 0.0f;
-    for (size_t i = 0; i < n; ++i) {
-        acc += ppg_signal[i];
-        if (i >= ma_win) acc -= ppg_signal[i - ma_win];
-        size_t denom = (i + 1 < ma_win) ? (i + 1) : ma_win;
-        smooth[i] = acc / static_cast<float>(denom);
-    }
+    // 自适应阈值
+    float max_val = *std::max_element(ppg_signal.begin(), ppg_signal.end());
+    float min_val = *std::min_element(ppg_signal.begin(), ppg_signal.end());
+    float dynamic_range = max_val - min_val;
     
-    // 2) 参数：窗口与最小间隔
-    // 最小脉搏间隔取400ms（≈150bpm上限），避免误检重复峰
-    const size_t min_interval = static_cast<size_t>(0.4f * sample_rate);
-    // 局部比较窗口：200ms用于极值判断
-    const size_t window_size = static_cast<size_t>(0.2f * sample_rate); // 200ms窗口
-    // 局部阈值窗口：1.5s，用于计算局部分位数阈值和显著性
-    const size_t local_win = static_cast<size_t>(2.0f * sample_rate);
+    if (dynamic_range < 0.001f) return pulse_peaks; // 信号变化太小
+    
+    float threshold = min_val + 0.6f * dynamic_range;
+    
+    // 最小脉搏间隔 (300ms ≈ 200bpm)
+    const size_t min_interval = static_cast<size_t>(0.3f * sample_rate);
+    
+    // 使用滑动窗口检测峰值
+    const size_t window_size = static_cast<size_t>(0.1f * sample_rate); // 100ms窗口
     
-    // 3) 使用局部分位阈值与显著性(prominence)判据
     size_t last_peak = 0;
-    for (size_t i = window_size; i + window_size < n; ++i) {
-        // 局部极大判定
+    
+    for (size_t i = window_size; i < n - window_size; i++) {
+        // 检查是否为局部最大值
         bool is_peak = true;
-        for (size_t j = i - window_size; j <= i + window_size; ++j) {
-            if (j != i && smooth[j] >= smooth[i]) { is_peak = false; break; }
+        for (size_t j = i - window_size; j <= i + window_size; j++) {
+            if (j != i && ppg_signal[j] >= ppg_signal[i]) {
+                is_peak = false;
+                break;
+            }
         }
-        if (!is_peak) continue;
-        
-        // 局部阈值（基线+分位幅值的一部分）
-        size_t l0 = (i > local_win ? i - local_win : 0);
-        size_t r0 = std::min(n - 1, i + local_win);
-        if (r0 <= l0 + 2) continue;
-        std::vector<float> window(smooth.begin() + l0, smooth.begin() + r0 + 1);
-        float p5 = compute_percentile(window, 0.05f);
-        float p50 = compute_percentile(window, 0.50f);
-        float p95 = compute_percentile(window, 0.95f);
-        float loc_range = std::max(0.0f, p95 - p5);
-        float loc_baseline = p50;
-        float loc_threshold = loc_baseline + 0.15f * loc_range; // 低门槛，避免只出1峰
-        
-        if (smooth[i] <= loc_threshold) continue;
-        
-        // 显著性：峰值高于局部中位线的幅度需达到一定比例
-        float prominence = smooth[i] - loc_baseline;
-        if (prominence < 0.1f * loc_range) continue;
-        
-        // 间隔判定
-        if (last_peak != 0 && i - last_peak <= min_interval) continue;
         
+        // 检查是否超过阈值且满足最小间隔
+        if (is_peak && ppg_signal[i] > threshold && 
+            (last_peak == 0 || i - last_peak > min_interval)) {
             pulse_peaks.push_back(static_cast<float>(i));
             last_peak = i;
         }
+    }
     
     return pulse_peaks;
 }

src/signal_processor/signal_processor.cpp

@@ -12,6 +12,145 @@ T clamp(T value, T min_val, T max_val) {
     return value;
 }
 
+// 新增：处理多个数据包的通道级滤波
+std::vector<SensorData> SignalProcessor::process_channel_based_filtering(
+    const std::vector<SensorData>& data_packets) {
+    
+    std::cout << "开始通道级滤波处理..." << std::endl;
+    
+    if (data_packets.empty()) {
+        std::cout << "输入数据包为空，返回空结果" << std::endl;
+        return {};
+    }
+    
+    std::cout << "输入数据包数量: " << data_packets.size() << std::endl;    
+    
+    // 按数据类型分组
+    std::map<DataType, std::vector<SensorData>> grouped_data;
+    for (const auto& packet : data_packets) {
+        grouped_data[packet.data_type].push_back(packet);
+    }
+    
+    std::cout << "按数据类型分组完成，共 " << grouped_data.size() << " 种类型" << std::endl;
+    
+    std::vector<SensorData> processed_packets;
+    
+    // 对每种数据类型分别处理
+    for (auto& [data_type, packets] : grouped_data) {
+        if (packets.empty()) continue;
+        
+        std::cout << "处理数据类型: " << static_cast<int>(data_type) << "，数据包数量: " << packets.size() << std::endl;
+        
+        // 获取第一个数据包作为模板
+        SensorData template_packet = packets[0];
+        
+        // 收集所有通道的完整数据
+        std::vector<std::vector<float>> all_channels;
+        size_t num_channels = 0;
+        
+        // 确定通道数量
+        if (auto* channels = std::get_if<std::vector<std::vector<float>>>(&packets[0].channel_data)) {
+            num_channels = channels->size();
+            all_channels.resize(num_channels);
+            std::cout << "通道数量: " << num_channels << std::endl;
+        } else {
+            std::cout << "警告: 无法获取通道数据，跳过此类型" << std::endl;
+            continue;
+        }
+        
+        // 收集所有数据包中相同通道的数据
+        std::cout << "开始收集通道数据..." << std::endl;
+        for (size_t ch = 0; ch < num_channels; ch++) {
+            std::cout << "处理通道 " << ch << "/" << num_channels << std::endl;
+            
+            for (const auto& packet : packets) {
+                if (auto* channels = std::get_if<std::vector<std::vector<float>>>(&packet.channel_data)) {
+                    if (ch < channels->size()) {
+                        all_channels[ch].insert(all_channels[ch].end(), 
+                                              (*channels)[ch].begin(), 
+                                              (*channels)[ch].end());
+                    }
+                }
+            }
+            
+            std::cout << "通道 " << ch << " 收集完成，采样点数: " << all_channels[ch].size() << std::endl;
+        }
+        
+        // 对完整通道数据进行滤波处理
+        std::cout << "开始应用滤波器..." << std::endl;
+        std::vector<std::vector<float>> filtered_channels;
+        
+        try {
+            filtered_channels = apply_channel_filters(all_channels, data_type);
+            std::cout << "滤波完成" << std::endl;
+        } catch (const std::exception& e) {
+            std::cerr << "滤波过程中出错: " << e.what() << std::endl;
+            std::cout << "使用原始数据继续处理" << std::endl;
+            filtered_channels = all_channels;
+        }
+        
+        // 将滤波后的数据重新分配回数据包结构
+        std::cout << "开始重新构建数据包..." << std::endl;
+        size_t samples_per_packet = 0;
+        if (auto* channels = std::get_if<std::vector<std::vector<float>>>(&packets[0].channel_data)) {
+            if (!channels->empty()) {
+                samples_per_packet = (*channels)[0].size();
+            }
+        }
+        
+        if (samples_per_packet == 0) {
+            std::cout << "警告: 无法确定每包采样点数，使用默认值" << std::endl;
+            samples_per_packet = 100; // 默认值
+        }
+        
+        // 重新构建数据包
+        size_t total_samples = filtered_channels[0].size();
+        size_t num_packets = (total_samples + samples_per_packet - 1) / samples_per_packet;
+        
+        std::cout << "总采样点数: " << total_samples << ", 每包采样点数: " << samples_per_packet 
+                  << ", 将创建 " << num_packets << " 个数据包" << std::endl;
+        
+        // 添加安全检查，避免创建过多数据包
+        if (num_packets > 1000) {
+            std::cout << "警告: 数据包数量过多 (" << num_packets << ")，限制为1000个" << std::endl;
+            num_packets = 1000;
+        }
+        
+        for (size_t p = 0; p < num_packets; p++) {
+            if (p % 100 == 0) {
+                std::cout << "创建数据包 " << p << "/" << num_packets << std::endl;
+            }
+            
+            SensorData new_packet = template_packet;
+            new_packet.packet_sn = p; // 重新分配包序号
+            
+            // 创建新的通道数据结构
+            auto& new_channels = new_packet.channel_data.emplace<std::vector<std::vector<float>>>();
+            new_channels.resize(num_channels);
+            
+            // 分配数据到各个通道
+            for (size_t ch = 0; ch < num_channels; ch++) {
+                size_t start_idx = p * samples_per_packet;
+                size_t end_idx = std::min(start_idx + samples_per_packet, filtered_channels[ch].size());
+                
+                if (start_idx < filtered_channels[ch].size()) {
+                    new_channels[ch].assign(filtered_channels[ch].begin() + start_idx,
+                                           filtered_channels[ch].begin() + end_idx);
+                }
+            }
+            
+            processed_packets.push_back(new_packet);
+        }
+        
+        std::cout << "数据类型 " << static_cast<int>(data_type) << " 处理完成，创建了 " 
+                  << num_packets << " 个数据包" << std::endl;
+    }
+    
+    std::cout << "通道级滤波处理完成，总共创建 " << processed_packets.size() << " 个数据包" << std::endl;
+    
+    return processed_packets;
+}
+
 // 新增：简化的通道级滤波处理（测试版本）
 std::vector<SensorData> SignalProcessor::process_channel_based_filtering_simple(
     const std::vector<SensorData>& data_packets) {
@@ -128,12 +267,6 @@ std::vector<SensorData> SignalProcessor::process_channel_based_filtering_simple(
                     case DataType::PPG:
                         // PPG基本处理：去除直流分量
                         merged_channels[ch] = remove_dc_offset(merged_channels[ch]);
-                        // 2. 0.5-8Hz带通滤波（更精确的PPG频带）
-                         merged_channels[ch] = bandpass_filter(merged_channels[ch], 50, 0.5, 8.0);
-                        // // 3. 50Hz陷波滤波（去除工频干扰）
-                         //merged_channels[ch] = filter(merged_channels[ch], 50, 49.5, 50.5, filtertype::notchpass);
-                        // // 4. 运动伪迹检测和去除（优化版本）
-                         merged_channels[ch] = remove_motion_artifacts(merged_channels[ch], 50);
                         break;
                     case DataType::RESPIRATION:
                         // 呼吸信号基本处理：去除直流分量
@@ -1063,7 +1196,7 @@ float SignalProcessor::calculate_PPG_sqi(const std::vector<float>& red_channel,
     return clamp(sqi, 0.0f, 1.0f);
 }
 
-// 增强版运动伪迹检测和去除函数
+// 新增：运动伪迹检测和去除函数
 std::vector<float> SignalProcessor::remove_motion_artifacts(const std::vector<float>& signal, double sample_rate) {
     if (signal.empty()) return signal;
     
@@ -1249,3 +1382,25 @@ void SignalProcessor::normalize_amplitude(std::vector<float>& signal) {
     }
 }
 
+// 使用示例：如何正确使用通道级滤波
+/*
+// 原来的错误用法（对单个数据包滤波）：
+std::vector<SensorData> raw_packets = get_raw_data_packets();
+for (auto& packet : raw_packets) {
+    packet = signal_processor.preprocess_signals(packet); // 错误！对单个包滤波
+}
+
+// 新的正确用法（通道级滤波）：
+std::vector<SensorData> raw_packets = get_raw_data_packets();
+std::vector<SensorData> processed_packets = 
+    signal_processor.process_channel_based_filtering(raw_packets);
+
+// 或者，如果你想保持原有的数据包结构，可以这样：
+std::vector<SensorData> raw_packets = get_raw_data_packets();
+std::vector<SensorData> processed_packets = 
+    signal_processor.process_channel_based_filtering(raw_packets);
+
+// 关键区别：
+// 1. 原来：对每个数据包内的短时间序列进行滤波（错误）
+// 2. 现在：收集所有数据包中相同通道的完整数据，进行滤波，然后重新分配
+*/