use ndarray::{Array3, ArrayViewMut2, Axis};
use crate::data::{Frames, Tomo, Volume};
use crate::dtype::{Complex32, Dtype, Element};
use crate::error::{Error, Result};
use crate::geometry::{Beam, Geometry};
use crate::params::{FilterName, StripeMethod};
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum DeviceKind {
Cpu,
Cuda,
Wgpu,
}
pub trait DeviceBuffer<T: Element> {
fn len(&self) -> usize;
fn is_empty(&self) -> bool {
self.len() == 0
}
fn copy_from_host(&mut self, src: &[T]) -> Result<()>;
fn copy_to_host(&self, dst: &mut [T]) -> Result<()>;
}
pub trait HostBuffer: Send {
fn as_mut_slice(&mut self) -> &mut [f32];
fn as_slice(&self) -> &[f32];
}
pub(crate) struct VecHostBuffer(Vec<f32>);
impl VecHostBuffer {
pub(crate) fn new(len: usize) -> Self {
VecHostBuffer(vec![0.0f32; len])
}
}
impl HostBuffer for VecHostBuffer {
fn as_mut_slice(&mut self) -> &mut [f32] {
&mut self.0
}
fn as_slice(&self) -> &[f32] {
&self.0
}
}
pub trait Backend: Send + Sync {
fn name(&self) -> &'static str;
fn device(&self) -> DeviceKind;
fn supports(&self, dt: Dtype) -> bool;
fn fft(&self) -> Option<&dyn Fft> {
None
}
fn fbp_filter(&self) -> Option<&dyn FbpFilter> {
None
}
fn backprojector(&self) -> Option<&dyn FilteredBackproject> {
None
}
fn fourier_reconstruct(&self) -> Option<&dyn FourierReconstruct> {
None
}
fn analytic_reconstruct(&self) -> Option<&dyn AnalyticReconstruct> {
None
}
fn lprec_reconstruct(&self) -> Option<&dyn LpRecReconstruct> {
None
}
fn projector(&self) -> Option<&dyn ForwardProject> {
None
}
fn ray_projector(&self) -> Option<&dyn RayProject> {
None
}
fn iterative_reconstruct(&self) -> Option<&dyn IterativeReconstruct> {
None
}
fn elementwise(&self) -> Option<&dyn Elementwise> {
None
}
fn rank_filter(&self) -> Option<&dyn RankFilter> {
None
}
fn alloc_host_buffer(&self, len: usize) -> Box<dyn HostBuffer> {
Box::new(VecHostBuffer::new(len))
}
fn wants_raw_chunks(&self) -> bool {
false
}
}
pub trait Fft: Send + Sync {
fn for_each_slice(
&self,
out: &mut Array3<f32>,
f: &(dyn Fn(usize, ArrayViewMut2<f32>) -> Result<()> + Sync),
) -> Result<()> {
for (row, slab) in out.axis_iter_mut(Axis(0)).enumerate() {
f(row, slab)?;
}
Ok(())
}
fn fft_1d(&self, buf: &mut [Complex32], len: usize, batch: usize, inverse: bool) -> Result<()>;
fn fft_2d(
&self,
buf: &mut [Complex32],
rows: usize,
cols: usize,
batch: usize,
inverse: bool,
) -> Result<()>;
}
pub trait FbpFilter {
fn make_filter(&self, name: FilterName, n: usize) -> Result<Vec<f32>>;
fn apply(&self, sino: &mut Tomo<f32>, filter: &[f32], geom: &Geometry) -> Result<()>;
}
fn invert_matrix(a: &[Vec<f64>]) -> Vec<Vec<f64>> {
let n = a.len();
let mut m: Vec<Vec<f64>> = (0..n)
.map(|i| {
let mut row = a[i].clone();
row.extend((0..n).map(|j| if i == j { 1.0 } else { 0.0 }));
row
})
.collect();
for col in 0..n {
let mut piv = col;
for r in (col + 1)..n {
if m[r][col].abs() > m[piv][col].abs() {
piv = r;
}
}
m.swap(col, piv);
let inv_d = 1.0 / m[col][col];
for v in m[col].iter_mut() {
*v *= inv_d;
}
let pivot_row = m[col].clone();
for (r, row) in m.iter_mut().enumerate() {
if r != col {
let factor = row[col];
if factor != 0.0 {
for (slot, &pv) in row.iter_mut().zip(pivot_row.iter()) {
*slot -= factor * pv;
}
}
}
}
}
m.into_iter().map(|row| row[n..].to_vec()).collect()
}
fn wint_ramp(order: usize, t: &[f64]) -> Vec<f64> {
let n = order;
let big_n = t.len();
debug_assert!(big_n >= n, "wint_ramp needs at least `order` samples");
let s: Vec<f64> = (0..n)
.map(|i| 1e-40 + (1.0 - 1e-40) * i as f64 / (n as f64 - 1.0))
.collect();
let logs: Vec<f64> = s.iter().map(|&x| x.ln()).collect();
let v: Vec<Vec<f64>> = (0..n)
.map(|i| (0..n).map(|j| (i as f64 * logs[j]).exp()).collect())
.collect();
let iv = invert_matrix(&v);
let anti = |i: usize, j: usize| ((i as f64 + 1.0) * logs[j]).exp() / (i as f64 + 1.0);
let u: Vec<Vec<f64>> = (0..=n)
.map(|i| (0..n - 1).map(|j| anti(i, j + 1) - anti(i, j)).collect())
.collect();
let mut w1 = vec![vec![0.0f64; n - 1]; n];
let mut w2 = vec![vec![0.0f64; n - 1]; n];
for r in 0..n {
for c in 0..n - 1 {
let (mut a1, mut a2) = (0.0, 0.0);
for k in 0..n {
a1 += iv[r][k] * u[k + 1][c];
a2 += iv[r][k] * u[k][c];
}
w1[r][c] = a1;
w2[r][c] = a2;
}
}
let mut p = Vec::with_capacity(big_n - 1);
for i in 1..n {
p.push(1.0 / i as f64);
}
let mid = big_n as isize - 2 * (n as isize - 1) - 1;
for _ in 0..mid.max(0) {
p.push(1.0 / (n as f64 - 1.0));
}
for i in (1..n).rev() {
p.push(1.0 / i as f64);
}
let mut w = vec![0.0f64; big_n];
for j in 0..=(big_n - n) {
let dt = t[j + n - 1] - t[j];
for k in 0..n - 1 {
let pjk = p[j + k];
for row in 0..n {
w[j + row] += pjk * (dt * dt * w1[row][k] + dt * t[j] * w2[row][k]);
}
}
}
if big_n >= 40 {
let anchor = big_n - 40;
let base = w[anchor] / anchor as f64;
for (kk, slot) in w.iter_mut().enumerate().skip(anchor) {
*slot = base * kk as f64;
}
}
w
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum RampShape {
Linear,
Wint,
}
pub fn make_fbp_filter(name: FilterName, n: usize, shape: RampShape) -> Result<Vec<f32>> {
if n == 0 {
return Err(crate::error::Error::InvalidParam(
"filter length must be > 0".into(),
));
}
let pad = (4 * n).next_power_of_two();
let nhalf = pad / 2 + 1;
const ORDER: usize = 12;
const WINT_MIN: usize = 2 * ORDER - 1;
let ramp_half: Vec<f32> = if name == FilterName::None {
Vec::new()
} else if shape == RampShape::Wint && nhalf >= WINT_MIN {
let t: Vec<f64> = (0..nhalf).map(|k| k as f64 / pad as f64).collect();
wint_ramp(ORDER, &t)
.iter()
.map(|&wk| (pad as f64 * wk) as f32)
.collect()
} else {
(0..nhalf).map(|k| k as f32 / pad as f32).collect()
};
let mut f = vec![0.0f32; pad];
for (k, slot) in f.iter_mut().enumerate() {
let fk = if k <= pad / 2 { k } else { pad - k };
let r = 2.0 * fk as f32 / pad as f32;
if name == FilterName::None {
*slot = 1.0; continue;
}
let ramp = ramp_half[fk];
let mut v = apodize(name, ramp, r);
if k == 0 {
v *= 2.0;
}
*slot = v;
}
Ok(f)
}
fn apodize(name: FilterName, ramp: f32, r: f32) -> f32 {
let pi = std::f32::consts::PI;
let v = match name {
FilterName::None | FilterName::Ramp => ramp,
FilterName::Shepp => {
let x = pi * r / 2.0;
if x == 0.0 {
ramp
} else {
ramp * (x.sin() / x)
}
}
FilterName::Cosine => ramp * (pi * r / 2.0).cos(),
FilterName::Cosine2 => {
let c = (pi * r / 2.0).cos();
ramp * c * c
}
FilterName::Hamming => ramp * (0.54 + 0.46 * (pi * r).cos()),
FilterName::Hann => ramp * 0.5 * (1.0 + (pi * r).cos()),
FilterName::Parzen => ramp * (1.0 - r).powi(3),
};
if v < 0.0 {
0.0
} else {
v
}
}
pub trait AnalyticReconstruct {
fn reconstruct(
&self,
sino: &Tomo<f32>,
geom: &Geometry,
algorithm: crate::params::Algorithm,
params: &crate::params::ReconParams,
) -> Result<Volume<f32>>;
fn streaming(
&self,
_algorithm: crate::params::Algorithm,
_params: &crate::params::ReconParams,
_geom: &Geometry,
_ncols: usize,
_max_nz: usize,
) -> Result<Option<Box<dyn StreamingAnalytic>>> {
Ok(None)
}
}
pub trait StreamingAnalytic {
fn reconstruct_chunk(&mut self, sino: &Tomo<f32>, geom: &Geometry) -> Result<Volume<f32>>;
fn reconstruct_chunk_raw(
&mut self,
_data: &[f32],
_dims: (usize, usize, usize),
_flat: Option<&Frames<f32>>,
_dark: Option<&Frames<f32>>,
_geom: &Geometry,
_stripe: StripeMethod,
) -> Result<Option<Volume<f32>>> {
Ok(None)
}
fn give_reuse_buffer(&mut self, _buf: Vec<f32>) {}
}
pub trait FourierReconstruct {
fn reconstruct(&self, filtered: &Tomo<f32>, geom: &Geometry, n: usize) -> Result<Volume<f32>>;
}
pub trait LpRecReconstruct {
fn reconstruct(&self, filtered: &Tomo<f32>, geom: &Geometry, n: usize) -> Result<Volume<f32>>;
}
pub trait FilteredBackproject {
fn backproject(&self, sino: &Tomo<f32>, geom: &Geometry, out: &mut Volume<f32>) -> Result<()>;
}
pub trait ForwardProject {
fn project(&self, vol: &Volume<f32>, geom: &Geometry, out: &mut Tomo<f32>) -> Result<()>;
}
#[derive(Clone, Debug, Default)]
pub struct RayRow {
pub pixels: Vec<u32>,
pub weights: Vec<f32>,
}
pub trait RayProject {
fn ray_rows(&self, geom: &Geometry, n: usize) -> Result<Vec<Vec<RayRow>>>;
}
pub(crate) fn parallel_ray_rows(geom: &Geometry, n: usize) -> Result<Vec<Vec<RayRow>>> {
if geom.beam != Beam::Parallel {
return Err(Error::InvalidParam(
"row-action projection currently supports parallel beam only".into(),
));
}
let nang = geom.angles.0.len();
let ncols = geom.detector.width;
if nang == 0 || ncols == 0 {
return Err(Error::InvalidParam(
"geometry has no angles or zero detector width".into(),
));
}
let center = geom.center.at(0);
let c0 = n as f32 / 2.0; let mut rows: Vec<Vec<RayRow>> = (0..nang).map(|_| vec![RayRow::default(); ncols]).collect();
for (ia, &a) in geom.angles.0.iter().enumerate() {
let (sn, cs) = a.sin_cos();
let arows = &mut rows[ia];
for iy in 0..n {
let gy = iy as f32 - c0;
for ix in 0..n {
let gx = ix as f32 - c0;
let t = gx * cs + gy * sn + center;
let t0 = t.floor();
let i0 = t0 as isize;
if i0 >= 0 && (i0 as usize) + 1 < ncols {
let frac = t - t0;
let pix = (iy * n + ix) as u32;
let d0 = i0 as usize;
arows[d0].pixels.push(pix);
arows[d0].weights.push(1.0 - frac);
arows[d0 + 1].pixels.push(pix);
arows[d0 + 1].weights.push(frac);
}
}
}
}
Ok(rows)
}
pub trait IterativeReconstruct {
fn solve(
&self,
sino: &Tomo<f32>,
geom: &Geometry,
algorithm: crate::params::Algorithm,
params: &crate::params::ReconParams,
) -> Result<Option<Volume<f32>>>;
}
pub trait Elementwise {
fn darkflat(&self, data: &mut Tomo<f32>, flat: &Frames<f32>, dark: &Frames<f32>) -> Result<()>;
fn minus_log(&self, data: &mut Tomo<f32>) -> Result<()>;
}
pub trait RankFilter {
fn median3d(&self, vol: &mut Volume<f32>, size: usize) -> Result<()>;
fn remove_outlier3d(&self, data: &mut Tomo<f32>, diff: f32, size: usize) -> Result<()>;
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn wint_ramp_matches_tomocupy_golden() {
let ne = 512usize;
let t: Vec<f64> = (0..ne / 2 + 1).map(|k| k as f64 / ne as f64).collect();
let w = wint_ramp(12, &t);
let golden: &[(usize, f64)] = &[
(0, 2.453569604067e-07),
(1, 4.042956064990e-06),
(2, 7.660118337826e-06),
(3, 9.761576171718e-06),
(4, 2.031827452663e-05),
(5, 1.049037500880e-05),
(6, 3.259454732421e-05),
(7, 1.901878617086e-05),
(8, 3.484518329315e-05),
(9, 3.256638900053e-05),
(10, 3.873577972859e-05),
(11, 4.168480391830e-05),
(12, 4.608636383489e-05),
(13, 4.912083786810e-05),
(64, 2.441406251635e-04),
(128, 4.882812503246e-04),
(200, 7.629394536308e-04),
(216, 8.239746099211e-04),
(217, 8.277893071893e-04),
(256, 9.765625006472e-04),
];
for &(i, g) in golden {
let rel = (w[i] - g).abs() / g.abs();
assert!(
rel < 1e-5,
"wint[{i}] = {:.12e}, golden {:.12e}, rel {:.2e}",
w[i],
g,
rel
);
}
}
}