signal_process.rs

use std::collections::VecDeque;
use std::f32::consts::PI;

pub struct ButterworthFilter {
    k1: f32,
    k2: f32,
    prev_input: f32,
    prev_output: f32,
}

impl ButterworthFilter {
    pub fn new(cutoff: f32, sample_rate: f32) -> Self {
        let wc = (2.0 * PI * cutoff / sample_rate).tan();
        let k1 = wc / (1.0 + wc);
        let k2 = (1.0 - wc) / (1.0 + wc);

        Self {
            k1,
            k2,
            prev_input: 0.0,
            prev_output: 0.0,
        }
    }

    pub fn filter(&mut self, input: f32) -> f32 {
        let output = self.k1 * input + self.k1 * self.prev_input + self.k2 * self.prev_output;
        self.prev_input = input;
        self.prev_output = output;
        output
    }
}

pub struct HighPassFilter {
    k1: f32,
    prev_input: f32,
    prev_output: f32,
}

impl HighPassFilter {
    pub fn new(cutoff: f32, sample_rate: f32) -> Self {
        let wc = (2.0 * PI * cutoff / sample_rate).tan();
        let k1 = 1.0 / (1.0 + wc);

        Self {
            k1,
            prev_input: 0.0,
            prev_output: 0.0,
        }
    }

    pub fn filter(&mut self, input: f32) -> f32 {
        let output = self.k1 * (input - self.prev_output);
        self.prev_input = input;
        self.prev_output = output;
        output
    }
}

pub struct MovingAverageFilter {
    window_size: usize,
    buffer: VecDeque<f32>,
    sum: f32,
}

impl MovingAverageFilter {
    pub fn new(window_size: usize) -> Self {
        Self {
            window_size,
            buffer: VecDeque::with_capacity(window_size),
            sum: 0.0,
        }
    }

    pub fn filter(&mut self, input: f32) -> f32 {
        if self.buffer.len() == self.window_size {
            // 如果缓冲区已满，移除最旧的值
            if let Some(old_value) = self.buffer.pop_front() {
                self.sum -= old_value;
            }
        }

        // 添加新值
        self.buffer.push_back(input);
        self.sum += input;

        // 返回当前窗口的平均值
        self.sum / self.buffer.len() as f32
    }
}

// 寻峰算法
pub fn detect_peaks(signal: &[f32], base_threshold: f32, min_distance: usize) -> (usize, bool) {
    if signal.len() < 3 {
        return (0, false);
    }

    // 计算信号统计特征
    let mean: f32 = signal.iter().sum::<f32>() / signal.len() as f32;
    let variance = signal.iter().map(|x| (x - mean).powi(2)).sum::<f32>() / signal.len() as f32;
    let std_dev = variance.sqrt();

    // 自适应阈值计算
    let dynamic_threshold = mean + std_dev; // 使用均值加标准差
    let final_threshold = base_threshold.min(dynamic_threshold); // 取较小值作为阈值

    let mut peaks = Vec::new();
    let window_size = 5; // 用于局部最大值检测的窗口大小

    for i in window_size..(signal.len() - window_size) {
        let current = signal[i];

        // 检查是否超过阈值
        if current < final_threshold {
            continue;
        }

        // 检查局部最大值
        let is_local_max = (i - window_size..i)
            .chain(i + 1..=i + window_size)
            .all(|j| current >= signal[j]);

        if is_local_max {
            // 检查与上一个峰值的距离
            if peaks.is_empty() || (i - peaks.last().unwrap() >= min_distance) {
                peaks.push(i);
            } else if signal[*peaks.last().unwrap()] < current {
                // 如果新峰值更大，替换旧峰值
                *peaks.last_mut().unwrap() = i;
            }
        }
    }

    // 峰值后处理：移除异常值
    if peaks.len() > 2 {
        let peak_values: Vec<f32> = peaks.iter().map(|&i| signal[i]).collect();
        let peak_mean = peak_values.iter().sum::<f32>() / peak_values.len() as f32;
        let peak_std = (peak_values
            .iter()
            .map(|x| (x - peak_mean).powi(2))
            .sum::<f32>()
            / peak_values.len() as f32)
            .sqrt();

        // 移除偏离均值超过2个标准差的峰值
        peaks.retain(|&i| (signal[i] - peak_mean).abs() <= 2.0 * peak_std);
    }

    let bigger = *signal.last().unwrap() > final_threshold;

    (peaks.len(), bigger) // 返回峰值数量和是否检测到新峰值
}