use std::path::{Path, PathBuf};
use serde::{Deserialize, Serialize};
use crate::analysis::AnalysisReport;
use crate::error::{Med64Error, Result};
use super::draw::*;
pub fn write_svg_snapshot(report: &AnalysisReport, path: impl AsRef<Path>) -> Result<()> {
let path = path.as_ref();
let series: Vec<(f64, f64)> =
report.asdr.points.iter().map(|p| (p.time_ms, p.smoothed_hz)).collect();
write_line_svg(&series, path, 800, 280, "#2563eb", "ASDR", "Time (ms)", "Rate (Hz)")
}
pub fn write_png_snapshot(report: &AnalysisReport, path: impl AsRef<Path>) -> Result<()> {
let series: Vec<(f64, f64)> =
report.asdr.points.iter().map(|p| (p.time_ms, p.smoothed_hz)).collect();
write_line_png(&series, path.as_ref(), 800, 240)
}
pub fn write_chart_snapshots(
report: &AnalysisReport,
dir: impl AsRef<Path>,
stem: &str,
) -> Result<Vec<PathBuf>> {
let dir = dir.as_ref();
std::fs::create_dir_all(dir)
.map_err(|source| Med64Error::WriteIo { path: dir.to_path_buf(), source })?;
let mut out = Vec::new();
let asdr_series: Vec<(f64, f64)> =
report.asdr.points.iter().map(|p| (p.time_ms, p.smoothed_hz)).collect();
let asdr_svg = dir.join(format!("{stem}_asdr.svg"));
write_line_svg(&asdr_series, &asdr_svg, 800, 280, "#2563eb", "ASDR", "Time (ms)", "Rate (Hz)")?;
out.push(asdr_svg);
let asdr_eps = dir.join(format!("{stem}_asdr.eps"));
write_line_eps(&asdr_series, &asdr_eps, 800, 280, "ASDR", "Time (ms)", "Rate (Hz)")?;
out.push(asdr_eps);
let asdr_bmp = dir.join(format!("{stem}_asdr.bmp"));
write_line_bmp(&asdr_series, &asdr_bmp, 800, 240)?;
out.push(asdr_bmp);
let asdr_png = dir.join(format!("{stem}_asdr.png"));
write_line_png(&asdr_series, &asdr_png, 800, 240)?;
out.push(asdr_png);
#[cfg(feature = "correlation")]
{
let corr_sum: u32 = report.correlogram.counts.iter().sum();
let corr_series: Vec<(f64, f64)> = if corr_sum == 0 {
report.correlogram.lag_ms.iter().map(|&x| (x, 0.0)).collect()
} else {
report
.correlogram
.lag_ms
.iter()
.zip(&report.correlogram.counts)
.map(|(&x, &c)| (x, c as f64))
.collect()
};
let botcc_title =
if corr_sum == 0 { "BOTCC (no single-channel bursts yet)" } else { "BOTCC" };
let corr_svg = dir.join(format!("{stem}_botcc.svg"));
write_line_svg(
&corr_series,
&corr_svg,
800,
280,
"#0891b2",
botcc_title,
"Lag (ms)",
"Count",
)?;
out.push(corr_svg);
let corr_eps = dir.join(format!("{stem}_botcc.eps"));
write_line_eps(&corr_series, &corr_eps, 800, 280, botcc_title, "Lag (ms)", "Count")?;
out.push(corr_eps);
let corr_bmp = dir.join(format!("{stem}_botcc.bmp"));
write_line_bmp(&corr_series, &corr_bmp, 800, 240)?;
out.push(corr_bmp);
let corr_png = dir.join(format!("{stem}_botcc.png"));
write_line_png(&corr_series, &corr_png, 800, 240)?;
out.push(corr_png);
}
let raster_svg = dir.join(format!("{stem}_raster.svg"));
write_raster_svg(report, &raster_svg, 900, 480)?;
out.push(raster_svg);
let raster_eps = dir.join(format!("{stem}_raster.eps"));
write_raster_eps(report, &raster_eps, 900, 480)?;
out.push(raster_eps);
let raster_bmp = dir.join(format!("{stem}_raster.bmp"));
write_raster_bmp(report, &raster_bmp, 900, 480)?;
out.push(raster_bmp);
let raster_png = dir.join(format!("{stem}_raster.png"));
write_raster_png(report, &raster_png, 900, 480)?;
out.push(raster_png);
let profile_series: Vec<(f64, f64)> =
report.burst_profile.points.iter().map(|p| (p.lag_ms, p.mean_rate_hz)).collect();
if !profile_series.is_empty() {
out.extend(write_named_line_snapshots(
&profile_series,
dir,
stem,
"profile",
"Burst profile",
"Lag (ms)",
"Mean rate (Hz)",
"#7c3aed",
)?);
}
let freq_series = aggregate_frequency_series(report);
if !freq_series.is_empty() {
out.extend(write_named_line_snapshots(
&freq_series,
dir,
stem,
"freq",
"Spike frequency",
"Time (ms)",
"Mean rate (Hz)",
"#ea580c",
)?);
}
if !report.filtered_by_channel.is_empty() || !report.filtered_preview.is_empty() {
let viewer_svg = dir.join(format!("{stem}_ch64.svg"));
write_channels64_svg(report, &viewer_svg, 960, 960)?;
out.push(viewer_svg);
let viewer_png = dir.join(format!("{stem}_ch64.png"));
write_channels64_png(report, &viewer_png, 960, 960)?;
out.push(viewer_png);
}
#[cfg(feature = "histograms")]
{
let isi_series: Vec<(f64, f64)> = report
.isi_histogram
.edges
.iter()
.zip(&report.isi_histogram.counts)
.map(|(&e, &c)| (e, c as f64))
.collect();
if !isi_series.is_empty() {
out.extend(write_named_line_snapshots(
&isi_series,
dir,
stem,
"isi_hist",
"ISI histogram",
"ISI (ms)",
"Count",
"#0d9488",
)?);
}
let amp_series: Vec<(f64, f64)> = report
.amplitude_histogram
.edges
.iter()
.zip(&report.amplitude_histogram.counts)
.map(|(&e, &c)| (e, c as f64))
.collect();
if !amp_series.is_empty() {
out.extend(write_named_line_snapshots(
&_series,
dir,
stem,
"amp_hist",
"Amplitude histogram",
"Amplitude (mV)",
"Count",
"#c026d3",
)?);
}
}
#[cfg(feature = "correlation")]
{
if !report.synchrony.is_empty() {
let syn_svg = dir.join(format!("{stem}_synchrony.svg"));
write_synchrony_bar_svg(&report.synchrony, &syn_svg, 800, 280)?;
out.push(syn_svg);
let syn_png = dir.join(format!("{stem}_synchrony.png"));
write_synchrony_bar_png(&report.synchrony, &syn_png, 800, 240)?;
out.push(syn_png);
}
}
Ok(out)
}
pub fn write_create_image_package(
report: &AnalysisReport,
dir: impl AsRef<Path>,
stem: &str,
) -> Result<Vec<PathBuf>> {
write_create_image_package_with_options(
report,
dir,
stem,
&CreateImagePackageOptions::default(),
)
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CreateImagePackageOptions {
pub width: u32,
pub height: u32,
pub include_asdr: bool,
pub include_raster: bool,
pub include_asdr_raster: bool,
pub include_single_ch: bool,
pub include_profile: bool,
pub profile_cumulative: bool,
pub include_botcc: bool,
pub include_frequency: bool,
pub include_raw: bool,
pub include_isi_hist: bool,
pub include_amp_hist: bool,
pub include_synchrony: bool,
pub write_svg: bool,
pub write_png: bool,
pub write_bmp: bool,
pub write_eps: bool,
pub alias_tab_names: bool,
pub copy_manifest: bool,
}
impl Default for CreateImagePackageOptions {
fn default() -> Self {
Self {
width: 800,
height: 280,
include_asdr: true,
include_raster: true,
include_asdr_raster: true,
include_single_ch: true,
include_profile: true,
profile_cumulative: false,
include_botcc: true,
include_frequency: true,
include_raw: true,
include_isi_hist: true,
include_amp_hist: true,
include_synchrony: true,
write_svg: true,
write_png: true,
write_bmp: true,
write_eps: true,
alias_tab_names: true,
copy_manifest: true,
}
}
}
impl CreateImagePackageOptions {
pub fn enabled_formats(&self) -> Vec<&'static str> {
let mut v = Vec::new();
if self.write_svg {
v.push("svg");
}
if self.write_png {
v.push("png");
}
if self.write_bmp {
v.push("bmp");
}
if self.write_eps {
v.push("eps");
}
v
}
}
pub fn write_create_image_package_with_options(
report: &AnalysisReport,
dir: impl AsRef<Path>,
stem: &str,
opts: &CreateImagePackageOptions,
) -> Result<Vec<PathBuf>> {
let dir = dir.as_ref();
std::fs::create_dir_all(dir)
.map_err(|source| Med64Error::WriteIo { path: dir.to_path_buf(), source })?;
let mut out = Vec::new();
let w = opts.width.max(64);
let h = opts.height.max(64);
let formats = opts.enabled_formats();
if opts.include_asdr {
let asdr_series: Vec<(f64, f64)> =
report.asdr.points.iter().map(|p| (p.time_ms, p.smoothed_hz)).collect();
out.extend(write_named_line_snapshots_sized(
&asdr_series,
dir,
stem,
"asdr",
"ASDR",
"Time (ms)",
"Rate (Hz)",
"#2563eb",
w,
h,
&formats,
)?);
}
#[cfg(feature = "correlation")]
if opts.include_botcc {
let corr_sum: u32 = report.correlogram.counts.iter().sum();
let corr_series: Vec<(f64, f64)> = if corr_sum == 0 {
report.correlogram.lag_ms.iter().map(|&x| (x, 0.0)).collect()
} else {
report
.correlogram
.lag_ms
.iter()
.zip(&report.correlogram.counts)
.map(|(&x, &c)| (x, c as f64))
.collect()
};
let botcc_title =
if corr_sum == 0 { "BOTCC (no single-channel bursts yet)" } else { "BOTCC" };
out.extend(write_named_line_snapshots_sized(
&corr_series,
dir,
stem,
"botcc",
botcc_title,
"Lag (ms)",
"Count",
"#0891b2",
w,
h,
&formats,
)?);
}
if opts.include_raster {
if formats.contains(&"svg") {
let raster_svg = dir.join(format!("{stem}_raster.svg"));
write_raster_svg(report, &raster_svg, w.max(900), h.max(480))?;
out.push(raster_svg);
}
if formats.contains(&"eps") {
let raster_eps = dir.join(format!("{stem}_raster.eps"));
write_raster_eps(report, &raster_eps, w.max(900), h.max(480))?;
out.push(raster_eps);
}
if formats.contains(&"bmp") {
let raster_bmp = dir.join(format!("{stem}_raster.bmp"));
write_raster_bmp(report, &raster_bmp, w.max(900), h.max(480))?;
out.push(raster_bmp);
}
if formats.contains(&"png") {
let raster_png = dir.join(format!("{stem}_raster.png"));
write_raster_png(report, &raster_png, w.max(900), h.max(480))?;
out.push(raster_png);
}
}
if opts.include_asdr_raster {
let combined = dir.join(format!("{stem}_asdr_raster.svg"));
write_asdr_raster_combined_svg(report, &combined, w, h * 2)?;
out.push(combined);
if formats.contains(&"png") {
let png = dir.join(format!("{stem}_asdr_raster.png"));
let html = dir.join(format!("{stem}_asdr_raster.html"));
let body = format!(
r#"<!DOCTYPE html><html><head><meta charset="utf-8"><title>ASDR+Raster</title></head>
<body><h1>ASDR + Raster</h1>
<p><img src="{stem}_asdr.png" alt="ASDR" style="max-width:100%"></p>
<p><img src="{stem}_raster.png" alt="Raster" style="max-width:100%"></p>
</body></html>"#
);
std::fs::write(&html, body)
.map_err(|source| Med64Error::WriteIo { path: html.clone(), source })?;
out.push(html);
let _ = png;
}
let alias = dir.join("ASDR_Raster.svg");
let _ = std::fs::copy(dir.join(format!("{stem}_asdr_raster.svg")), &alias);
if alias.is_file() {
out.push(alias);
}
}
if opts.include_profile {
let mut cum = 0.0_f64;
let profile_series: Vec<(f64, f64)> = report
.burst_profile
.points
.iter()
.map(|p| {
let y = if opts.profile_cumulative {
cum += p.mean_rate_hz;
cum
} else {
p.mean_rate_hz
};
(p.lag_ms, y)
})
.collect();
if !profile_series.is_empty() {
out.extend(write_named_line_snapshots_sized(
&profile_series,
dir,
stem,
"profile",
if opts.profile_cumulative {
"Burst profile (cumulative)"
} else {
"Burst profile"
},
"Lag (ms)",
"Mean rate (Hz)",
"#7c3aed",
w,
h,
&formats,
)?);
}
}
if opts.include_frequency {
let freq_series = aggregate_frequency_series(report);
if !freq_series.is_empty() {
out.extend(write_named_line_snapshots_sized(
&freq_series,
dir,
stem,
"freq",
"Spike frequency",
"Time (ms)",
"Mean rate (Hz)",
"#ea580c",
w,
h,
&formats,
)?);
}
}
if (opts.include_raw || opts.include_single_ch)
&& (!report.filtered_by_channel.is_empty() || !report.filtered_preview.is_empty())
{
if formats.contains(&"svg") {
let viewer_svg = dir.join(format!("{stem}_ch64.svg"));
write_channels64_svg(report, &viewer_svg, 960, 960)?;
out.push(viewer_svg);
}
if formats.contains(&"png") {
let viewer_png = dir.join(format!("{stem}_ch64.png"));
write_channels64_png(report, &viewer_png, 960, 960)?;
out.push(viewer_png);
}
}
#[cfg(feature = "histograms")]
{
if opts.include_isi_hist {
let isi_series: Vec<(f64, f64)> = report
.isi_histogram
.edges
.iter()
.zip(&report.isi_histogram.counts)
.map(|(&e, &c)| (e, c as f64))
.collect();
if !isi_series.is_empty() {
out.extend(write_named_line_snapshots_sized(
&isi_series,
dir,
stem,
"isi_hist",
"ISI histogram",
"ISI (ms)",
"Count",
"#0d9488",
w,
h,
&formats,
)?);
}
}
if opts.include_amp_hist {
let amp_series: Vec<(f64, f64)> = report
.amplitude_histogram
.edges
.iter()
.zip(&report.amplitude_histogram.counts)
.map(|(&e, &c)| (e, c as f64))
.collect();
if !amp_series.is_empty() {
out.extend(write_named_line_snapshots_sized(
&_series,
dir,
stem,
"amp_hist",
"Amplitude histogram",
"Amplitude (mV)",
"Count",
"#c026d3",
w,
h,
&formats,
)?);
}
}
}
#[cfg(feature = "correlation")]
if opts.include_synchrony && !report.synchrony.is_empty() {
if formats.contains(&"svg") {
let syn_svg = dir.join(format!("{stem}_synchrony.svg"));
write_synchrony_bar_svg(&report.synchrony, &syn_svg, w, h)?;
out.push(syn_svg);
}
if formats.contains(&"png") {
let syn_png = dir.join(format!("{stem}_synchrony.png"));
write_synchrony_bar_png(&report.synchrony, &syn_png, w, h.saturating_sub(40).max(120))?;
out.push(syn_png);
}
}
if opts.alias_tab_names {
let aliases = [
("asdr", "ASDR"),
("botcc", "BOTCC"),
("raster", "Raster"),
("profile", "BurstProfile"),
("freq", "Frequency"),
("ch64", "RawChannels"),
("isi_hist", "ISIHistogram"),
("amp_hist", "AmplitudeHistogram"),
("synchrony", "Synchrony"),
("asdr_raster", "ASDR_Raster"),
];
for (suffix, tab) in aliases {
for ext in &formats {
let src = dir.join(format!("{stem}_{suffix}.{ext}"));
if src.is_file() {
let dst = dir.join(format!("{tab}.{ext}"));
if src != dst {
let _ = std::fs::copy(&src, &dst);
if dst.is_file() && !out.contains(&dst) {
out.push(dst);
}
}
}
}
}
}
if opts.copy_manifest {
let manifest = dir.join("copy_image_manifest.json");
let files: Vec<String> = out
.iter()
.filter_map(|p| p.file_name().map(|n| n.to_string_lossy().into_owned()))
.collect();
let body = serde_json::json!({
"stem": stem,
"width": opts.width,
"height": opts.height,
"formats": formats,
"files": files,
"note": "clipboard substitute listing Create Image outputs",
});
std::fs::write(
&manifest,
serde_json::to_string_pretty(&body).unwrap_or_else(|_| "{}".into()),
)
.map_err(|source| Med64Error::WriteIo { path: manifest.clone(), source })?;
out.push(manifest);
}
Ok(out)
}