use crate::data::{Layout, Tomo};
use crate::error::Result;
use crate::params::StripeMethod;
use ndarray::{Array2, Array3, ArrayViewMut2, Axis};
use rayon::prelude::*;
use crate::prep::{fft, wavelet};
pub fn remove_stripe(data: &mut Tomo<f32>, method: StripeMethod) -> Result<()> {
match method {
StripeMethod::None => Ok(()),
StripeMethod::Fw { sigma, level } => remove_stripe_fw(data, sigma, level),
StripeMethod::Ti { nblock, beta } => remove_stripe_ti(data, beta, nblock),
StripeMethod::Sf { size } => remove_stripe_sf(data, size),
StripeMethod::VoAll {
snr,
la_size,
sm_size,
} => remove_all_stripe(data, snr, la_size, sm_size),
StripeMethod::VoSort { size, dim } => remove_stripe_based_sorting(data, size, dim),
StripeMethod::VoFilter { sigma, size, dim } => {
remove_stripe_based_filtering(data, sigma, size, dim)
}
StripeMethod::VoLarge {
snr,
size,
drop_ratio,
norm,
} => remove_large_stripe(data, snr, size, drop_ratio, norm),
StripeMethod::VoDead { snr, size, norm } => remove_dead_stripe(data, snr, size, norm),
StripeMethod::VoFit { order, sigma } => remove_stripe_based_fitting(data, order, sigma),
}
}
fn par_over_rows<F>(arr: &mut Array3<f32>, f: F)
where
F: Fn(ArrayViewMut2<f32>) + Sync + Send,
{
let lanes: Vec<ArrayViewMut2<f32>> = arr.axis_iter_mut(Axis(1)).collect();
lanes.into_par_iter().for_each(f);
}
fn remove_stripe_sf(data: &mut Tomo<f32>, size: usize) -> Result<()> {
let target = data.layout;
let mut proj = data.to_layout(Layout::Projection);
let (dx, dy, dz) = proj.array.dim();
if dx == 0 || dy == 0 || dz == 0 || size == 0 {
return Ok(());
}
let half = (size / 2) as isize; let last = dz as isize - 1;
let dxf = dx as f32;
let sizef = size as f32;
par_over_rows(&mut proj.array, |mut lane| {
let mut average_row = vec![0.0f32; dz];
let mut smooth_row = vec![0.0f32; dz];
for j in 0..dz {
let mut acc = 0.0f32;
for p in 0..dx {
acc += lane[[p, j]] / dxf;
}
average_row[j] = acc;
}
for (i, sv) in smooth_row.iter_mut().enumerate() {
let mut acc = 0.0f32;
for jj in 0..size {
let mut k = i as isize + jj as isize - half;
if k < 0 {
k = 0;
}
if k > last {
k = last;
}
acc += average_row[k as usize];
}
*sv = acc / sizef;
}
for p in 0..dx {
for j in 0..dz {
lane[[p, j]] -= average_row[j] - smooth_row[j];
}
}
});
*data = proj.to_layout(target);
Ok(())
}
fn round_to_f32(a: &Array2<f64>) -> Array2<f64> {
a.mapv(|v| v as f32 as f64)
}
fn damp_vector(my: usize, sigma: f32) -> Vec<f64> {
let two_sig2 = 2.0f32 * sigma * sigma;
let damp: Vec<f32> = (0..my)
.map(|k| {
let y_hat = ((-(my as i64) + 2 * k as i64) as f32 + 1.0) / 2.0;
1.0f32 - (-(y_hat * y_hat) / two_sig2).exp()
})
.collect();
let half = my / 2;
(0..my).map(|i| damp[(i + half) % my] as f64).collect()
}
fn damp_vertical(cv: &Array2<f64>, sigma: f32) -> Array2<f64> {
let (my, mx) = cv.dim();
let d = damp_vector(my, sigma);
let mut out = Array2::<f64>::zeros((my, mx));
let mut col = vec![0.0f64; my];
for c in 0..mx {
for (r, v) in col.iter_mut().enumerate() {
*v = cv[[r, c]];
}
let damped = fft::filter_real_column(&col, &d);
for r in 0..my {
out[[r, c]] = damped[r];
}
}
out
}
fn crop(a: &Array2<f64>, rows: usize, cols: usize) -> Array2<f64> {
Array2::from_shape_fn((rows, cols), |(r, c)| a[[r, c]])
}
fn fw_slice(sino: &Array2<f64>, sigma: f32, level: usize, nx: usize, xshift: usize) -> Array2<f64> {
let (nproj, ncol) = sino.dim();
let mut approx = Array2::<f64>::zeros((nx, ncol));
for p in 0..nproj {
for c in 0..ncol {
approx[[xshift + p, c]] = sino[[p, c]];
}
}
let mut chs = Vec::with_capacity(level);
let mut cvs = Vec::with_capacity(level);
let mut cds = Vec::with_capacity(level);
for _ in 0..level {
let (ca, ch, cv, cd) = wavelet::dwt2(&approx);
approx = round_to_f32(&ca);
chs.push(round_to_f32(&ch));
cvs.push(round_to_f32(&cv));
cds.push(round_to_f32(&cd));
}
for cv in cvs.iter_mut() {
*cv = damp_vertical(cv, sigma);
}
let mut sli = approx;
for n in (0..level).rev() {
let (hr, hc) = chs[n].dim();
let cropped = crop(&sli, hr, hc);
sli = wavelet::idwt2(&cropped, &chs[n], &cvs[n], &cds[n]);
}
Array2::from_shape_fn((nproj, ncol), |(p, c)| sli[[xshift + p, c]])
}
fn remove_stripe_fw(data: &mut Tomo<f32>, sigma: f32, level: Option<usize>) -> Result<()> {
let target = data.layout;
let mut proj = data.to_layout(Layout::Projection);
let (nproj, nrows, ncol) = proj.array.dim();
if nproj == 0 || nrows == 0 || ncol == 0 {
return Ok(());
}
let level = level.unwrap_or_else(|| {
let size = nproj.max(nrows).max(ncol);
(size as f64).log2().ceil() as usize
});
if level == 0 {
return Ok(());
}
let nx = nproj + nproj / 8; let xshift = (nx - nproj) / 2;
par_over_rows(&mut proj.array, |mut lane| {
let sino = lane.mapv(|v| v as f64);
let out = fw_slice(&sino, sigma, level, nx, xshift);
lane.assign(&out.mapv(|v| v as f32));
});
*data = proj.to_layout(target);
Ok(())
}
fn ti_kernel(m: usize, n: usize) -> Vec<f64> {
let table: [&[&[f64]]; 3] = [
&[
&[1.0, -1.0],
&[-3.0 / 2.0, 2.0, -1.0 / 2.0],
&[-11.0 / 6.0, 3.0, -3.0 / 2.0, 1.0 / 3.0],
],
&[&[-1.0, 2.0, -1.0], &[2.0, -5.0, 4.0, -1.0]],
&[&[-1.0, 3.0, -3.0, 1.0]],
];
table[m - 1][n - 1].to_vec()
}
fn convolve_full(a: &[f64], b: &[f64]) -> Vec<f64> {
if a.is_empty() || b.is_empty() {
return Vec::new();
}
let mut out = vec![0.0f64; a.len() + b.len() - 1];
for (i, &av) in a.iter().enumerate() {
for (j, &bv) in b.iter().enumerate() {
out[i + j] += av * bv;
}
}
out
}
fn ti_matxvec(h: &[f64], x: &[f64]) -> Vec<f64> {
let hf: Vec<f64> = h.iter().rev().copied().collect();
let s = convolve_full(x, &hf);
let u = &s[h.len() - 1..x.len()];
convolve_full(u, h)
}
fn dot(a: &[f64], b: &[f64]) -> f64 {
a.iter().zip(b).map(|(x, y)| x * y).sum()
}
fn ti_cgm(h: &[f64], alpha: f64, f: &[f64]) -> Vec<f64> {
let n = f.len();
let x0 = vec![0.0f64; n];
let mut r = f.to_vec();
let mut w: Vec<f64> = r.iter().map(|v| -v).collect();
let apply = |w: &[f64]| -> Vec<f64> {
let mv = ti_matxvec(h, w);
mv.iter()
.zip(w)
.map(|(m, wv)| m + alpha * wv)
.collect::<Vec<f64>>()
};
let mut z = apply(&w);
let mut a = dot(&r, &w) / dot(&w, &z);
let mut x: Vec<f64> = x0.iter().zip(&w).map(|(x0v, wv)| x0v + a * wv).collect();
for _ in 0..1_000_000 {
for (rv, zv) in r.iter_mut().zip(&z) {
*rv -= a * zv;
}
let norm = dot(&r, &r).sqrt();
if norm < 0.0000001 {
break;
}
let bb = dot(&r, &z) / dot(&w, &z);
for (wv, rv) in w.iter_mut().zip(&r) {
*wv = -rv + bb * *wv;
}
z = apply(&w);
a = dot(&r, &w) / dot(&w, &z);
for (xv, wv) in x.iter_mut().zip(&w) {
*xv += a * wv;
}
}
x
}
fn ti_parameter(mysino: &[Vec<f64>], r: usize, n: usize) -> f64 {
let mut min = f64::INFINITY;
let mut max = f64::NEG_INFINITY;
for j in 0..n {
let mut s = 0.0f64;
for row in mysino.iter().take(r) {
s += row[j];
}
if s < min {
min = s;
}
if s > max {
max = s;
}
}
1.0 / (2.0 * (max - min))
}
fn ti_ring(sino: &Array2<f32>, m: usize, n: usize) -> Array2<f32> {
let (nproj, ncol) = sino.dim();
let r = ncol; let nn = nproj; let mut mysino = vec![vec![0.0f64; nn]; r];
for (col, row) in mysino.iter_mut().enumerate() {
for (angle, cell) in row.iter_mut().enumerate() {
let v = sino[[angle, col]] as f64;
*cell = if v.is_nan() { 0.0 } else { v };
}
}
let alpha = ti_parameter(&mysino, r, nn);
let pp: Vec<f64> = mysino
.iter()
.map(|row| row.iter().sum::<f64>() / nn as f64)
.collect();
let h = ti_kernel(m, n);
let f: Vec<f64> = ti_matxvec(&h, &pp).iter().map(|v| -v).collect();
let q = ti_cgm(&h, alpha, &f);
let mut out = Array2::<f32>::zeros((nproj, ncol));
for col in 0..ncol {
for angle in 0..nproj {
out[[angle, col]] = (mysino[col][angle] + q[col]) as f32;
}
}
out
}
fn ti_ringb(sino: &Array2<f32>, m: usize, n: usize, step: usize) -> Array2<f32> {
let (nproj, ncol) = sino.dim();
let r = ncol; let nn = nproj; let mut mysino = vec![vec![0.0f64; nn]; r];
for (col, row) in mysino.iter_mut().enumerate() {
for (angle, cell) in row.iter_mut().enumerate() {
*cell = sino[[angle, col]] as f64;
}
}
let h = ti_kernel(m, n);
let nblock = nn.checked_div(step).unwrap_or(0);
let mut newm = vec![vec![1.0f64; nn]; r];
for k in 0..nblock {
let j0 = k * step;
let j1 = j0 + step;
let (mut min, mut max) = (f64::INFINITY, f64::NEG_INFINITY);
for j in j0..j1 {
let mut s = 0.0f64;
for row in mysino.iter().take(r) {
s += row[j];
}
if s < min {
min = s;
}
if s > max {
max = s;
}
}
let alpha = 1.0 / (2.0 * (max - min));
let pp: Vec<f64> = mysino
.iter()
.map(|row| row[j0..j1].iter().sum::<f64>() / step as f64)
.collect();
let f: Vec<f64> = ti_matxvec(&h, &pp).iter().map(|v| -v).collect();
let q = ti_cgm(&h, alpha, &f);
for (col, row) in mysino.iter().enumerate() {
for j in j0..j1 {
newm[col][j] = row[j] + q[col];
}
}
}
let mut out = Array2::<f32>::zeros((nproj, ncol));
for col in 0..ncol {
for angle in 0..nproj {
out[[angle, col]] = newm[col][angle] as f32;
}
}
out
}
fn remove_stripe_ti(data: &mut Tomo<f32>, beta: f32, nblock: usize) -> Result<()> {
let target = data.layout;
let mut proj = data.to_layout(Layout::Projection);
let (nproj, nrows, ncol) = proj.array.dim();
if nproj == 0 || nrows == 0 || ncol == 0 {
return Ok(());
}
let step = nproj.checked_div(nblock).unwrap_or(0);
par_over_rows(&mut proj.array, |mut lane| {
let sino = lane.to_owned();
let (d1, d2) = if nblock == 0 {
(ti_ring(&sino, 1, 1), ti_ring(&sino, 2, 1))
} else {
(ti_ringb(&sino, 1, 1, step), ti_ringb(&sino, 2, 1, step))
};
let mut p = Array2::<f32>::zeros((nproj, ncol));
let mut pmin = f32::INFINITY;
for r in 0..nproj {
for c in 0..ncol {
let v = d1[[r, c]] * d2[[r, c]];
p[[r, c]] = v;
if v < pmin {
pmin = v;
}
}
}
let shift = beta * pmin.abs();
for c in 0..ncol {
for r in 0..nproj {
lane[[r, c]] = (p[[r, c]] + shift).sqrt();
}
}
});
*data = proj.to_layout(target);
Ok(())
}
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 uniform_filter1d_axis0(sino: &Array2<f32>, size: usize) -> Array2<f32> {
let (nrow, ncol) = sino.dim();
let half = (size / 2) as isize;
let n = nrow as isize;
let inv = 1.0f64 / size as f64;
let mut out = Array2::<f32>::zeros((nrow, ncol));
for c in 0..ncol {
for i in 0..nrow {
let mut sum = 0.0f64;
for k in 0..size {
let r = reflect_index(i as isize - half + k as isize, n);
sum += sino[[r, c]] as f64;
}
out[[i, c]] = (sum * inv) as f32;
}
}
out
}
fn median_filter_1d(list: &[f32], size: usize) -> Vec<f32> {
let n = list.len();
let half = (size / 2) as isize;
let mid = size / 2;
let ni = n as isize;
let mut out = vec![0.0f32; n];
let mut win = vec![0.0f32; size];
for i in 0..n {
for (k, w) in win.iter_mut().enumerate() {
*w = list[reflect_index(i as isize - half + k as isize, ni)];
}
win.sort_by(|a, b| a.total_cmp(b));
out[i] = win[mid];
}
out
}
fn median_filter_axis0(arr: &Array2<f32>, size: usize) -> Array2<f32> {
let (nrow, ncol) = arr.dim();
let mut out = Array2::<f32>::zeros((nrow, ncol));
let mut col = vec![0.0f32; nrow];
for c in 0..ncol {
for (r, v) in col.iter_mut().enumerate() {
*v = arr[[r, c]];
}
let med = median_filter_1d(&col, size);
for r in 0..nrow {
out[[r, c]] = med[r];
}
}
out
}
fn median_filter_axis1(arr: &Array2<f32>, size: usize) -> Array2<f32> {
let (nrow, ncol) = arr.dim();
let mut out = Array2::<f32>::zeros((nrow, ncol));
let mut row = vec![0.0f32; ncol];
for r in 0..nrow {
for (c, v) in row.iter_mut().enumerate() {
*v = arr[[r, c]];
}
let med = median_filter_1d(&row, size);
for c in 0..ncol {
out[[r, c]] = med[c];
}
}
out
}
fn median_filter_2d(arr: &Array2<f32>, size: usize) -> Array2<f32> {
let (nrow, ncol) = arr.dim();
let half = (size / 2) as isize;
let (nr, nc) = (nrow as isize, ncol as isize);
let mid = (size * size) / 2;
let mut out = Array2::<f32>::zeros((nrow, ncol));
let mut win = vec![0.0f32; size * size];
for i in 0..nrow {
for j in 0..ncol {
let mut t = 0;
for di in 0..size {
let ri = reflect_index(i as isize - half + di as isize, nr);
for dj in 0..size {
let cj = reflect_index(j as isize - half + dj as isize, nc);
win[t] = arr[[ri, cj]];
t += 1;
}
}
win.sort_by(|a, b| a.total_cmp(b));
out[[i, j]] = win[mid];
}
}
out
}
fn binary_dilation_1d(mask: &[f32]) -> Vec<f32> {
let n = mask.len();
let mut out = vec![0.0f32; n];
for i in 0..n {
let l = i > 0 && mask[i - 1] > 0.0;
let m = mask[i] > 0.0;
let r = i + 1 < n && mask[i + 1] > 0.0;
if l || m || r {
out[i] = 1.0;
}
}
out
}
fn polyfit1(x: &[f64], y: &[f64]) -> (f64, f64) {
let n = x.len() as f64;
let sx: f64 = x.iter().sum();
let sy: f64 = y.iter().sum();
let sxx: f64 = x.iter().map(|v| v * v).sum();
let sxy: f64 = x.iter().zip(y).map(|(a, b)| a * b).sum();
let denom = n * sxx - sx * sx;
let slope = if denom != 0.0 {
(n * sxy - sx * sy) / denom
} else {
0.0
};
let intercept = (sy - slope * sx) / n;
(slope, intercept)
}
fn detect_stripe(listdata: &[f32], snr: f32) -> Vec<f32> {
let numdata = listdata.len();
let mut listmask = vec![0.0f32; numdata];
if numdata == 0 {
return listmask;
}
let mut listsorted: Vec<f32> = listdata.to_vec();
listsorted.sort_by(|a, b| b.total_cmp(a));
let ndrop = (0.25 * numdata as f64) as i16 as usize; if numdata < 2 * ndrop + 2 {
return listmask; }
let lo = ndrop;
let hi = numdata - ndrop - 1; let xs: Vec<f64> = (lo..hi).map(|v| v as f64).collect();
let ys: Vec<f64> = (lo..hi).map(|v| listsorted[v] as f64).collect();
let (slope, intercept) = polyfit1(&xs, &ys);
let numt1 = intercept + slope * (numdata - 1) as f64;
let mut noiselevel = (numt1 - intercept).abs();
if noiselevel < 1e-6 {
noiselevel = 1e-6;
}
let snr = snr as f64;
let val1 = (listsorted[0] as f64 - intercept).abs() / noiselevel;
let val2 = (listsorted[numdata - 1] as f64 - numt1).abs() / noiselevel;
if val1 >= snr {
let upper = intercept + noiselevel * snr * 0.5;
for (j, &v) in listdata.iter().enumerate() {
if v as f64 > upper {
listmask[j] = 1.0;
}
}
}
if val2 >= snr {
let lower = numt1 - noiselevel * snr * 0.5;
for (j, &v) in listdata.iter().enumerate() {
if v as f64 <= lower {
listmask[j] = 1.0;
}
}
}
listmask
}
fn argsort_columns(sino: &Array2<f32>) -> (Array2<f32>, Vec<Vec<usize>>) {
let (nrow, ncol) = sino.dim();
let mut sorted = Array2::<f32>::zeros((nrow, ncol));
let mut perm = vec![vec![0usize; nrow]; ncol];
for c in 0..ncol {
let mut idx: Vec<usize> = (0..nrow).collect();
idx.sort_by(|&a, &b| sino[[a, c]].total_cmp(&sino[[b, c]]));
for (rank, &row) in idx.iter().enumerate() {
sorted[[rank, c]] = sino[[row, c]];
perm[c][rank] = row;
}
}
(sorted, perm)
}
fn rs_large(sino: &Array2<f32>, snr: f32, size: usize, drop_ratio: f32, norm: bool) -> Array2<f32> {
let (nrow, ncol) = sino.dim();
let dr = drop_ratio.clamp(0.0, 0.8) as f64;
let ndrop = (0.5 * dr * nrow as f64) as usize;
let (sinosort, _) = argsort_columns(sino);
let sinosmooth = median_filter_axis1(&sinosort, size);
let cnt = (nrow.saturating_sub(2 * ndrop)).max(1) as f64;
let mut listfact = vec![1.0f64; ncol];
for (c, lf) in listfact.iter_mut().enumerate() {
let (mut s1, mut s2) = (0.0f64, 0.0f64);
for r in ndrop..(nrow - ndrop) {
s1 += sinosort[[r, c]] as f64;
s2 += sinosmooth[[r, c]] as f64;
}
let (m1, m2) = (s1 / cnt, s2 / cnt);
*lf = if m2 != 0.0 { m1 / m2 } else { 1.0 };
}
let listfact_f32: Vec<f32> = listfact.iter().map(|&v| v as f32).collect();
let listmask = binary_dilation_1d(&detect_stripe(&listfact_f32, snr));
let mut work = sino.clone();
if norm {
for c in 0..ncol {
let f = listfact[c];
for r in 0..nrow {
work[[r, c]] = (work[[r, c]] as f64 / f) as f32;
}
}
}
let (_, perm) = argsort_columns(&work);
let mut out = work;
for c in 0..ncol {
if listmask[c] > 0.0 {
for rank in 0..nrow {
out[[perm[c][rank], c]] = sinosmooth[[rank, c]];
}
}
}
out
}
fn bracket(goodx: &[usize], xmiss: usize) -> (usize, f64) {
let mut i0 = 0;
for k in 0..goodx.len().saturating_sub(1) {
if goodx[k] <= xmiss && xmiss <= goodx[k + 1] {
i0 = k;
break;
}
}
let (g0, g1) = (goodx[i0] as f64, goodx[i0 + 1] as f64);
let t = if g1 != g0 {
(xmiss as f64 - g0) / (g1 - g0)
} else {
0.0
};
(i0, t)
}
fn rs_dead(sino: &Array2<f32>, snr: f32, size: usize, norm: bool) -> Array2<f32> {
let (nrow, ncol) = sino.dim();
let sinosmooth = uniform_filter1d_axis0(sino, 10);
let mut listdiff = vec![0.0f32; ncol];
for (c, ld) in listdiff.iter_mut().enumerate() {
let mut s = 0.0f64;
for r in 0..nrow {
s += (sino[[r, c]] - sinosmooth[[r, c]]).abs() as f64;
}
*ld = s as f32;
}
let listdiffbck = median_filter_1d(&listdiff, size);
let listfact: Vec<f32> = (0..ncol)
.map(|c| {
if listdiffbck[c] != 0.0 {
listdiff[c] / listdiffbck[c]
} else {
1.0
}
})
.collect();
let mut listmask = binary_dilation_1d(&detect_stripe(&listfact, snr));
listmask[..ncol.min(2)].fill(0.0);
listmask[ncol.saturating_sub(2)..].fill(0.0);
let goodx: Vec<usize> = (0..ncol).filter(|&c| listmask[c] < 1.0).collect();
let badx: Vec<usize> = (0..ncol).filter(|&c| listmask[c] > 0.0).collect();
let mut work = sino.clone();
if !badx.is_empty() && goodx.len() >= 2 {
for &xmiss in &badx {
let (i0, t) = bracket(&goodx, xmiss);
let (c0, c1) = (goodx[i0], goodx[i0 + 1]);
for r in 0..nrow {
let v0 = sino[[r, c0]] as f64;
let v1 = sino[[r, c1]] as f64;
work[[r, xmiss]] = ((1.0 - t) * v0 + t * v1) as f32;
}
}
}
if norm {
rs_large(&work, snr, size, 0.1, true)
} else {
work
}
}
fn rs_sort_with(sino: &Array2<f32>, smooth: impl Fn(&Array2<f32>) -> Array2<f32>) -> Array2<f32> {
let (nrow, ncol) = sino.dim();
let mut sortedv = Array2::<f32>::zeros((ncol, nrow));
let mut perm = vec![vec![0usize; nrow]; ncol];
for c in 0..ncol {
let mut idx: Vec<usize> = (0..nrow).collect();
idx.sort_by(|&a, &b| sino[[a, c]].total_cmp(&sino[[b, c]]));
for (rank, &row) in idx.iter().enumerate() {
sortedv[[c, rank]] = sino[[row, c]];
perm[c][rank] = row;
}
}
let smoothed = smooth(&sortedv);
let mut out = Array2::<f32>::zeros((nrow, ncol));
for c in 0..ncol {
for rank in 0..nrow {
out[[perm[c][rank], c]] = smoothed[[c, rank]];
}
}
out
}
fn rs_sort(sino: &Array2<f32>, size: usize) -> Array2<f32> {
rs_sort_with(sino, |s| median_filter_axis0(s, size))
}
fn remove_all_stripe(data: &mut Tomo<f32>, snr: f32, la_size: usize, sm_size: usize) -> Result<()> {
let target = data.layout;
let mut proj = data.to_layout(Layout::Projection);
let (nproj, nrows, ncol) = proj.array.dim();
if nproj < 2 || nrows == 0 || ncol < 4 || la_size == 0 || sm_size == 0 {
return Ok(());
}
par_over_rows(&mut proj.array, |mut lane| {
let sino = lane.to_owned();
let sino = rs_dead(&sino, snr, la_size, true);
let sino = rs_sort(&sino, sm_size);
lane.assign(&sino);
});
*data = proj.to_layout(target);
Ok(())
}
fn remove_large_stripe(
data: &mut Tomo<f32>,
snr: f32,
size: usize,
drop_ratio: f32,
norm: bool,
) -> Result<()> {
let target = data.layout;
let mut proj = data.to_layout(Layout::Projection);
let (nproj, nrows, ncol) = proj.array.dim();
if nproj < 2 || nrows == 0 || ncol < 4 || size == 0 {
return Ok(());
}
par_over_rows(&mut proj.array, |mut lane| {
let sino = lane.to_owned();
let sino = rs_large(&sino, snr, size, drop_ratio, norm);
lane.assign(&sino);
});
*data = proj.to_layout(target);
Ok(())
}
fn remove_dead_stripe(data: &mut Tomo<f32>, snr: f32, size: usize, norm: bool) -> Result<()> {
let target = data.layout;
let mut proj = data.to_layout(Layout::Projection);
let (nproj, nrows, ncol) = proj.array.dim();
if nproj < 2 || nrows == 0 || ncol < 4 || size == 0 {
return Ok(());
}
par_over_rows(&mut proj.array, |mut lane| {
let sino = lane.to_owned();
let sino = rs_dead(&sino, snr, size, norm);
lane.assign(&sino);
});
*data = proj.to_layout(target);
Ok(())
}
fn remove_stripe_based_sorting(data: &mut Tomo<f32>, size: Option<usize>, dim: u8) -> Result<()> {
let target = data.layout;
let mut proj = data.to_layout(Layout::Projection);
let (nproj, nrows, ncol) = proj.array.dim();
if nproj < 2 || nrows == 0 || ncol == 0 {
return Ok(());
}
let size = size.unwrap_or_else(|| {
if ncol > 2000 {
21
} else {
5.max((0.01 * ncol as f64) as usize)
}
});
if size == 0 {
return Ok(());
}
par_over_rows(&mut proj.array, |mut lane| {
let sino = lane.to_owned();
let corrected = if dim == 1 {
rs_sort(&sino, size)
} else {
rs_sort_with(&sino, |s| median_filter_2d(s, size))
};
lane.assign(&corrected);
});
*data = proj.to_layout(target);
Ok(())
}
fn reflect_whole_sample(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
}
fn gaussian_window(len: usize, sigma: f64) -> Vec<f64> {
let center = (len as f64 - 1.0) / 2.0;
let sig2 = 2.0 * sigma * sigma;
(0..len)
.map(|k| {
let n = k as f64 - center;
(-(n * n) / sig2).exp()
})
.collect()
}
#[inline]
fn listsign(k: usize) -> f64 {
if k.is_multiple_of(2) {
1.0
} else {
-1.0
}
}
fn rs_filter_smooth(sino: &Array2<f32>, window: &[f64], pad: usize) -> Array2<f32> {
let (nproj, ncol) = sino.dim();
let len = nproj + 2 * pad;
debug_assert_eq!(window.len(), len);
let n = nproj as isize;
let mut smooth = Array2::<f32>::zeros((nproj, ncol));
let mut signed = vec![0.0f64; len];
for c in 0..ncol {
for (k, sv) in signed.iter_mut().enumerate() {
let src = reflect_whole_sample(k as isize - pad as isize, n);
*sv = sino[[src, c]] as f64 * listsign(k);
}
let filtered = fft::filter_real_column(&signed, window);
for p in 0..nproj {
smooth[[p, c]] = (filtered[pad + p] * listsign(pad + p)) as f32;
}
}
smooth
}
fn remove_stripe_based_filtering(
data: &mut Tomo<f32>,
sigma: f32,
size: Option<usize>,
dim: u8,
) -> Result<()> {
let target = data.layout;
let mut proj = data.to_layout(Layout::Projection);
let (nproj, nrows, ncol) = proj.array.dim();
if nproj < 2 || nrows == 0 || ncol == 0 {
return Ok(());
}
let pad = 150.min((0.1 * nproj as f64) as usize);
let window = gaussian_window(nproj + 2 * pad, sigma as f64);
let size = size.unwrap_or_else(|| {
if ncol > 2000 {
21
} else {
5.max((0.01 * ncol as f64) as usize)
}
});
if size == 0 {
return Ok(());
}
par_over_rows(&mut proj.array, |mut lane| {
let sino = lane.to_owned();
let smooth = rs_filter_smooth(&sino, &window, pad);
let smooth_cor = if dim == 1 {
rs_sort(&smooth, size)
} else {
rs_sort_with(&smooth, |s| median_filter_2d(s, size))
};
for p in 0..nproj {
for c in 0..ncol {
let sharp = sino[[p, c]] - smooth[[p, c]];
lane[[p, c]] = smooth_cor[[p, c]] + sharp;
}
}
});
*data = proj.to_layout(target);
Ok(())
}
fn solve_dense(a: &mut [Vec<f64>], b: &mut [f64]) {
let n = b.len();
for col in 0..n {
let piv = a
.iter()
.enumerate()
.skip(col)
.max_by(|(_, x), (_, y)| x[col].abs().total_cmp(&y[col].abs()))
.map(|(r, _)| r)
.unwrap_or(col);
if piv != col {
a.swap(col, piv);
b.swap(col, piv);
}
let pivot_row = a[col].clone();
let bcol = b[col];
let d = pivot_row[col];
for (r, ar) in a.iter_mut().enumerate().skip(col + 1) {
let f = ar[col] / d;
if f != 0.0 {
for (arc, &pc) in ar.iter_mut().zip(pivot_row.iter()).skip(col) {
*arc -= f * pc;
}
b[r] -= f * bcol;
}
}
}
for col in (0..n).rev() {
let s: f64 = a[col]
.iter()
.zip(b.iter())
.skip(col + 1)
.map(|(ac, bc)| ac * bc)
.sum();
b[col] = (b[col] - s) / a[col][col];
}
}
fn savgol_coeffs(window: usize, order: usize) -> Vec<f64> {
if window <= 1 {
return vec![1.0; window];
}
let pos = window / 2; let posf = pos as f64;
let m = order + 1;
let mut powers = vec![vec![0.0f64; window]; m];
for k in 0..window {
let u = (k as f64 - posf) / posf;
let mut p = 1.0;
for row in powers.iter_mut() {
row[k] = p;
p *= u;
}
}
let mut mat = vec![vec![0.0f64; m]; m];
for (i, mrow) in mat.iter_mut().enumerate() {
for (j, cell) in mrow.iter_mut().enumerate() {
*cell = (0..window).map(|k| powers[i][k] * powers[j][k]).sum();
}
}
let mut z = vec![0.0f64; m];
z[0] = 1.0;
solve_dense(&mut mat, &mut z);
(0..window)
.map(|k| (0..m).map(|j| z[j] * powers[j][k]).sum())
.collect()
}
fn savgol_filter_axis0(sino: &Array2<f32>, window: usize, order: usize) -> Array2<f32> {
let (nrow, ncol) = sino.dim();
let coeffs = savgol_coeffs(window, order);
let pos = (window / 2) as isize;
let n = nrow as isize;
let mut out = Array2::<f32>::zeros((nrow, ncol));
for c in 0..ncol {
for i in 0..nrow {
let mut s = 0.0f64;
for (k, &ck) in coeffs.iter().enumerate() {
let idx = reflect_whole_sample(i as isize + k as isize - pos, n);
s += ck * sino[[idx, c]] as f64;
}
out[[i, c]] = s as f32;
}
}
out
}
fn create_2d_window(nrow: usize, ncol: usize, sigma: (f64, f64), pad: usize) -> Array2<f64> {
let (sigmax, sigmay) = sigma;
let height = nrow + 2 * pad;
let width = ncol + 2 * pad;
let centerx = (width as f64 - 1.0) / 2.0;
let centery = (height as f64 - 1.0) / 2.0;
let numx = 2.0 * sigmax * sigmax;
let numy = 2.0 * sigmay * sigmay;
let mut w = Array2::<f64>::zeros((height, width));
for y in 0..height {
let dy = y as f64 - centery;
for x in 0..width {
let dx = x as f64 - centerx;
w[[y, x]] = (-(dx * dx / numx + dy * dy / numy)).exp();
}
}
w
}
fn create_matsign(nrow: usize, ncol: usize, pad: usize) -> Array2<f64> {
let height = nrow + 2 * pad;
let width = ncol + 2 * pad;
let mut s = Array2::<f64>::zeros((height, width));
for y in 0..height {
for x in 0..width {
s[[y, x]] = if (x + y) % 2 == 0 { 1.0 } else { -1.0 };
}
}
s
}
fn two_d_filter(
mat: &Array2<f32>,
win2d: &Array2<f64>,
matsign: &Array2<f64>,
pad: usize,
) -> Array2<f64> {
let (nrow, ncol) = mat.dim();
let height = nrow + 2 * pad;
let width = ncol + 2 * pad;
let mut matpad = Array2::<f64>::zeros((height, width));
for r in 0..nrow {
for x in 0..width {
let sc = if x < pad {
0
} else if x >= pad + ncol {
ncol - 1
} else {
x - pad
};
matpad[[r + pad, x]] = mat[[r, sc]] as f64;
}
}
for x in 0..width {
let mut sum = 0.0f64;
for r in 0..nrow {
sum += matpad[[r + pad, x]];
}
let colmean = sum / nrow as f64;
for r in 0..pad {
matpad[[r, x]] = colmean;
}
for r in (pad + nrow)..height {
matpad[[r, x]] = colmean;
}
}
let mut modulated = Array2::<f64>::zeros((height, width));
for y in 0..height {
for x in 0..width {
modulated[[y, x]] = matpad[[y, x]] * matsign[[y, x]];
}
}
let filt = fft::filter_real_2d(&modulated, win2d);
let mut out = Array2::<f64>::zeros((nrow, ncol));
for r in 0..nrow {
for c in 0..ncol {
let (y, x) = (r + pad, c + pad);
out[[r, c]] = filt[[y, x]] * matsign[[y, x]];
}
}
out
}
fn rs_fit(
sino: &Array2<f32>,
order: usize,
win2d: &Array2<f64>,
matsign: &Array2<f64>,
pad: usize,
) -> Array2<f32> {
let (nrow, ncol) = sino.dim();
let mut window = nrow;
if window % 2 == 0 {
window -= 1;
}
let order = if order >= window { window - 1 } else { order };
let sinofit = savgol_filter_axis0(sino, window, order);
let sinofitsmooth = two_d_filter(&sinofit, win2d, matsign, pad);
let denom = (nrow * ncol) as f64;
let num1 = sinofit.iter().map(|&v| v as f64).sum::<f64>() / denom;
let num2 = sinofitsmooth.iter().sum::<f64>() / denom;
let mut out = Array2::<f32>::zeros((nrow, ncol));
for r in 0..nrow {
for c in 0..ncol {
let fit = sinofit[[r, c]] as f64;
let smooth = num1 * sinofitsmooth[[r, c]] / num2;
out[[r, c]] = (sino[[r, c]] as f64 / fit * smooth) as f32;
}
}
out
}
fn remove_stripe_based_fitting(
data: &mut Tomo<f32>,
order: usize,
sigma: (f32, f32),
) -> Result<()> {
let target = data.layout;
let mut proj = data.to_layout(Layout::Projection);
let (nproj, nrows, ncol) = proj.array.dim();
if nproj < 2 || nrows == 0 || ncol == 0 {
return Ok(());
}
let pad = 150.min((0.1 * nproj as f64) as usize);
let sigma = (sigma.0 as f64, sigma.1 as f64);
let win2d = create_2d_window(nproj, ncol, sigma, pad);
let matsign = create_matsign(nproj, ncol, pad);
par_over_rows(&mut proj.array, |mut lane| {
let sino = lane.to_owned();
let fixed = rs_fit(&sino, order, &win2d, &matsign, pad);
lane.assign(&fixed);
});
*data = proj.to_layout(target);
Ok(())
}