use serde::{Deserialize, Serialize};
use crate::analysis::filter::{BandpassFilter, LowPassKind};
use crate::error::{Med64Error, Result};
use crate::toolkit::spectrum::load_channel_mv;
use std::path::Path;
#[derive(Debug, Clone)]
pub struct BandpassBand {
pub name: String,
pub highpass_hz: f64,
pub lowpass_hz: f64,
}
#[derive(Debug, Clone)]
pub struct MultiBandpassOptions {
pub channel: usize,
pub max_blocks: Option<usize>,
pub bands: Vec<BandpassBand>,
}
impl Default for MultiBandpassOptions {
fn default() -> Self {
Self {
channel: 0,
max_blocks: Some(5),
bands: vec![
BandpassBand { name: "delta".into(), highpass_hz: 0.5, lowpass_hz: 4.0 },
BandpassBand { name: "theta".into(), highpass_hz: 4.0, lowpass_hz: 8.0 },
BandpassBand { name: "alpha".into(), highpass_hz: 8.0, lowpass_hz: 13.0 },
BandpassBand { name: "beta".into(), highpass_hz: 13.0, lowpass_hz: 30.0 },
BandpassBand { name: "gamma".into(), highpass_hz: 30.0, lowpass_hz: 100.0 },
],
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MultiBandpassTrace {
pub name: String,
pub highpass_hz: f64,
pub lowpass_hz: f64,
pub millivolts: Vec<f64>,
pub rms_mv: f64,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MultiBandpassReport {
pub path: std::path::PathBuf,
pub channel: usize,
pub times_ms: Vec<f64>,
pub raw_mv: Vec<f64>,
pub bands: Vec<MultiBandpassTrace>,
}
pub fn multi_bandpass(
path: impl AsRef<Path>,
options: &MultiBandpassOptions,
) -> Result<MultiBandpassReport> {
let path = path.as_ref();
let (header, samples) = load_channel_mv(path, options.channel, options.max_blocks)?;
let fs = header.sampling_frequency_hz;
let period = 1.0 / fs;
let times_ms: Vec<f64> = (0..samples.len()).map(|i| i as f64 * 1000.0 / fs).collect();
let mut bands = Vec::new();
for band in &options.bands {
let mut filter = BandpassFilter::new(
period,
band.highpass_hz,
band.lowpass_hz,
LowPassKind::Butterworth,
);
let mut filtered = samples.clone();
filter.filter_block(&mut filtered);
let rms = if filtered.is_empty() {
0.0
} else {
(filtered.iter().map(|v| v * v).sum::<f64>() / filtered.len() as f64).sqrt()
};
bands.push(MultiBandpassTrace {
name: band.name.clone(),
highpass_hz: band.highpass_hz,
lowpass_hz: band.lowpass_hz,
millivolts: filtered,
rms_mv: rms,
});
}
Ok(MultiBandpassReport {
path: path.to_path_buf(),
channel: options.channel,
times_ms,
raw_mv: samples,
bands,
})
}
pub fn write_multi_bandpass_csv(
report: &MultiBandpassReport,
path: impl AsRef<Path>,
) -> Result<()> {
let path = path.as_ref();
let mut header = String::from("time_ms,raw_mv");
for b in &report.bands {
header.push(',');
header.push_str(&b.name);
}
header.push('\n');
let mut body = header;
let n = report.times_ms.len();
for i in 0..n {
body.push_str(&format!("{:.3},{:.8}", report.times_ms[i], report.raw_mv[i]));
for b in &report.bands {
let v = b.millivolts.get(i).copied().unwrap_or(0.0);
body.push_str(&format!(",{v:.8}"));
}
body.push('\n');
}
std::fs::write(path, body)
.map_err(|source| Med64Error::WriteIo { path: path.to_path_buf(), source })?;
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn bands_have_rms() {
let report = multi_bandpass(
crate::fixture_paths::sample_data1(),
&MultiBandpassOptions { max_blocks: Some(1), ..Default::default() },
)
.unwrap();
assert_eq!(report.bands.len(), 5);
assert!(report.bands.iter().any(|b| b.rms_mv > 0.0));
}
}