use std::path::{Path, PathBuf};
use serde::{Deserialize, Serialize};
use crate::analysis::{AnalysisOptions, AnalysisReport, StatResultReport};
use crate::error::{Med64Error, Result};
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AnalysisProject {
pub version: u32,
pub source_path: PathBuf,
pub options: AnalysisOptionsSnapshot,
pub spike_count: usize,
pub single_burst_count: usize,
pub multi_burst_count: usize,
pub stats: Option<StatResultReport>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AnalysisOptionsSnapshot {
pub highpass_hz: Option<f64>,
pub lowpass_hz: Option<f64>,
pub threshold_percent: f64,
pub channel_spike_limit_hz: f64,
pub per_trace: bool,
pub max_blocks: Option<usize>,
}
impl From<&AnalysisOptions> for AnalysisOptionsSnapshot {
fn from(o: &AnalysisOptions) -> Self {
Self {
highpass_hz: o.highpass_hz,
lowpass_hz: o.lowpass_hz,
threshold_percent: o.threshold_percent,
channel_spike_limit_hz: o.channel_spike_limit_hz,
per_trace: o.per_trace,
max_blocks: o.max_blocks,
}
}
}
impl AnalysisProject {
pub fn from_report(report: &AnalysisReport, options: &AnalysisOptions) -> Self {
use crate::analysis::compute_stat_results;
Self {
version: 1,
source_path: report.path.clone(),
options: AnalysisOptionsSnapshot::from(options),
spike_count: report.spikes.len(),
single_burst_count: report.single_bursts.len(),
multi_burst_count: report.multi_bursts.len(),
stats: Some(compute_stat_results(report)),
}
}
pub fn to_options(&self) -> AnalysisOptions {
AnalysisOptions {
highpass_hz: self.options.highpass_hz,
lowpass_hz: self.options.lowpass_hz,
threshold_percent: self.options.threshold_percent,
channel_spike_limit_hz: self.options.channel_spike_limit_hz,
per_trace: self.options.per_trace,
max_blocks: self.options.max_blocks,
..AnalysisOptions::default()
}
}
}
pub fn save_project(project: &AnalysisProject, path: impl AsRef<Path>) -> Result<()> {
let path = path.as_ref();
let json = serde_json::to_string_pretty(project)
.map_err(|e| Med64Error::InvalidWrite { message: e.to_string() })?;
std::fs::write(path, json)
.map_err(|source| Med64Error::WriteIo { path: path.to_path_buf(), source })
}
pub fn load_project(path: impl AsRef<Path>) -> Result<AnalysisProject> {
let path = path.as_ref();
let text = std::fs::read_to_string(path)
.map_err(|source| Med64Error::Io { path: path.to_path_buf(), source })?;
serde_json::from_str(&text)
.map_err(|e| Med64Error::InvalidMoflo { path: path.to_path_buf(), message: e.to_string() })
}