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
//! Oversample modes and shihyou color bins for PDM AverageBinPresto.

use serde::{Deserialize, Serialize};

/// Wire `combooversample`: None | Linear 1/2 | Linear 1/64 | Spline 1/2 | Spline 1/64.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
pub enum OversampleMode {
    #[default]
    None,
    Linear2,
    Linear64,
    Spline2,
    Spline64,
}

impl OversampleMode {
    pub fn parse(s: &str) -> Option<Self> {
        let t = s.trim().to_ascii_lowercase();
        match t.as_str() {
            "none" | "off" | "0" => Some(Self::None),
            "linear 1/2" | "linear1/2" | "linear_2" | "2" => Some(Self::Linear2),
            "linear 1/64" | "linear1/64" | "linear_64" | "64" => Some(Self::Linear64),
            "spline 1/2" | "spline1/2" | "spline_2" => Some(Self::Spline2),
            "spline 1/64" | "spline1/64" | "spline_64" => Some(Self::Spline64),
            _ => None,
        }
    }

    pub fn as_wire_str(self) -> &'static str {
        match self {
            Self::None => "None",
            Self::Linear2 => "Linear 1/2",
            Self::Linear64 => "Linear 1/64",
            Self::Spline2 => "Spline 1/2",
            Self::Spline64 => "Spline 1/64",
        }
    }

    pub fn factor(self) -> usize {
        match self {
            Self::None => 1,
            Self::Linear2 | Self::Spline2 => 2,
            Self::Linear64 | Self::Spline64 => 64,
        }
    }

    pub fn is_spline(self) -> bool {
        matches!(self, Self::Spline2 | Self::Spline64)
    }
}

/// Wire `comboshihyou` palette levels: 5 / 10 / 20 (0 = off).
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
pub enum ShihyouBins {
    #[default]
    Off = 0,
    Five = 5,
    Ten = 10,
    Twenty = 20,
}

impl ShihyouBins {
    pub fn parse(s: &str) -> Option<Self> {
        match s.trim() {
            "0" | "off" | "none" => Some(Self::Off),
            "5" => Some(Self::Five),
            "10" => Some(Self::Ten),
            "20" => Some(Self::Twenty),
            _ => None,
        }
    }

    pub fn levels(self) -> usize {
        self as usize
    }
}

/// Port of `AverageBinPresto.kurai` / `kurai5` / `kurai20`.
/// Returns palette short (0…N+2). Missing / sentinel −1 → 2.
pub fn color_bin(val: f64, maxamp: f64, shihyou: ShihyouBins) -> u16 {
    let n = shihyou.levels();
    if n == 0 {
        return 0;
    }
    if (val + 1.0).abs() < 1e-9 {
        return 2;
    }
    if maxamp <= 0.0 {
        return 0;
    }
    for k in (1..n).rev() {
        if val > maxamp * k as f64 / n as f64 {
            return (k + 3) as u16;
        }
    }
    if val > 0.0 {
        3
    } else {
        0
    }
}

/// Dense oversampled delay grid (`rows*factor` × `cols*factor`).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct OversampleGrid {
    pub rows: usize,
    pub cols: usize,
    pub factor: usize,
    pub mode: OversampleMode,
    /// Row-major delays; NaN = missing.
    pub delays_ms: Vec<f64>,
    pub color_index: Vec<u16>,
}

/// Upsample a rectangular delay field (row-major, missing = NaN).
pub fn upsample_delay_grid(
    delays: &[f64],
    rows: usize,
    cols: usize,
    mode: OversampleMode,
    shihyou: ShihyouBins,
) -> OversampleGrid {
    let factor = mode.factor().max(1);
    if factor == 1 || rows == 0 || cols == 0 {
        let maxamp = delays.iter().copied().filter(|v| v.is_finite()).fold(0.0_f64, f64::max);
        let color_index = delays
            .iter()
            .map(|&v| if v.is_finite() { color_bin(v, maxamp, shihyou) } else { 0 })
            .collect();
        return OversampleGrid {
            rows,
            cols,
            factor: 1,
            mode,
            delays_ms: delays.to_vec(),
            color_index,
        };
    }
    let out_rows = rows * factor;
    let out_cols = cols * factor;
    let mut out = vec![f64::NAN; out_rows * out_cols];
    for or in 0..out_rows {
        for oc in 0..out_cols {
            let yr = or as f64 / factor as f64;
            let xc = oc as f64 / factor as f64;
            let v = if mode.is_spline() {
                sample_bicubic(delays, rows, cols, yr, xc)
            } else {
                sample_bilinear(delays, rows, cols, yr, xc)
            };
            out[or * out_cols + oc] = v;
        }
    }
    let maxamp = out.iter().copied().filter(|v| v.is_finite()).fold(0.0_f64, f64::max);
    let color_index = out
        .iter()
        .map(|&v| if v.is_finite() { color_bin(v, maxamp, shihyou) } else { 0 })
        .collect();
    OversampleGrid { rows: out_rows, cols: out_cols, factor, mode, delays_ms: out, color_index }
}

fn sample_at(delays: &[f64], rows: usize, cols: usize, r: isize, c: isize) -> Option<f64> {
    if r < 0 || c < 0 || r as usize >= rows || c as usize >= cols {
        return None;
    }
    let v = delays[r as usize * cols + c as usize];
    if v.is_finite() {
        Some(v)
    } else {
        None
    }
}

fn sample_bilinear(delays: &[f64], rows: usize, cols: usize, y: f64, x: f64) -> f64 {
    let r0 = y.floor() as isize;
    let c0 = x.floor() as isize;
    let fr = y - r0 as f64;
    let fc = x - c0 as f64;
    let mut acc = 0.0;
    let mut wsum = 0.0;
    for (dr, wr) in [(0, 1.0 - fr), (1, fr)] {
        for (dc, wc) in [(0, 1.0 - fc), (1, fc)] {
            let w = wr * wc;
            if w <= 0.0 {
                continue;
            }
            if let Some(v) = sample_at(delays, rows, cols, r0 + dr, c0 + dc) {
                acc += v * w;
                wsum += w;
            }
        }
    }
    if wsum > 0.0 {
        acc / wsum
    } else {
        f64::NAN
    }
}

fn cubic_hermite(p0: f64, p1: f64, p2: f64, p3: f64, t: f64) -> f64 {
    let t2 = t * t;
    let t3 = t2 * t;
    0.5 * ((2.0 * p1)
        + (-p0 + p2) * t
        + (2.0 * p0 - 5.0 * p1 + 4.0 * p2 - p3) * t2
        + (-p0 + 3.0 * p1 - 3.0 * p2 + p3) * t3)
}

fn sample_bicubic(delays: &[f64], rows: usize, cols: usize, y: f64, x: f64) -> f64 {
    let r1 = y.floor() as isize;
    let c1 = x.floor() as isize;
    let fr = y - r1 as f64;
    let fc = x - c1 as f64;
    let mut col_samples = [0.0_f64; 4];
    for (i, dr) in [-1, 0, 1, 2].into_iter().enumerate() {
        let mut row_vals = [f64::NAN; 4];
        let mut any = false;
        for (j, dc) in [-1, 0, 1, 2].into_iter().enumerate() {
            if let Some(v) = sample_at(delays, rows, cols, r1 + dr, c1 + dc) {
                row_vals[j] = v;
                any = true;
            }
        }
        if !any {
            return sample_bilinear(delays, rows, cols, y, x);
        }
        // Fill NaNs from nearest valid in the row.
        let fallback = row_vals.iter().copied().find(|v| v.is_finite()).unwrap_or(0.0);
        for v in &mut row_vals {
            if !v.is_finite() {
                *v = fallback;
            }
        }
        col_samples[i] = cubic_hermite(row_vals[0], row_vals[1], row_vals[2], row_vals[3], fc);
    }
    cubic_hermite(col_samples[0], col_samples[1], col_samples[2], col_samples[3], fr)
}

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

    #[test]
    fn kurai10_high_bin() {
        assert_eq!(color_bin(9.1, 10.0, ShihyouBins::Ten), 12);
        assert_eq!(color_bin(0.5, 10.0, ShihyouBins::Ten), 3);
        assert_eq!(color_bin(-1.0, 10.0, ShihyouBins::Ten), 2);
    }

    #[test]
    fn linear2_doubles_dims() {
        let delays = vec![0.0, 10.0, 20.0, 30.0];
        let g = upsample_delay_grid(&delays, 2, 2, OversampleMode::Linear2, ShihyouBins::Ten);
        assert_eq!(g.rows, 4);
        assert_eq!(g.cols, 4);
        assert!(g.delays_ms.iter().all(|v| v.is_finite()));
    }

    #[test]
    fn parse_wire_strings() {
        assert_eq!(OversampleMode::parse("Linear 1/64"), Some(OversampleMode::Linear64));
        assert_eq!(ShihyouBins::parse("20"), Some(ShihyouBins::Twenty));
    }
}