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

use serde::Serialize;

use crate::analysis::stats::percent_change_from_first;
use crate::analysis::task::{run_analysis, AnalysisOptions, AnalysisReport};
use crate::error::Result;
use crate::reader::discover_data_files;
use crate::reader::is_modat_file;

#[derive(Debug, Clone, Serialize)]
pub struct DosePoint {
    pub path: PathBuf,
    pub label: String,
    pub spike_count: usize,
    pub single_bursts: usize,
    pub multi_bursts: usize,
    pub mean_rate_hz: f64,
}

#[derive(Debug, Clone, Serialize)]
pub struct DoseSeriesReport {
    pub points: Vec<DosePoint>,
}

/// Editable dose table row (spreadsheet UX substitute).
#[derive(Debug, Clone, Serialize)]
pub struct DoseEditRow {
    pub index: usize,
    pub label: String,
    pub spike_count: usize,
    pub percent_change: f64,
}

#[derive(Debug, Clone, Serialize)]
pub struct DoseEditTable {
    pub rows: Vec<DoseEditRow>,
}

impl DoseEditTable {
    pub fn from_report(report: &DoseSeriesReport) -> Self {
        let first = report.points.first().map(|p| p.spike_count as f64).unwrap_or(0.0);
        let rows = report
            .points
            .iter()
            .enumerate()
            .map(|(i, p)| DoseEditRow {
                index: i,
                label: p.label.clone(),
                spike_count: p.spike_count,
                percent_change: percent_change_from_first(first, p.spike_count as f64, i == 0),
            })
            .collect();
        Self { rows }
    }
}

/// Apply label / spike_count overrides: `(index, optional_label, optional_spike_count)`.
pub fn apply_dose_edits(
    report: &DoseSeriesReport,
    edits: &[(usize, Option<String>, Option<usize>)],
) -> DoseSeriesReport {
    let mut out = report.clone();
    for &(idx, ref label, spikes) in edits {
        if let Some(row) = out.points.get_mut(idx) {
            if let Some(l) = label {
                row.label = l.clone();
            }
            if let Some(s) = spikes {
                row.spike_count = s;
            }
        }
    }
    out
}

/// Run analysis on every `.modat` in a directory (e.g. sample data6 CAP series).
pub fn run_dose_series(dir: impl AsRef<Path>, options: &AnalysisOptions) -> Result<Vec<DosePoint>> {
    Ok(run_dose_series_report(dir, options)?.points)
}

pub fn run_dose_series_report(
    dir: impl AsRef<Path>,
    options: &AnalysisOptions,
) -> Result<DoseSeriesReport> {
    let dir = dir.as_ref();
    let mut files = discover_data_files(dir)?;
    files.retain(|p| is_modat_file(p));
    files.sort();

    let mut points = Vec::new();
    for path in files {
        let report: AnalysisReport = run_analysis(&path, options)?;
        let label = path.file_stem().map(|s| s.to_string_lossy().into_owned()).unwrap_or_default();
        let duration_sec = report.header.real_trace_duration_ms / 1000.0;
        let mean_rate =
            if duration_sec > 0.0 { report.spikes.len() as f64 / duration_sec } else { 0.0 };
        points.push(DosePoint {
            path,
            label,
            spike_count: report.spikes.len(),
            single_bursts: report.single_bursts.len(),
            multi_bursts: report.multi_bursts.len(),
            mean_rate_hz: mean_rate,
        });
    }
    Ok(DoseSeriesReport { points })
}

/// Write dose-series summary CSV.
pub fn write_dose_csv(report: &DoseSeriesReport, path: impl AsRef<Path>) -> Result<()> {
    let path = path.as_ref();
    let mut w = std::io::BufWriter::new(std::fs::File::create(path).map_err(|source| {
        crate::error::Med64Error::WriteIo { path: path.to_path_buf(), source }
    })?);
    use std::io::Write;
    writeln!(w, "label,spikes,single_bursts,multi_bursts,mean_rate_hz,path")
        .map_err(|source| crate::error::Med64Error::WriteIo { path: path.to_path_buf(), source })?;
    for p in &report.points {
        writeln!(
            w,
            "{},{},{},{},{:.3},\"{}\"",
            csv_escape(&p.label),
            p.spike_count,
            p.single_bursts,
            p.multi_bursts,
            p.mean_rate_hz,
            p.path.display()
        )
        .map_err(|source| crate::error::Med64Error::WriteIo { path: path.to_path_buf(), source })?;
    }
    Ok(())
}

/// Write dose-response HTML chart (Chart.js).
pub fn write_dose_html(report: &DoseSeriesReport, path: impl AsRef<Path>) -> Result<()> {
    let path = path.as_ref();
    let labels: Vec<_> = report.points.iter().map(|p| p.label.clone()).collect();
    let rates: Vec<_> = report.points.iter().map(|p| p.mean_rate_hz).collect();
    let json_labels = serde_json::to_string(&labels).unwrap_or_else(|_| "[]".into());
    let json_rates = serde_json::to_string(&rates).unwrap_or_else(|_| "[]".into());
    let html = format!(
        r#"<!DOCTYPE html><html><head><meta charset="utf-8"><title>Dose response</title>
<script src="https://cdn.jsdelivr.net/npm/chart.js"></script></head><body>
<h1>Mean spike rate vs condition</h1><canvas id="c" width="800" height="400"></canvas>
<script>
const ctx=document.getElementById('c');
new Chart(ctx,{{type:'line',data:{{labels:{json_labels},datasets:[{{label:'Hz',data:{json_rates},borderColor:'#2563eb'}}]}},options:{{scales:{{y:{{title:{{display:true,text:'Spikes/s'}}}}}}}}}});
</script></body></html>"#
    );
    std::fs::write(path, html)
        .map_err(|source| crate::error::Med64Error::WriteIo { path: path.to_path_buf(), source })?;
    Ok(())
}

/// Interactive editable dose table (contenteditable + client-side % change + CSV export).
pub fn write_dose_interactive_html(
    report: &DoseSeriesReport,
    path: impl AsRef<Path>,
) -> Result<()> {
    let path = path.as_ref();
    let table = DoseEditTable::from_report(report);
    let mut rows = String::new();
    for r in &table.rows {
        rows.push_str(&format!(
            r#"<tr data-i="{i}"><td contenteditable="true" class="label">{label}</td>
<td contenteditable="true" class="spikes">{spikes}</td>
<td class="pct">{pct:.2}</td></tr>"#,
            i = r.index,
            label = html_escape(&r.label),
            spikes = r.spike_count,
            pct = r.percent_change,
        ));
    }
    let html = format!(
        r#"<!DOCTYPE html><html><head><meta charset="utf-8"><title>Dose edit table</title>
<style>body{{font-family:system-ui;margin:1rem}}table{{border-collapse:collapse}}td,th{{border:1px solid #cbd5e1;padding:.4rem .6rem}}
td[contenteditable]{{background:#fffbeb}}</style></head><body>
<h1>Dose series (editable)</h1>
<p>Edit labels / spike counts; % change recalculates from the first row. Export CSV is client-side.</p>
<button id="export">Export CSV</button>
<table id="t"><thead><tr><th>Label</th><th>Spikes</th><th>% change</th></tr></thead>
<tbody>{rows}</tbody></table>
<script>
function pct(first,cur,isFirst){{return isFirst?100: (first===0?0:(first/cur)*100);}}
function recompute(){{
  const trs=[...document.querySelectorAll('#t tbody tr')];
  const first=parseFloat(trs[0]?.querySelector('.spikes')?.textContent)||0;
  trs.forEach((tr,i)=>{{
    const spikes=parseFloat(tr.querySelector('.spikes').textContent)||0;
    tr.querySelector('.pct').textContent=pct(first,spikes,i===0).toFixed(2);
  }});
}}
document.getElementById('t').addEventListener('input',recompute);
document.getElementById('export').onclick=()=>{{
  const trs=[...document.querySelectorAll('#t tbody tr')];
  let csv='label,spikes,percent_change\\n';
  trs.forEach(tr=>{{
    csv+=tr.querySelector('.label').textContent.trim()+','+
      tr.querySelector('.spikes').textContent.trim()+','+
      tr.querySelector('.pct').textContent.trim()+'\\n';
  }});
  const a=document.createElement('a');
  a.href=URL.createObjectURL(new Blob([csv],{{type:'text/csv'}}));
  a.download='dose_edit.csv';a.click();
}};
</script></body></html>"#
    );
    std::fs::write(path, html)
        .map_err(|source| crate::error::Med64Error::WriteIo { path: path.to_path_buf(), source })?;
    Ok(())
}

fn html_escape(s: &str) -> String {
    s.replace('&', "&amp;").replace('<', "&lt;").replace('>', "&gt;")
}

fn csv_escape(s: &str) -> String {
    if s.contains(',') || s.contains('"') {
        format!("\"{}\"", s.replace('"', "\"\""))
    } else {
        s.to_string()
    }
}

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

    #[test]
    fn interactive_html_has_contenteditable() {
        let report = DoseSeriesReport {
            points: vec![
                DosePoint {
                    path: PathBuf::from("a.modat"),
                    label: "ctrl".into(),
                    spike_count: 100,
                    single_bursts: 1,
                    multi_bursts: 0,
                    mean_rate_hz: 1.0,
                },
                DosePoint {
                    path: PathBuf::from("b.modat"),
                    label: "drug".into(),
                    spike_count: 50,
                    single_bursts: 0,
                    multi_bursts: 0,
                    mean_rate_hz: 0.5,
                },
            ],
        };
        let dir = std::env::temp_dir().join(format!("med64_dose_html_{}", std::process::id()));
        let _ = std::fs::create_dir_all(&dir);
        let path = dir.join("interactive.html");
        write_dose_interactive_html(&report, &path).unwrap();
        let html = std::fs::read_to_string(&path).unwrap();
        assert!(html.contains("contenteditable"));
        let edited = apply_dose_edits(&report, &[(1, Some("edited".into()), Some(25))]);
        assert_eq!(edited.points[1].label, "edited");
        assert_eq!(edited.points[1].spike_count, 25);
        let _ = std::fs::remove_dir_all(&dir);
    }
}