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);
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, &)?;
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)
}