use ndarray::{Array3, ArrayViewMut2};
use crate::backend::Fft;
use crate::data::Tomo;
use crate::dtype::Complex32;
use crate::error::Result;
use crate::geometry::Geometry;
const KW: f32 = 2.0;
const BETA: f32 = 9.0;
fn bessel_i0(x: f32) -> f32 {
let mut sum = 1.0f64;
let mut term = 1.0f64;
let half = x as f64 / 2.0;
for m in 1..40 {
term *= (half / m as f64) * (half / m as f64);
sum += term;
if term < 1e-12 * sum {
break;
}
}
sum as f32
}
fn kb(d: f32, i0_beta: f32) -> f32 {
let t = 1.0 - (d / KW) * (d / KW);
if t <= 0.0 {
0.0
} else {
bessel_i0(BETA * t.sqrt()) / i0_beta
}
}
fn apod(i: usize, m: usize) -> f32 {
let x = (i as f32 - m as f32 / 2.0) / m as f32; let w = 2.0 * KW;
let a = (std::f32::consts::PI * w * x).powi(2) - BETA * BETA;
if a > 1e-6 {
let s = a.sqrt();
s.sin() / s
} else if a < -1e-6 {
let s = (-a).sqrt();
s.sinh() / s
} else {
1.0
}
}
fn quadrant_swap(g: &mut [Complex32], m: usize) {
let h = m / 2;
for y in 0..h {
for x in 0..m {
let a = y * m + x;
let b = ((y + h) % m) * m + ((x + h) % m);
g.swap(a, b);
}
}
}
pub fn gridrec(sino: &Tomo<f32>, geom: &Geometry, n: usize, fft: &dyn Fft) -> Result<Array3<f32>> {
let b = sino.as_layout(crate::data::Layout::Sinogram);
let nz = b.n_rows();
let nang = b.n_angles();
let ncols = b.n_cols();
let pad = (2 * ncols).next_power_of_two();
let m = pad; let two_pi = 2.0 * std::f32::consts::PI;
let i0_beta = bessel_i0(BETA);
let trig: Vec<(f32, f32)> = geom
.angles
.0
.iter()
.map(|&a| a.sin_cos())
.map(|(s, c)| (c, s))
.collect();
let rho: Vec<f32> = (0..pad)
.map(|k| {
if k <= pad / 2 {
k as f32
} else {
k as f32 - pad as f32
}
})
.collect();
let ramp_scale = std::f32::consts::PI / nang as f32;
let kb_ft_norm = 2.0 * KW / i0_beta;
let deapod: Vec<f32> = (0..m).map(|i| apod(i, m) * kb_ft_norm).collect();
let bdata = b
.array
.as_slice()
.expect("contiguous sinogram (to_layout yields a standard-layout copy)");
let mut out = Array3::<f32>::zeros((nz, n, n));
let off = (m - n) / 2;
let pad_side = pad / 2 - ncols / 2;
let process_row = |row: usize, mut slab: ArrayViewMut2<f32>| -> Result<()> {
let mut radial = vec![Complex32::new(0.0, 0.0); nang * pad];
for ia in 0..nang {
let src = row * nang * ncols + ia * ncols;
let dst = ia * pad;
let first = bdata[src];
let last = bdata[src + ncols - 1];
for slot in radial[dst..dst + pad_side].iter_mut() {
*slot = Complex32::new(first, 0.0);
}
for j in 0..ncols {
radial[dst + pad_side + j] = Complex32::new(bdata[src + j], 0.0);
}
for slot in radial[dst + pad_side + ncols..dst + pad].iter_mut() {
*slot = Complex32::new(last, 0.0);
}
}
fft.fft_1d(&mut radial, pad, nang, false)?;
let center = geom.center.at(row) + pad_side as f32;
let mut grid = vec![Complex32::new(0.0, 0.0); m * m];
let half = m as f32 / 2.0;
for ia in 0..nang {
let (c, s) = trig[ia];
for k in 0..pad {
let r = rho[k];
let ramp = r.abs() * ramp_scale;
if ramp == 0.0 {
continue;
}
let phase = two_pi * r * center / pad as f32;
let shift = Complex32::new(phase.cos(), phase.sin());
let val = radial[ia * pad + k] * shift * ramp;
let gx = half + r * c;
let gy = half + r * s;
let ix0 = (gx - KW).ceil() as isize;
let ix1 = (gx + KW).floor() as isize;
let iy0 = (gy - KW).ceil() as isize;
let iy1 = (gy + KW).floor() as isize;
for iy in iy0..=iy1 {
if iy < 0 || iy as usize >= m {
continue;
}
let wy = kb((iy as f32 - gy).abs(), i0_beta);
if wy == 0.0 {
continue;
}
let base = iy as usize * m;
for ix in ix0..=ix1 {
if ix < 0 || ix as usize >= m {
continue;
}
let w = wy * kb((ix as f32 - gx).abs(), i0_beta);
if w != 0.0 {
grid[base + ix as usize] += val * w;
}
}
}
}
}
quadrant_swap(&mut grid, m);
fft.fft_2d(&mut grid, m, m, 1, true)?;
quadrant_swap(&mut grid, m);
let r2max = (ncols as f32 / 2.0) * (ncols as f32 / 2.0);
for iy in 0..n {
let gy = off + iy;
let dy = gy as f32 - m as f32 / 2.0;
for ix in 0..n {
let gx = off + ix;
let dx = gx as f32 - m as f32 / 2.0;
slab[[iy, ix]] = if dx * dx + dy * dy < r2max {
let de = deapod[gy] * deapod[gx];
let v = grid[gy * m + gx].re;
if de.abs() > 1e-6 {
v / de
} else {
v
}
} else {
0.0
};
}
}
Ok(())
};
fft.for_each_slice(&mut out, &process_row)?;
Ok(out)
}