use serde::{Deserialize, Serialize};
#[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)
}
}
#[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
}
}
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
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct OversampleGrid {
pub rows: usize,
pub cols: usize,
pub factor: usize,
pub mode: OversampleMode,
pub delays_ms: Vec<f64>,
pub color_index: Vec<u16>,
}
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);
}
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));
}
}