use super::threshold::index_to_ms;
use super::types::{Spike, SpikeDirection, SpikeTrain, UNDEFINED_INDEX};
use crate::header::Med64Header;
#[derive(Debug, Clone)]
pub struct SpikeDetectOptions {
pub plus_threshold_mv: f64,
pub minus_threshold_mv: f64,
pub refractory_samples: usize,
pub trace: u32,
pub channel: usize,
pub block_offset_ms: f64,
pub session_offset_ms: f64,
pub detect_plus: bool,
pub detect_minus: bool,
}
impl Default for SpikeDetectOptions {
fn default() -> Self {
Self {
plus_threshold_mv: 0.5,
minus_threshold_mv: -0.5,
refractory_samples: 50,
trace: 0,
channel: 0,
block_offset_ms: 0.0,
session_offset_ms: 0.0,
detect_plus: true,
detect_minus: true,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Compare {
None,
Inside,
Greater,
Less,
GreaterHalf,
LessHalf,
}
struct OpenSpike {
direction: SpikeDirection,
start_index: usize,
peak_index: usize,
peak_mv: f64,
train_index: usize,
}
pub fn detect_spikes(
header: &Med64Header,
samples_mv: &[f64],
options: &SpikeDetectOptions,
) -> SpikeTrain {
detect_spikes_inner(header, samples_mv, options, false)
}
pub fn detect_spikes_f32(
header: &Med64Header,
samples_mv: &[f64],
options: &SpikeDetectOptions,
) -> SpikeTrain {
detect_spikes_inner(header, samples_mv, options, true)
}
fn detect_spikes_inner(
header: &Med64Header,
samples_mv: &[f64],
options: &SpikeDetectOptions,
as_f32: bool,
) -> SpikeTrain {
let plus = options.plus_threshold_mv;
let minus = options.minus_threshold_mv;
let plus_half = plus / 2.0;
let minus_half = minus / 2.0;
let channel_offset = options.channel as i64;
let refractory = options.refractory_samples as i64;
let sample = |i: usize| -> f64 {
if as_f32 {
samples_mv[i] as f32 as f64
} else {
samples_mv[i]
}
};
let mut train = SpikeTrain::default();
let mut open: Option<OpenSpike> = None;
let mut last_peak_abs: i64 = -1;
let mut allow = true;
let mut prev_compare = Compare::None;
for index in 0..samples_mv.len() {
let abs_index = channel_offset + index as i64;
let value = sample(index);
let compare = compare_value(
value,
options.detect_minus.then_some(plus),
options.detect_minus.then_some(plus_half),
options.detect_plus.then_some(minus),
options.detect_plus.then_some(minus_half),
);
if let Some(spike) = open.as_mut() {
if is_spike_end(spike.direction, compare) {
let end_index = index.saturating_sub(1);
update_spike_end(header, &mut train, spike, end_index, options);
open = None;
} else if is_update_peak(spike.direction, spike.peak_mv, value) {
spike.peak_index = index;
spike.peak_mv = value;
update_spike_peak(header, &mut train, spike, options);
last_peak_abs = abs_index;
}
}
if open.is_none() {
if last_peak_abs > 0 && abs_index < last_peak_abs + refractory {
allow = false;
} else if last_peak_abs > 0 && abs_index == last_peak_abs + refractory {
if (compare == Compare::Greater && prev_compare == Compare::Greater)
|| (compare == Compare::Less && prev_compare == Compare::Less)
{
allow = false;
} else if allow {
allow = true;
} else {
allow = prev_compare != compare;
}
} else if allow {
allow = true;
} else {
allow = prev_compare != compare;
}
if allow {
if options.detect_plus && is_plus_start(compare, prev_compare) {
let peak_index = index;
let peak_mv = value;
let train_index = train.spikes.len();
train.push(make_spike(
header,
options,
SpikeDirection::Plus,
peak_index,
peak_index,
peak_mv,
));
open = Some(OpenSpike {
direction: SpikeDirection::Plus,
start_index: peak_index,
peak_index,
peak_mv,
train_index,
});
last_peak_abs = abs_index;
} else if options.detect_minus && is_minus_start(compare, prev_compare) {
let peak_index = index;
let peak_mv = value;
let train_index = train.spikes.len();
train.push(make_spike(
header,
options,
SpikeDirection::Minus,
peak_index,
peak_index,
peak_mv,
));
open = Some(OpenSpike {
direction: SpikeDirection::Minus,
start_index: peak_index,
peak_index,
peak_mv,
train_index,
});
last_peak_abs = abs_index;
}
}
}
prev_compare = compare;
}
train
}
fn make_spike(
header: &Med64Header,
options: &SpikeDetectOptions,
direction: SpikeDirection,
start_index: usize,
peak_index: usize,
peak_mv: f64,
) -> Spike {
let within_trace = index_to_ms(header, peak_index, options.block_offset_ms);
let within_session = options.session_offset_ms + within_trace;
Spike {
channel: options.channel,
trace: options.trace,
direction,
peak_index,
start_index,
end_index: UNDEFINED_INDEX,
peak_mv,
within_trace_time_ms: within_trace,
within_session_time_ms: within_session,
duration_ms: 0.0,
waveform_mv: Vec::new(),
waveform_times_ms: Vec::new(),
}
}
fn update_spike_peak(
header: &Med64Header,
train: &mut SpikeTrain,
open: &OpenSpike,
options: &SpikeDetectOptions,
) {
if let Some(spike) = train.spikes.get_mut(open.train_index) {
spike.peak_index = open.peak_index;
spike.peak_mv = open.peak_mv;
spike.within_trace_time_ms = index_to_ms(header, open.peak_index, options.block_offset_ms);
spike.within_session_time_ms = options.session_offset_ms + spike.within_trace_time_ms;
}
}
fn update_spike_end(
header: &Med64Header,
train: &mut SpikeTrain,
open: &OpenSpike,
end_index: usize,
options: &SpikeDetectOptions,
) {
if let Some(spike) = train.spikes.get_mut(open.train_index) {
spike.start_index = open.start_index;
spike.end_index = end_index;
spike.duration_ms =
(end_index.saturating_sub(open.start_index) as f64) * header.interval_ms();
let _ = header;
let _ = options;
}
}
fn compare_value(
value: f64,
minus_gate: Option<f64>,
minus_half: Option<f64>,
plus_gate: Option<f64>,
plus_half: Option<f64>,
) -> Compare {
if let Some(m) = minus_gate {
if value < m {
return Compare::Less;
}
if let Some(mh) = minus_half {
if value < mh {
return Compare::LessHalf;
}
}
}
if let Some(p) = plus_gate {
if value > p {
return Compare::Greater;
}
if let Some(ph) = plus_half {
if value > ph {
return Compare::GreaterHalf;
}
}
}
Compare::Inside
}
fn is_spike_end(direction: SpikeDirection, compare: Compare) -> bool {
match direction {
SpikeDirection::Plus => !matches!(compare, Compare::Greater | Compare::GreaterHalf),
SpikeDirection::Minus => !matches!(compare, Compare::Less | Compare::LessHalf),
}
}
fn is_update_peak(direction: SpikeDirection, current_peak: f64, value: f64) -> bool {
if !value.is_finite() {
return false;
}
match direction {
SpikeDirection::Plus => value > current_peak,
SpikeDirection::Minus => value < current_peak,
}
}
fn is_plus_start(compare: Compare, prev: Compare) -> bool {
compare == Compare::Greater && prev != Compare::Greater
}
fn is_minus_start(compare: Compare, prev: Compare) -> bool {
compare == Compare::Less && prev != Compare::Less
}
#[cfg(test)]
mod tests {
use super::*;
use crate::header::Med64Header;
use std::path::PathBuf;
fn test_header() -> Med64Header {
Med64Header {
path: PathBuf::from("test.modat"),
number_of_traces: 1,
blocks_per_trace: 1,
data_format_version: 0,
sampling_frequency_hz: 20_000.0,
trace_duration_ms: 100.0,
daq_voltage_range: 10.0,
conversion_factor: 0.001,
active_channels: [1; 64],
start_year: 2020,
start_month: 1,
start_day: 1,
start_time_ms: 0,
start_timezone_minutes: 0,
number_of_real_data_blocks: 1,
real_trace_duration_ms: 100.0,
extended_active_channels: None,
}
}
#[test]
fn detects_positive_spike() {
let header = test_header();
let mut samples = vec![0.0; 500];
for i in 150..170 {
samples[i] = 1.0;
}
let train = detect_spikes(
&header,
&samples,
&SpikeDetectOptions {
plus_threshold_mv: 0.5,
minus_threshold_mv: -0.5,
refractory_samples: 20,
..Default::default()
},
);
assert!(!train.is_empty());
}
#[test]
fn minus_only_finds_negative_train() {
let header = test_header();
let mut samples = vec![0.0; 2000];
for peak in [100, 300, 500, 700, 900, 1100, 1300, 1500, 1700, 1900] {
for i in peak..peak + 15 {
if i < samples.len() {
samples[i] = -1.2;
}
}
}
let train = detect_spikes(
&header,
&samples,
&SpikeDetectOptions {
plus_threshold_mv: -0.5,
minus_threshold_mv: -0.5,
refractory_samples: 20,
detect_plus: false,
detect_minus: true,
..Default::default()
},
);
assert!(
train.len() >= 8,
"minus-only should find many negative spikes, got {}",
train.len()
);
assert!(train.spikes.iter().all(|s| s.direction == SpikeDirection::Minus));
let plus_disabled = detect_spikes(
&header,
&samples,
&SpikeDetectOptions {
plus_threshold_mv: 0.5,
minus_threshold_mv: -0.5,
refractory_samples: 20,
detect_plus: false,
detect_minus: true,
..Default::default()
},
);
let both = detect_spikes(
&header,
&samples,
&SpikeDetectOptions {
plus_threshold_mv: -0.5,
minus_threshold_mv: -0.5,
refractory_samples: 20,
detect_plus: true,
detect_minus: true,
..Default::default()
},
);
assert!(
both.len() >= train.len(),
"both polarities should find at least the minus-only set (both={}, minus={})",
both.len(),
train.len()
);
let _ = plus_disabled;
}
#[test]
fn longer_refractory_finds_fewer_spikes() {
let header = test_header();
let mut samples = vec![0.0; 500];
for block in [(100, 110), (115, 125), (140, 150)] {
for i in block.0..block.1 {
samples[i] = 1.0;
}
}
let base = SpikeDetectOptions {
plus_threshold_mv: 0.5,
minus_threshold_mv: -0.5,
..Default::default()
};
let long_refractory = detect_spikes(
&header,
&samples,
&SpikeDetectOptions { refractory_samples: 50, ..base.clone() },
);
let short_refractory =
detect_spikes(&header, &samples, &SpikeDetectOptions { refractory_samples: 5, ..base });
assert!(
long_refractory.len() < short_refractory.len(),
"long={} short={}",
long_refractory.len(),
short_refractory.len()
);
}
}