use std::path::Path;
use crate::analysis::{AnalysisOptions, AutoThresholdBase};
use crate::error::{Med64Error, Result};
use crate::toolkit::batch_export_prefs::{BatchExportPrefs, ChartImageType, ExportTraceType};
#[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,
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 {
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);
}
}
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,
}
}
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)
}
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);
}
}