use ndarray::ArrayViewMut2;
use crate::backend::{Backend, Fft};
use crate::data::{Layout, Tomo};
use crate::dtype::Complex32;
use crate::error::{Error, Result};
use crate::params::PhaseMethod;
#[allow(clippy::approx_constant)]
const PHASE_PI: f64 = 3.14159265359;
const PLANCK_CONSTANT: f64 = 6.58211928e-19; const SPEED_OF_LIGHT: f64 = 299_792_458e2;
pub fn retrieve_phase(
data: &mut Tomo<f32>,
method: PhaseMethod,
backend: &dyn Backend,
) -> Result<()> {
match method {
PhaseMethod::None => Ok(()),
PhaseMethod::Paganin {
pixel_size,
dist,
energy,
alpha,
} => {
let fft = require_fft(backend)?;
let (ps, dist_f, alpha_f) = (pixel_size as f64, dist as f64, alpha as f64);
let wl = wavelength(energy as f64);
run_phase(data, pixel_size, dist, energy, fft, move |nx, ny| {
pointwise_filter(nx, ny, ps, |ix, iy| {
let w2 = ix * ix + iy * iy;
(1.0 / (wl * dist_f * w2 / (4.0 * PHASE_PI) + alpha_f)) as f32
})
})
}
PhaseMethod::GPaganin {
pixel_size,
dist,
energy,
db,
w,
} => {
let fft = require_fft(backend)?;
let (ps, dist_f, db_f, w_f) = (pixel_size as f64, dist as f64, db as f64, w as f64);
let two_pi_ps = (2.0 * PHASE_PI * ps) as f32;
let aph = db_f * (dist_f * wavelength(energy as f64)) / (4.0 * PHASE_PI);
let scale = (2.0 * aph / (w_f * w_f)) as f32;
run_phase(data, pixel_size, dist, energy, fft, move |nx, ny| {
pointwise_filter(nx, ny, ps, |ix, iy| {
let kf = (ix as f32 * two_pi_ps).cos() + (iy as f32 * two_pi_ps).cos();
1.0f32 / (1.0 - scale * (kf - 2.0))
})
})
}
PhaseMethod::Farago {
pixel_size,
dist,
energy,
db,
} => {
let fft = require_fft(backend)?;
let ps = pixel_size as f64;
let theta_scale = (PHASE_PI * wavelength(energy as f64) * dist as f64) as f32;
run_phase(data, pixel_size, dist, energy, fft, move |nx, ny| {
farago_filter_grid(nx, ny, ps, theta_scale, db)
})
}
}
}
fn wavelength(energy: f64) -> f64 {
2.0 * PHASE_PI * PLANCK_CONSTANT * SPEED_OF_LIGHT / energy
}
pub fn margin_rows(method: &PhaseMethod) -> usize {
let (pixel_size, dist, energy) = match *method {
PhaseMethod::None => return 0,
PhaseMethod::Paganin {
pixel_size,
dist,
energy,
..
}
| PhaseMethod::GPaganin {
pixel_size,
dist,
energy,
..
}
| PhaseMethod::Farago {
pixel_size,
dist,
energy,
..
} => (pixel_size, dist, energy),
};
let (ps, dist) = (pixel_size as f64, dist as f64);
(PHASE_PI * wavelength(energy as f64) * dist / (ps * ps)).ceil() as usize
}
fn calc_pad_width(dim: usize, pixel_size: f64, wl: f64, dist: f64) -> usize {
let pad_pix = (PHASE_PI * wl * dist / (pixel_size * pixel_size)).ceil();
let dimf = dim as f64;
((2.0f64.powf((dimf + pad_pix).log2().ceil()) - dimf) * 0.5) as usize
}
fn reciprocal_coord(pixel_size: f64, num_grid: usize) -> Vec<f64> {
let n = num_grid as f64 - 1.0;
let scale = 0.5 / (n * pixel_size);
let mut rc = Vec::with_capacity(num_grid);
let mut v = -n;
for _ in 0..num_grid {
rc.push(v * scale);
v += 2.0;
}
rc
}
fn reciprocal_coord_f32(pixel_size: f64, num_grid: usize) -> Vec<f32> {
let n = (num_grid - 1) as f64;
let scale = (0.5 / (n * pixel_size)) as f32;
let mut rc = Vec::with_capacity(num_grid);
let mut v = -((num_grid - 1) as f32);
for _ in 0..num_grid {
rc.push(v * scale);
v += 2.0;
}
rc
}
#[allow(clippy::needless_range_loop)]
fn pointwise_filter(
nx: usize,
ny: usize,
pixel_size: f64,
factor: impl Fn(f64, f64) -> f32,
) -> (Vec<f32>, f32) {
let indx = reciprocal_coord(pixel_size, nx);
let indy = reciprocal_coord(pixel_size, ny);
let mut filt = vec![0.0f32; nx * ny];
let mut maxf = f32::NEG_INFINITY;
for i in 0..nx {
for j in 0..ny {
let f = factor(indx[i], indy[j]);
filt[i * ny + j] = f;
if f > maxf {
maxf = f;
}
}
}
(filt, maxf)
}
#[allow(clippy::needless_range_loop)]
fn farago_filter_grid(
nx: usize,
ny: usize,
pixel_size: f64,
theta_scale: f32,
db: f32,
) -> (Vec<f32>, f32) {
let rcx = reciprocal_coord_f32(pixel_size, nx);
let rcy = reciprocal_coord_f32(pixel_size, ny);
let mut filt = vec![0.0f32; nx * ny];
let mut maxf = f32::NEG_INFINITY;
for i in 0..nx {
let sx = rcx[i] * rcx[i];
for j in 0..ny {
let w2 = sx + rcy[j] * rcy[j];
let theta = theta_scale * w2;
let f = 1.0f32 / (theta.cos() + db * theta.sin());
filt[i * ny + j] = f;
if f > maxf {
maxf = f;
}
}
}
(filt, maxf)
}
fn require_fft(backend: &dyn Backend) -> Result<&dyn Fft> {
backend.fft().ok_or_else(|| Error::MissingCapability {
backend: backend.name(),
capability: "Fft",
})
}
#[allow(clippy::needless_range_loop)]
fn run_phase(
data: &mut Tomo<f32>,
pixel_size: f32,
dist: f32,
energy: f32,
fft: &dyn Fft,
build_filter: impl Fn(usize, usize) -> (Vec<f32>, f32),
) -> Result<()> {
let target = data.layout;
let proj = data.as_layout(Layout::Projection); let (nproj, dy, dz) = proj.array.dim();
if nproj == 0 || dy == 0 || dz == 0 {
return Ok(());
}
let src = &proj.array;
let (ps, dist_f, energy_f) = (pixel_size as f64, dist as f64, energy as f64);
let wl = wavelength(energy_f);
let pad_r = calc_pad_width(dy, ps, wl, dist_f);
let pad_c = calc_pad_width(dz, ps, wl, dist_f);
let nx = dy + 2 * pad_r;
let ny = dz + 2 * pad_c;
let mut val_acc = 0.0f64;
for m in 0..nproj {
for i in 0..dy {
val_acc += 0.5 * (src[[m, i, 0]] as f64 + src[[m, i, dz - 1]] as f64);
}
}
let val = (val_acc / (nproj * dy) as f64) as f32;
let (filt, maxf) = build_filter(nx, ny);
let mut out = ndarray::Array3::<f32>::zeros((nproj, dy, dz));
let process_proj = |m: usize, mut slab: ArrayViewMut2<f32>| -> Result<()> {
let mut buf = vec![Complex32::new(0.0, 0.0); nx * ny];
let mut prj = vec![0.0f32; nx * ny];
for k in prj.iter_mut() {
*k = val;
}
for i in 0..dy {
for j in 0..dz {
prj[(i + pad_r) * ny + (j + pad_c)] = src[[m, i, j]];
}
}
for i in 0..pad_r {
for j in 0..ny {
prj[i * ny + j] = prj[pad_r * ny + j];
}
}
for i in (nx - pad_r)..nx {
for j in 0..ny {
prj[i * ny + j] = prj[(nx - pad_r - 1) * ny + j];
}
}
for i in 0..nx {
let left = prj[i * ny + pad_c];
for j in 0..pad_c {
prj[i * ny + j] = left;
}
let right = prj[i * ny + (ny - pad_c - 1)];
for j in (ny - pad_c)..ny {
prj[i * ny + j] = right;
}
}
for (b, &p) in buf.iter_mut().zip(prj.iter()) {
*b = Complex32::new(p, 0.0);
}
fft.fft_2d(&mut buf, nx, ny, 1, false)?;
for i in 0..nx {
let si = (i + nx - nx / 2) % nx;
for j in 0..ny {
let sj = (j + ny - ny / 2) % ny;
buf[i * ny + j] *= filt[si * ny + sj] / maxf;
}
}
fft.fft_2d(&mut buf, nx, ny, 1, true)?;
for i in 0..dy {
for j in 0..dz {
slab[[i, j]] = buf[(i + pad_r) * ny + (j + pad_c)].re;
}
}
Ok(())
};
fft.for_each_slice(&mut out, &process_proj)?;
*data = Tomo::new(out, Layout::Projection).to_layout(target);
Ok(())
}