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 std::io::Write;
use std::path::{Path, PathBuf};

use serde::{Deserialize, Serialize};

use crate::analysis::AnalysisReport;
use crate::error::{Med64Error, Result};

#[cfg(feature = "histograms")]
use super::csv::write_histogram_csv;
use super::csv::{
    write_asdr_csv, write_average_waveforms_csv, write_burst_profile_csv, write_filtered_raw_csv,
    write_frequency_csv, write_intra_burst_csv, write_multi_burst_csv, write_raster_csv,
    write_single_burst_csv, write_spike_timestamps_csv, write_spike_timestamps_plus_waveforms_csv,
};
#[cfg(feature = "correlation")]
use super::csv::{write_correlogram_csv, write_synchrony_csv};
use super::tables::{write_amplitude_rank_csv, write_result_table_csv, write_stat_results_csv};
use super::util::{create_writer, io};

/// Burst Detector–style export package (summary / individual / ASDR / raster).
pub fn write_burst_detector_bundle(
    report: &AnalysisReport,
    dir: impl AsRef<Path>,
) -> Result<Vec<PathBuf>> {
    write_burst_detector_bundle_with_options(report, dir, &BurstDetectorBundleOptions::default())
}

/// Preferences for which Burst Detector package members to write.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BurstDetectorBundleOptions {
    pub include_asdr: bool,
    pub include_raster: bool,
    pub include_profile: bool,
    pub include_botcc: bool,
    pub include_summary: bool,
    /// Intra-burst spike CSV (`IntraBurstSpikes.csv`).
    #[serde(default = "default_true")]
    pub include_intra_burst: bool,
    /// Amplitude histogram CSV when `histograms` feature is on.
    #[serde(default = "default_true")]
    pub include_amplitude_hist: bool,
    /// ISI histogram CSV when `histograms` feature is on.
    #[serde(default = "default_true")]
    pub include_isi_hist: bool,
}

fn default_true() -> bool {
    true
}

impl Default for BurstDetectorBundleOptions {
    fn default() -> Self {
        Self {
            include_asdr: true,
            include_raster: true,
            include_profile: true,
            include_botcc: true,
            include_summary: true,
            include_intra_burst: true,
            include_amplitude_hist: true,
            include_isi_hist: true,
        }
    }
}

/// Burst Detector export with selectable members + `batch_prefs.json`.
pub fn write_burst_detector_bundle_with_options(
    report: &AnalysisReport,
    dir: impl AsRef<Path>,
    options: &BurstDetectorBundleOptions,
) -> Result<Vec<PathBuf>> {
    let dir = dir.as_ref();
    std::fs::create_dir_all(dir)
        .map_err(|source| Med64Error::WriteIo { path: dir.to_path_buf(), source })?;
    let mut outputs = Vec::new();

    if options.include_summary {
        let summary = dir.join("Summary.csv");
        {
            let mut w = create_writer(&summary)?;
            writeln!(
                w,
                "metric,value\nspikes,{}\nsingle_channel_bursts,{}\nmulti_channel_bursts,{}\nasdr_bins,{}\nasdr_upper_hz,{:.6}\nasdr_lower_hz,{:.6}\nduration_ms,{:.3}",
                report.spikes.len(),
                report.single_bursts.len(),
                report.multi_bursts.len(),
                report.asdr.points.len(),
                report.asdr.threshold_hz,
                report.asdr.lower_threshold,
                report.header.real_trace_duration_ms
            )
            .map_err(io(&summary))?;
        }
        outputs.push(summary);
    }

    let individual = dir.join("Individual_SingleChannelBurst.csv");
    write_single_burst_csv(report, &individual)?;
    outputs.push(individual);

    let details = dir.join("Details_MultiChannelBurst.csv");
    write_multi_burst_csv(report, &details)?;
    outputs.push(details);

    if options.include_asdr {
        let asdr = dir.join("ASDR.csv");
        write_asdr_csv(report, &asdr)?;
        outputs.push(asdr);
    }

    if options.include_raster {
        let raster = dir.join("Raster.csv");
        write_raster_csv(report, &raster)?;
        outputs.push(raster);
    }

    if options.include_profile {
        let profile = dir.join("BurstProfile.csv");
        write_burst_profile_csv(report, &profile)?;
        outputs.push(profile);
    }

    if options.include_intra_burst {
        let intra = dir.join("IntraBurstSpikes.csv");
        write_intra_burst_csv(report, &intra)?;
        outputs.push(intra);
    }

    let result = dir.join("ResultTable.csv");
    write_result_table_csv(report, &result)?;
    outputs.push(result);

    #[cfg(feature = "histograms")]
    {
        if options.include_isi_hist {
            let isi = dir.join("ISI_Histogram.csv");
            write_histogram_csv(
                &report.isi_histogram.edges,
                &report.isi_histogram.counts,
                &isi,
                "isi_ms",
            )?;
            outputs.push(isi);
        }
        if options.include_amplitude_hist {
            let amp = dir.join("Amplitude_Histogram.csv");
            write_histogram_csv(
                &report.amplitude_histogram.edges,
                &report.amplitude_histogram.counts,
                &amp,
                "amplitude_mv",
            )?;
            outputs.push(amp);
        }
    }

    #[cfg(feature = "correlation")]
    if options.include_botcc {
        let botcc = dir.join("BOTCC.csv");
        write_correlogram_csv(report, &botcc)?;
        outputs.push(botcc);
    }

    let prefs = dir.join("batch_prefs.json");
    let prefs_json = serde_json::to_string_pretty(options)
        .map_err(|e| Med64Error::InvalidWrite { message: e.to_string() })?;
    std::fs::write(&prefs, prefs_json)
        .map_err(|source| Med64Error::WriteIo { path: prefs.clone(), source })?;
    outputs.push(prefs);

    Ok(outputs)
}

/// Write the full burst-analysis CSV bundle into `dir`.
pub fn write_analysis_bundle(
    report: &AnalysisReport,
    dir: impl AsRef<Path>,
    stem: &str,
) -> Result<Vec<PathBuf>> {
    let dir = dir.as_ref();
    std::fs::create_dir_all(dir)
        .map_err(|source| Med64Error::WriteIo { path: dir.to_path_buf(), source })?;
    let mut outputs = Vec::new();
    let spike = dir.join(format!("{stem}_spikes.csv"));
    write_spike_timestamps_csv(report, &spike)?;
    outputs.push(spike);

    let single = dir.join(format!("{stem}_bursts.csv"));
    write_single_burst_csv(report, &single)?;
    outputs.push(single);

    let multi = dir.join(format!("{stem}_multiburst.csv"));
    write_multi_burst_csv(report, &multi)?;
    outputs.push(multi);

    let asdr = dir.join(format!("{stem}_asdr.csv"));
    write_asdr_csv(report, &asdr)?;
    outputs.push(asdr);

    let intra = dir.join(format!("{stem}_intraburst.csv"));
    write_intra_burst_csv(report, &intra)?;
    outputs.push(intra);

    let freq = dir.join(format!("{stem}_freq.csv"));
    write_frequency_csv(report, &freq)?;
    outputs.push(freq);

    if !report.filtered_preview.is_empty() && report.filtered_by_channel.is_empty() {
        let filt = dir.join(format!("{stem}_filtered.csv"));
        write_filtered_raw_csv(report, &filt)?;
        outputs.push(filt);
    }

    #[cfg(feature = "histograms")]
    {
        let isi = dir.join(format!("{stem}_isi.csv"));
        write_histogram_csv(
            &report.isi_histogram.edges,
            &report.isi_histogram.counts,
            &isi,
            "isi_ms",
        )?;
        outputs.push(isi);
        let amp = dir.join(format!("{stem}_amplitude.csv"));
        write_histogram_csv(
            &report.amplitude_histogram.edges,
            &report.amplitude_histogram.counts,
            &amp,
            "amplitude_mv",
        )?;
        outputs.push(amp);
    }

    #[cfg(feature = "correlation")]
    {
        let cg = dir.join(format!("{stem}_correlogram.csv"));
        write_correlogram_csv(report, &cg)?;
        outputs.push(cg);
        let syn = dir.join(format!("{stem}_synchrony.csv"));
        write_synchrony_csv(report, &syn)?;
        outputs.push(syn);
    }

    let raster = dir.join(format!("{stem}_raster.csv"));
    write_raster_csv(report, &raster)?;
    outputs.push(raster);

    let profile = dir.join(format!("{stem}_burst_profile.csv"));
    write_burst_profile_csv(report, &profile)?;
    outputs.push(profile);

    let stats = dir.join(format!("{stem}_stat_results.csv"));
    write_stat_results_csv(report, &stats)?;
    outputs.push(stats);

    let result_table = dir.join(format!("{stem}_result_table.csv"));
    write_result_table_csv(report, &result_table)?;
    outputs.push(result_table);

    let amp_rank = dir.join(format!("{stem}_amplitude_rank.csv"));
    write_amplitude_rank_csv(report, &amp_rank)?;
    outputs.push(amp_rank);

    let plus = dir.join(format!("{stem}_SpikeTimeStampPlusSpikes.csv"));
    write_spike_timestamps_plus_waveforms_csv(report, &plus)?;
    outputs.push(plus);

    let avgs = crate::analysis::average_spike_waveforms(&report.spikes, false);
    if !avgs.is_empty() {
        let avg_path = dir.join(format!("{stem}_AverageSpikeWaveform.csv"));
        write_average_waveforms_csv(&avgs, &avg_path)?;
        outputs.push(avg_path);
    }

    if !report.filtered_by_channel.is_empty() || !report.filtered_preview.is_empty() {
        let filt = dir.join(format!("{stem}_FilteredRawData.csv"));
        write_filtered_raw_csv(report, &filt)?;
        if !outputs.iter().any(|p| p == &filt) {
            outputs.push(filt);
        }
    }

    // Display-name aliases.
    let named = [
        ("Spike Time Stamp.csv", format!("{stem}_spikes.csv")),
        ("Single-Channel Burst.csv", format!("{stem}_bursts.csv")),
        ("Multi-Channel Burst.csv", format!("{stem}_multiburst.csv")),
        ("ASDR Chart.csv", format!("{stem}_asdr.csv")),
        ("Intra-burst Spike Time Stamp.csv", format!("{stem}_intraburst.csv")),
        ("Spike Frequency Chart.csv", format!("{stem}_freq.csv")),
        ("Spike ISI Histogram.csv", format!("{stem}_isi.csv")),
        ("Spike Amplitude Histogram.csv", format!("{stem}_amplitude.csv")),
        ("Burst Correlation.csv", format!("{stem}_correlogram.csv")),
        ("Burst Onset Time Cross Correlogram.csv", format!("{stem}_correlogram.csv")),
        ("Synchrony Index.csv", format!("{stem}_synchrony.csv")),
        ("BOTCC.csv", format!("{stem}_correlogram.csv")),
        ("ResultTable.csv", format!("{stem}_result_table.csv")),
    ];
    for (alias, src_name) in named {
        let src = dir.join(&src_name);
        if src.exists() {
            let dst = dir.join(alias);
            let _ = std::fs::copy(&src, &dst);
            if dst.exists() {
                outputs.push(dst);
            }
        }
    }

    Ok(outputs)
}