use crate::data::{Layout, Tomo};
use crate::error::{Error, Result};
use ndarray::Array3;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Rotation {
Left,
Right,
}
fn linspace(start: f64, stop: f64, num: usize) -> Vec<f64> {
if num == 0 {
return Vec::new();
}
if num == 1 {
return vec![start];
}
let step = (stop - start) / (num - 1) as f64;
let mut y: Vec<f64> = (0..num).map(|k| k as f64 * step + start).collect();
y[num - 1] = stop; y
}
pub fn sino_360_to_180(data: &Tomo<f32>, overlap: usize, rotation: Rotation) -> Result<Tomo<f32>> {
let src = data.as_layout(Layout::Projection);
let (dx, dy, dz) = src.array.dim();
if overlap > dz {
return Err(Error::InvalidParam(format!(
"sino_360_to_180: overlap ({overlap}) exceeds detector width ({dz})"
)));
}
let n = dx / 2;
let width = 2 * dz - overlap;
let mut out = Array3::<f32>::zeros((n, dy, width));
if n == 0 || dy == 0 || dz == 0 {
return Ok(Tomo::new(out, Layout::Projection));
}
let a = &src.array;
let keep = dz - overlap;
match rotation {
Rotation::Left => {
let w = linspace(0.0, 1.0, overlap);
for p in 0..n {
for r in 0..dy {
for t in 0..keep {
out[[p, r, t]] = a[[n + p, r, dz - 1 - t]];
}
for t in 0..keep {
out[[p, r, dz + t]] = a[[p, r, overlap + t]];
}
for c in 0..overlap {
let first = w[c] * a[[p, r, c]] as f64;
let second = w[overlap - 1 - c] * a[[n + p, r, overlap - 1 - c]] as f64;
out[[p, r, keep + c]] = (first + second) as f32;
}
}
}
}
Rotation::Right => {
let w = linspace(1.0, 0.0, overlap);
for p in 0..n {
for r in 0..dy {
for t in 0..keep {
out[[p, r, t]] = a[[p, r, t]];
}
for t in 0..keep {
out[[p, r, dz + t]] = a[[n + p, r, keep - 1 - t]];
}
for c in 0..overlap {
let first = w[c] * a[[p, r, keep + c]] as f64;
let second = w[overlap - 1 - c] * a[[n + p, r, dz - 1 - c]] as f64;
out[[p, r, keep + c]] = (first + second) as f32;
}
}
}
}
}
Ok(Tomo::new(out, Layout::Projection))
}
fn sample_setup(arr: &Array3<f32>, axis: usize) -> Result<((usize, usize, usize), Vec<f32>)> {
if axis > 2 {
return Err(Error::InvalidParam(format!(
"downsample/upsample: axis ({axis}) must be 0, 1 or 2"
)));
}
let std = arr.as_standard_layout(); let flat = std.iter().copied().collect();
Ok((arr.dim(), flat))
}
pub fn downsample(arr: &Array3<f32>, level: u32, axis: usize) -> Result<Array3<f32>> {
let ((dx, dy, dz), data) = sample_setup(arr, axis)?;
let binsize = 1usize << level;
let bs_f = binsize as f32;
let (odx, ody, odz) = match axis {
0 => (dx / binsize, dy, dz),
1 => (dx, dy / binsize, dz),
_ => (dx, dy, dz / binsize),
};
let mut out = vec![0.0f32; odx * ody * odz];
let mut ind = 0usize; match axis {
0 => {
for m in 0..odx {
let i = m * (ody * odz); for _p in 0..binsize {
for n in 0..dy {
let j = n * dz;
for k in 0..dz {
out[i + j + k] += data[ind] / bs_f;
ind += 1;
}
}
}
}
}
1 => {
for m in 0..dx {
let i = m * (ody * dz);
for n in 0..ody {
let j = n * dz;
for _p in 0..binsize {
for k in 0..dz {
out[i + j + k] += data[ind] / bs_f;
ind += 1;
}
}
}
}
}
_ => {
for m in 0..dx {
let i = m * (dy * odz);
for n in 0..dy {
let j = n * odz;
for k in 0..odz {
for _p in 0..binsize {
out[i + j + k] += data[ind] / bs_f;
ind += 1;
}
}
}
}
}
}
Ok(Array3::from_shape_vec((odx, ody, odz), out).expect("downsample shape"))
}
pub fn upsample(arr: &Array3<f32>, level: u32, axis: usize) -> Result<Array3<f32>> {
let ((dx, dy, dz), data) = sample_setup(arr, axis)?;
let binsize = 1usize << level;
let (odx, ody, odz) = match axis {
0 => (dx * binsize, dy, dz),
1 => (dx, dy * binsize, dz),
_ => (dx, dy, dz * binsize),
};
let mut out = vec![0.0f32; odx * ody * odz];
let mut ind = 0usize; match axis {
0 => {
for m in 0..dx {
let i = m * (dy * dz);
for _p in 0..binsize {
for n in 0..dy {
let j = n * dz;
for k in 0..dz {
out[ind] = data[i + j + k];
ind += 1;
}
}
}
}
}
1 => {
for m in 0..dx {
let i = m * (dy * dz);
for n in 0..dy {
let j = n * dz;
for _p in 0..binsize {
for k in 0..dz {
out[ind] = data[i + j + k];
ind += 1;
}
}
}
}
}
_ => {
for m in 0..dx {
let i = m * (dy * dz);
for n in 0..dy {
let j = n * dz;
for k in 0..dz {
for _p in 0..binsize {
out[ind] = data[i + j + k];
ind += 1;
}
}
}
}
}
}
Ok(Array3::from_shape_vec((odx, ody, odz), out).expect("upsample shape"))
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum PadMode {
Constant(f32),
Edge,
}
fn get_npad(dim: usize) -> usize {
let d = dim as f64;
((d * std::f64::consts::SQRT_2 - d) / 2.0).ceil() as usize
}
pub fn pad(
arr: &Array3<f32>,
axis: usize,
npad: Option<usize>,
mode: PadMode,
) -> Result<Array3<f32>> {
if axis > 2 {
return Err(Error::InvalidParam(format!(
"pad: axis ({axis}) must be 0, 1 or 2"
)));
}
let dims = [arr.dim().0, arr.dim().1, arr.dim().2];
let dim = dims[axis];
let npad = npad.unwrap_or_else(|| get_npad(dim));
if dim == 0 && npad > 0 && mode == PadMode::Edge {
return Err(Error::InvalidParam(
"pad: cannot edge-pad a zero-length axis".into(),
));
}
let mut newdims = dims;
newdims[axis] = dim + 2 * npad;
let mut out = Array3::<f32>::zeros((newdims[0], newdims[1], newdims[2]));
for o0 in 0..newdims[0] {
for o1 in 0..newdims[1] {
for o2 in 0..newdims[2] {
let mut coord = [o0, o1, o2];
let t = coord[axis];
let v = if t >= npad && t < npad + dim {
coord[axis] = t - npad;
arr[[coord[0], coord[1], coord[2]]]
} else {
match mode {
PadMode::Constant(c) => c,
PadMode::Edge => {
coord[axis] = if t < npad { 0 } else { dim - 1 };
arr[[coord[0], coord[1], coord[2]]]
}
}
};
out[[o0, o1, o2]] = v;
}
}
}
Ok(out)
}