use super::types::{Spike, SpikeTrain};
#[derive(Debug, Clone, Default)]
pub struct SpikeFilterOptions {
pub min_amplitude_mv: Option<f64>,
pub max_amplitude_mv: Option<f64>,
pub min_duration_ms: Option<f64>,
pub max_duration_ms: Option<f64>,
}
pub fn filter_spikes(train: SpikeTrain, options: &SpikeFilterOptions) -> SpikeTrain {
SpikeTrain { spikes: train.spikes.into_iter().filter(|spike| keep(spike, options)).collect() }
}
fn keep(spike: &Spike, options: &SpikeFilterOptions) -> bool {
let amp = spike.peak_mv.abs();
if options.min_amplitude_mv.is_some_and(|min| amp < min) {
return false;
}
if options.max_amplitude_mv.is_some_and(|max| amp > max) {
return false;
}
if options.min_duration_ms.is_some_and(|min| spike.duration_ms < min) {
return false;
}
if options.max_duration_ms.is_some_and(|max| spike.duration_ms > max) {
return false;
}
true
}
pub fn attach_waveforms(
train: &mut SpikeTrain,
samples_mv: &[f64],
channel: usize,
interval_ms: f64,
pre_ms: f64,
post_ms: f64,
block_offset_ms: f64,
) {
let pre = (pre_ms / interval_ms).round() as isize;
let post = (post_ms / interval_ms).round() as isize;
for spike in train.spikes.iter_mut().filter(|s| s.channel == channel) {
let start = (spike.peak_index as isize - pre).max(0) as usize;
let end = ((spike.peak_index as isize + post + 1) as usize).min(samples_mv.len());
spike.waveform_mv = samples_mv[start..end].to_vec();
spike.waveform_times_ms =
(start..end).map(|i| block_offset_ms + i as f64 * interval_ms).collect();
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::analysis::spike::{Spike, SpikeDirection};
#[test]
fn drops_small_amplitude() {
let mut train = SpikeTrain::default();
train.push(Spike {
peak_mv: 0.01,
duration_ms: 1.0,
direction: SpikeDirection::Plus,
..Default::default()
});
train.push(Spike { peak_mv: 1.0, duration_ms: 1.0, ..Default::default() });
let kept = filter_spikes(
train,
&SpikeFilterOptions { min_amplitude_mv: Some(0.1), ..Default::default() },
);
assert_eq!(kept.len(), 1);
}
}