med64 0.0.2

Headless MED64 electrophysiology toolkit: .modat I/O, spike/burst analysis, assays, spike-rate maps, and CSV/HTML/SVG/HDF5 export
Documentation
use super::types::{Spike, SpikeTrain};

/// Amplitude / duration gates (`SpikeFilteringService`).
#[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
}

/// Attach pre/post peak waveform snippets in millivolts.
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);
    }
}