use crate::data::{Layout, Tomo};
use crate::error::{Error, Result};
pub fn scale(data: &mut Tomo<f32>) -> Result<f32> {
let arr = &mut data.array;
if arr.is_empty() {
return Err(Error::InvalidParam("scale: empty projection stack".into()));
}
let mx = arr.iter().copied().fold(f32::NEG_INFINITY, f32::max);
let mn = arr.iter().copied().fold(f32::INFINITY, f32::min);
let scl = mx.abs().max(mn.abs());
arr.mapv_inplace(|v| v / scl);
Ok(scl)
}
pub fn blur_edges(data: &mut Tomo<f32>, low: f64, high: f64) -> Result<()> {
let target = data.layout;
let mut proj = data.to_layout(Layout::Projection);
let (dx, dy, dz) = proj.array.dim();
if dy == 0 || dz == 0 {
*data = proj.to_layout(target);
return Ok(());
}
let (cy, cz) = (dy as f64 / 2.0, dz as f64 / 2.0);
let mut rad = vec![0.0f64; dy * dz];
let mut rad_max = f64::NEG_INFINITY;
for row in 0..dy {
let dr = row as f64 - cy;
for col in 0..dz {
let dc = col as f64 - cz;
let r = (dr * dr + dc * dc).sqrt();
rad[row * dz + col] = r;
if r > rad_max {
rad_max = r;
}
}
}
let (rmin, rmax) = (low * rad_max, high * rad_max);
let mut mask = vec![0.0f64; dy * dz];
for (idx, &r) in rad.iter().enumerate() {
let mut m = 0.0f64;
if r < rmin {
m = 1.0;
}
if r > rmax {
m = 0.0;
}
if r >= rmin && r <= rmax {
m = (rmax - r) / (rmax - rmin);
}
mask[idx] = m;
}
for i in 0..dx {
for row in 0..dy {
for col in 0..dz {
let m = mask[row * dz + col];
proj.array[[i, row, col]] = (proj.array[[i, row, col]] as f64 * m) as f32;
}
}
}
*data = proj.to_layout(target);
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
use crate::data::Layout;
use ndarray::Array3;
#[test]
fn scale_normalizes_by_peak_magnitude() {
let arr = Array3::from_shape_vec((1, 1, 4), vec![2.0f32, -4.0, 1.0, -3.0]).unwrap();
let mut t = Tomo::new(arr, Layout::Projection);
let scl = scale(&mut t).unwrap();
assert_eq!(scl, 4.0);
assert_eq!(t.array.as_slice().unwrap(), &[0.5, -1.0, 0.25, -0.75]);
}
#[test]
fn scale_rejects_empty() {
let mut t = Tomo::new(Array3::<f32>::zeros((0, 0, 0)), Layout::Projection);
assert!(matches!(scale(&mut t), Err(Error::InvalidParam(_))));
}
#[test]
fn blur_edges_feathers_radially() {
let arr = Array3::from_elem((1, 4, 4), 1.0f32);
let mut t = Tomo::new(arr, Layout::Projection);
blur_edges(&mut t, 0.0, 0.8).unwrap();
assert_eq!(t.array[[0, 2, 2]], 1.0, "centre not kept");
assert_eq!(t.array[[0, 0, 0]], 0.0, "corner not blurred to 0");
let mid = t.array[[0, 0, 2]];
assert!(mid > 0.0 && mid < 1.0, "edge pixel {mid} not feathered");
}
}