use ndarray::Array3;
use crate::data::{Layout, Tomo};
use crate::error::{Error, Result};
pub fn stripes_detect3d(tomo: &Tomo<f32>, size: usize, radius: usize) -> Result<Array3<f32>> {
let proj = tomo.as_layout(Layout::Projection);
let input = &proj.array; let (dz, dy, dx) = input.dim();
if dz == 0 || dy == 0 || dx == 0 {
return Err(Error::InvalidParam(
"stripes_detect3d: every dimension must be non-zero".into(),
));
}
if size == 0 || size > dz / 2 {
return Err(Error::InvalidParam(format!(
"stripes_detect3d: size ({size}) must be > 0 and <= n_angles/2 ({})",
dz / 2
)));
}
let radius = radius as isize;
let window_half = size as isize; let window_full = 2 * size + 1; let midval_index = ((0.5f32 * window_full as f32) as isize - 1) as usize;
let mut temp = smooth_mean(input);
let grad = gradient_x_step2(input);
ratio_map(&grad, &mut temp, radius);
Ok(vertical_median(&temp, window_half, midval_index))
}
fn smooth_mean(input: &Array3<f32>) -> Array3<f32> {
let (dz, dy, dx) = input.dim();
let (dzi, dyi, dxi) = (dz as isize, dy as isize, dx as isize);
let mut out = Array3::<f32>::zeros((dz, dy, dx));
for k in 0..dz {
for j in 0..dy {
for i in 0..dx {
let (ki, ji, ii) = (k as isize, j as isize, i as isize);
let mut i1 = ii - 1;
let mut i2 = ii + 1;
let mut j1 = ji - 1;
let mut j2 = ji + 1;
let mut k1 = ki - 1;
let mut k2 = ki + 1;
if i1 < 0 {
i1 = i2;
}
if i2 >= dxi {
i2 = i1;
}
if j1 < 0 {
j1 = j2;
}
if j2 >= dyi {
j2 = j1;
}
if k1 < 0 {
k1 = k2;
}
if k2 >= dzi {
k2 = k1;
}
let val1 = input[[k, j, i1 as usize]];
let val2 = input[[k, j, i2 as usize]];
let val3 = input[[k, j1 as usize, i]];
let val4 = input[[k, j2 as usize, i]];
let val5 = input[[k1 as usize, j, i]];
let val6 = input[[k2 as usize, j, i]];
out[[k, j, i]] =
0.1428f32 * (input[[k, j, i]] + val1 + val2 + val3 + val4 + val5 + val6);
}
}
}
out
}
fn gradient_x_step2(input: &Array3<f32>) -> Array3<f32> {
let (dz, dy, dx) = input.dim();
let dxi = dx as isize;
let mut out = Array3::<f32>::zeros((dz, dy, dx));
for k in 0..dz {
for j in 0..dy {
for i in 0..dx {
let mut i1 = i as isize + 2;
if i1 >= dxi {
i1 = i as isize - 2;
}
out[[k, j, i]] = input[[k, j, i1 as usize]] - input[[k, j, i]];
}
}
}
out
}
fn ratio_map(grad: &Array3<f32>, temp: &mut Array3<f32>, radius: isize) {
let (dz, dy, dx) = grad.dim();
let (dzi, dyi, dxi) = (dz as isize, dy as isize, dx as isize);
let diameter = 2 * radius + 1;
let all_pixels_window = (diameter * diameter) as f32;
let horiz_norm = (radius * 3) as f32;
for k in 0..dz {
for j in 0..dy {
for i in 0..dx {
let (ki, ji) = (k as isize, j as isize);
let mut mean_plate = 0.0f32;
for j_m in -radius..=radius {
let mut j1 = ji + j_m;
if j1 < 0 || j1 >= dyi {
j1 = ji - j_m;
}
for k_m in -radius..=radius {
let mut k1 = ki + k_m;
if k1 < 0 || k1 >= dzi {
k1 = ki - k_m;
}
mean_plate += grad[[k1 as usize, j1 as usize, i]].abs();
}
}
mean_plate /= all_pixels_window;
let mut mean_horiz = 0.0f32;
for j_m in -1..=1 {
let mut j1 = ji + j_m;
if j1 < 0 || j1 >= dyi {
j1 = ji - j_m;
}
for i_m in 1..=radius {
let mut i1 = i as isize + i_m;
if i1 >= dxi {
i1 = i as isize - i_m;
}
mean_horiz += grad[[k, j1 as usize, i1 as usize]].abs();
}
}
mean_horiz /= horiz_norm;
let mut mean_horiz2 = 0.0f32;
for j_m in -1..=1 {
let mut j1 = ji + j_m;
if j1 < 0 || j1 >= dyi {
j1 = ji - j_m;
}
for i_m in -radius..=-1 {
let mut i1 = i as isize + i_m;
if i1 < 0 {
i1 = i as isize - i_m;
}
mean_horiz2 += grad[[k, j1 as usize, i1 as usize]].abs();
}
}
mean_horiz2 /= horiz_norm;
let mut out_val = temp[[k, j, i]];
let mut min_val = 0.0f32;
if mean_horiz >= mean_plate && mean_horiz != 0.0 {
out_val = mean_plate / mean_horiz;
}
if mean_horiz < mean_plate && mean_plate != 0.0 {
out_val = mean_horiz / mean_plate;
}
if mean_horiz2 >= mean_plate && mean_horiz2 != 0.0 {
min_val = mean_plate / mean_horiz2;
}
if mean_horiz2 < mean_plate && mean_plate != 0.0 {
min_val = mean_horiz2 / mean_plate;
}
if out_val > min_val {
out_val = min_val;
}
temp[[k, j, i]] = out_val;
}
}
}
}
fn vertical_median(temp: &Array3<f32>, window_half: isize, midval_index: usize) -> Array3<f32> {
let (dz, dy, dx) = temp.dim();
let dzi = dz as isize;
let mut out = Array3::<f32>::zeros((dz, dy, dx));
let mut values: Vec<f32> = Vec::with_capacity((2 * window_half + 1) as usize);
for k in 0..dz {
for j in 0..dy {
for i in 0..dx {
values.clear();
for k_m in -window_half..=window_half {
let mut k1 = k as isize + k_m;
if k1 < 0 || k1 >= dzi {
k1 = k as isize - k_m;
}
values.push(temp[[k1 as usize, j, i]]);
}
values.sort_by(|a, b| a.total_cmp(b));
out[[k, j, i]] = values[midval_index];
}
}
}
out
}
pub fn stripes_mask3d(
weights: &Array3<f32>,
threshold: f32,
min_stripe_length: usize,
min_stripe_depth: usize,
min_stripe_width: usize,
sensitivity_perc: f32,
) -> Result<Array3<bool>> {
let (dz, dy, dx) = weights.dim();
if dz == 0 || dy == 0 || dx == 0 {
return Err(Error::InvalidParam(
"stripes_mask3d: every dimension must be non-zero".into(),
));
}
if min_stripe_length == 0 || min_stripe_length >= dz {
return Err(Error::InvalidParam(format!(
"stripes_mask3d: min_stripe_length ({min_stripe_length}) must be > 0 and < n_angles ({dz})"
)));
}
if min_stripe_depth >= dy {
return Err(Error::InvalidParam(format!(
"stripes_mask3d: min_stripe_depth ({min_stripe_depth}) must be < n_detY ({dy})"
)));
}
if min_stripe_width == 0 || min_stripe_width >= dx {
return Err(Error::InvalidParam(format!(
"stripes_mask3d: min_stripe_width ({min_stripe_width}) must be > 0 and < n_detX ({dx})"
)));
}
if !(sensitivity_perc > 0.0 && sensitivity_perc <= 100.0) {
return Err(Error::InvalidParam(format!(
"stripes_mask3d: sensitivity_perc ({sensitivity_perc}) must be in (0, 100]"
)));
}
let mut mask = weights.mapv(|w| w <= threshold);
mask = remove_inconsistent_stripes(
&mask,
min_stripe_length,
min_stripe_depth,
sensitivity_perc,
true,
);
mask = remove_inconsistent_stripes(
&mask,
min_stripe_length,
min_stripe_depth,
sensitivity_perc,
false,
);
mask = remove_short_stripes(&mask, min_stripe_length);
for _ in 0..min_stripe_width {
mask = merge_stripes(&mask, min_stripe_width);
}
Ok(mask)
}
fn remove_inconsistent_stripes(
src: &Array3<bool>,
min_len: usize,
min_depth: usize,
sensitivity: f32,
depth_pass: bool,
) -> Array3<bool> {
let (dz, dy, dx) = src.dim();
let mut out = src.clone();
if depth_pass {
if min_depth == 0 {
return out; }
let half = (min_depth / 2) as isize;
let threshold = ((0.01f32 * sensitivity) * min_depth as f32) as i32;
let dyi = dy as isize;
for k in 0..dz {
for j in 0..dy {
for i in 0..dx {
if !src[[k, j, i]] {
continue;
}
let mut counter = 0i32;
for y_m in -half..=half {
let mut y1 = j as isize + y_m;
if y1 < 0 || y1 >= dyi {
y1 = j as isize - y_m;
}
if src[[k, y1 as usize, i]] {
counter += 1;
}
}
if counter > threshold {
out[[k, j, i]] = false;
}
}
}
}
} else {
let half = (min_len / 2) as isize;
let threshold = ((0.01f32 * sensitivity) * min_len as f32) as i32;
let dzi = dz as isize;
for k in 0..dz {
for j in 0..dy {
for i in 0..dx {
if !src[[k, j, i]] {
continue;
}
let mut counter = 0i32;
for k_m in -half..=half {
let mut k1 = k as isize + k_m;
if k1 < 0 || k1 >= dzi {
k1 = k as isize - k_m;
}
if src[[k1 as usize, j, i]] {
counter += 1;
}
}
if counter < threshold {
out[[k, j, i]] = false;
}
}
}
}
}
out
}
fn remove_short_stripes(src: &Array3<bool>, min_len: usize) -> Array3<bool> {
let (dz, dy, dx) = src.dim();
let mut out = src.clone();
let half = (min_len / 2) as isize;
let dzi = dz as isize;
for k in 0..dz {
for j in 0..dy {
for i in 0..dx {
if !src[[k, j, i]] {
continue;
}
let mut counter = 0i32;
for k_m in -half..=half {
let mut k1 = k as isize + k_m;
if k1 < 0 || k1 >= dzi {
k1 = k as isize - k_m;
}
if src[[k1 as usize, j, i]] {
counter += 1;
}
}
if counter < half as i32 {
out[[k, j, i]] = false;
}
}
}
}
out
}
fn merge_stripes(src: &Array3<bool>, min_width: usize) -> Array3<bool> {
let (dz, dy, dx) = src.dim();
let mut out = src.clone();
let half_w = (min_width / 2) as isize;
let vert_len = (2 * min_width) as isize;
let (dzi, dxi) = (dz as isize, dx as isize);
for k in 0..dz {
for j in 0..dy {
for i in 0..dx {
if src[[k, j, i]] {
continue;
}
let ii = i as isize;
let mut mask_left = false;
for x in -half_w..=0 {
let mut x_l = ii + x;
if x_l < 0 {
x_l = ii - x;
}
if src[[k, j, x_l as usize]] {
mask_left = true;
break;
}
}
let mut mask_right = false;
for x in 0..=half_w {
let mut x_r = ii + x;
if x_r >= dxi {
x_r = ii - x;
}
if src[[k, j, x_r as usize]] {
mask_right = true;
break;
}
}
let mut out_val = false;
if mask_left && mask_right {
out_val = true;
}
if !out_val {
let ki = k as isize;
let mut mask_up = false;
for x in -vert_len..=0 {
let mut k_u = ki + x;
if k_u < 0 {
k_u = ki - x;
}
if src[[k_u as usize, j, i]] {
mask_up = true;
break;
}
}
let mut mask_down = false;
for x in 0..=vert_len {
let mut k_d = ki + x;
if k_d >= dzi {
k_d = ki - x;
}
if src[[k_d as usize, j, i]] {
mask_down = true;
break;
}
}
if mask_up && mask_down {
out_val = true;
}
}
out[[k, j, i]] = out_val;
}
}
}
out
}