use median::Filter;
pub fn medfilt(arr: Vec<f64>, window_size: usize, edge_mode: &str) -> Vec<f64> {
let radius = window_size / 2;
let mut filtered: Vec<f64> = vec![0.0; arr.len()];
let mut filter = Filter::new(window_size);
for i in 0..arr.len() {
if i == 0 {
for _ in 0..radius {
if edge_mode == "extension" {
filter.consume(arr[0]);
} else if edge_mode == "zeropadding" {
filter.consume(0.0);
}
}
for &v in arr.iter().take(radius + 1) {
filter.consume(v);
}
filtered[i] = filter.median();
} else if i >= arr.len().saturating_sub(radius) {
let pad = if edge_mode == "extension" {
arr[arr.len() - 1]
} else {
0.0
};
filtered[i] = filter.consume(pad);
} else {
filtered[i] = filter.consume(arr[i + radius]);
}
}
filtered
}
pub fn multi_3point_average(arr: &[f64], iteration: usize) -> Vec<f64> {
let one_third: f64 = 1.0 / 3.0;
let mut filtered: Vec<f64> = arr.to_vec();
let mut buffer: Vec<f64> = arr.to_vec();
for _ in 0..iteration {
for i in 1..filtered.len() - 1 {
filtered[i] = one_third * (buffer[i - 1] + buffer[i] + buffer[i + 1]);
}
buffer = filtered.clone();
}
filtered
}
pub fn boxcar(arr: &[f64], kernel_size: usize) -> Vec<f64> {
let kernel_weight: f64 = 1.0 / kernel_size as f64;
let half_kernel: usize = kernel_size / 2;
(0..arr.len())
.map(|i| {
let start = i.saturating_sub(half_kernel);
let end = usize::min(i + half_kernel + 1, arr.len());
arr[start..end].iter().sum::<f64>() * kernel_weight
})
.collect()
}
#[cfg(test)]
mod tests {
use super::*;
fn brute_zeropad_median(arr: &[f64], window: usize) -> Vec<f64> {
let n = arr.len();
let r = window / 2;
(0..n)
.map(|i| {
let mut w: Vec<f64> = (0..window)
.map(|k| {
let idx = i as isize + k as isize - r as isize;
if idx < 0 || idx as usize >= n {
0.0
} else {
arr[idx as usize]
}
})
.collect();
w.sort_by(|a, b| a.partial_cmp(b).unwrap());
w[window / 2]
})
.collect()
}
#[test]
fn medfilt_zeropadding_matches_windowed_median_including_the_tail() {
let arr: Vec<f64> = (1..=12).map(|v| v as f64).collect();
let window = 5usize;
let got = medfilt(arr.clone(), window, "zeropadding");
let want = brute_zeropad_median(&arr, window);
assert_eq!(
got, want,
"medfilt must equal the zero-padded windowed median at every index"
);
assert!(
got[arr.len() - window / 2..].iter().all(|&v| v > 0.0),
"right-edge samples must be filled with medians, not left at 0.0"
);
}
}