use std::io::Write;
use std::path::Path;
use crate::analysis::AnalysisReport;
use crate::error::Result;
use super::util::{create_writer, io};
pub fn write_stat_results_csv(report: &AnalysisReport, path: impl AsRef<Path>) -> Result<()> {
use crate::analysis::compute_stat_results;
let path = path.as_ref();
let stats = compute_stat_results(report);
let mut writer = create_writer(path)?;
writeln!(
writer,
"channel,spike_count,mean_rate_hz,mean_isi_ms,cv_isi,mean_amplitude_mv,burst_count,mean_burst_duration_ms,active"
)
.map_err(io(path))?;
for row in &stats.channels {
writeln!(
writer,
"{},{},{:.6},{:.6},{:.6},{:.8},{},{:.6},{}",
row.channel + 1,
row.spike_count,
row.mean_rate_hz,
row.mean_isi_ms,
row.cv_isi,
row.mean_amplitude_mv,
row.burst_count,
row.mean_burst_duration_ms,
row.active
)
.map_err(io(path))?;
}
Ok(())
}
pub fn write_result_table_csv(report: &AnalysisReport, path: impl AsRef<Path>) -> Result<()> {
write_result_table_csv_with_options(
report,
path,
&crate::analysis::ResultTableOptions::default(),
)
}
pub fn write_result_table_csv_with_options(
report: &AnalysisReport,
path: impl AsRef<Path>,
options: &crate::analysis::ResultTableOptions,
) -> Result<()> {
use crate::analysis::compute_burst_result_table;
let path = path.as_ref();
let table = compute_burst_result_table(report, options);
let mut writer = create_writer(path)?;
writeln!(writer, "Metrics,Value type,Raw value").map_err(io(path))?;
for row in &table.rows {
let value = match row.value {
Some(v) if v.is_finite() => format!("{v:.6}"),
_ => String::new(),
};
writeln!(writer, "{},{},{}", row.title.replace(',', ";"), row.value_type, value)
.map_err(io(path))?;
}
Ok(())
}
pub fn write_result_table_compare_csv(
table: &crate::analysis::MultiFileResultTable,
path: impl AsRef<Path>,
) -> Result<()> {
let path = path.as_ref();
let mut writer = create_writer(path)?;
if table.columns.is_empty() {
writeln!(writer, "Metrics,Value type").map_err(io(path))?;
return Ok(());
}
write!(writer, "Metrics,Value type").map_err(io(path))?;
for col in &table.columns {
write!(writer, ",{}", sanitize_csv_field(&col.label)).map_err(io(path))?;
}
for (i, col) in table.columns.iter().enumerate() {
if i == 0 {
write!(writer, ",% change from #1").map_err(io(path))?;
} else {
write!(writer, ",% {}", sanitize_csv_field(&col.label)).map_err(io(path))?;
}
}
writeln!(writer).map_err(io(path))?;
for metric in table.metric_rows() {
write!(
writer,
"{},{}",
sanitize_csv_field(&metric.title),
sanitize_csv_field(&metric.value_type)
)
.map_err(io(path))?;
for col_idx in 0..table.columns.len() {
let v = table.raw_value(col_idx, &metric.map_label);
write!(writer, ",{}", fmt_csv_f64(v)).map_err(io(path))?;
}
for col_idx in 0..table.columns.len() {
let v = table.percent_change(col_idx, &metric.map_label);
write!(writer, ",{}", fmt_csv_f64(v)).map_err(io(path))?;
}
writeln!(writer).map_err(io(path))?;
}
Ok(())
}
fn sanitize_csv_field(s: &str) -> String {
s.replace(',', ";")
}
fn fmt_csv_f64(v: f64) -> String {
if v.is_finite() {
format!("{:.6}", v)
} else {
String::new()
}
}
pub fn write_amplitude_rank_csv(report: &AnalysisReport, path: impl AsRef<Path>) -> Result<()> {
use crate::analysis::amplitude_rank_report;
let path = path.as_ref();
let ranked = amplitude_rank_report(report, 1000);
let mut writer = create_writer(path)?;
writeln!(writer, "rank,channel,direction,peak_mv,time_ms").map_err(io(path))?;
for row in &ranked.rows {
let dir = match row.direction {
crate::analysis::SpikeDirection::Plus => "plus",
crate::analysis::SpikeDirection::Minus => "minus",
};
writeln!(
writer,
"{},{},{},{:.8},{:.6}",
row.rank,
row.channel + 1,
dir,
row.peak_mv,
row.time_ms
)
.map_err(io(path))?;
}
Ok(())
}