use std::path::Path;
use crate::error::{Med64Error, Result};
use crate::layout::WellPlate;
use crate::toolkit::propagation::{AverageBinKind, PropagationOptions};
use crate::toolkit::propagation_oversample::{OversampleMode, ShihyouBins};
#[derive(Debug, Clone)]
pub struct PropagationPrefs {
pub oversample: OversampleMode,
pub shihyou: ShihyouBins,
pub average_bin: AverageBinKind,
pub well_plate: WellPlate,
pub electrode_pitch_um: f64,
}
impl Default for PropagationPrefs {
fn default() -> Self {
Self {
oversample: OversampleMode::None,
shihyou: ShihyouBins::Off,
average_bin: AverageBinKind::None,
well_plate: WellPlate::Wells24,
electrode_pitch_um: 150.0,
}
}
}
impl PropagationPrefs {
pub fn apply_to(&self, options: &mut PropagationOptions) {
options.average_bin = self.average_bin;
options.well_plate = self.well_plate;
options.electrode_pitch_um = self.electrode_pitch_um;
options.oversample = self.oversample;
options.shihyou = self.shihyou;
}
}
pub fn load_propagation_prefs(path: impl AsRef<Path>) -> Result<PropagationPrefs> {
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 = PropagationPrefs::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 {
"combooversample" | "oversample" => {
if let Some(m) = OversampleMode::parse(v) {
prefs.oversample = m;
}
}
"comboshihyou" | "shihyou" => {
if let Some(s) = ShihyouBins::parse(v) {
prefs.shihyou = s;
}
}
"average_bin" | "avebin" | "bin" => {
if let Some(b) = AverageBinKind::parse(v) {
prefs.average_bin = b;
}
}
"wellsuu" | "plate" | "well_plate" => {
if let Some(p) = WellPlate::parse(v) {
prefs.well_plate = p;
}
}
"electrode_pitch_um" | "pitch" => {
prefs.electrode_pitch_um = v.parse().unwrap_or(150.0);
}
_ => {}
}
}
Ok(prefs)
}
pub fn write_propagation_prefs(prefs: &PropagationPrefs, path: impl AsRef<Path>) -> Result<()> {
let path = path.as_ref();
let bin = match prefs.average_bin {
AverageBinKind::None => "none",
AverageBinKind::Bin16 => "16",
AverageBinKind::Bin32 => "32",
AverageBinKind::Presto => "presto",
};
let plate = match prefs.well_plate {
WellPlate::Wells6 => "6",
WellPlate::Wells24 => "24",
WellPlate::Wells48 => "48",
WellPlate::Wells96 => "96",
};
let body = format!(
"# Propagation Delay Map prefs (pdm99)\n\
combooversample={}\n\
comboshihyou={}\n\
average_bin={bin}\n\
wellsuu={plate}\n\
electrode_pitch_um={}\n",
prefs.oversample.as_wire_str(),
prefs.shihyou.levels(),
prefs.electrode_pitch_um
);
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 prefs_roundtrip_wire_strings() {
let dir = std::env::temp_dir().join(format!("med64-pdmprefs-{}", std::process::id()));
let _ = std::fs::create_dir_all(&dir);
let path = dir.join("conf_propagationdelaymap.properties");
let prefs = PropagationPrefs {
oversample: OversampleMode::Linear64,
shihyou: ShihyouBins::Twenty,
average_bin: AverageBinKind::Presto,
well_plate: WellPlate::Wells24,
electrode_pitch_um: 200.0,
};
write_propagation_prefs(&prefs, &path).unwrap();
let loaded = load_propagation_prefs(&path).unwrap();
assert_eq!(loaded.oversample, OversampleMode::Linear64);
assert_eq!(loaded.shihyou, ShihyouBins::Twenty);
let mut opts = PropagationOptions::default();
loaded.apply_to(&mut opts);
assert_eq!(opts.oversample, OversampleMode::Linear64);
assert_eq!(opts.conduction_bins, 1); let _ = std::fs::remove_dir_all(dir);
}
}