use std::collections::BTreeMap;
use std::path::{Path, PathBuf};
use crate::analysis::AnalysisReport;
use crate::error::{Med64Error, Result};
use crate::export::{
write_line_bmp, write_line_png, write_raster_bmp, write_raster_png, write_single_burst_csv,
};
use crate::toolkit::batch_export_prefs::ExportTraceType;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum SingleChannelBurstChartImageFormat {
#[default]
Emf,
Bmp,
Png,
}
impl SingleChannelBurstChartImageFormat {
pub fn ext(self) -> &'static str {
match self {
Self::Emf => "emf",
Self::Bmp => "bmp",
Self::Png => "png",
}
}
fn parse(v: &str) -> Self {
match v.trim().to_ascii_lowercase().as_str() {
"bmp" | "1" => Self::Bmp,
"png" | "2" => Self::Png,
_ => Self::Emf,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum SingleChannelBurstChartType {
#[default]
None,
Bursts,
Duration,
Interval,
Spikes,
Raster,
}
#[derive(Debug, Clone)]
pub struct SingleChannelBurstExportPrefs {
pub trace_type: ExportTraceType,
pub chart_image_format: SingleChannelBurstChartImageFormat,
pub export_spike_events_image: bool,
pub spike_events_image_suffix: String,
pub export_bursts_image: bool,
pub bursts_image_suffix: String,
pub export_spikes_image: bool,
pub spikes_image_suffix: String,
pub export_interval_image: bool,
pub interval_image_suffix: String,
pub export_duration_image: bool,
pub duration_image_suffix: String,
pub export_bursts_csv: bool,
pub bursts_csv_suffix: String,
pub export_spikes_csv: bool,
pub spikes_csv_suffix: String,
pub export_interval_csv: bool,
pub interval_csv_suffix: String,
pub export_duration_csv: bool,
pub duration_csv_suffix: String,
pub export_information_csv: bool,
pub information_suffix: String,
}
impl Default for SingleChannelBurstExportPrefs {
fn default() -> Self {
Self {
trace_type: ExportTraceType::Single,
chart_image_format: SingleChannelBurstChartImageFormat::Emf,
export_spike_events_image: false,
spike_events_image_suffix: "Spike events".into(),
export_bursts_image: false,
bursts_image_suffix: "Number of bursts in a trace".into(),
export_spikes_image: false,
spikes_image_suffix: "Number of spikes in a burst".into(),
export_interval_image: false,
interval_image_suffix: "Inter-burst interval".into(),
export_duration_image: false,
duration_image_suffix: "Duration of a burst".into(),
export_bursts_csv: false,
bursts_csv_suffix: "Number of bursts in a trace".into(),
export_spikes_csv: false,
spikes_csv_suffix: "Number of spikes in a burst".into(),
export_interval_csv: false,
interval_csv_suffix: "Inter-burst interval".into(),
export_duration_csv: false,
duration_csv_suffix: "Duration of a burst".into(),
export_information_csv: false,
information_suffix: "All".into(),
}
}
}
impl SingleChannelBurstExportPrefs {
pub fn is_checked_any(&self) -> bool {
self.export_spike_events_image
|| self.export_bursts_image
|| self.export_spikes_image
|| self.export_duration_image
|| self.export_bursts_csv
|| self.export_spikes_csv
|| self.export_duration_csv
|| self.export_information_csv
}
pub fn cli_sc_batch_default() -> Self {
Self {
export_spike_events_image: true,
export_bursts_image: true,
export_spikes_image: true,
export_duration_image: true,
export_bursts_csv: true,
export_spikes_csv: true,
export_duration_csv: true,
export_information_csv: true,
..Self::default()
}
}
pub fn filename_csv(&self, basename: &str, suffix: &str, trace: Option<u32>) -> String {
match (self.trace_type, trace) {
(ExportTraceType::AllInEach, Some(t)) => {
format!("{basename}_{t:03}_{suffix}.csv")
}
(ExportTraceType::AllInEach, None) => {
format!("{basename}_001_{suffix}.csv")
}
_ => format!("{basename}{suffix}.csv"),
}
}
pub fn filename_image(&self, basename: &str, suffix: &str, trace: Option<u32>) -> String {
let ext = self.chart_image_format.ext();
match (self.trace_type, trace) {
(ExportTraceType::AllInEach, Some(t)) => {
format!("{basename}_{t:03}_{suffix}.{ext}")
}
(ExportTraceType::AllInEach, None) => {
format!("{basename}_001_{suffix}.{ext}")
}
_ => format!("{basename}{suffix}.{ext}"),
}
}
}
fn parse_bool(v: &str) -> bool {
matches!(v.trim().to_ascii_lowercase().as_str(), "1" | "true" | "yes" | "on")
}
fn parse_trace_type(v: &str) -> ExportTraceType {
let t = v.trim();
if let Ok(n) = t.parse::<i32>() {
return match n {
1 => ExportTraceType::AllInEach,
2 => ExportTraceType::AllInOne,
_ => ExportTraceType::Single,
};
}
match t.to_ascii_lowercase().replace('_', "").as_str() {
"allineach" | "all-in-each" | "each" => ExportTraceType::AllInEach,
"allinone" | "all-in-one" | "one" => ExportTraceType::AllInOne,
_ => ExportTraceType::Single,
}
}
pub fn load_single_channel_burst_export_prefs(
path: impl AsRef<Path>,
) -> Result<SingleChannelBurstExportPrefs> {
let path = path.as_ref();
let text = std::fs::read_to_string(path)
.map_err(|source| Med64Error::Io { path: path.to_path_buf(), source })?;
let mut prefs = SingleChannelBurstExportPrefs::default();
for line in text.lines() {
let line = line.trim();
if line.is_empty() || line.starts_with('#') {
continue;
}
let Some((k, v)) = line.split_once('=') else {
continue;
};
let k = k.trim();
let v = v.trim();
match k {
"exportTraceType" => prefs.trace_type = parse_trace_type(v),
"exportChartImageFormat" | "chartImageFormat" => {
prefs.chart_image_format = SingleChannelBurstChartImageFormat::parse(v)
}
"exportImageSpikesEventsCheck" => prefs.export_spike_events_image = parse_bool(v),
"exportImageSpikesEvents" => prefs.spike_events_image_suffix = v.to_string(),
"exportImageBurstsCheck" => prefs.export_bursts_image = parse_bool(v),
"exportImageBursts" => prefs.bursts_image_suffix = v.to_string(),
"exportImageSpikesCheck" => prefs.export_spikes_image = parse_bool(v),
"exportImageSpikes" => prefs.spikes_image_suffix = v.to_string(),
"exportImageIntervalCheck" => prefs.export_interval_image = parse_bool(v),
"exportImageInterval" => prefs.interval_image_suffix = v.to_string(),
"exportImageDurationCheck" => prefs.export_duration_image = parse_bool(v),
"exportImageDuration" => prefs.duration_image_suffix = v.to_string(),
"exportCsvBurstsCheck" => prefs.export_bursts_csv = parse_bool(v),
"exportCsvBursts" => prefs.bursts_csv_suffix = v.to_string(),
"exportCsvSpikesCheck" => prefs.export_spikes_csv = parse_bool(v),
"exportCsvSpikes" => prefs.spikes_csv_suffix = v.to_string(),
"exportCsvIntervalCheck" => prefs.export_interval_csv = parse_bool(v),
"exportCsvInterval" => prefs.interval_csv_suffix = v.to_string(),
"exportCsvDurationCheck" => prefs.export_duration_csv = parse_bool(v),
"exportCsvDuration" => prefs.duration_csv_suffix = v.to_string(),
"exportCsvInformationCheck" => prefs.export_information_csv = parse_bool(v),
"exportCsvInformation" => prefs.information_suffix = v.to_string(),
_ => {}
}
}
Ok(prefs)
}
pub fn write_single_channel_burst_export_prefs(
prefs: &SingleChannelBurstExportPrefs,
path: impl AsRef<Path>,
) -> Result<()> {
let path = path.as_ref();
let fmt = match prefs.chart_image_format {
SingleChannelBurstChartImageFormat::Emf => "emf",
SingleChannelBurstChartImageFormat::Bmp => "bmp",
SingleChannelBurstChartImageFormat::Png => "png",
};
let trace = match prefs.trace_type {
ExportTraceType::Single => "Single",
ExportTraceType::AllInEach => "AllInEach",
ExportTraceType::AllInOne => "AllInOne",
};
let body = format!(
"# med64 Single-Channel Burst export prefs\n\
exportTraceType={trace}\n\
exportChartImageFormat={fmt}\n\
exportImageSpikesEventsCheck={}\n\
exportImageSpikesEvents={}\n\
exportImageBurstsCheck={}\n\
exportImageBursts={}\n\
exportImageSpikesCheck={}\n\
exportImageSpikes={}\n\
exportImageIntervalCheck={}\n\
exportImageInterval={}\n\
exportImageDurationCheck={}\n\
exportImageDuration={}\n\
exportCsvBurstsCheck={}\n\
exportCsvBursts={}\n\
exportCsvSpikesCheck={}\n\
exportCsvSpikes={}\n\
exportCsvIntervalCheck={}\n\
exportCsvInterval={}\n\
exportCsvDurationCheck={}\n\
exportCsvDuration={}\n\
exportCsvInformationCheck={}\n\
exportCsvInformation={}\n",
prefs.export_spike_events_image as u8,
prefs.spike_events_image_suffix,
prefs.export_bursts_image as u8,
prefs.bursts_image_suffix,
prefs.export_spikes_image as u8,
prefs.spikes_image_suffix,
prefs.export_interval_image as u8,
prefs.interval_image_suffix,
prefs.export_duration_image as u8,
prefs.duration_image_suffix,
prefs.export_bursts_csv as u8,
prefs.bursts_csv_suffix,
prefs.export_spikes_csv as u8,
prefs.spikes_csv_suffix,
prefs.export_interval_csv as u8,
prefs.interval_csv_suffix,
prefs.export_duration_csv as u8,
prefs.duration_csv_suffix,
prefs.export_information_csv as u8,
prefs.information_suffix,
);
if let Some(parent) = path.parent() {
std::fs::create_dir_all(parent).ok();
}
std::fs::write(path, body)
.map_err(|source| Med64Error::WriteIo { path: path.to_path_buf(), source })
}
fn write_chart_image(
series: &[(f64, f64)],
path: &Path,
format: SingleChannelBurstChartImageFormat,
) -> Result<()> {
match format {
SingleChannelBurstChartImageFormat::Bmp => write_line_bmp(series, path, 800, 480),
SingleChannelBurstChartImageFormat::Png => write_line_png(series, path, 800, 480),
SingleChannelBurstChartImageFormat::Emf => {
let pixels = crate::export::line_chart_pixels_public(series, 800, 480);
crate::emf::write_bgr_emf(path, 800, 480, &pixels)
}
}
}
fn write_raster_image(
report: &AnalysisReport,
path: &Path,
format: SingleChannelBurstChartImageFormat,
) -> Result<()> {
match format {
SingleChannelBurstChartImageFormat::Bmp => write_raster_bmp(report, path, 800, 480),
SingleChannelBurstChartImageFormat::Png => write_raster_png(report, path, 800, 480),
SingleChannelBurstChartImageFormat::Emf => {
let pixels = crate::export::raster_chart_pixels(report, 800, 480);
crate::emf::write_bgr_emf(path, 800, 480, &pixels)
}
}
}
fn bursts_per_trace(report: &AnalysisReport) -> Vec<(f64, f64)> {
let mut map: BTreeMap<u32, usize> = BTreeMap::new();
for b in &report.single_bursts {
*map.entry(b.trace).or_default() += 1;
}
map.into_iter().map(|(t, n)| (t as f64 + 1.0, n as f64)).collect()
}
fn spikes_in_burst_series(report: &AnalysisReport) -> Vec<(f64, f64)> {
report
.single_bursts
.iter()
.enumerate()
.map(|(i, b)| (i as f64 + 1.0, b.num_spikes as f64))
.collect()
}
fn duration_series(report: &AnalysisReport) -> Vec<(f64, f64)> {
report.single_bursts.iter().enumerate().map(|(i, b)| (i as f64 + 1.0, b.duration_ms)).collect()
}
fn interval_series(report: &AnalysisReport) -> Vec<(f64, f64)> {
report
.single_bursts
.iter()
.enumerate()
.map(|(i, b)| (i as f64 + 1.0, b.interburst_interval_ms))
.collect()
}
fn write_xy_csv(series: &[(f64, f64)], path: &Path, x_hdr: &str, y_hdr: &str) -> Result<()> {
let mut out = format!("{x_hdr},{y_hdr}\n");
for (x, y) in series {
out.push_str(&format!("{x:.6},{y:.6}\n"));
}
std::fs::write(path, out)
.map_err(|source| Med64Error::WriteIo { path: path.to_path_buf(), source })
}
pub fn write_single_channel_burst_export_package(
report: &AnalysisReport,
out_dir: impl AsRef<Path>,
prefs: &SingleChannelBurstExportPrefs,
basename: &str,
) -> Result<Vec<PathBuf>> {
if !prefs.is_checked_any() {
return Err(Med64Error::InvalidWrite {
message: "no SC burst export target selected (is_checked_any=false)".into(),
});
}
let dir = out_dir.as_ref();
std::fs::create_dir_all(dir)
.map_err(|source| Med64Error::WriteIo { path: dir.to_path_buf(), source })?;
let mut outputs = Vec::new();
let trace = None;
if prefs.export_information_csv {
let path = dir.join(prefs.filename_csv(basename, &prefs.information_suffix, trace));
write_single_burst_csv(report, &path)?;
outputs.push(path);
}
if prefs.export_bursts_csv {
let path = dir.join(prefs.filename_csv(basename, &prefs.bursts_csv_suffix, trace));
write_xy_csv(&bursts_per_trace(report), &path, "trace", "bursts")?;
outputs.push(path);
}
if prefs.export_spikes_csv {
let path = dir.join(prefs.filename_csv(basename, &prefs.spikes_csv_suffix, trace));
write_xy_csv(&spikes_in_burst_series(report), &path, "burst", "spikes")?;
outputs.push(path);
}
if prefs.export_duration_csv {
let path = dir.join(prefs.filename_csv(basename, &prefs.duration_csv_suffix, trace));
write_xy_csv(&duration_series(report), &path, "burst", "duration_ms")?;
outputs.push(path);
}
if prefs.export_interval_csv {
let path = dir.join(prefs.filename_csv(basename, &prefs.interval_csv_suffix, trace));
write_xy_csv(&interval_series(report), &path, "burst", "interval_ms")?;
outputs.push(path);
}
if prefs.export_spike_events_image {
let path =
dir.join(prefs.filename_image(basename, &prefs.spike_events_image_suffix, trace));
write_raster_image(report, &path, prefs.chart_image_format)?;
outputs.push(path);
}
if prefs.export_bursts_image {
let path = dir.join(prefs.filename_image(basename, &prefs.bursts_image_suffix, trace));
write_chart_image(&bursts_per_trace(report), &path, prefs.chart_image_format)?;
outputs.push(path);
}
if prefs.export_spikes_image {
let path = dir.join(prefs.filename_image(basename, &prefs.spikes_image_suffix, trace));
write_chart_image(&spikes_in_burst_series(report), &path, prefs.chart_image_format)?;
outputs.push(path);
}
if prefs.export_duration_image {
let path = dir.join(prefs.filename_image(basename, &prefs.duration_image_suffix, trace));
write_chart_image(&duration_series(report), &path, prefs.chart_image_format)?;
outputs.push(path);
}
if prefs.export_interval_image {
let path = dir.join(prefs.filename_image(basename, &prefs.interval_image_suffix, trace));
write_chart_image(&interval_series(report), &path, prefs.chart_image_format)?;
outputs.push(path);
}
let prefs_path = dir.join("scb_export_prefs.properties");
write_single_channel_burst_export_prefs(prefs, &prefs_path)?;
outputs.push(prefs_path);
Ok(outputs)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::analysis::{run_analysis, AnalysisOptions};
#[test]
fn scb_export_prefs_roundtrip() {
let dir = std::env::temp_dir().join(format!("med64-scb-{}", std::process::id()));
let _ = std::fs::create_dir_all(&dir);
let path = dir.join("scb.properties");
let prefs = SingleChannelBurstExportPrefs {
trace_type: ExportTraceType::AllInOne,
chart_image_format: SingleChannelBurstChartImageFormat::Png,
export_bursts_csv: true,
export_bursts_image: true,
bursts_csv_suffix: "Number of bursts in a trace".into(),
..SingleChannelBurstExportPrefs::default()
};
write_single_channel_burst_export_prefs(&prefs, &path).unwrap();
let loaded = load_single_channel_burst_export_prefs(&path).unwrap();
assert_eq!(loaded.trace_type, ExportTraceType::AllInOne);
assert_eq!(loaded.chart_image_format, SingleChannelBurstChartImageFormat::Png);
assert!(loaded.export_bursts_csv);
assert!(loaded.is_checked_any());
let interval_only = SingleChannelBurstExportPrefs {
export_interval_csv: true,
export_interval_image: true,
..SingleChannelBurstExportPrefs::default()
};
assert!(!interval_only.is_checked_any(), "interval toggles ignored by is_checked_any");
assert_eq!(loaded.filename_csv("rec", "All", None), "recAll.csv");
let each =
SingleChannelBurstExportPrefs { trace_type: ExportTraceType::AllInEach, ..prefs };
assert_eq!(each.filename_image("rec", "Spike events", None), "rec_001_Spike events.png");
let _ = std::fs::remove_dir_all(dir);
}
#[test]
fn scb_package_writes_expected_filenames() {
let data = crate::fixture_paths::sample_data1();
if !data.exists() {
return;
}
let report = run_analysis(
&data,
&AnalysisOptions { max_blocks: Some(2), ..AnalysisOptions::reference() },
)
.unwrap();
let dir = std::env::temp_dir().join(format!("med64-scb-pkg-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
let prefs = SingleChannelBurstExportPrefs {
chart_image_format: SingleChannelBurstChartImageFormat::Emf,
export_information_csv: true,
export_bursts_csv: true,
export_spike_events_image: true,
export_bursts_image: true,
..SingleChannelBurstExportPrefs::default()
};
let files =
write_single_channel_burst_export_package(&report, &dir, &prefs, "stem").unwrap();
let names: Vec<_> = files
.iter()
.filter_map(|p| p.file_name().map(|n| n.to_string_lossy().into_owned()))
.collect();
assert!(names.iter().any(|n| n == "stemAll.csv"));
assert!(names.iter().any(|n| n == "stemNumber of bursts in a trace.csv"));
assert!(names.iter().any(|n| n == "stemSpike events.emf"));
assert!(names.iter().any(|n| n == "stemNumber of bursts in a trace.emf"));
let emf = dir.join("stemSpike events.emf");
let bytes = std::fs::read(&emf).unwrap();
assert_eq!(&bytes[0..4], &1u32.to_le_bytes());
assert_eq!(&bytes[40..44], &0x464D_4520u32.to_le_bytes());
assert!(bytes.len() > 100, "spike events image should be >100 bytes, got {}", bytes.len());
let bursts_csv = dir.join("stemNumber of bursts in a trace.csv");
let csv_body = std::fs::read_to_string(&bursts_csv).unwrap();
assert!(
!csv_body.trim().is_empty() && csv_body.len() > 1,
"bursts csv should be non-empty"
);
let _ = std::fs::remove_dir_all(dir);
}
}