use crate::backend::Backend;
use crate::data::{Tomo, Volume};
use crate::error::{Error, Result};
use ndarray::{Array2, Array3, Axis};
pub fn circ_mask(vol: &mut Volume<f32>, ratio: f32, val: f32) -> Result<()> {
if !(0.0..=1.0).contains(&ratio) {
return Err(Error::InvalidParam(
"circ_mask ratio must be in [0,1]".into(),
));
}
let (nz, ny, nx) = vol.dims();
let cy = (ny as f32 - 1.0) / 2.0;
let cx = (nx as f32 - 1.0) / 2.0;
let radius = ratio * (ny.min(nx) as f32) / 2.0;
let r2 = radius * radius;
for z in 0..nz {
for y in 0..ny {
let dy = y as f32 - cy;
for x in 0..nx {
let dx = x as f32 - cx;
if dy * dy + dx * dx > r2 {
vol.array[[z, y, x]] = val;
}
}
}
}
Ok(())
}
pub fn remove_nan(data: &mut Tomo<f32>, val: f32) -> Result<()> {
data.array
.mapv_inplace(|v| if v.is_finite() { v } else { val });
Ok(())
}
pub fn remove_neg(data: &mut Tomo<f32>, val: f32) -> Result<()> {
data.array.mapv_inplace(|v| if v < 0.0 { val } else { v });
Ok(())
}
pub fn adjust_range(data: &mut Tomo<f32>, dmin: Option<f32>, dmax: Option<f32>) -> Result<()> {
let arr = &mut data.array;
if arr.is_empty() {
return Ok(());
}
let data_max = arr.iter().copied().fold(f32::NEG_INFINITY, f32::max);
let data_min = arr.iter().copied().fold(f32::INFINITY, f32::min);
let dmax = dmax.unwrap_or(data_max);
let dmin = dmin.unwrap_or(data_min);
if dmax < data_max {
arr.mapv_inplace(|v| if v > dmax { dmax } else { v });
}
let cur_min = arr.iter().copied().fold(f32::INFINITY, f32::min);
if dmin > cur_min {
arr.mapv_inplace(|v| if v < dmin { dmin } else { v });
}
Ok(())
}
pub fn median_filter_nonfinite(data: &mut Tomo<f32>, size: usize) -> Result<()> {
if size == 0 {
return Err(Error::InvalidParam(
"median_filter_nonfinite size must be > 0".into(),
));
}
let (n0, n1, n2) = data.array.dim();
let h = size / 2;
let mut window: Vec<f32> = Vec::new();
for i0 in 0..n0 {
let snap = data.array.index_axis(Axis(0), i0).to_owned();
for i1 in 0..n1 {
for i2 in 0..n2 {
if snap[[i1, i2]].is_finite() {
continue;
}
let x_lo = i1.saturating_sub(h);
let x_hi = (i1 + h + 1).min(n1);
let y_lo = i2.saturating_sub(h);
let y_hi = (i2 + h + 1).min(n2);
window.clear();
for x in x_lo..x_hi {
for y in y_lo..y_hi {
let v = snap[[x, y]];
if v.is_finite() {
window.push(v);
}
}
}
if window.is_empty() {
return Err(Error::InvalidParam(
"median_filter_nonfinite: kernel contains only non-finite \
values; increase size"
.into(),
));
}
data.array[[i0, i1, i2]] = median_f32(&mut window);
}
}
}
Ok(())
}
fn median_f32(vals: &mut [f32]) -> f32 {
vals.sort_by(|a, b| a.partial_cmp(b).expect("vals are finite"));
let n = vals.len();
if n % 2 == 1 {
vals[n / 2]
} else {
(vals[n / 2 - 1] + vals[n / 2]) / 2.0
}
}
pub fn median_filter3d(vol: &mut Volume<f32>, size: usize, backend: &dyn Backend) -> Result<()> {
backend
.rank_filter()
.ok_or(Error::MissingCapability {
backend: backend.name(),
capability: "RankFilter",
})?
.median3d(vol, size)
}
pub fn remove_outlier3d(
data: &mut Tomo<f32>,
diff: f32,
size: usize,
backend: &dyn Backend,
) -> Result<()> {
backend
.rank_filter()
.ok_or(Error::MissingCapability {
backend: backend.name(),
capability: "RankFilter",
})?
.remove_outlier3d(data, diff, size)
}
pub fn median_filter(data: &mut Tomo<f32>, size: usize, axis: usize) -> Result<()> {
if size == 0 {
return Err(Error::InvalidParam("median_filter size must be > 0".into()));
}
if axis > 2 {
return Err(Error::InvalidParam(
"median_filter axis must be 0, 1, or 2".into(),
));
}
data.array = median2d_reflect(&data.array, size, axis);
Ok(())
}
pub fn remove_outlier(data: &mut Tomo<f32>, diff: f32, size: usize, axis: usize) -> Result<()> {
if size == 0 {
return Err(Error::InvalidParam(
"remove_outlier size must be > 0".into(),
));
}
if axis > 2 {
return Err(Error::InvalidParam(
"remove_outlier axis must be 0, 1, or 2".into(),
));
}
let tmp = median2d_reflect(&data.array, size, axis);
ndarray::Zip::from(&mut data.array)
.and(&tmp)
.for_each(|a, &t| {
if *a - t >= diff {
*a = t;
}
});
Ok(())
}
pub fn remove_outlier1d(data: &mut Tomo<f32>, diff: f32, size: usize, axis: usize) -> Result<()> {
if size == 0 {
return Err(Error::InvalidParam(
"remove_outlier1d size must be > 0".into(),
));
}
if axis > 2 {
return Err(Error::InvalidParam(
"remove_outlier1d axis must be 0, 1, or 2".into(),
));
}
let dims = data.array.dim();
let shape = [dims.0, dims.1, dims.2];
let len = shape[axis] as isize;
if len == 0 {
return Ok(());
}
let orgn = (size / 2) as isize;
let rank = size / 2;
let (a1, a2) = match axis {
0 => (1usize, 2usize),
1 => (0usize, 2usize),
_ => (0usize, 1usize),
};
let mut tmp = ndarray::Array3::<f32>::zeros(dims);
let mut window: Vec<f32> = Vec::with_capacity(size);
for p1 in 0..shape[a1] {
for p2 in 0..shape[a2] {
for i in 0..shape[axis] {
window.clear();
for k in 0..size {
let src = mirror_index(i as isize + k as isize - orgn, len);
let mut idx = [0usize; 3];
idx[axis] = src;
idx[a1] = p1;
idx[a2] = p2;
window.push(data.array[[idx[0], idx[1], idx[2]]]);
}
window.sort_by(|a, b| a.partial_cmp(b).expect("input is finite"));
let mut oidx = [0usize; 3];
oidx[axis] = i;
oidx[a1] = p1;
oidx[a2] = p2;
tmp[[oidx[0], oidx[1], oidx[2]]] = window[rank];
}
}
}
ndarray::Zip::from(&mut data.array)
.and(&tmp)
.for_each(|a, &t| {
if *a - t >= diff {
*a = t;
}
});
Ok(())
}
pub fn gaussian_filter(data: &mut Tomo<f32>, sigma: f64, order: usize, axis: usize) -> Result<()> {
if axis > 2 {
return Err(Error::InvalidParam(
"gaussian_filter axis must be 0, 1, or 2".into(),
));
}
if sigma < 0.0 || sigma.is_nan() {
return Err(Error::InvalidParam(
"gaussian_filter sigma must be >= 0".into(),
));
}
if sigma <= 1e-15 {
return Ok(());
}
let lw = (4.0 * sigma + 0.5) as usize;
let weights = gaussian_kernel1d(sigma, order, lw);
let nslices = [data.array.dim().0, data.array.dim().1, data.array.dim().2][axis];
for s in 0..nslices {
let slice = data.array.index_axis(Axis(axis), s).to_owned();
let filtered = gaussian_filter2d(&slice, &weights);
data.array.index_axis_mut(Axis(axis), s).assign(&filtered);
}
Ok(())
}
pub fn sobel_filter(data: &mut Tomo<f32>, axis: usize) -> Result<()> {
if axis > 2 {
return Err(Error::InvalidParam(
"sobel_filter axis must be 0, 1, or 2".into(),
));
}
const DERIV: [f64; 3] = [-1.0, 0.0, 1.0];
const SMOOTH: [f64; 3] = [1.0, 2.0, 1.0];
let nslices = [data.array.dim().0, data.array.dim().1, data.array.dim().2][axis];
for s in 0..nslices {
let slice = data.array.index_axis(Axis(axis), s).to_owned();
let deriv = correlate1d_2d(&slice, &DERIV, 1);
let out = correlate1d_2d(&deriv, &SMOOTH, 0);
data.array.index_axis_mut(Axis(axis), s).assign(&out);
}
Ok(())
}
fn gaussian_filter2d(slice: &Array2<f32>, weights: &[f64]) -> Array2<f32> {
let mut cur = correlate1d_2d(slice, weights, 0);
cur = correlate1d_2d(&cur, weights, 1);
cur
}
enum Sym {
Even,
Odd,
None,
}
fn filter_symmetry(weights: &[f64], size1: usize) -> Sym {
let fsize = weights.len();
if fsize.is_multiple_of(2) {
return Sym::None;
}
let half = fsize / 2;
if (1..=half).all(|i| (weights[i + size1] - weights[size1 - i]).abs() <= f64::EPSILON) {
return Sym::Even;
}
if (1..=half).all(|i| (weights[size1 + i] + weights[size1 - i]).abs() <= f64::EPSILON) {
return Sym::Odd;
}
Sym::None
}
fn correlate1d_2d(img: &Array2<f32>, weights: &[f64], sax: usize) -> Array2<f32> {
let (nr, nc) = img.dim();
let fsize = weights.len();
let size1 = fsize / 2;
let size2 = fsize - size1 - 1;
let sym = filter_symmetry(weights, size1);
let (nr_i, nc_i) = (nr, nc);
let len = if sax == 0 { nr_i } else { nc_i } as isize;
let lines = if sax == 0 { nc_i } else { nr_i };
let mut out = Array2::<f32>::zeros((nr, nc));
for line in 0..lines {
let get = |p: isize| -> f64 {
let q = reflect_index(p, len);
(if sax == 0 {
img[[q, line]]
} else {
img[[line, q]]
}) as f64
};
for ll in 0..len {
let acc: f64 = match sym {
Sym::Even => {
let mut a = get(ll) * weights[size1];
let mut jj = -(size1 as isize);
while jj < 0 {
a +=
(get(ll + jj) + get(ll - jj)) * weights[(size1 as isize + jj) as usize];
jj += 1;
}
a
}
Sym::Odd => {
let mut a = get(ll) * weights[size1];
let mut jj = -(size1 as isize);
while jj < 0 {
a +=
(get(ll + jj) - get(ll - jj)) * weights[(size1 as isize + jj) as usize];
jj += 1;
}
a
}
Sym::None => {
let mut a = get(ll + size2 as isize) * weights[size1 + size2];
let mut jj = -(size1 as isize);
while jj < size2 as isize {
a += get(ll + jj) * weights[(size1 as isize + jj) as usize];
jj += 1;
}
a
}
};
let o = acc as f32;
if sax == 0 {
out[[ll as usize, line]] = o;
} else {
out[[line, ll as usize]] = o;
}
}
}
out
}
fn gaussian_kernel1d(sigma: f64, order: usize, lw: usize) -> Vec<f64> {
let sigma2 = sigma * sigma;
let n = 2 * lw + 1;
let f = -0.5 / sigma2;
let mut phi: Vec<f64> = (0..n)
.map(|i| {
let xi = i as i64 - lw as i64;
let xx = (xi * xi) as f64;
(f * xx).exp()
})
.collect();
let s = pairwise_sum_f64(&phi);
for v in &mut phi {
*v /= s;
}
let mut kernel = if order == 0 {
phi
} else {
let mut q = vec![0.0f64; order + 1];
q[0] = 1.0;
for _ in 0..order {
let mut nq = vec![0.0f64; order + 1];
for i in 0..=order {
if i < order {
nq[i] += ((i + 1) as f64) * q[i + 1];
}
if i >= 1 {
nq[i] += (-1.0 / sigma2) * q[i - 1];
}
}
q = nq;
}
(0..n)
.map(|i| {
let xi = (i as i64 - lw as i64) as f64;
let mut acc = 0.0f64;
let mut xpow = 1.0f64;
for &qj in &q {
acc += xpow * qj;
xpow *= xi;
}
acc * phi[i]
})
.collect()
};
kernel.reverse();
kernel
}
fn pairwise_sum_f64(a: &[f64]) -> f64 {
let n = a.len();
if n == 0 {
return 0.0;
}
if n < 8 {
let mut res = 0.0f64;
for &v in a {
res += v;
}
return res;
}
if n <= 128 {
let mut r = [a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7]];
let mut i = 8;
while i + 8 <= n {
for k in 0..8 {
r[k] += a[i + k];
}
i += 8;
}
let mut res = ((r[0] + r[1]) + (r[2] + r[3])) + ((r[4] + r[5]) + (r[6] + r[7]));
while i < n {
res += a[i];
i += 1;
}
return res;
}
let mut n2 = n / 2;
n2 -= n2 % 8;
pairwise_sum_f64(&a[..n2]) + pairwise_sum_f64(&a[n2..])
}
fn median2d_reflect(arr: &ndarray::Array3<f32>, size: usize, axis: usize) -> ndarray::Array3<f32> {
let dims = arr.dim();
let shape = [dims.0, dims.1, dims.2];
let orgn = (size / 2) as isize;
let rank = (size * size) / 2;
let (a1, a2) = match axis {
0 => (1usize, 2usize),
1 => (0usize, 2usize),
_ => (0usize, 1usize),
};
let nr = shape[a1] as isize;
let nc = shape[a2] as isize;
let mut out = ndarray::Array3::<f32>::zeros(dims);
let mut window: Vec<f32> = Vec::with_capacity(size * size);
for s in 0..shape[axis] {
for r in 0..shape[a1] {
for c in 0..shape[a2] {
window.clear();
for dr in 0..size {
let sr = reflect_index(r as isize + dr as isize - orgn, nr);
for dc in 0..size {
let sc = reflect_index(c as isize + dc as isize - orgn, nc);
let mut idx = [0usize; 3];
idx[axis] = s;
idx[a1] = sr;
idx[a2] = sc;
window.push(arr[[idx[0], idx[1], idx[2]]]);
}
}
window.sort_by(|a, b| a.partial_cmp(b).expect("input is finite"));
let mut oidx = [0usize; 3];
oidx[axis] = s;
oidx[a1] = r;
oidx[a2] = c;
out[[oidx[0], oidx[1], oidx[2]]] = window[rank];
}
}
}
out
}
fn reflect_index(i: isize, n: isize) -> usize {
if n <= 1 {
return 0;
}
let period = 2 * n;
let mut j = i % period;
if j < 0 {
j += period;
}
if j >= n {
j = period - 1 - j;
}
j as usize
}
fn mirror_index(i: isize, n: isize) -> usize {
if n <= 1 {
return 0;
}
let period = 2 * (n - 1);
let mut m = i % period;
if m < 0 {
m += period;
}
if m >= n {
m = period - m;
}
m as usize
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum InpaintingType {
Mean,
Median,
Random,
}
pub fn inpainter_morph(
data: &mut Tomo<f32>,
mask: &Array3<bool>,
size: usize,
iterations: usize,
inpainting: InpaintingType,
axis: Option<usize>,
) -> Result<()> {
if size < 1 {
return Err(Error::InvalidParam(
"inpainter_morph size must be >= 1".into(),
));
}
if data.array.dim() != mask.dim() {
return Err(Error::ShapeMismatch {
expected: format!("{:?}", data.array.dim()),
found: format!("{:?}", mask.dim()),
});
}
let (d0, d1, d2) = data.array.dim();
if d0 == 0 || d1 == 0 || d2 == 0 {
return Err(Error::InvalidParam(
"inpainter_morph: a dimension has length zero".into(),
));
}
match axis {
None => {
let out = {
let std = data.array.as_standard_layout();
let inp = std.as_slice().expect("standard layout is contiguous");
let msk: Vec<bool> = mask.iter().copied().collect();
inpainter_core(inp, &msk, (d2, d1, d0), iterations, size, inpainting)
};
data.array =
Array3::from_shape_vec((d0, d1, d2), out).expect("output length matches shape");
}
Some(a) => {
if a > 2 {
return Err(Error::InvalidParam(
"inpainter_morph axis must be 0, 1, or 2 (or None)".into(),
));
}
let n = data.array.len_of(Axis(a));
for m in 0..n {
let slice = data.array.index_axis(Axis(a), m).to_owned();
let mslice = mask.index_axis(Axis(a), m);
let (s0, s1) = slice.dim();
let out = {
let sstd = slice.as_standard_layout();
let sflat = sstd.as_slice().expect("standard layout is contiguous");
let mflat: Vec<bool> = mslice.iter().copied().collect();
inpainter_core(sflat, &mflat, (s1, s0, 1), iterations, size, inpainting)
};
let out2d =
Array2::from_shape_vec((s0, s1), out).expect("output length matches slice");
data.array.index_axis_mut(Axis(a), m).assign(&out2d);
}
}
}
Ok(())
}
#[derive(Clone, Copy)]
struct Geom {
dimx: usize,
dimy: usize,
dimz: usize,
hw: isize,
kh: isize,
window_fullength: usize,
is3d: bool,
}
impl Geom {
#[inline]
fn idx(&self, i: usize, j: usize, k: usize) -> usize {
self.dimx * self.dimy * k + j * self.dimx + i
}
#[inline]
fn in_bounds(&self, i1: isize, j1: isize, k1: isize) -> bool {
(0..self.dimx as isize).contains(&i1)
&& (0..self.dimy as isize).contains(&j1)
&& (0..self.dimz as isize).contains(&k1)
}
}
struct Lcg(u64);
impl Lcg {
fn new(seed: u64) -> Self {
Lcg(seed)
}
fn next_u32(&mut self) -> u32 {
self.0 = self
.0
.wrapping_mul(6_364_136_223_846_793_005)
.wrapping_add(1_442_695_040_888_963_407);
(self.0 >> 33) as u32
}
}
fn inpainter_core(
input: &[f32],
mask: &[bool],
dims: (usize, usize, usize),
iterations: usize,
hw: usize,
method: InpaintingType,
) -> Vec<f32> {
let (dimx, dimy, dimz) = dims;
let mut output = input.to_vec();
let mut updated = input.to_vec();
let mut m_upd = mask.to_vec();
let mut countmask = 0usize;
for ((o, u), &mk) in output.iter_mut().zip(updated.iter_mut()).zip(mask.iter()) {
if mk {
*o = 0.0;
*u = 0.0;
countmask += 1;
}
}
let is3d = dimz != 1;
let w_fullsize = 2 * hw + 1;
let window_fullength = if is3d {
w_fullsize * w_fullsize * w_fullsize
} else {
w_fullsize * w_fullsize
};
let g = Geom {
dimx,
dimy,
dimz,
hw: hw as isize,
kh: if is3d { hw as isize } else { 0 },
window_fullength,
is3d,
};
let mut gauss = vec![0.0f32; window_fullength];
{
let denom = (2 * window_fullength) as f32;
let mut c = 0usize;
for i_m in -g.hw..=g.hw {
for j_m in -g.hw..=g.hw {
for k_m in -g.kh..=g.kh {
let num =
(i_m as f32).powf(2.0) + (j_m as f32).powf(2.0) + (k_m as f32).powf(2.0);
gauss[c] = (-num / denom).exp();
c += 1;
}
}
}
}
if countmask == 0 {
return output;
}
let iterations_mask_complete = countmask;
let mut lcg = Lcg::new(0x9E37_79B9_7F4A_7C15);
for _l in 0..iterations_mask_complete {
for i in 0..dimx {
for j in 0..dimy {
for k in 0..dimz {
match method {
InpaintingType::Mean => {
eucl_cell(&g, (i, j, k), &output, &mut updated, &mut m_upd, &gauss);
}
InpaintingType::Median | InpaintingType::Random => {
median_rand_cell(
&g,
(i, j, k),
&output,
&mut updated,
&mut m_upd,
method,
&mut lcg,
);
}
}
}
}
}
output.copy_from_slice(&updated);
if !m_upd.iter().any(|&b| b) {
break;
}
}
if method == InpaintingType::Random {
smoothing_pass(&g, mask, &output, &mut updated);
}
output.copy_from_slice(&updated);
if iterations > 0 {
m_upd.copy_from_slice(mask);
for _l in 0..iterations {
for i in 0..dimx {
for j in 0..dimy {
for k in 0..dimz {
match method {
InpaintingType::Mean => {
eucl_cell(&g, (i, j, k), &output, &mut updated, &mut m_upd, &gauss);
}
InpaintingType::Median | InpaintingType::Random => {
median_rand_cell(
&g,
(i, j, k),
&output,
&mut updated,
&mut m_upd,
method,
&mut lcg,
);
}
}
}
}
}
output.copy_from_slice(&updated);
}
if method == InpaintingType::Random {
smoothing_pass(&g, mask, &output, &mut updated);
output.copy_from_slice(&updated);
}
}
output
}
fn eucl_cell(
g: &Geom,
pos: (usize, usize, usize),
output: &[f32],
updated: &mut [f32],
m_upd: &mut [bool],
gauss: &[f32],
) {
let (i, j, k) = pos;
let index = g.idx(i, j, k);
if !m_upd[index] {
return;
}
if !vicinity_nonzero(g, pos, output) {
return;
}
let mut sum_val = 0.0f32;
let mut sumweights = 0.0f32;
let mut counter_local = 0u32;
let mut cg = 0usize;
for i_m in -g.hw..=g.hw {
let i1 = i as isize + i_m;
for j_m in -g.hw..=g.hw {
let j1 = j as isize + j_m;
for k_m in -g.kh..=g.kh {
let k1 = k as isize + k_m;
if g.in_bounds(i1, j1, k1) {
let v = output[g.idx(i1 as usize, j1 as usize, k1 as usize)];
if v != 0.0 {
sum_val = v.mul_add(gauss[cg], sum_val);
sumweights += gauss[cg];
counter_local += 1;
}
}
cg += 1;
}
}
}
if counter_local > 0 {
updated[index] = sum_val / sumweights;
m_upd[index] = false;
}
}
fn median_rand_cell(
g: &Geom,
pos: (usize, usize, usize),
output: &[f32],
updated: &mut [f32],
m_upd: &mut [bool],
method: InpaintingType,
lcg: &mut Lcg,
) {
let (i, j, k) = pos;
let index = g.idx(i, j, k);
if !m_upd[index] {
return;
}
let kr: isize = if g.is3d { 1 } else { 0 };
let mut vicinity_sum = 0.0f32;
for i_m in -1..=1 {
let i1 = i as isize + i_m;
for j_m in -1..=1 {
let j1 = j as isize + j_m;
for k_m in -kr..=kr {
let k1 = k as isize + k_m;
if g.in_bounds(i1, j1, k1) {
let v = output[g.idx(i1 as usize, j1 as usize, k1 as usize)];
if v != 0.0 {
vicinity_sum += v;
}
}
}
}
}
if vicinity_sum == 0.0 {
return;
}
let mut values = vec![0.0f32; g.window_fullength];
let mut counter_local = 0usize;
for i_m in -g.hw..=g.hw {
let i1 = i as isize + i_m;
for j_m in -g.hw..=g.hw {
let j1 = j as isize + j_m;
for k_m in -g.kh..=g.kh {
let k1 = k as isize + k_m;
if g.in_bounds(i1, j1, k1) {
let v = output[g.idx(i1 as usize, j1 as usize, k1 as usize)];
if v != 0.0 {
values[counter_local] = v;
counter_local += 1;
}
}
}
}
}
match method {
InpaintingType::Median => {
let sort_len = if g.is3d {
g.window_fullength
} else {
counter_local.saturating_sub(1)
};
values[..sort_len].sort_by(|a, b| a.partial_cmp(b).expect("input is finite"));
updated[index] = values[counter_local / 2];
}
InpaintingType::Random => {
let r0 = lcg.next_u32() as usize % counter_local;
let r1 = lcg.next_u32() as usize % counter_local;
updated[index] = 0.5 * (values[r0] + values[r1]);
}
InpaintingType::Mean => unreachable!("mean uses eucl_cell"),
}
m_upd[index] = false;
}
fn smoothing_pass(g: &Geom, mask: &[bool], output: &[f32], updated: &mut [f32]) {
for i in 0..g.dimx {
for j in 0..g.dimy {
for k in 0..g.dimz {
mean_smoothing_cell(g, (i, j, k), mask, output, updated);
}
}
}
}
fn mean_smoothing_cell(
g: &Geom,
pos: (usize, usize, usize),
mask: &[bool],
output: &[f32],
updated: &mut [f32],
) {
let (i, j, k) = pos;
let index = g.idx(i, j, k);
if !mask[index] {
return;
}
let kr: isize = if g.is3d { 1 } else { 0 };
let mut sum_val = 0.0f32;
let mut counter_local = 0u32;
for i_m in -1..=1 {
let i1 = i as isize + i_m;
for j_m in -1..=1 {
let j1 = j as isize + j_m;
for k_m in -kr..=kr {
let k1 = k as isize + k_m;
if g.in_bounds(i1, j1, k1) {
let v = output[g.idx(i1 as usize, j1 as usize, k1 as usize)];
if v != 0.0 {
sum_val += v;
counter_local += 1;
}
}
}
}
}
if counter_local > 0 {
updated[index] = sum_val / counter_local as f32;
}
}
fn vicinity_nonzero(g: &Geom, pos: (usize, usize, usize), output: &[f32]) -> bool {
let (i, j, k) = pos;
let kr: isize = if g.is3d { 1 } else { 0 };
for i_m in -1..=1 {
let i1 = i as isize + i_m;
for j_m in -1..=1 {
let j1 = j as isize + j_m;
for k_m in -kr..=kr {
let k1 = k as isize + k_m;
if g.in_bounds(i1, j1, k1)
&& output[g.idx(i1 as usize, j1 as usize, k1 as usize)] != 0.0
{
return true;
}
}
}
}
false
}
#[cfg(test)]
mod tests {
use super::*;
use crate::data::Layout;
use ndarray::Array3;
#[test]
fn circ_mask_zeros_corners_keeps_center() {
let mut v = Volume::new(Array3::from_elem((1, 5, 5), 1.0f32));
circ_mask(&mut v, 1.0, 0.0).unwrap();
assert_eq!(v.array[[0, 0, 0]], 0.0); assert_eq!(v.array[[0, 2, 2]], 1.0); }
#[test]
fn remove_nan_and_neg() {
let arr =
Array3::from_shape_vec((1, 1, 4), vec![f32::NAN, -2.0, 3.0, f32::INFINITY]).unwrap();
let mut t = Tomo::new(arr, Layout::Projection);
remove_nan(&mut t, 0.0).unwrap();
remove_neg(&mut t, 0.0).unwrap();
assert_eq!(t.array.as_slice().unwrap(), &[0.0, 0.0, 3.0, 0.0]);
}
#[test]
fn median_filter_rejects_bad_params() {
let mut t = Tomo::new(Array3::<f32>::zeros((1, 4, 4)), Layout::Projection);
assert!(matches!(
median_filter(&mut t, 0, 0),
Err(Error::InvalidParam(_))
));
assert!(matches!(
median_filter(&mut t, 3, 3),
Err(Error::InvalidParam(_))
));
}
#[test]
fn median_filter_replaces_spike_with_2d_median() {
#[rustfmt::skip]
let slice = vec![
0.0f32, 1.0, 2.0,
3.0, 100.0, 4.0,
5.0, 6.0, 7.0,
];
let arr = Array3::from_shape_vec((1, 3, 3), slice).unwrap();
let mut t = Tomo::new(arr, Layout::Projection);
median_filter(&mut t, 3, 0).unwrap();
assert_eq!(t.array[[0, 1, 1]], 4.0);
}
#[test]
fn remove_outlier_rejects_bad_params() {
let mut t = Tomo::new(Array3::<f32>::zeros((1, 4, 4)), Layout::Projection);
assert!(matches!(
remove_outlier(&mut t, 0.5, 0, 0),
Err(Error::InvalidParam(_))
));
assert!(matches!(
remove_outlier(&mut t, 0.5, 3, 3),
Err(Error::InvalidParam(_))
));
}
#[test]
fn remove_outlier_replaces_only_above_threshold() {
#[rustfmt::skip]
let slice = vec![
0.0f32, 1.0, 2.0,
3.0, 100.0, 4.0,
5.0, 6.0, 7.0,
];
let mut t = Tomo::new(
Array3::from_shape_vec((1, 3, 3), slice.clone()).unwrap(),
Layout::Projection,
);
remove_outlier(&mut t, 1.0, 3, 0).unwrap();
assert_eq!(t.array[[0, 1, 1]], 4.0); assert_eq!(t.array[[0, 0, 0]], 0.0);
let mut t = Tomo::new(
Array3::from_shape_vec((1, 3, 3), slice).unwrap(),
Layout::Projection,
);
remove_outlier(&mut t, 1000.0, 3, 0).unwrap();
assert_eq!(t.array[[0, 1, 1]], 100.0);
}
#[test]
fn gaussian_filter_rejects_bad_params() {
let mut t = Tomo::new(Array3::<f32>::zeros((1, 4, 4)), Layout::Projection);
assert!(matches!(
gaussian_filter(&mut t, 1.0, 0, 3),
Err(Error::InvalidParam(_))
));
assert!(matches!(
gaussian_filter(&mut t, -1.0, 0, 0),
Err(Error::InvalidParam(_))
));
}
#[test]
fn gaussian_filter_zero_sigma_is_noop() {
let arr = Array3::from_shape_vec((1, 2, 3), vec![1.0f32, 2.0, 3.0, 4.0, 5.0, 6.0]).unwrap();
let mut t = Tomo::new(arr.clone(), Layout::Projection);
gaussian_filter(&mut t, 0.0, 0, 0).unwrap();
assert_eq!(t.array, arr);
}
#[test]
fn gaussian_filter_smooths_spike() {
let mut slice = vec![0.0f32; 49];
slice[3 * 7 + 3] = 1.0;
let arr = Array3::from_shape_vec((1, 7, 7), slice).unwrap();
let before: f64 = arr.iter().map(|&v| v as f64).sum();
let mut t = Tomo::new(arr, Layout::Projection);
gaussian_filter(&mut t, 1.0, 0, 0).unwrap();
let c = t.array[[0, 3, 3]];
assert!(c > 0.0 && c < 1.0, "centre {c} not in (0,1)");
assert!(t.array[[0, 3, 2]] > 0.0, "neighbour not raised");
assert!(t.array[[0, 2, 3]] > 0.0, "neighbour not raised");
let max = t.array.iter().copied().fold(f32::NEG_INFINITY, f32::max);
assert_eq!(c, max);
let after: f64 = t.array.iter().map(|&v| v as f64).sum();
assert!((after - before).abs() < 0.05, "mass {before} -> {after}");
}
#[test]
fn sobel_filter_rejects_bad_axis() {
let mut t = Tomo::new(Array3::<f32>::zeros((1, 4, 4)), Layout::Projection);
assert!(matches!(
sobel_filter(&mut t, 3),
Err(Error::InvalidParam(_))
));
}
#[test]
fn sobel_filter_responds_to_ramp_edge() {
#[rustfmt::skip]
let slice = vec![
0.0f32, 1.0, 2.0, 3.0, 4.0,
0.0, 1.0, 2.0, 3.0, 4.0,
0.0, 1.0, 2.0, 3.0, 4.0,
];
let arr = Array3::from_shape_vec((1, 3, 5), slice).unwrap();
let mut t = Tomo::new(arr, Layout::Projection);
sobel_filter(&mut t, 0).unwrap();
let want = [4.0f32, 8.0, 8.0, 8.0, 4.0];
for r in 0..3 {
for (c, &w) in want.iter().enumerate() {
assert_eq!(t.array[[0, r, c]], w, "mismatch at ({r},{c})");
}
}
}
#[test]
fn remove_outlier1d_rejects_bad_params() {
let mut t = Tomo::new(Array3::<f32>::zeros((1, 1, 4)), Layout::Projection);
assert!(matches!(
remove_outlier1d(&mut t, 0.5, 0, 2),
Err(Error::InvalidParam(_))
));
assert!(matches!(
remove_outlier1d(&mut t, 0.5, 3, 3),
Err(Error::InvalidParam(_))
));
}
#[test]
fn remove_outlier1d_replaces_spike_with_mirror_median() {
let line = vec![1.0f32, 2.0, 10.0, 2.0, 1.0];
let arr = Array3::from_shape_vec((1, 1, 5), line).unwrap();
let mut t = Tomo::new(arr, Layout::Projection);
remove_outlier1d(&mut t, 0.5, 3, 2).unwrap();
assert_eq!(t.array[[0, 0, 2]], 2.0);
assert_eq!(t.array[[0, 0, 1]], 2.0);
assert_eq!(t.array[[0, 0, 3]], 2.0);
assert_eq!(t.array[[0, 0, 0]], 1.0);
assert_eq!(t.array[[0, 0, 4]], 1.0);
}
#[test]
fn inpainter_morph_rejects_zero_size() {
let mut t = Tomo::new(Array3::<f32>::ones((1, 3, 3)), Layout::Projection);
let mask = Array3::from_elem((1, 3, 3), false);
assert!(matches!(
inpainter_morph(&mut t, &mask, 0, 2, InpaintingType::Mean, None),
Err(Error::InvalidParam(_))
));
}
#[test]
fn inpainter_morph_rejects_shape_mismatch() {
let mut t = Tomo::new(Array3::<f32>::ones((1, 3, 3)), Layout::Projection);
let mask = Array3::from_elem((1, 3, 4), false);
assert!(matches!(
inpainter_morph(&mut t, &mask, 2, 2, InpaintingType::Mean, None),
Err(Error::ShapeMismatch { .. })
));
}
#[test]
fn inpainter_morph_rejects_bad_axis() {
let mut t = Tomo::new(Array3::<f32>::ones((2, 3, 3)), Layout::Projection);
let mask = Array3::from_elem((2, 3, 3), false);
assert!(matches!(
inpainter_morph(&mut t, &mask, 2, 2, InpaintingType::Mean, Some(3)),
Err(Error::InvalidParam(_))
));
}
#[test]
fn inpainter_morph_mean_and_median_fill_uniform() {
let mut mask = Array3::from_elem((1, 3, 3), false);
mask[[0, 1, 1]] = true;
for ty in [InpaintingType::Mean, InpaintingType::Median] {
let mut t = Tomo::new(Array3::<f32>::ones((1, 3, 3)), Layout::Projection);
inpainter_morph(&mut t, &mask, 1, 0, ty, None).unwrap();
assert_eq!(
t.array[[0, 1, 1]],
1.0,
"{ty:?} should fill centre with 1.0"
);
assert_eq!(t.array[[0, 0, 0]], 1.0);
}
}
#[test]
fn inpainter_morph_random_fills_masked_region() {
let mut mask = Array3::from_elem((1, 4, 4), false);
for r in 1..3 {
for c in 1..3 {
mask[[0, r, c]] = true;
}
}
let mut t = Tomo::new(Array3::<f32>::ones((1, 4, 4)), Layout::Projection);
inpainter_morph(&mut t, &mask, 2, 2, InpaintingType::Random, None).unwrap();
for r in 1..3 {
for c in 1..3 {
assert_eq!(t.array[[0, r, c]], 1.0, "masked ({r},{c}) not filled");
}
}
}
#[test]
fn inpainter_morph_axis_inpaints_each_slice() {
let mut arr = Array3::<f32>::ones((2, 3, 3));
arr.index_axis_mut(Axis(0), 1).fill(2.0);
let mut t = Tomo::new(arr, Layout::Projection);
let mut mask = Array3::from_elem((2, 3, 3), false);
mask[[0, 1, 1]] = true;
mask[[1, 1, 1]] = true;
inpainter_morph(&mut t, &mask, 1, 0, InpaintingType::Mean, Some(0)).unwrap();
assert_eq!(t.array[[0, 1, 1]], 1.0);
assert_eq!(t.array[[1, 1, 1]], 2.0);
}
}