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
//! Spike detector end-to-end pipeline.
//!
//! Pipeline: pre-filter → threshold table → spike detect →
//! scatter / mean-wave / ISI / autocorrelogram / raster-hist / heatmap /
//! optional clustering → export package (timestamps, waveforms, filtered, HDF5).

mod bundle;
mod panel;
mod run;
mod threshold;
mod types;

pub use bundle::{write_spike_detector_bundle, write_spike_detector_create_image};
pub use panel::{write_spike_detector_panel_html, write_spike_detector_result_table_html};
pub use run::{analysis_options_from, run_spike_detector};
pub use threshold::{
    apply_to_all_cluster, apply_to_all_minus_thresh, apply_to_all_on_off, apply_to_all_plus_thresh,
    compute_threshold_table, load_settings_table_csv, load_threshold_properties,
    write_settings_table_csv, write_threshold_properties,
};
pub use types::{
    ChannelThresholdRow, Histogram, SpikeDetectorExportMatrix, SpikeDetectorExportOptions,
    SpikeDetectorOptions, SpikeDetectorPanelPrefs, SpikeDetectorReport, SpikePolarity,
    ThresholdCalcRange,
};

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn toolkit_defaults_and_threshold_table() {
        let path = crate::fixture_paths::sample_data1();
        let opts =
            SpikeDetectorOptions { max_blocks: Some(2), ..SpikeDetectorOptions::toolkit_default() };
        let rows = compute_threshold_table(&path, &opts).unwrap();
        assert_eq!(rows.len(), 64);
        assert!(rows.iter().any(|r| r.minus_mv.unwrap_or(0.0).abs() > 0.0));
    }

    #[test]
    fn runs_spike_detector_on_sample() {
        let path = crate::fixture_paths::sample_data6_cap();
        let dir = std::env::temp_dir().join(format!("med64-sd-{}", std::process::id()));
        let _ = std::fs::create_dir_all(&dir);
        let opts = SpikeDetectorOptions {
            max_blocks: Some(4),
            export: SpikeDetectorExportOptions {
                hdf5: false,
                filtered_waveforms: false,
                ..SpikeDetectorExportOptions::default()
            },
            ..SpikeDetectorOptions::toolkit_default()
        };
        let report = run_spike_detector(&path, &opts, Some(&dir)).unwrap();
        assert!(
            report.spike_count > 50,
            "expected spikes on CAP (minus-only toolkit post-filter), got {}",
            report.spike_count
        );
        assert!(dir.join("spike_detector.html").exists());
        assert!(dir.join("thresholds.properties").exists());
        let _ = std::fs::remove_dir_all(&dir);
    }

    #[test]
    fn toolkit_default_count_band_vs_both_polarity() {
        let path = crate::fixture_paths::sample_data6_cap();
        let quiet = SpikeDetectorExportOptions {
            hdf5: false,
            filtered_waveforms: false,
            timestamps_only: false,
            timestamps_plus_spikes: false,
            amplitude_rank: false,
            html_dashboard: false,
            analysis_csvs: false,
            ..SpikeDetectorExportOptions::default()
        };
        let minus = run_spike_detector(
            &path,
            &SpikeDetectorOptions {
                max_blocks: Some(5),
                polarity: SpikePolarity::MinusOnly,
                export: quiet.clone(),
                ..SpikeDetectorOptions::toolkit_default()
            },
            None,
        )
        .unwrap();
        let both = run_spike_detector(
            &path,
            &SpikeDetectorOptions {
                max_blocks: Some(5),
                polarity: SpikePolarity::Both,
                export: quiet,
                ..SpikeDetectorOptions::toolkit_default()
            },
            None,
        )
        .unwrap();
        // Toolkit minus-only disables the Greater-gate; CAP yields thousands of spikes.
        assert!(
            minus.spike_count > 1000 && minus.spike_count < 200_000,
            "minus-only spike_count={} out of band",
            minus.spike_count
        );
        assert!(
            minus.spike_count <= both.spike_count,
            "minus {} > both {}",
            minus.spike_count,
            both.spike_count
        );
    }
}