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
//! Multi-Channel Burst chart / analysis prefs from `default.properties`.

use std::path::Path;

use crate::analysis::{AnalysisOptions, AutoThresholdBase};
use crate::error::{Med64Error, Result};
use crate::toolkit::batch_export_prefs::{BatchExportPrefs, ChartImageType, ExportTraceType};

/// Chart + threshold keys from Multi-Channel Burst `default.properties`.
///
/// Export toggles live in [`crate::BatchExportPrefs`] and are merged when present in the same file.
#[derive(Debug, Clone)]
pub struct MultiChannelBurstChartPrefs {
    pub bin_msec: f64,
    pub smoothing_bin: usize,
    pub high_threshold: f64,
    pub low_threshold: f64,
    pub calc_threshold: bool,
    pub calc_threshold_percent_median: Option<f64>,
    pub calc_threshold_percent_mean: Option<f64>,
    pub asdr_chart_type: i32,
    pub asdr_line_color: String,
    pub asdr_line_width: f64,
    pub asdr_column_color: String,
    pub asdr_column_width: f64,
    pub asdr_smoothing_line_color: String,
    pub asdr_background_color: String,
    pub asdr_export_center_type: i32,
    pub asdr_export_range_msec: f64,
    pub grid_on_off: String,
    pub raster_color_type: i32,
    pub raster_vivid_color: [String; 5],
    pub raster_one_color: String,
    pub raster_background_color: String,
    pub raster_color_max_spikes: f64,
    /// Batch export matrix keys when co-located in the same properties file.
    pub batch_export: BatchExportPrefs,
}

impl Default for MultiChannelBurstChartPrefs {
    fn default() -> Self {
        Self {
            bin_msec: 50.0,
            smoothing_bin: 10,
            high_threshold: 300.0,
            low_threshold: 150.0,
            calc_threshold: true,
            calc_threshold_percent_median: Some(300.0),
            calc_threshold_percent_mean: Some(300.0),
            asdr_chart_type: 1,
            asdr_line_color: "000000".into(),
            asdr_line_width: 1.0,
            asdr_column_color: "000000".into(),
            asdr_column_width: 1.0,
            asdr_smoothing_line_color: "ff0000".into(),
            asdr_background_color: "ffffff".into(),
            asdr_export_center_type: 0,
            asdr_export_range_msec: 1000.0,
            grid_on_off: "On".into(),
            raster_color_type: 1,
            raster_vivid_color: [
                "800080".into(),
                "0000ff".into(),
                "008000".into(),
                "ffa500".into(),
                "ff0000".into(),
            ],
            raster_one_color: "000000".into(),
            raster_background_color: "ffffff".into(),
            raster_color_max_spikes: 1000.0,
            batch_export: BatchExportPrefs::default(),
        }
    }
}

impl MultiChannelBurstChartPrefs {
    /// Map burst-threshold keys onto [`AnalysisOptions::multi_burst`].
    pub fn apply_to(&self, options: &mut AnalysisOptions) {
        options.multi_burst.bin_width_ms = self.bin_msec.max(1.0);
        options.multi_burst.smoothing_bins = self.smoothing_bin;
        if self.calc_threshold {
            options.multi_burst.manual_upper = None;
            options.multi_burst.manual_lower = None;
            options.multi_burst.auto_threshold_percent = self.high_threshold;
            options.multi_burst.auto_threshold_percent_low = self.low_threshold;
            if let Some(p) = self.calc_threshold_percent_median {
                options.multi_burst.auto_threshold_base = AutoThresholdBase::MedianMad;
                options.multi_burst.auto_threshold_percent = p;
            } else if let Some(p) = self.calc_threshold_percent_mean {
                options.multi_burst.auto_threshold_base = AutoThresholdBase::Mean;
                options.multi_burst.auto_threshold_percent = p;
            }
        } else {
            options.multi_burst.manual_upper = Some(self.high_threshold);
            options.multi_burst.manual_lower = Some(self.low_threshold);
        }
    }

    /// CSS custom properties for burst HTML wrappers (ASDR / raster colors).
    pub fn css_vars(&self) -> String {
        format!(
            ":root {{\n\
               --mcb-asdr-line: #{line};\n\
               --mcb-asdr-line-width: {lw}px;\n\
               --mcb-asdr-column: #{col};\n\
               --mcb-asdr-column-width: {cw}px;\n\
               --mcb-asdr-smooth: #{smooth};\n\
               --mcb-asdr-bg: #{bg};\n\
               --mcb-raster-one: #{rone};\n\
               --mcb-raster-bg: #{rbg};\n\
               --mcb-raster-v0: #{v0};\n\
               --mcb-raster-v1: #{v1};\n\
               --mcb-raster-v2: #{v2};\n\
               --mcb-raster-v3: #{v3};\n\
               --mcb-raster-v4: #{v4};\n\
               --mcb-grid: {grid};\n\
             }}\n",
            line = strip_hash(&self.asdr_line_color),
            lw = self.asdr_line_width,
            col = strip_hash(&self.asdr_column_color),
            cw = self.asdr_column_width,
            smooth = strip_hash(&self.asdr_smoothing_line_color),
            bg = strip_hash(&self.asdr_background_color),
            rone = strip_hash(&self.raster_one_color),
            rbg = strip_hash(&self.raster_background_color),
            v0 = strip_hash(&self.raster_vivid_color[0]),
            v1 = strip_hash(&self.raster_vivid_color[1]),
            v2 = strip_hash(&self.raster_vivid_color[2]),
            v3 = strip_hash(&self.raster_vivid_color[3]),
            v4 = strip_hash(&self.raster_vivid_color[4]),
            grid = if self.grid_on_off.eq_ignore_ascii_case("on") { "1" } else { "0" },
        )
    }
}

fn strip_hash(s: &str) -> &str {
    s.trim().trim_start_matches('#')
}

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,
    }
}

fn parse_image_type(v: &str) -> ChartImageType {
    let t = v.trim();
    if let Ok(n) = t.parse::<i32>() {
        return if n == 1 { ChartImageType::Png } else { ChartImageType::Bmp };
    }
    match t.to_ascii_lowercase().as_str() {
        "png" | "1" => ChartImageType::Png,
        _ => ChartImageType::Bmp,
    }
}

/// Load MCB chart prefs (+ optional batch-export keys) from a properties file.
pub fn load_multi_channel_burst_chart_prefs(
    path: impl AsRef<Path>,
) -> Result<MultiChannelBurstChartPrefs> {
    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 = MultiChannelBurstChartPrefs::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 {
            "binMSec" => prefs.bin_msec = v.parse().unwrap_or(prefs.bin_msec),
            "smoothingBin" => prefs.smoothing_bin = v.parse().unwrap_or(prefs.smoothing_bin),
            "highThreshold" => prefs.high_threshold = v.parse().unwrap_or(prefs.high_threshold),
            "lowThreshold" => prefs.low_threshold = v.parse().unwrap_or(prefs.low_threshold),
            "calcThreshold" => prefs.calc_threshold = parse_bool(v),
            "calcThresholdPercentMedian" => {
                prefs.calc_threshold_percent_median = v.parse().ok();
            }
            "calcThresholdPercentMean" => {
                prefs.calc_threshold_percent_mean = v.parse().ok();
            }
            "ASDRChartType" => prefs.asdr_chart_type = v.parse().unwrap_or(prefs.asdr_chart_type),
            "ASDRLineColor" => prefs.asdr_line_color = v.to_string(),
            "ASDRLineWidth" => prefs.asdr_line_width = v.parse().unwrap_or(prefs.asdr_line_width),
            "ASDRColumnColor" => prefs.asdr_column_color = v.to_string(),
            "ASDRColumnWidth" => {
                prefs.asdr_column_width = v.parse().unwrap_or(prefs.asdr_column_width)
            }
            "ASDRSmoothingLineColor" => prefs.asdr_smoothing_line_color = v.to_string(),
            "ASDRBackgroundColor" => prefs.asdr_background_color = v.to_string(),
            "ASDRExportCenterType" => {
                prefs.asdr_export_center_type = v.parse().unwrap_or(prefs.asdr_export_center_type)
            }
            "ASDRExportRangeMSec" => {
                prefs.asdr_export_range_msec = v.parse().unwrap_or(prefs.asdr_export_range_msec)
            }
            "gridonoff" => prefs.grid_on_off = v.to_string(),
            "rasterColorType" => {
                prefs.raster_color_type = v.parse().unwrap_or(prefs.raster_color_type)
            }
            "rasterVividColor0" => prefs.raster_vivid_color[0] = v.to_string(),
            "rasterVividColor1" => prefs.raster_vivid_color[1] = v.to_string(),
            "rasterVividColor2" => prefs.raster_vivid_color[2] = v.to_string(),
            "rasterVividColor3" => prefs.raster_vivid_color[3] = v.to_string(),
            "rasterVividColor4" => prefs.raster_vivid_color[4] = v.to_string(),
            "rasterOneColor" => prefs.raster_one_color = v.to_string(),
            "rasterBackgroundColor" => prefs.raster_background_color = v.to_string(),
            "rasterColorMaxSpikes" => {
                prefs.raster_color_max_spikes = v.parse().unwrap_or(prefs.raster_color_max_spikes)
            }
            "exportTraceType" => prefs.batch_export.export_trace_type = parse_trace_type(v),
            "chartImageType" => prefs.batch_export.chart_image_type = parse_image_type(v),
            "exportSpikeEvents" => prefs.batch_export.export_spike_events = parse_bool(v),
            "spikeEventsSuffix" => prefs.batch_export.spike_events_suffix = v.to_string(),
            "exportChart" => prefs.batch_export.export_chart = parse_bool(v),
            "chartSuffix" => prefs.batch_export.chart_suffix = v.to_string(),
            "exportBurst" => prefs.batch_export.export_burst = parse_bool(v),
            "burstSuffix" => prefs.batch_export.burst_suffix = v.to_string(),
            "exportSummaryValues" => prefs.batch_export.export_summary_values = parse_bool(v),
            "summaryValuesSuffix" => prefs.batch_export.summary_values_suffix = v.to_string(),
            "exportIndividualValues" => prefs.batch_export.export_individual_values = parse_bool(v),
            "individualValuesSuffix" => prefs.batch_export.individual_values_suffix = v.to_string(),
            "exportDetails" => prefs.batch_export.export_details = parse_bool(v),
            "detailsSuffix" => prefs.batch_export.details_suffix = v.to_string(),
            _ => {}
        }
    }
    Ok(prefs)
}

/// Write MCB chart prefs (+ nested batch-export keys).
pub fn write_multi_channel_burst_chart_prefs(
    prefs: &MultiChannelBurstChartPrefs,
    path: impl AsRef<Path>,
) -> Result<()> {
    let path = path.as_ref();
    let body = format!(
        "# med64 Multi-Channel Burst chart prefs\n\
         binMSec={}\n\
         smoothingBin={}\n\
         highThreshold={}\n\
         lowThreshold={}\n\
         calcThreshold={}\n\
         calcThresholdPercentMedian={}\n\
         calcThresholdPercentMean={}\n\
         ASDRChartType={}\n\
         ASDRLineColor={}\n\
         ASDRLineWidth={}\n\
         ASDRColumnColor={}\n\
         ASDRColumnWidth={}\n\
         ASDRSmoothingLineColor={}\n\
         ASDRBackgroundColor={}\n\
         ASDRExportCenterType={}\n\
         ASDRExportRangeMSec={}\n\
         gridonoff={}\n\
         rasterColorType={}\n\
         rasterVividColor0={}\n\
         rasterVividColor1={}\n\
         rasterVividColor2={}\n\
         rasterVividColor3={}\n\
         rasterVividColor4={}\n\
         rasterOneColor={}\n\
         rasterBackgroundColor={}\n\
         rasterColorMaxSpikes={}\n\
         exportTraceType={}\n\
         chartImageType={}\n\
         exportSpikeEvents={}\n\
         spikeEventsSuffix={}\n\
         exportChart={}\n\
         chartSuffix={}\n\
         exportBurst={}\n\
         burstSuffix={}\n\
         exportSummaryValues={}\n\
         summaryValuesSuffix={}\n\
         exportIndividualValues={}\n\
         individualValuesSuffix={}\n\
         exportDetails={}\n\
         detailsSuffix={}\n",
        prefs.bin_msec,
        prefs.smoothing_bin,
        prefs.high_threshold,
        prefs.low_threshold,
        if prefs.calc_threshold { "1" } else { "0" },
        prefs.calc_threshold_percent_median.map(|v| v.to_string()).unwrap_or_default(),
        prefs.calc_threshold_percent_mean.map(|v| v.to_string()).unwrap_or_default(),
        prefs.asdr_chart_type,
        prefs.asdr_line_color,
        prefs.asdr_line_width,
        prefs.asdr_column_color,
        prefs.asdr_column_width,
        prefs.asdr_smoothing_line_color,
        prefs.asdr_background_color,
        prefs.asdr_export_center_type,
        prefs.asdr_export_range_msec,
        prefs.grid_on_off,
        prefs.raster_color_type,
        prefs.raster_vivid_color[0],
        prefs.raster_vivid_color[1],
        prefs.raster_vivid_color[2],
        prefs.raster_vivid_color[3],
        prefs.raster_vivid_color[4],
        prefs.raster_one_color,
        prefs.raster_background_color,
        prefs.raster_color_max_spikes,
        prefs.batch_export.export_trace_type as i32,
        prefs.batch_export.chart_image_type as i32,
        prefs.batch_export.export_spike_events,
        prefs.batch_export.spike_events_suffix,
        prefs.batch_export.export_chart,
        prefs.batch_export.chart_suffix,
        prefs.batch_export.export_burst,
        prefs.batch_export.burst_suffix,
        prefs.batch_export.export_summary_values,
        prefs.batch_export.summary_values_suffix,
        prefs.batch_export.export_individual_values,
        prefs.batch_export.individual_values_suffix,
        prefs.batch_export.export_details,
        prefs.batch_export.details_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 })
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn mcb_chart_prefs_roundtrip() {
        let dir = std::env::temp_dir().join(format!("med64-mcb-chart-{}", std::process::id()));
        let _ = std::fs::create_dir_all(&dir);
        let path = dir.join("default.properties");
        let mut prefs = MultiChannelBurstChartPrefs::default();
        prefs.bin_msec = 25.0;
        prefs.smoothing_bin = 7;
        prefs.high_threshold = 250.0;
        prefs.low_threshold = 125.0;
        prefs.asdr_line_color = "112233".into();
        prefs.raster_vivid_color[0] = "abcdef".into();
        prefs.grid_on_off = "Off".into();
        prefs.batch_export.export_chart = true;
        prefs.batch_export.chart_suffix = "ChartX".into();
        write_multi_channel_burst_chart_prefs(&prefs, &path).unwrap();
        let loaded = load_multi_channel_burst_chart_prefs(&path).unwrap();
        assert_eq!(loaded.bin_msec, 25.0);
        assert_eq!(loaded.smoothing_bin, 7);
        assert_eq!(loaded.high_threshold, 250.0);
        assert_eq!(loaded.asdr_line_color, "112233");
        assert_eq!(loaded.raster_vivid_color[0], "abcdef");
        assert_eq!(loaded.grid_on_off, "Off");
        assert!(loaded.batch_export.export_chart);
        assert_eq!(loaded.batch_export.chart_suffix, "ChartX");
        let mut opts = AnalysisOptions::default();
        loaded.apply_to(&mut opts);
        assert_eq!(opts.multi_burst.bin_width_ms, 25.0);
        assert_eq!(opts.multi_burst.smoothing_bins, 7);
        assert!(opts.multi_burst.manual_upper.is_none());
        let css = loaded.css_vars();
        assert!(css.contains("--mcb-asdr-line: #112233"));
        assert!(css.contains("--mcb-grid: 0"));
        let _ = std::fs::remove_dir_all(dir);
    }
}