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
//! HTML chart writers for analysis dashboards.

use std::path::Path;

use serde::Serialize;

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

#[derive(Serialize)]
struct LineSeries {
    label: String,
    x: Vec<f64>,
    y: Vec<f64>,
}

fn chart_shell(
    title: &str,
    subtitle: &str,
    canvas_id: &str,
    datasets_json: &str,
    x_label: &str,
    y_label: &str,
) -> String {
    format!(
        r#"<!DOCTYPE html>
<html><head><meta charset="utf-8"><title>{title}</title>
<script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
<style>body{{font-family:system-ui;margin:1.5rem;background:#fafafa}}
h1{{font-size:1.25rem}} .sub{{color:#555;margin-bottom:1rem}}</style></head>
<body><h1>{title}</h1><div class="sub">{subtitle}</div>
<canvas id="{canvas_id}"></canvas>
<script>
const datasets = {datasets_json};
new Chart(document.getElementById('{canvas_id}'), {{
  type: 'line',
  data: {{ datasets }},
  options: {{
    responsive: true,
    interaction: {{ mode: 'index', intersect: false }},
    scales: {{
      x: {{ type: 'linear', title: {{ display: true, text: '{x_label}' }} }},
      y: {{ title: {{ display: true, text: '{y_label}' }} }}
    }}
  }}
}});
</script></body></html>"#
    )
}

pub fn write_burst_chart_html(report: &AnalysisReport, path: impl AsRef<Path>) -> Result<()> {
    let path = path.as_ref();
    let mut datasets = Vec::new();
    if !report.asdr.points.is_empty() {
        datasets.push(LineSeries {
            label: "ASDR (spikes/s)".into(),
            x: report.asdr.points.iter().map(|p| p.time_ms).collect(),
            y: report.asdr.points.iter().map(|p| p.smoothed_hz).collect(),
        });
    }
    for (i, burst) in report.multi_bursts.iter().take(5).enumerate() {
        datasets.push(LineSeries {
            label: format!("Multi burst {}", i + 1),
            x: vec![burst.start_ms, burst.end_ms],
            y: vec![burst.peak_rate_hz, burst.peak_rate_hz],
        });
    }
    let json = serde_json::to_string(&datasets.iter().enumerate().map(|(i, s)| {
        serde_json::json!({
            "label": s.label,
            "data": s.x.iter().zip(&s.y).map(|(x,y)| serde_json::json!({"x": x, "y": y})).collect::<Vec<_>>(),
            "borderColor": format!("hsl({} 70% 45%)", i * 47 % 360),
            "pointRadius": 0,
        })
    }).collect::<Vec<_>>()).unwrap_or("[]".into());
    let html = chart_shell(
        "Burst / ASDR Chart",
        &format!("{} · {} multi bursts", report.path.display(), report.multi_bursts.len()),
        "burst",
        &json,
        "Time (ms)",
        "Rate (Hz)",
    );
    std::fs::write(path, html)
        .map_err(|source| crate::error::Med64Error::WriteIo { path: path.to_path_buf(), source })?;
    Ok(())
}

pub fn write_isi_chart_html(report: &AnalysisReport, path: impl AsRef<Path>) -> Result<()> {
    let out_path = path.as_ref().to_path_buf();
    #[cfg(feature = "histograms")]
    {
        let edges = &report.isi_histogram.edges;
        let counts = &report.isi_histogram.counts;
        let mut x = Vec::new();
        let mut y = Vec::new();
        for (i, &c) in counts.iter().enumerate() {
            if let Some(&e) = edges.get(i) {
                x.push(e);
                y.push(c as f64);
            }
        }
        let series = [LineSeries { label: "ISI histogram".into(), x, y }];
        let json = serde_json::to_string(&series.iter().enumerate().map(|(i, s)| {
            serde_json::json!({
                "label": s.label,
                "data": s.x.iter().zip(&s.y).map(|(x,y)| serde_json::json!({"x": x, "y": y})).collect::<Vec<_>>(),
                "borderColor": format!("hsl({} 70% 45%)", i * 47 % 360),
                "fill": true,
            })
        }).collect::<Vec<_>>()).unwrap_or("[]".into());
        let html = chart_shell(
            "ISI Histogram",
            &report.path.display().to_string(),
            "isi",
            &json,
            "ISI (ms)",
            "Count",
        );
        std::fs::write(&out_path, html).map_err(|source| crate::error::Med64Error::WriteIo {
            path: out_path.clone(),
            source,
        })?;
        Ok(())
    }
    #[cfg(not(feature = "histograms"))]
    {
        let _ = (report, path);
        Err(crate::error::Med64Error::InvalidWrite {
            message: "ISI chart requires histograms feature".into(),
        })
    }
}

pub fn write_amplitude_chart_html(report: &AnalysisReport, path: impl AsRef<Path>) -> Result<()> {
    let out_path = path.as_ref().to_path_buf();
    use crate::analysis::amplitude_rank_report;
    let ranked = amplitude_rank_report(report, 200);
    let x: Vec<f64> = ranked.rows.iter().map(|r| r.time_ms).collect();
    let y: Vec<f64> = ranked.rows.iter().map(|r| r.peak_mv).collect();
    let json = serde_json::to_string(&[serde_json::json!({
        "label": "Spike amplitude",
        "data": x.iter().zip(&y).map(|(x,y)| serde_json::json!({"x": x, "y": y})).collect::<Vec<_>>(),
        "borderColor": "#9333ea",
        "pointRadius": 2,
        "showLine": false,
    })]).unwrap();
    let html = chart_shell(
        "Amplitude Chart",
        &report.path.display().to_string(),
        "amp",
        &json,
        "Time (ms)",
        "Peak (mV)",
    );
    std::fs::write(&out_path, html)
        .map_err(|source| crate::error::Med64Error::WriteIo { path: out_path, source })?;
    Ok(())
}

pub fn write_correlation_chart_html(report: &AnalysisReport, path: impl AsRef<Path>) -> Result<()> {
    let out_path = path.as_ref().to_path_buf();
    #[cfg(feature = "correlation")]
    {
        let x = report.correlogram.lag_ms.clone();
        let y: Vec<f64> = report.correlogram.counts.iter().map(|&c| c as f64).collect();
        let json = serde_json::to_string(&[serde_json::json!({
            "label": "Burst onset correlogram",
            "data": x.iter().zip(&y).map(|(x,y)| serde_json::json!({"x": x, "y": y})).collect::<Vec<_>>(),
            "borderColor": "#0891b2",
            "pointRadius": 0,
        })]).unwrap();
        let html = chart_shell(
            "Burst Correlation",
            &report.path.display().to_string(),
            "corr",
            &json,
            "Lag (ms)",
            "Count",
        );
        std::fs::write(&out_path, html)
            .map_err(|source| crate::error::Med64Error::WriteIo { path: out_path, source })?;
        Ok(())
    }
    #[cfg(not(feature = "correlation"))]
    {
        let _ = (report, path);
        Err(crate::error::Med64Error::InvalidWrite {
            message: "correlation chart requires correlation feature".into(),
        })
    }
}

pub fn write_freq_count_chart_html(report: &AnalysisReport, path: impl AsRef<Path>) -> Result<()> {
    let out_path = path.as_ref().to_path_buf();
    let mut by_ch: std::collections::BTreeMap<usize, Vec<&crate::analysis::SpikeFrequencyBin>> =
        std::collections::BTreeMap::new();
    for bin in &report.frequency_bins {
        by_ch.entry(bin.channel).or_default().push(bin);
    }
    let datasets: Vec<_> = by_ch
        .into_iter()
        .take(8)
        .enumerate()
        .map(|(i, (ch, bins))| {
            serde_json::json!({
                "label": format!("Ch {}", ch + 1),
                "data": bins.iter().map(|b| serde_json::json!({"x": (b.start_ms + b.end_ms)/2.0, "y": b.rate_hz})).collect::<Vec<_>>(),
                "borderColor": format!("hsl({} 70% 45%)", i * 47 % 360),
                "pointRadius": 0,
            })
        })
        .collect();
    let json = serde_json::to_string(&datasets).unwrap_or("[]".into());
    let html = chart_shell(
        "Spike Frequency Chart",
        &format!("{} · spike frequency window", report.path.display()),
        "freq",
        &json,
        "Time (ms)",
        "Rate (Hz)",
    );
    std::fs::write(&out_path, html)
        .map_err(|source| crate::error::Med64Error::WriteIo { path: out_path, source })?;
    Ok(())
}

pub fn write_map_chart_html(map: &RateMapReport, path: impl AsRef<Path>) -> Result<()> {
    let path = path.as_ref();
    let max = map.max_rate_hz.max(1e-9);
    let cols = map.cells.iter().map(|c| c.col).max().map(|c| c + 1).unwrap_or(8);
    let rows = map.cells.iter().map(|c| c.row).max().map(|c| c + 1).unwrap_or(8);
    // Place cells on a dense grid (missing electrodes → empty).
    let mut grid: Vec<Option<&crate::rate_map::RateMapCell>> = vec![None; rows * cols];
    for c in &map.cells {
        let idx = c.row * cols + c.col;
        if idx < grid.len() {
            grid[idx] = Some(c);
        }
    }
    let cells: Vec<_> = grid
        .iter()
        .enumerate()
        .map(|(i, opt)| {
            let row = i / cols;
            let col = i % cols;
            match opt {
                Some(c) => serde_json::json!({
                    "label": c.label,
                    "row": c.row,
                    "col": c.col,
                    "rate": c.rate_hz,
                    "count": c.spike_count,
                    "well": c.well,
                    "intensity": (c.rate_hz / max).min(1.0),
                    "empty": false,
                }),
                None => serde_json::json!({
                    "label": format!("r{row}c{col}"),
                    "row": row,
                    "col": col,
                    "rate": 0.0,
                    "count": 0,
                    "well": null,
                    "intensity": 0.0,
                    "empty": true,
                }),
            }
        })
        .collect();
    let html = format!(
        r#"<!DOCTYPE html>
<html><head><meta charset="utf-8"><title>Map Chart</title>
<style>
body{{font-family:system-ui;margin:1rem;background:#fafafa}}
.wrap{{display:flex;gap:1.5rem;flex-wrap:wrap;align-items:flex-start}}
.grid{{display:grid;gap:4px;max-width:640px}}
.cell{{aspect-ratio:1;border-radius:4px;display:flex;align-items:center;justify-content:center;
font-size:0.65rem;color:#111;cursor:pointer;border:1px solid transparent}}
.cell:hover{{border-color:#334155}}
.cell.empty{{opacity:.25}}
#detail{{min-width:12rem;padding:.75rem 1rem;background:#fff;border:1px solid #e2e8f0;border-radius:8px}}
.legend{{display:flex;align-items:center;gap:.5rem;margin-top:.75rem;font-size:.8rem;color:#555}}
.legend .bar{{height:12px;width:160px;background:linear-gradient(90deg,hsl(220 0% 90%),hsl(220 70% 40%));border-radius:2px}}
</style></head><body>
<h1>Spike rate map</h1>
<p>{} · max {:.2} Hz · grid {rows}×{cols}</p>
<div class="wrap">
  <div>
    <div class="grid" id="g" style="grid-template-columns:repeat({cols},1fr)"></div>
    <div class="legend"><span>0</span><div class="bar"></div><span>{:.2} Hz</span></div>
  </div>
  <div id="detail"><b>Select a cell</b><br>Click an electrode for label / rate / count.</div>
</div>
<script>
const cells = {cells};
const g = document.getElementById('g');
const detail = document.getElementById('detail');
cells.forEach(c => {{
  const d = document.createElement('div');
  d.className = 'cell' + (c.empty ? ' empty' : '');
  d.style.background = `hsl(220 ${{c.intensity*70}}% ${{90-c.intensity*50}}%)`;
  d.title = c.label + ' ' + c.rate.toFixed(2) + ' Hz';
  d.textContent = c.well != null ? 'W'+(c.well+1) : '';
  d.onclick = () => {{
    detail.innerHTML = `<b>${{c.label}}</b><br>Rate: ${{c.rate.toFixed(3)}} Hz<br>Count: ${{c.count}}<br>Row ${{c.row}}, Col ${{c.col}}` +
      (c.well != null ? `<br>Well ${{c.well+1}}` : '');
  }};
  g.appendChild(d);
}});
</script></body></html>"#,
        map.path.display(),
        map.max_rate_hz,
        map.max_rate_hz,
        cells = serde_json::to_string(&cells).unwrap_or("[]".into())
    );
    std::fs::write(path, html)
        .map_err(|source| crate::error::Med64Error::WriteIo { path: path.to_path_buf(), source })?;
    Ok(())
}

pub fn write_analysis_dashboard_html(
    report: &AnalysisReport,
    dir: impl AsRef<Path>,
    stem: &str,
) -> Result<Vec<std::path::PathBuf>> {
    let dir = dir.as_ref();
    std::fs::create_dir_all(dir)
        .map_err(|source| crate::error::Med64Error::WriteIo { path: dir.to_path_buf(), source })?;
    let mut out = Vec::new();
    let burst = dir.join(format!("{stem}_burst_chart.html"));
    write_burst_chart_html(report, &burst)?;
    out.push(burst);
    let freq = dir.join(format!("{stem}_freq_chart.html"));
    write_freq_count_chart_html(report, &freq)?;
    out.push(freq);
    #[cfg(feature = "histograms")]
    {
        let isi = dir.join(format!("{stem}_isi_chart.html"));
        write_isi_chart_html(report, &isi)?;
        out.push(isi);
    }
    let amp = dir.join(format!("{stem}_amplitude_chart.html"));
    write_amplitude_chart_html(report, &amp)?;
    out.push(amp);
    #[cfg(feature = "correlation")]
    {
        let corr = dir.join(format!("{stem}_correlation_chart.html"));
        write_correlation_chart_html(report, &corr)?;
        out.push(corr);
    }
    Ok(out)
}