med64 0.0.2

Headless MED64 electrophysiology toolkit: .modat I/O, spike/burst analysis, assays, spike-rate maps, and CSV/HTML/SVG/HDF5 export
Documentation
//! Analysis project save/load (parameters + burst settings).

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() })
}