use std::path::{Path, PathBuf};
use crate::analysis::AnalysisReport;
use crate::error::Result;
use crate::toolkit::poincare::{poincare_isi, PoincareReport};
use super::compute::{RateMapBatchReport, RateMapReport, StvMetrics};
use super::wells::write_rate_map_html;
pub fn write_rate_map_channel_table_csv(
rate_map: &RateMapReport,
path: impl AsRef<Path>,
) -> Result<()> {
let path = path.as_ref();
let mut w = String::from("ch,label,well,rate_hz,spike_count\n");
for c in &rate_map.cells {
w.push_str(&format!(
"{},{},{},{:.6},{}\n",
c.channel + 1,
c.label,
c.well.map(|x| (x + 1).to_string()).unwrap_or_default(),
c.rate_hz,
c.spike_count
));
}
std::fs::write(path, w)
.map_err(|source| crate::error::Med64Error::WriteIo { path: path.to_path_buf(), source })
}
fn rate_by_channel(rate_map: &RateMapReport, n: usize) -> Vec<f64> {
let mut rates = vec![0.0; n];
for c in &rate_map.cells {
if c.channel < n {
rates[c.channel] = c.rate_hz;
}
}
rates
}
pub fn write_rate_table1_csv(rate_map: &RateMapReport, path: impl AsRef<Path>) -> Result<()> {
let path = path.as_ref();
let rates = rate_by_channel(rate_map, 13);
let header: Vec<String> = (1..=13).map(|i| format!("Ch{i}")).collect();
let row: Vec<String> = rates.iter().map(|r| format!("{r:.6}")).collect();
let mut w = header.join(",");
w.push('\n');
w.push_str(&row.join(","));
w.push('\n');
std::fs::write(path, w)
.map_err(|source| crate::error::Med64Error::WriteIo { path: path.to_path_buf(), source })
}
pub fn write_rate_table2_csv(rate_map: &RateMapReport, path: impl AsRef<Path>) -> Result<()> {
let path = path.as_ref();
let rates = rate_by_channel(rate_map, 32);
let mut header = String::from("File #,Index");
for i in 1..=32 {
header.push_str(&format!(",Ch{i}"));
}
header.push('\n');
let mut row = String::from("1,1");
for r in &rates {
row.push_str(&format!(",{r:.6}"));
}
row.push('\n');
let mut w = header;
w.push_str(&row);
std::fs::write(path, w)
.map_err(|source| crate::error::Med64Error::WriteIo { path: path.to_path_buf(), source })
}
pub fn write_rate_table2r_csv(
rate_map: &RateMapReport,
stv: Option<&[StvMetrics]>,
path: impl AsRef<Path>,
) -> Result<()> {
let path = path.as_ref();
let rates = rate_by_channel(rate_map, 32);
let mut header = String::from("File #,Index");
for i in 1..=32 {
header.push_str(&format!(",Ch{i}"));
}
if stv.is_some() {
header.push_str(",ISI");
}
header.push('\n');
let mut row = String::from("1,1");
for r in &rates {
row.push_str(&format!(",{r:.6}"));
}
if let Some(rows) = stv {
let mean_isi = if rows.is_empty() {
0.0
} else {
rows.iter().map(|r| r.mean_isi_ms).sum::<f64>() / rows.len() as f64
};
row.push_str(&format!(",{mean_isi:.6}"));
}
row.push('\n');
let mut w = header;
w.push_str(&row);
std::fs::write(path, w)
.map_err(|source| crate::error::Med64Error::WriteIo { path: path.to_path_buf(), source })
}
pub fn write_poincare_isi_csv(report: &PoincareReport, path: impl AsRef<Path>) -> Result<()> {
let path = path.as_ref();
let mut w = String::from("isi_n,isi_n1\n");
for p in &report.points {
w.push_str(&format!("{:.6},{:.6}\n", p.isi_n_ms, p.isi_n1_ms));
}
std::fs::write(path, w)
.map_err(|source| crate::error::Med64Error::WriteIo { path: path.to_path_buf(), source })
}
pub fn write_rate_table3_csv(
files: &[(String, RateMapReport)],
path: impl AsRef<Path>,
) -> Result<()> {
let path = path.as_ref();
let mut channels = std::collections::BTreeSet::new();
for (_, map) in files {
for c in &map.cells {
channels.insert(c.channel);
}
}
let mut w = String::from("#,ch");
for (lab, _) in files {
w.push(',');
w.push_str(&lab.replace(',', ";"));
}
w.push('\n');
for (i, &ch) in channels.iter().enumerate() {
w.push_str(&format!("{},{}", i + 1, ch + 1));
for (_, map) in files {
let rate = map.cells.iter().find(|c| c.channel == ch).map(|c| c.rate_hz).unwrap_or(0.0);
w.push_str(&format!(",{rate:.6}"));
}
w.push('\n');
}
std::fs::write(path, w)
.map_err(|source| crate::error::Med64Error::WriteIo { path: path.to_path_buf(), source })
}
pub fn write_rate_table3_from_batch(
batch: &RateMapBatchReport,
path: impl AsRef<Path>,
) -> Result<()> {
let pairs: Vec<(String, RateMapReport)> = batch
.maps
.iter()
.zip(batch.files.iter())
.take(8)
.map(|(map, f)| {
let label = f
.path
.file_stem()
.map(|s| s.to_string_lossy().into_owned())
.unwrap_or_else(|| "File".to_string());
(label, map.clone())
})
.collect();
write_rate_table3_csv(&pairs, path)
}
#[cfg(feature = "correlation")]
pub fn write_synchrony_table_csv(
syn: &[crate::analysis::ChannelSynchrony],
path: impl AsRef<Path>,
) -> Result<()> {
let path = path.as_ref();
let mut w = String::from("ch_a,ch_b,synchrony_index,coincident_bursts,bursts_a\n");
for s in syn {
w.push_str(&format!(
"{},{},{:.6},{},{}\n",
s.channel_a + 1,
s.channel_b + 1,
s.synchrony_index,
s.coincident_bursts,
s.bursts_a
));
}
std::fs::write(path, w)
.map_err(|source| crate::error::Med64Error::WriteIo { path: path.to_path_buf(), source })
}
pub fn write_rate_map_speed_table_csv(
rate_map: &RateMapReport,
delays_ms: &[(usize, f64)],
path: impl AsRef<Path>,
) -> Result<()> {
let path = path.as_ref();
let mut w = String::from("ch,delay_ms,rate_hz\n");
let mut delay_map: std::collections::BTreeMap<usize, f64> = delays_ms.iter().copied().collect();
for c in &rate_map.cells {
let d = delay_map.remove(&c.channel).unwrap_or(f64::NAN);
w.push_str(&format!(
"{},{},{:.6}\n",
c.channel + 1,
if d.is_finite() { format!("{d:.6}") } else { String::new() },
c.rate_hz
));
}
std::fs::write(path, w)
.map_err(|source| crate::error::Med64Error::WriteIo { path: path.to_path_buf(), source })
}
pub fn smooth_rate_map_rates(rates: &[f64], window: usize) -> Vec<f64> {
let w = window.max(1);
let mut out = vec![0.0; rates.len()];
for i in 0..rates.len() {
let lo = i.saturating_sub(w / 2);
let hi = (i + w / 2 + 1).min(rates.len());
let slice = &rates[lo..hi];
out[i] = slice.iter().sum::<f64>() / slice.len() as f64;
}
out
}
pub fn write_rate_map_smoothing_csv(
rate_map: &RateMapReport,
window: usize,
path: impl AsRef<Path>,
) -> Result<()> {
let path = path.as_ref();
let rates: Vec<f64> = rate_map.cells.iter().map(|c| c.rate_hz).collect();
let smooth = smooth_rate_map_rates(&rates, window);
let mut w = String::from("ch,rate_hz,smoothed_hz\n");
for (i, c) in rate_map.cells.iter().enumerate() {
w.push_str(&format!(
"{},{:.6},{:.6}\n",
c.channel + 1,
c.rate_hz,
smooth.get(i).copied().unwrap_or(0.0)
));
}
std::fs::write(path, w)
.map_err(|source| crate::error::Med64Error::WriteIo { path: path.to_path_buf(), source })
}
pub fn write_rate_map_raw_package(
rate_map: &RateMapReport,
out_dir: impl AsRef<Path>,
) -> Result<Vec<PathBuf>> {
let dir = out_dir.as_ref();
std::fs::create_dir_all(dir)
.map_err(|source| crate::error::Med64Error::WriteIo { path: dir.to_path_buf(), source })?;
let mut outs = Vec::new();
let mut rates = vec![0.0; 64];
for c in &rate_map.cells {
if c.channel < rates.len() {
rates[c.channel] = c.rate_hz;
}
}
let png = dir.join("raw_rates.png");
crate::png::write_heatmap_png(&png, 8, 8, &rates, 16)?;
outs.push(png);
let csv = dir.join("raw_rates.csv");
{
let mut w = String::from("channel,rate_hz\n");
for (ch, r) in rates.iter().enumerate() {
w.push_str(&format!("{},{:.6}\n", ch + 1, r));
}
std::fs::write(&csv, w)
.map_err(|source| crate::error::Med64Error::WriteIo { path: csv.clone(), source })?;
outs.push(csv);
}
Ok(outs)
}
pub fn write_rate_map_filtered_export(
analysis: &AnalysisReport,
out_dir: impl AsRef<Path>,
) -> Result<Vec<PathBuf>> {
let dir = out_dir.as_ref();
std::fs::create_dir_all(dir)
.map_err(|source| crate::error::Med64Error::WriteIo { path: dir.to_path_buf(), source })?;
let path = dir.join("filtered_export.csv");
crate::export::write_filtered_raw_csv(analysis, &path)?;
Ok(vec![path])
}
pub fn write_rate_map_average_package(
analysis: &AnalysisReport,
path: impl AsRef<Path>,
) -> Result<PathBuf> {
let path = path.as_ref().to_path_buf();
let avgs = crate::analysis::average_spike_waveforms(&analysis.spikes, true);
crate::export::write_average_waveforms_csv(&avgs, &path)?;
Ok(path)
}
pub fn write_rate_map_propagation_package(
path: impl AsRef<Path>,
analysis: &AnalysisReport,
out_dir: impl AsRef<Path>,
) -> Result<Vec<PathBuf>> {
use crate::toolkit::propagation::{
propagation_from_spikes, write_propagation_csv, write_propagation_html, PropagationOptions,
};
let dir = out_dir.as_ref();
std::fs::create_dir_all(dir)
.map_err(|source| crate::error::Med64Error::WriteIo { path: dir.to_path_buf(), source })?;
let report =
propagation_from_spikes(path.as_ref(), &analysis.spikes, &PropagationOptions::default());
let mut outs = Vec::new();
let csv = dir.join("propa_delay.csv");
write_propagation_csv(&report, &csv)?;
outs.push(csv);
let html = dir.join("propa_delay.html");
write_propagation_html(&report, &html)?;
outs.push(html);
Ok(outs)
}
#[derive(Debug, Clone)]
pub struct RawViewerHtmlOptions {
pub amp_mv: f64,
pub duration_ms: f64,
pub downsample: usize,
}
impl Default for RawViewerHtmlOptions {
fn default() -> Self {
Self { amp_mv: 0.1, duration_ms: 1000.0, downsample: 8 }
}
}
pub fn write_raw_viewer_html(
report: &AnalysisReport,
path: impl AsRef<Path>,
opts: &RawViewerHtmlOptions,
) -> Result<()> {
let path = path.as_ref();
let interval = report.header.interval_ms().max(1e-9);
let ds = opts.downsample.max(1);
let mut channels_json = String::from("[");
for ch in 0..64 {
let samples = report.filtered_by_channel.get(&ch);
let data: Vec<f64> =
samples.map(|s| s.iter().step_by(ds).copied().collect()).unwrap_or_default();
if ch > 0 {
channels_json.push(',');
}
channels_json.push_str(&serde_json::to_string(&data).unwrap_or_else(|_| "[]".into()));
}
channels_json.push(']');
let html = format!(
r#"<!DOCTYPE html><html><head><meta charset="utf-8"><title>Raw viewer</title>
<style>body{{font-family:system-ui;margin:1rem}}.g{{display:grid;grid-template-columns:repeat(8,1fr);gap:4px}}
canvas{{width:100%;height:48px;background:#fff;border:1px solid #e2e8f0}}</style></head><body>
<h1>Raw 64-channel viewer</h1>
<label>Amp (mV) <select id="amp"><option>0.05</option><option selected>0.1</option><option>0.2</option><option>0.5</option></select></label>
<label>Duration (ms) <select id="dur"><option>250</option><option selected>1000</option><option>2000</option></select></label>
<label>Scrubber <input id="scrubber" type="range" min="0" max="100" value="0"></label>
<div class="g" id="g"></div>
<script>
const channels={channels_json};
const interval={interval}* {ds};
const g=document.getElementById('g');
for(let i=0;i<64;i++){{const c=document.createElement('canvas');c.width=160;c.height=48;c.dataset.ch=i;g.appendChild(c);}}
function draw(){{
const amp=+document.getElementById('amp').value||{amp};
const dur=+document.getElementById('dur').value||{dur};
const scrub=+document.getElementById('scrubber').value/100;
document.querySelectorAll('canvas').forEach(cv=>{{
const ch=+cv.dataset.ch; const data=channels[ch]||[];
const ctx=cv.getContext('2d'); ctx.clearRect(0,0,cv.width,cv.height);
const n=Math.max(2, Math.floor(dur/(interval||1)));
const start=Math.floor(scrub*Math.max(0,data.length-n));
ctx.beginPath();
for(let i=0;i<n && start+i<data.length;i++){{
const x=i/(n-1)*cv.width;
const y=cv.height/2 - (data[start+i]/amp)*cv.height*0.45;
if(i===0)ctx.moveTo(x,y); else ctx.lineTo(x,y);
}}
ctx.strokeStyle='#2563eb';ctx.stroke();
}});
}}
['amp','dur','scrubber'].forEach(id=>document.getElementById(id).addEventListener('input',draw));
draw();
</script></body></html>"#,
channels_json = channels_json,
interval = interval,
ds = ds,
amp = opts.amp_mv,
dur = opts.duration_ms,
);
std::fs::write(path, html)
.map_err(|source| crate::error::Med64Error::WriteIo { path: path.to_path_buf(), source })
}
pub fn write_rate_map_start_package(
rate_map: &RateMapReport,
analysis: Option<&AnalysisReport>,
out_dir: impl AsRef<Path>,
) -> Result<Vec<PathBuf>> {
let dir = out_dir.as_ref();
std::fs::create_dir_all(dir)
.map_err(|source| crate::error::Med64Error::WriteIo { path: dir.to_path_buf(), source })?;
let mut outs = Vec::new();
let map = dir.join("mapchart.html");
write_rate_map_html(rate_map, &map)?;
outs.push(map);
outs.extend(write_rate_map_raw_package(rate_map, dir)?);
if let Some(report) = analysis {
let raw = dir.join("raw_viewer.html");
write_raw_viewer_html(report, &raw, &RawViewerHtmlOptions::default())?;
outs.push(raw);
let tables = dir.join("rate_map_channel_table.csv");
write_rate_map_channel_table_csv(rate_map, &tables)?;
outs.push(tables);
outs.extend(write_rate_map_propagation_package(&rate_map.path, report, dir)?);
let poi = dir.join("poincare_isi.csv");
let pr = poincare_isi(&report.spikes);
{
let mut w = String::from("isi_n_ms,isi_n1_ms\n");
for p in &pr.points {
w.push_str(&format!("{:.6},{:.6}\n", p.isi_n_ms, p.isi_n1_ms));
}
std::fs::write(&poi, w).map_err(|source| crate::error::Med64Error::WriteIo {
path: poi.clone(),
source,
})?;
}
outs.push(poi);
}
let index = dir.join("index.html");
let body = r#"<!DOCTYPE html><html><head><meta charset="utf-8"><title>Spike-rate map</title></head>
<body><h1>Spike-rate map</h1>
<ul>
<li><a href="mapchart.html">Map chart</a></li>
<li><a href="raw_viewer.html">Raw viewer</a></li>
<li><a href="raw_rates.png">Raw rates PNG</a></li>
<li><a href="rate_map_channel_table.csv">Tables</a></li>
<li><a href="propagation_delay.html">Propagation</a></li>
<li><a href="poincare_isi.csv">Poincaré ISI</a></li>
</ul></body></html>"#;
std::fs::write(&index, body)
.map_err(|source| crate::error::Med64Error::WriteIo { path: index.clone(), source })?;
outs.push(index);
Ok(outs)
}
#[cfg(test)]
mod raw_viewer_tests {
use super::*;
use crate::analysis::{run_analysis, AnalysisOptions};
#[test]
fn raw_viewer_html_contains_scrubber() {
let report = run_analysis(
crate::fixture_paths::sample_data1(),
&AnalysisOptions {
max_blocks: Some(1),
retain_filtered: true,
..AnalysisOptions::reference()
},
)
.unwrap();
let dir = std::env::temp_dir().join(format!("med64_raw_{}", std::process::id()));
let _ = std::fs::create_dir_all(&dir);
let path = dir.join("raw_viewer.html");
write_raw_viewer_html(&report, &path, &RawViewerHtmlOptions::default()).unwrap();
let html = std::fs::read_to_string(&path).unwrap();
assert!(html.contains("scrubber"));
let _ = std::fs::remove_dir_all(&dir);
}
}