use crate::backend::Backend;
use crate::data::{Dataset, Frames, Layout, Tomo};
use crate::error::{Error, Result};
use ndarray::Array2;
fn elementwise(backend: &dyn Backend) -> Result<&dyn crate::backend::Elementwise> {
backend.elementwise().ok_or(Error::MissingCapability {
backend: backend.name(),
capability: "Elementwise",
})
}
pub(crate) fn darkflat_frames(
flat: &Frames<f32>,
dark: &Frames<f32>,
) -> Result<(Array2<f32>, Array2<f32>)> {
let dark2d = dark
.array
.mean_axis(ndarray::Axis(0))
.ok_or_else(|| Error::InvalidParam("empty dark stack".into()))?;
let flat2d = flat
.array
.mean_axis(ndarray::Axis(0))
.ok_or_else(|| Error::InvalidParam("empty flat stack".into()))?;
let mut denom = &flat2d - &dark2d;
denom.mapv_inplace(|v| if v.abs() < 1e-6 { 1.0 } else { v });
Ok((dark2d, denom))
}
pub fn normalize(
data: &mut Tomo<f32>,
flat: &Frames<f32>,
dark: &Frames<f32>,
backend: &dyn Backend,
) -> Result<()> {
elementwise(backend)?.darkflat(data, flat, dark)
}
pub fn minus_log(data: &mut Tomo<f32>, backend: &dyn Backend) -> Result<()> {
elementwise(backend)?.minus_log(data)
}
pub fn normalize_dataset(ds: &mut Dataset<f32>, backend: &dyn Backend) -> Result<()> {
if let (Some(flat), Some(dark)) = (&ds.flat, &ds.dark) {
normalize(&mut ds.data, flat, dark, backend)?;
}
minus_log(&mut ds.data, backend)
}
pub fn normalize_bg(data: &mut Tomo<f32>, air: 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 {
return Ok(());
}
let nair = air.min(dz);
let arr = &mut proj.array;
for m in 0..dx {
for n in 0..dy {
let mut air_left = 0.0f32;
let mut air_right = 0.0f32;
for j in 0..nair {
air_left += arr[[m, n, j]];
air_right += arr[[m, n, dz - 1 - j]];
}
air_left /= nair as f32;
air_right /= nair as f32;
if air_left <= 0.0 {
air_left = 1.0;
}
if air_right <= 0.0 {
air_right = 1.0;
}
let air_slope = (air_right - air_left) / (dz - 1) as f32;
for j in 0..dz {
let air_val = air_slope.mul_add(j as f32, air_left);
arr[[m, n, j]] /= air_val;
}
}
}
*data = proj.to_layout(target);
Ok(())
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Averaging {
Mean,
Median,
}
fn median_frames(frames: &ndarray::Array3<f32>, start: usize, end: usize) -> Array2<f32> {
let (_, ny, nx) = frames.dim();
let g = end - start;
let mid = g / 2;
let mut out = Array2::<f32>::zeros((ny, nx));
let mut col = vec![0.0f32; g];
for y in 0..ny {
for x in 0..nx {
for (k, c) in col.iter_mut().enumerate() {
*c = frames[[start + k, y, x]];
}
col.sort_by(|a, b| a.total_cmp(b));
out[[y, x]] = if g.is_multiple_of(2) {
(col[mid - 1] + col[mid]) / 2.0
} else {
col[mid]
};
}
}
out
}
fn round_half_even_div2(diff: usize) -> usize {
let k = diff / 2;
if diff.is_multiple_of(2) || k.is_multiple_of(2) {
k
} else {
k + 1
}
}
pub fn normalize_nf(
data: &mut Tomo<f32>,
flats: &Frames<f32>,
dark: &Frames<f32>,
flat_loc: &[usize],
cutoff: Option<f32>,
averaging: Averaging,
) -> Result<()> {
let target = data.layout;
let mut proj = data.to_layout(Layout::Projection);
let (nproj, ny, nx) = proj.array.dim();
let (nflat, fy, fx) = flats.array.dim();
let (ndark, ky, kx) = dark.array.dim();
if fy != ny || fx != nx || ky != ny || kx != nx {
return Err(Error::InvalidParam(
"normalize_nf: flats/dark frame shape must match the projection frame".into(),
));
}
let num_flats = flat_loc.len();
if num_flats == 0 || nflat < num_flats || ndark == 0 {
return Err(Error::InvalidParam(
"normalize_nf: need ≥1 flat group (flat_loc) and ≥1 flat/dark frame".into(),
));
}
let dark2d = match averaging {
Averaging::Mean => {
let mut d = Array2::<f32>::zeros((ny, nx));
for y in 0..ny {
for x in 0..nx {
let mut s = 0.0f32;
for k in 0..ndark {
s += dark.array[[k, y, x]];
}
d[[y, x]] = s / ndark as f32;
}
}
d
}
Averaging::Median => {
let mut d = Array2::<f32>::zeros((ny, nx));
let mut col = vec![0.0f64; ndark];
for y in 0..ny {
for x in 0..nx {
for (k, c) in col.iter_mut().enumerate() {
*c = dark.array[[k, y, x]] as f64;
}
col.sort_by(|a, b| a.total_cmp(b));
let med = if ndark % 2 == 1 {
col[ndark / 2]
} else {
(col[ndark / 2 - 1] + col[ndark / 2]) / 2.0
};
d[[y, x]] = med as f32;
}
}
d
}
};
let num_per_flat = nflat / num_flats; let l = 1e-6f32;
let mut tend = 0usize;
for m in 0..num_flats {
let fstart = m * num_per_flat;
let fend = fstart + num_per_flat;
let flat = median_frames(&flats.array, fstart, fend);
let tstart = if m == 0 { 0 } else { tend };
tend = if m + 1 >= num_flats {
nproj
} else {
(round_half_even_div2(flat_loc[m + 1] - flat_loc[m]) + flat_loc[m]).min(nproj)
};
let mut denom = Array2::<f32>::zeros((ny, nx));
for y in 0..ny {
for x in 0..nx {
let d = flat[[y, x]] - dark2d[[y, x]];
denom[[y, x]] = if d < l { l } else { d };
}
}
for p in tstart..tend {
for y in 0..ny {
for x in 0..nx {
let mut v = (proj.array[[p, y, x]] - dark2d[[y, x]]) / denom[[y, x]];
if let Some(c) = cutoff {
if v > c {
v = c;
}
}
proj.array[[p, y, x]] = v;
}
}
}
}
*data = proj.to_layout(target);
Ok(())
}
pub fn normalize_roi(data: &mut Tomo<f32>, roi: [usize; 4]) -> Result<()> {
let [r0, r1, r2, r3] = roi;
let target = data.layout;
let mut proj = data.to_layout(Layout::Projection);
let (nproj, ny, nx) = proj.array.dim();
if r0 >= r2 || r1 >= r3 || r2 > ny || r3 > nx {
return Err(Error::InvalidParam(
"normalize_roi: roi must satisfy 0<=r0<r2<=n_rows and 0<=r1<r3<=n_cols".into(),
));
}
let n = ((r2 - r0) * (r3 - r1)) as f32;
let mut buf: Vec<f32> = Vec::with_capacity((r2 - r0) * (r3 - r1));
for p in 0..nproj {
buf.clear();
for y in r0..r2 {
for x in r1..r3 {
buf.push(proj.array[[p, y, x]]);
}
}
let bg = pairwise_sum_f32(&buf) / n;
if bg != 0.0 {
for y in 0..ny {
for x in 0..nx {
proj.array[[p, y, x]] /= bg;
}
}
}
}
*data = proj.to_layout(target);
Ok(())
}
fn pairwise_sum_f32(a: &[f32]) -> f32 {
let n = a.len();
if n == 0 {
return 0.0;
}
if n < 8 {
let mut res = 0.0f32;
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_f32(&a[..n2]) + pairwise_sum_f32(&a[n2..])
}
#[cfg(test)]
mod tests {
use super::*;
use ndarray::Array3;
#[test]
fn pairwise_sum_small_and_block() {
assert_eq!(pairwise_sum_f32(&[1.0, 2.0, 3.0]), 6.0);
let v: Vec<f32> = (0..100).map(|k| k as f32).collect();
assert_eq!(pairwise_sum_f32(&v), 4950.0);
let v: Vec<f32> = (0..200).map(|_| 1.0).collect();
assert_eq!(pairwise_sum_f32(&v), 200.0);
}
#[test]
fn normalize_roi_divides_by_roi_mean_and_rejects_bad_roi() {
let arr = Array3::from_shape_vec((1, 2, 2), vec![1.0f32, 2.0, 3.0, 4.0]).unwrap();
let mut t = Tomo::new(arr, Layout::Projection);
normalize_roi(&mut t, [0, 0, 2, 2]).unwrap();
let got: Vec<f32> = t.array.iter().copied().collect();
assert_eq!(got, vec![1.0 / 2.5, 2.0 / 2.5, 3.0 / 2.5, 4.0 / 2.5]);
let mut t = Tomo::new(Array3::<f32>::zeros((1, 2, 2)), Layout::Projection);
assert!(matches!(
normalize_roi(&mut t, [0, 0, 3, 2]),
Err(Error::InvalidParam(_))
));
}
}