use std::io::Write;
use std::path::{Path, PathBuf};
use serde::{Deserialize, Serialize};
use crate::analysis::AnalysisReport;
use crate::error::{Med64Error, Result};
#[cfg(feature = "histograms")]
use super::csv::write_histogram_csv;
use super::csv::{
write_asdr_csv, write_average_waveforms_csv, write_burst_profile_csv, write_filtered_raw_csv,
write_frequency_csv, write_intra_burst_csv, write_multi_burst_csv, write_raster_csv,
write_single_burst_csv, write_spike_timestamps_csv, write_spike_timestamps_plus_waveforms_csv,
};
#[cfg(feature = "correlation")]
use super::csv::{write_correlogram_csv, write_synchrony_csv};
use super::tables::{write_amplitude_rank_csv, write_result_table_csv, write_stat_results_csv};
use super::util::{create_writer, io};
pub fn write_burst_detector_bundle(
report: &AnalysisReport,
dir: impl AsRef<Path>,
) -> Result<Vec<PathBuf>> {
write_burst_detector_bundle_with_options(report, dir, &BurstDetectorBundleOptions::default())
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BurstDetectorBundleOptions {
pub include_asdr: bool,
pub include_raster: bool,
pub include_profile: bool,
pub include_botcc: bool,
pub include_summary: bool,
#[serde(default = "default_true")]
pub include_intra_burst: bool,
#[serde(default = "default_true")]
pub include_amplitude_hist: bool,
#[serde(default = "default_true")]
pub include_isi_hist: bool,
}
fn default_true() -> bool {
true
}
impl Default for BurstDetectorBundleOptions {
fn default() -> Self {
Self {
include_asdr: true,
include_raster: true,
include_profile: true,
include_botcc: true,
include_summary: true,
include_intra_burst: true,
include_amplitude_hist: true,
include_isi_hist: true,
}
}
}
pub fn write_burst_detector_bundle_with_options(
report: &AnalysisReport,
dir: impl AsRef<Path>,
options: &BurstDetectorBundleOptions,
) -> 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 outputs = Vec::new();
if options.include_summary {
let summary = dir.join("Summary.csv");
{
let mut w = create_writer(&summary)?;
writeln!(
w,
"metric,value\nspikes,{}\nsingle_channel_bursts,{}\nmulti_channel_bursts,{}\nasdr_bins,{}\nasdr_upper_hz,{:.6}\nasdr_lower_hz,{:.6}\nduration_ms,{:.3}",
report.spikes.len(),
report.single_bursts.len(),
report.multi_bursts.len(),
report.asdr.points.len(),
report.asdr.threshold_hz,
report.asdr.lower_threshold,
report.header.real_trace_duration_ms
)
.map_err(io(&summary))?;
}
outputs.push(summary);
}
let individual = dir.join("Individual_SingleChannelBurst.csv");
write_single_burst_csv(report, &individual)?;
outputs.push(individual);
let details = dir.join("Details_MultiChannelBurst.csv");
write_multi_burst_csv(report, &details)?;
outputs.push(details);
if options.include_asdr {
let asdr = dir.join("ASDR.csv");
write_asdr_csv(report, &asdr)?;
outputs.push(asdr);
}
if options.include_raster {
let raster = dir.join("Raster.csv");
write_raster_csv(report, &raster)?;
outputs.push(raster);
}
if options.include_profile {
let profile = dir.join("BurstProfile.csv");
write_burst_profile_csv(report, &profile)?;
outputs.push(profile);
}
if options.include_intra_burst {
let intra = dir.join("IntraBurstSpikes.csv");
write_intra_burst_csv(report, &intra)?;
outputs.push(intra);
}
let result = dir.join("ResultTable.csv");
write_result_table_csv(report, &result)?;
outputs.push(result);
#[cfg(feature = "histograms")]
{
if options.include_isi_hist {
let isi = dir.join("ISI_Histogram.csv");
write_histogram_csv(
&report.isi_histogram.edges,
&report.isi_histogram.counts,
&isi,
"isi_ms",
)?;
outputs.push(isi);
}
if options.include_amplitude_hist {
let amp = dir.join("Amplitude_Histogram.csv");
write_histogram_csv(
&report.amplitude_histogram.edges,
&report.amplitude_histogram.counts,
&,
"amplitude_mv",
)?;
outputs.push(amp);
}
}
#[cfg(feature = "correlation")]
if options.include_botcc {
let botcc = dir.join("BOTCC.csv");
write_correlogram_csv(report, &botcc)?;
outputs.push(botcc);
}
let prefs = dir.join("batch_prefs.json");
let prefs_json = serde_json::to_string_pretty(options)
.map_err(|e| Med64Error::InvalidWrite { message: e.to_string() })?;
std::fs::write(&prefs, prefs_json)
.map_err(|source| Med64Error::WriteIo { path: prefs.clone(), source })?;
outputs.push(prefs);
Ok(outputs)
}
pub fn write_analysis_bundle(
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 outputs = Vec::new();
let spike = dir.join(format!("{stem}_spikes.csv"));
write_spike_timestamps_csv(report, &spike)?;
outputs.push(spike);
let single = dir.join(format!("{stem}_bursts.csv"));
write_single_burst_csv(report, &single)?;
outputs.push(single);
let multi = dir.join(format!("{stem}_multiburst.csv"));
write_multi_burst_csv(report, &multi)?;
outputs.push(multi);
let asdr = dir.join(format!("{stem}_asdr.csv"));
write_asdr_csv(report, &asdr)?;
outputs.push(asdr);
let intra = dir.join(format!("{stem}_intraburst.csv"));
write_intra_burst_csv(report, &intra)?;
outputs.push(intra);
let freq = dir.join(format!("{stem}_freq.csv"));
write_frequency_csv(report, &freq)?;
outputs.push(freq);
if !report.filtered_preview.is_empty() && report.filtered_by_channel.is_empty() {
let filt = dir.join(format!("{stem}_filtered.csv"));
write_filtered_raw_csv(report, &filt)?;
outputs.push(filt);
}
#[cfg(feature = "histograms")]
{
let isi = dir.join(format!("{stem}_isi.csv"));
write_histogram_csv(
&report.isi_histogram.edges,
&report.isi_histogram.counts,
&isi,
"isi_ms",
)?;
outputs.push(isi);
let amp = dir.join(format!("{stem}_amplitude.csv"));
write_histogram_csv(
&report.amplitude_histogram.edges,
&report.amplitude_histogram.counts,
&,
"amplitude_mv",
)?;
outputs.push(amp);
}
#[cfg(feature = "correlation")]
{
let cg = dir.join(format!("{stem}_correlogram.csv"));
write_correlogram_csv(report, &cg)?;
outputs.push(cg);
let syn = dir.join(format!("{stem}_synchrony.csv"));
write_synchrony_csv(report, &syn)?;
outputs.push(syn);
}
let raster = dir.join(format!("{stem}_raster.csv"));
write_raster_csv(report, &raster)?;
outputs.push(raster);
let profile = dir.join(format!("{stem}_burst_profile.csv"));
write_burst_profile_csv(report, &profile)?;
outputs.push(profile);
let stats = dir.join(format!("{stem}_stat_results.csv"));
write_stat_results_csv(report, &stats)?;
outputs.push(stats);
let result_table = dir.join(format!("{stem}_result_table.csv"));
write_result_table_csv(report, &result_table)?;
outputs.push(result_table);
let amp_rank = dir.join(format!("{stem}_amplitude_rank.csv"));
write_amplitude_rank_csv(report, &_rank)?;
outputs.push(amp_rank);
let plus = dir.join(format!("{stem}_SpikeTimeStampPlusSpikes.csv"));
write_spike_timestamps_plus_waveforms_csv(report, &plus)?;
outputs.push(plus);
let avgs = crate::analysis::average_spike_waveforms(&report.spikes, false);
if !avgs.is_empty() {
let avg_path = dir.join(format!("{stem}_AverageSpikeWaveform.csv"));
write_average_waveforms_csv(&avgs, &avg_path)?;
outputs.push(avg_path);
}
if !report.filtered_by_channel.is_empty() || !report.filtered_preview.is_empty() {
let filt = dir.join(format!("{stem}_FilteredRawData.csv"));
write_filtered_raw_csv(report, &filt)?;
if !outputs.iter().any(|p| p == &filt) {
outputs.push(filt);
}
}
let named = [
("Spike Time Stamp.csv", format!("{stem}_spikes.csv")),
("Single-Channel Burst.csv", format!("{stem}_bursts.csv")),
("Multi-Channel Burst.csv", format!("{stem}_multiburst.csv")),
("ASDR Chart.csv", format!("{stem}_asdr.csv")),
("Intra-burst Spike Time Stamp.csv", format!("{stem}_intraburst.csv")),
("Spike Frequency Chart.csv", format!("{stem}_freq.csv")),
("Spike ISI Histogram.csv", format!("{stem}_isi.csv")),
("Spike Amplitude Histogram.csv", format!("{stem}_amplitude.csv")),
("Burst Correlation.csv", format!("{stem}_correlogram.csv")),
("Burst Onset Time Cross Correlogram.csv", format!("{stem}_correlogram.csv")),
("Synchrony Index.csv", format!("{stem}_synchrony.csv")),
("BOTCC.csv", format!("{stem}_correlogram.csv")),
("ResultTable.csv", format!("{stem}_result_table.csv")),
];
for (alias, src_name) in named {
let src = dir.join(&src_name);
if src.exists() {
let dst = dir.join(alias);
let _ = std::fs::copy(&src, &dst);
if dst.exists() {
outputs.push(dst);
}
}
}
Ok(outputs)
}