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;

use crate::analysis::AnalysisReport;
use crate::error::Result;

use super::util::{create_writer, io};

pub fn write_stat_results_csv(report: &AnalysisReport, path: impl AsRef<Path>) -> Result<()> {
    use crate::analysis::compute_stat_results;
    let path = path.as_ref();
    let stats = compute_stat_results(report);
    let mut writer = create_writer(path)?;
    writeln!(
        writer,
        "channel,spike_count,mean_rate_hz,mean_isi_ms,cv_isi,mean_amplitude_mv,burst_count,mean_burst_duration_ms,active"
    )
    .map_err(io(path))?;
    for row in &stats.channels {
        writeln!(
            writer,
            "{},{},{:.6},{:.6},{:.6},{:.8},{},{:.6},{}",
            row.channel + 1,
            row.spike_count,
            row.mean_rate_hz,
            row.mean_isi_ms,
            row.cv_isi,
            row.mean_amplitude_mv,
            row.burst_count,
            row.mean_burst_duration_ms,
            row.active
        )
        .map_err(io(path))?;
    }
    Ok(())
}

/// result-table clipboard layout (Metrics / Value type / Raw value).
pub fn write_result_table_csv(report: &AnalysisReport, path: impl AsRef<Path>) -> Result<()> {
    write_result_table_csv_with_options(
        report,
        path,
        &crate::analysis::ResultTableOptions::default(),
    )
}

/// Result table CSV with ChannelCriteria / StatTypeUnits aggregation options.
pub fn write_result_table_csv_with_options(
    report: &AnalysisReport,
    path: impl AsRef<Path>,
    options: &crate::analysis::ResultTableOptions,
) -> Result<()> {
    use crate::analysis::compute_burst_result_table;
    let path = path.as_ref();
    let table = compute_burst_result_table(report, options);
    let mut writer = create_writer(path)?;
    writeln!(writer, "Metrics,Value type,Raw value").map_err(io(path))?;
    for row in &table.rows {
        let value = match row.value {
            Some(v) if v.is_finite() => format!("{v:.6}"),
            _ => String::new(),
        };
        writeln!(writer, "{},{},{}", row.title.replace(',', ";"), row.value_type, value)
            .map_err(io(path))?;
    }
    Ok(())
}

/// Multi-file result table with `% change from #1` columns.
///
/// Layout (CSV):
/// `Metrics,Value type,<file1>,<file2>,...,% #1,<file2> %change,...`
pub fn write_result_table_compare_csv(
    table: &crate::analysis::MultiFileResultTable,
    path: impl AsRef<Path>,
) -> Result<()> {
    let path = path.as_ref();
    let mut writer = create_writer(path)?;
    if table.columns.is_empty() {
        writeln!(writer, "Metrics,Value type").map_err(io(path))?;
        return Ok(());
    }

    write!(writer, "Metrics,Value type").map_err(io(path))?;
    for col in &table.columns {
        write!(writer, ",{}", sanitize_csv_field(&col.label)).map_err(io(path))?;
    }
    for (i, col) in table.columns.iter().enumerate() {
        if i == 0 {
            write!(writer, ",% change from #1").map_err(io(path))?;
        } else {
            write!(writer, ",% {}", sanitize_csv_field(&col.label)).map_err(io(path))?;
        }
    }
    writeln!(writer).map_err(io(path))?;

    for metric in table.metric_rows() {
        write!(
            writer,
            "{},{}",
            sanitize_csv_field(&metric.title),
            sanitize_csv_field(&metric.value_type)
        )
        .map_err(io(path))?;
        for col_idx in 0..table.columns.len() {
            let v = table.raw_value(col_idx, &metric.map_label);
            write!(writer, ",{}", fmt_csv_f64(v)).map_err(io(path))?;
        }
        for col_idx in 0..table.columns.len() {
            let v = table.percent_change(col_idx, &metric.map_label);
            write!(writer, ",{}", fmt_csv_f64(v)).map_err(io(path))?;
        }
        writeln!(writer).map_err(io(path))?;
    }
    Ok(())
}

fn sanitize_csv_field(s: &str) -> String {
    s.replace(',', ";")
}

fn fmt_csv_f64(v: f64) -> String {
    if v.is_finite() {
        format!("{:.6}", v)
    } else {
        String::new()
    }
}

pub fn write_amplitude_rank_csv(report: &AnalysisReport, path: impl AsRef<Path>) -> Result<()> {
    use crate::analysis::amplitude_rank_report;
    let path = path.as_ref();
    let ranked = amplitude_rank_report(report, 1000);
    let mut writer = create_writer(path)?;
    writeln!(writer, "rank,channel,direction,peak_mv,time_ms").map_err(io(path))?;
    for row in &ranked.rows {
        let dir = match row.direction {
            crate::analysis::SpikeDirection::Plus => "plus",
            crate::analysis::SpikeDirection::Minus => "minus",
        };
        writeln!(
            writer,
            "{},{},{},{:.8},{:.6}",
            row.rank,
            row.channel + 1,
            dir,
            row.peak_mv,
            row.time_ms
        )
        .map_err(io(path))?;
    }
    Ok(())
}