#![forbid(unsafe_code)]
pub mod center;
pub(crate) mod fourierrec;
mod gridrec;
pub mod lamino;
pub(crate) mod lprec;
pub mod ring;
pub mod tilt_flow;
pub mod vector;
use crate::backend::{Backend, FilteredBackproject, ForwardProject, RayProject, RayRow};
use crate::data::{Layout, Tomo, Volume};
use crate::error::{Error, Result};
use crate::geometry::{Angles, Beam, Center, Geometry};
use crate::params::{Algorithm, ReconParams};
use ndarray::{Array3, Axis};
fn missing(capability: &'static str, backend: &dyn Backend) -> Error {
Error::MissingCapability {
backend: backend.name(),
capability,
}
}
pub fn recon(
sino: &Tomo<f32>,
geom: &Geometry,
algorithm: Algorithm,
params: &ReconParams,
backend: &dyn Backend,
) -> Result<Volume<f32>> {
if algorithm.is_analytic() {
analytic(sino, geom, algorithm, params, backend)
} else {
iterative(sino, geom, algorithm, params, backend)
}
}
fn grid_size(sino: &Tomo<f32>, params: &ReconParams) -> usize {
params.num_gridx.unwrap_or_else(|| sino.n_cols())
}
fn init_volume(params: &ReconParams, nz: usize, n: usize, default: f32) -> Result<Volume<f32>> {
match ¶ms.init {
Some(v) => {
if v.dims() != (nz, n, n) {
return Err(Error::ShapeMismatch {
expected: format!("init volume [{nz}, {n}, {n}]"),
found: format!("{:?}", v.dims()),
});
}
Ok(v.clone())
}
None => Ok(Volume::new(Array3::from_elem((nz, n, n), default))),
}
}
fn analytic(
sino: &Tomo<f32>,
geom: &Geometry,
algorithm: Algorithm,
params: &ReconParams,
backend: &dyn Backend,
) -> Result<Volume<f32>> {
let n = grid_size(sino, params);
let nz = sino.n_rows();
if algorithm == Algorithm::Gridrec {
let fft = backend.fft().ok_or_else(|| missing("Fft", backend))?;
return Ok(Volume::new(gridrec::gridrec(sino, geom, n, fft)?));
}
if matches!(
algorithm,
Algorithm::Fbp | Algorithm::Linerec | Algorithm::Fourierrec
) {
if let Some(ar) = backend.analytic_reconstruct() {
return ar.reconstruct(sino, geom, algorithm, params);
}
}
let filt = backend
.fbp_filter()
.ok_or_else(|| missing("FbpFilter", backend))?;
let kernel = filt.make_filter(params.filter_name, sino.n_cols())?;
let mut filtered = sino.clone();
filt.apply(&mut filtered, &kernel, geom)?;
if algorithm == Algorithm::Fourierrec {
if let Some(fr) = backend.fourier_reconstruct() {
return fr.reconstruct(&filtered, geom, n);
}
let fft = backend.fft().ok_or_else(|| missing("Fft", backend))?;
return Ok(Volume::new(fourierrec::fourierrec(
&filtered, geom, n, fft,
)?));
}
if algorithm == Algorithm::Lprec {
if let Some(lr) = backend.lprec_reconstruct() {
return lr.reconstruct(&filtered, geom, n);
}
let fft = backend.fft().ok_or_else(|| missing("Fft", backend))?;
return Ok(Volume::new(lprec::lprec(&filtered, geom, n, fft)?));
}
let bp = backend
.backprojector()
.ok_or_else(|| missing("FilteredBackproject", backend))?;
let centered = Geometry {
center: Center::Scalar(sino.n_cols() as f32 / 2.0),
..geom.clone()
};
let mut vol = Volume::new(Array3::zeros((nz, n, n)));
bp.backproject(&filtered, ¢ered, &mut vol)?;
let dtheta = std::f32::consts::PI / sino.n_angles() as f32;
vol.array.mapv_inplace(|v| v * dtheta);
Ok(vol)
}
fn iterative(
sino: &Tomo<f32>,
geom: &Geometry,
algorithm: Algorithm,
params: &ReconParams,
backend: &dyn Backend,
) -> Result<Volume<f32>> {
if params.init.is_some() && matches!(algorithm, Algorithm::Art | Algorithm::Bart) {
return Err(Error::InvalidParam(
"warm-start `init` is not supported for row-action ART/BART".into(),
));
}
if params.ext_pad {
return ext_pad_solve(sino, geom, algorithm, params, backend);
}
if matches!(algorithm, Algorithm::Art | Algorithm::Bart) {
let rp = backend
.ray_projector()
.ok_or_else(|| missing("RayProject", backend))?;
return match algorithm {
Algorithm::Art => art(sino, geom, params, rp),
_ => bart(sino, geom, params, rp),
};
}
if let Some(it) = backend.iterative_reconstruct() {
if let Some(vol) = it.solve(sino, geom, algorithm, params)? {
return Ok(vol);
}
}
if matches!(geom.beam, Beam::Laminography { .. })
&& matches!(
algorithm,
Algorithm::Cgls | Algorithm::Grad | Algorithm::Tikh
)
{
return Err(Error::InvalidParam(format!(
"laminography iterative reconstruction does not support {algorithm:?}: its \
per-slice step size assumes parallel-beam slice-separability; use \
SIRT/MLEM/OSEM/OSPML/PML/TV"
)));
}
let proj = backend
.projector()
.ok_or_else(|| missing("ForwardProject", backend))?;
let bp = backend
.backprojector()
.ok_or_else(|| missing("FilteredBackproject", backend))?;
match algorithm {
Algorithm::Sirt => sirt(sino, geom, params, proj, bp),
Algorithm::Mlem => mlem(sino, geom, params, proj, bp),
Algorithm::Osem => osem(sino, geom, params, proj, bp),
Algorithm::OspmlQuad => ospml(sino, geom, params, proj, bp, params.num_block, None),
Algorithm::PmlQuad => ospml(sino, geom, params, proj, bp, 1, None),
Algorithm::OspmlHybrid => ospml(
sino,
geom,
params,
proj,
bp,
params.num_block,
params.reg_par.get(1).copied(),
),
Algorithm::PmlHybrid => ospml(
sino,
geom,
params,
proj,
bp,
1,
params.reg_par.get(1).copied(),
),
Algorithm::Grad => grad(sino, geom, params, proj, bp),
Algorithm::Tikh => tikh(sino, geom, params, proj, bp),
Algorithm::Cgls => cgls(sino, geom, params, proj, bp),
Algorithm::Tv => tv(sino, geom, params, proj, bp),
Algorithm::Vector => Err(Error::InvalidParam(
"vector tomography is not a scalar reconstruction; call \
crate::recon::vector::{vector,vector2,vector3} directly"
.into(),
)),
_ => unreachable!("non-iterative algorithm reached iterative dispatch"),
}
}
fn ext_pad_solve(
sino: &Tomo<f32>,
geom: &Geometry,
algorithm: Algorithm,
params: &ReconParams,
backend: &dyn Backend,
) -> Result<Volume<f32>> {
let b = sino.as_layout(Layout::Sinogram);
let (nz, nang, ncols) = (b.n_rows(), b.n_angles(), b.n_cols());
let n = grid_size(sino, params);
let pad = (ncols / 4).max(1);
let ncols_ext = ncols + 2 * pad;
let n_ext = n + 2 * pad;
let mut ext = Array3::<f32>::zeros((nz, nang, ncols_ext));
for iz in 0..nz {
for ia in 0..nang {
let src = b.array.index_axis(Axis(0), iz);
let row = src.index_axis(Axis(0), ia);
let mut dst = ext.index_axis_mut(Axis(0), iz);
let mut dst = dst.index_axis_mut(Axis(0), ia);
let (first, last) = (row[0], row[ncols - 1]);
for j in 0..pad {
dst[j] = first;
dst[pad + ncols + j] = last;
}
for j in 0..ncols {
dst[pad + j] = row[j];
}
}
}
let sino_ext = Tomo::new(ext, Layout::Sinogram);
let mut geom_ext = geom.clone();
geom_ext.detector.width = ncols_ext;
geom_ext.center = match &geom.center {
Center::Scalar(c) => Center::Scalar(c + pad as f32),
Center::PerRow(v) => Center::PerRow(v.iter().map(|c| c + pad as f32).collect()),
};
let core = ndarray::Slice::from(pad..pad + n);
let embed = |src: &Array3<f32>| -> Array3<f32> {
let mut out = Array3::<f32>::zeros((nz, n_ext, n_ext));
let mut view = out.slice_axis_mut(Axis(1), core);
view.slice_axis_mut(Axis(2), core).assign(src);
out
};
let mut params_ext = params.clone();
params_ext.ext_pad = false; params_ext.num_gridx = Some(n_ext);
params_ext.num_gridy = params.num_gridy.map(|_| n_ext);
if let Some(v) = ¶ms.init {
if v.dims() != (nz, n, n) {
return Err(Error::ShapeMismatch {
expected: format!("init volume [{nz}, {n}, {n}]"),
found: format!("{:?}", v.dims()),
});
}
params_ext.init = Some(Volume::new(embed(&v.array)));
}
if params.reg_data.len() == nz * n * n {
let prior =
Array3::from_shape_vec((nz, n, n), params.reg_data.clone()).expect("len checked above");
params_ext.reg_data = embed(&prior).into_raw_vec_and_offset().0;
}
let vol = iterative(&sino_ext, &geom_ext, algorithm, ¶ms_ext, backend)?;
Ok(Volume::new(
vol.array
.slice_axis(Axis(1), core)
.slice_axis(Axis(2), core)
.to_owned(),
))
}
fn sirt(
sino: &Tomo<f32>,
geom: &Geometry,
params: &ReconParams,
proj: &dyn ForwardProject,
bp: &dyn FilteredBackproject,
) -> Result<Volume<f32>> {
let n = grid_size(sino, params);
let nz = sino.n_rows();
let b = sino.as_layout(Layout::Sinogram);
let nang = b.n_angles();
let ncols = b.n_cols();
let ones_img = Volume::new(Array3::from_elem((nz, n, n), 1.0));
let mut ray = Tomo::new(Array3::zeros((nz, nang, ncols)), Layout::Sinogram);
proj.project(&ones_img, geom, &mut ray)?;
let rw = ray
.array
.mapv(|v| if v.abs() > 1e-6 { 1.0 / v } else { 0.0 });
let ones_sino = Tomo::new(Array3::from_elem((nz, nang, ncols), 1.0), Layout::Sinogram);
let mut sens = Volume::new(Array3::zeros((nz, n, n)));
bp.backproject(&ones_sino, geom, &mut sens)?;
let cw = sens
.array
.mapv(|v| if v.abs() > 1e-6 { 1.0 / v } else { 0.0 });
let mut vol = init_volume(params, nz, n, 0.0)?;
let mut ax = Tomo::new(Array3::zeros((nz, nang, ncols)), Layout::Sinogram);
let mut corr = Volume::new(Array3::zeros((nz, n, n)));
for _ in 0..params.num_iter.max(1) {
proj.project(&vol, geom, &mut ax)?; let mut resid = &b.array - &ax.array; resid *= &rw; bp.backproject(&Tomo::new(resid, Layout::Sinogram), geom, &mut corr)?;
vol.array += &(&cw * &corr.array); }
Ok(vol)
}
fn mlem(
sino: &Tomo<f32>,
geom: &Geometry,
params: &ReconParams,
proj: &dyn ForwardProject,
bp: &dyn FilteredBackproject,
) -> Result<Volume<f32>> {
let n = grid_size(sino, params);
let nz = sino.n_rows();
let b = sino.as_layout(Layout::Sinogram);
let nang = b.n_angles();
let ncols = b.n_cols();
let ones_sino = Tomo::new(Array3::from_elem((nz, nang, ncols), 1.0), Layout::Sinogram);
let mut sens = Volume::new(Array3::zeros((nz, n, n)));
bp.backproject(&ones_sino, geom, &mut sens)?;
let mut vol = init_volume(params, nz, n, 1.0)?; let mut ax = Tomo::new(Array3::zeros((nz, nang, ncols)), Layout::Sinogram);
let mut corr = Volume::new(Array3::zeros((nz, n, n)));
for _ in 0..params.num_iter.max(1) {
proj.project(&vol, geom, &mut ax)?; let mut ratio = b.array.clone();
ndarray::Zip::from(&mut ratio)
.and(&ax.array)
.for_each(|r, &a| {
*r = if a.abs() > 1e-6 { *r / a } else { 0.0 }; });
bp.backproject(&Tomo::new(ratio, Layout::Sinogram), geom, &mut corr)?;
ndarray::Zip::from(&mut vol.array)
.and(&corr.array)
.and(&sens.array)
.for_each(|x, &c, &s| {
if s.abs() > 1e-6 {
*x = *x * c / s; }
});
}
Ok(vol)
}
pub(crate) fn ordered_subsets(nang: usize, params: &ReconParams) -> Vec<Vec<usize>> {
let num_block = params.num_block.clamp(1, nang.max(1));
let order: Vec<usize> = if params.ind_block.len() == nang {
params.ind_block.iter().map(|&i| i as usize).collect()
} else {
(0..nang).collect()
};
let blocksize = nang / num_block;
let remainder = nang % num_block;
let mut subsets = Vec::with_capacity(num_block);
let mut start = 0;
for os in 0..num_block {
let len = blocksize + usize::from(os < remainder);
subsets.push(order[start..start + len].to_vec());
start += len;
}
subsets
}
struct OsSubset {
geom: Geometry,
b: Array3<f32>,
sens: Array3<f32>,
}
fn build_subsets(
b: &Tomo<f32>,
geom: &Geometry,
n: usize,
block_params: &ReconParams,
bp: &dyn FilteredBackproject,
) -> Result<Vec<OsSubset>> {
let nz = b.n_rows();
let ncols = b.n_cols();
let nang = b.n_angles();
let mut subsets = Vec::new();
for idx in ordered_subsets(nang, block_params) {
let len = idx.len();
let mut sub_geom = geom.clone();
sub_geom.angles = Angles(idx.iter().map(|&p| geom.angles.0[p]).collect());
let sub_b = b
.array
.select(Axis(1), &idx)
.as_standard_layout()
.into_owned();
let ones = Tomo::new(Array3::from_elem((nz, len, ncols), 1.0), Layout::Sinogram);
let mut sens = Volume::new(Array3::zeros((nz, n, n)));
bp.backproject(&ones, &sub_geom, &mut sens)?;
subsets.push(OsSubset {
geom: sub_geom,
b: sub_b,
sens: sens.array,
});
}
Ok(subsets)
}
fn subset_em_correction(
vol: &Volume<f32>,
sub: &OsSubset,
proj: &dyn ForwardProject,
bp: &dyn FilteredBackproject,
corr: &mut Volume<f32>,
) -> Result<()> {
let nz = vol.dims().0;
let len = sub.geom.angles.0.len();
let ncols = sub.b.shape()[2];
let mut ax = Tomo::new(Array3::zeros((nz, len, ncols)), Layout::Sinogram);
proj.project(vol, &sub.geom, &mut ax)?; let mut ratio = sub.b.clone();
ndarray::Zip::from(&mut ratio)
.and(&ax.array)
.for_each(|r, &a| {
*r = if a.abs() > 1e-6 { *r / a } else { 0.0 }; });
bp.backproject(&Tomo::new(ratio, Layout::Sinogram), &sub.geom, corr)
}
fn osem(
sino: &Tomo<f32>,
geom: &Geometry,
params: &ReconParams,
proj: &dyn ForwardProject,
bp: &dyn FilteredBackproject,
) -> Result<Volume<f32>> {
let n = grid_size(sino, params);
let b = sino.as_layout(Layout::Sinogram);
let nz = b.n_rows();
let subsets = build_subsets(&b, geom, n, params, bp)?;
let mut vol = init_volume(params, nz, n, 1.0)?; let mut corr = Volume::new(Array3::zeros((nz, n, n)));
for _ in 0..params.num_iter.max(1) {
for sub in &subsets {
subset_em_correction(&vol, sub, proj, bp, &mut corr)?;
ndarray::Zip::from(&mut vol.array)
.and(&corr.array)
.and(&sub.sens)
.for_each(|x, &c, &s| {
if s.abs() > 1e-6 {
*x = *x * c / s; }
});
}
}
Ok(vol)
}
fn penalized_ml_update(
x: &mut ndarray::ArrayViewMut2<f32>,
corr: &ndarray::ArrayView2<f32>,
sens: &ndarray::ArrayView2<f32>,
reg: f32,
delta: Option<f32>,
) {
const S: f32 = std::f32::consts::FRAC_1_SQRT_2;
const NEIGHBORS: [(isize, isize, f32); 8] = [
(-1, 0, 1.0),
(1, 0, 1.0),
(0, -1, 1.0),
(0, 1, 1.0),
(-1, -1, S),
(-1, 1, S),
(1, -1, S),
(1, 1, S),
];
let (h, w) = x.dim();
let old = x.to_owned();
for i in 0..h {
for j in 0..w {
let xij = old[[i, j]];
let e = -xij * corr[[i, j]];
let (mut f, mut g) = (0.0f32, sens[[i, j]]);
if reg != 0.0 {
let mut wtot = 0.0f32;
for (di, dj, raw) in NEIGHBORS {
let (ni, nj) = (i as isize + di, j as isize + dj);
if ni >= 0 && ni < h as isize && nj >= 0 && nj < w as isize {
wtot += raw;
}
}
for (di, dj, raw) in NEIGHBORS {
let (ni, nj) = (i as isize + di, j as isize + dj);
if ni >= 0 && ni < h as isize && nj >= 0 && nj < w as isize {
let xg = old[[ni as usize, nj as usize]];
let gamma = match delta {
Some(d) => 1.0 / (1.0 + ((xij - xg) / d).abs()),
None => 1.0,
};
let coef = 2.0 * reg * (raw / wtot) * gamma;
f += coef;
g -= coef * (xij + xg);
}
}
}
x[[i, j]] = if f != 0.0 {
(-g + (g * g - 8.0 * f * e).sqrt()) / (4.0 * f)
} else if g.abs() > 1e-6 {
-e / g } else {
xij
};
}
}
}
fn ospml(
sino: &Tomo<f32>,
geom: &Geometry,
params: &ReconParams,
proj: &dyn ForwardProject,
bp: &dyn FilteredBackproject,
block_count: usize,
delta: Option<f32>,
) -> Result<Volume<f32>> {
let n = grid_size(sino, params);
let b = sino.as_layout(Layout::Sinogram);
let nz = b.n_rows();
let reg = params.reg_par.first().copied().unwrap_or(0.0);
let block_params = ReconParams {
num_block: block_count,
..params.clone()
};
let subsets = build_subsets(&b, geom, n, &block_params, bp)?;
let mut vol = init_volume(params, nz, n, 1.0)?; let mut corr = Volume::new(Array3::zeros((nz, n, n)));
for _ in 0..params.num_iter.max(1) {
for sub in &subsets {
subset_em_correction(&vol, sub, proj, bp, &mut corr)?; for z in 0..nz {
penalized_ml_update(
&mut vol.array.index_axis_mut(Axis(0), z),
&corr.array.index_axis(Axis(0), z),
&sub.sens.index_axis(Axis(0), z),
reg,
delta,
);
}
}
}
Ok(vol)
}
fn gradient_descent(
sino: &Tomo<f32>,
geom: &Geometry,
params: &ReconParams,
proj: &dyn ForwardProject,
bp: &dyn FilteredBackproject,
tikhonov: Option<(f32, Array3<f32>)>,
) -> Result<Volume<f32>> {
let n = grid_size(sino, params);
let b = sino.as_layout(Layout::Sinogram);
let nz = b.n_rows();
let nang = b.n_angles();
let ncols = b.n_cols();
let r = 1.0 / ((ncols * nang) as f32 / 2.0).sqrt();
let fixed_step = params.reg_par.first().copied().unwrap_or(1.0);
let mut vol = init_volume(params, nz, n, 0.0)?;
vol.array.mapv_inplace(|v| v / r);
let mut recon0 = vol.array.clone();
let mut grad0 = Array3::<f32>::zeros((nz, n, n));
let mut ax = Tomo::new(Array3::zeros((nz, nang, ncols)), Layout::Sinogram);
let mut bpv = Volume::new(Array3::zeros((nz, n, n)));
let mut lambda = vec![0.0f32; nz];
for it in 0..params.num_iter.max(1) {
proj.project(&vol, geom, &mut ax)?; let mut prox1 = ax.array.clone();
ndarray::Zip::from(&mut prox1)
.and(&b.array)
.for_each(|p, &d| *p = *p * r - d); bp.backproject(&Tomo::new(prox1, Layout::Sinogram), geom, &mut bpv)?;
let mut grad = bpv.array.mapv(|v| 2.0 * r * v);
if let Some((reg1, ref prior)) = tikhonov {
ndarray::Zip::from(&mut grad)
.and(&vol.array)
.and(prior)
.for_each(|g, &x, &p0| *g += 2.0 * reg1 * (x - p0));
}
for (z, lam) in lambda.iter_mut().enumerate() {
*lam = if fixed_step >= 0.0 {
fixed_step
} else if it == 0 {
1e-3
} else {
let (mut num, mut den) = (0.0f32, 0.0f32);
ndarray::Zip::from(vol.array.index_axis(Axis(0), z))
.and(recon0.index_axis(Axis(0), z))
.and(grad.index_axis(Axis(0), z))
.and(grad0.index_axis(Axis(0), z))
.for_each(|&x, &x0, &g, &g0| {
let dg = g - g0;
num += (x - x0) * dg;
den += dg * dg;
});
if den != 0.0 {
num / den
} else {
1e-3
}
};
}
recon0 = vol.array.clone();
grad0 = grad.clone();
for (z, &l) in lambda.iter().enumerate() {
ndarray::Zip::from(vol.array.index_axis_mut(Axis(0), z))
.and(grad.index_axis(Axis(0), z))
.for_each(|x, &g| *x -= l * g); }
}
vol.array.mapv_inplace(|v| v * r); Ok(vol)
}
fn grad(
sino: &Tomo<f32>,
geom: &Geometry,
params: &ReconParams,
proj: &dyn ForwardProject,
bp: &dyn FilteredBackproject,
) -> Result<Volume<f32>> {
gradient_descent(sino, geom, params, proj, bp, None)
}
fn tikh(
sino: &Tomo<f32>,
geom: &Geometry,
params: &ReconParams,
proj: &dyn ForwardProject,
bp: &dyn FilteredBackproject,
) -> Result<Volume<f32>> {
let n = grid_size(sino, params);
let nz = sino.n_rows();
let reg1 = params.reg_par.get(1).copied().unwrap_or(0.0);
let prior = if params.reg_data.is_empty() {
Array3::zeros((nz, n, n))
} else {
Array3::from_shape_vec((nz, n, n), params.reg_data.clone()).map_err(|_| {
Error::ShapeMismatch {
expected: format!("reg_data of {nz}ยท{n}ยท{n} = {} elements", nz * n * n),
found: format!("{} elements", params.reg_data.len()),
}
})?
};
gradient_descent(sino, geom, params, proj, bp, Some((reg1, prior)))
}
fn cgls(
sino: &Tomo<f32>,
geom: &Geometry,
params: &ReconParams,
proj: &dyn ForwardProject,
bp: &dyn FilteredBackproject,
) -> Result<Volume<f32>> {
let n = grid_size(sino, params);
let b = sino.as_layout(Layout::Sinogram);
let nz = b.n_rows();
let nang = b.n_angles();
let ncols = b.n_cols();
fn slice_dot(a: &ndarray::ArrayView2<f32>, c: &ndarray::ArrayView2<f32>) -> f32 {
let mut acc = 0.0f32;
ndarray::Zip::from(a).and(c).for_each(|&x, &y| acc += x * y);
acc
}
let mut vol = init_volume(params, nz, n, 0.0)?;
let mut ax = Tomo::new(Array3::zeros((nz, nang, ncols)), Layout::Sinogram);
proj.project(&vol, geom, &mut ax)?;
let mut r = Tomo::new(&b.array - &ax.array, Layout::Sinogram);
let mut z = Volume::new(Array3::zeros((nz, n, n)));
bp.backproject(&r, geom, &mut z)?;
let mut p = z.clone();
let mut gamma: Vec<f32> = (0..nz)
.map(|s| {
let zs = z.array.index_axis(Axis(0), s);
slice_dot(&zs, &zs)
})
.collect();
let mut w = Tomo::new(Array3::zeros((nz, nang, ncols)), Layout::Sinogram);
for _ in 0..params.num_iter.max(1) {
proj.project(&p, geom, &mut w)?; for (s, ws) in w.array.outer_iter().enumerate() {
let wdot = slice_dot(&ws, &ws);
if wdot <= 0.0 || wdot.is_nan() {
continue;
}
let alpha = gamma[s] / wdot;
ndarray::Zip::from(vol.array.index_axis_mut(Axis(0), s))
.and(p.array.index_axis(Axis(0), s))
.for_each(|x, &pv| *x += alpha * pv);
ndarray::Zip::from(r.array.index_axis_mut(Axis(0), s))
.and(ws)
.for_each(|rv, &wv| *rv -= alpha * wv);
}
bp.backproject(&r, geom, &mut z)?; for (s, zs) in z.array.outer_iter().enumerate() {
let gamma_new = slice_dot(&zs, &zs);
let beta = if gamma[s] > 0.0 {
gamma_new / gamma[s]
} else {
0.0
};
gamma[s] = gamma_new;
ndarray::Zip::from(p.array.index_axis_mut(Axis(0), s))
.and(zs)
.for_each(|pv, &zv| *pv = zv + beta * *pv);
}
}
Ok(vol)
}
fn tv(
sino: &Tomo<f32>,
geom: &Geometry,
params: &ReconParams,
proj: &dyn ForwardProject,
bp: &dyn FilteredBackproject,
) -> Result<Volume<f32>> {
let n = grid_size(sino, params);
let b = sino.as_layout(Layout::Sinogram);
let nz = b.n_rows();
let nang = b.n_angles();
let ncols = b.n_cols();
let r = 1.0 / ((ncols * nang) as f32 / 2.0).sqrt();
let lambda = params.reg_par.first().copied().unwrap_or(1.0); const C: f32 = 0.35;
let mut xbar = init_volume(params, nz, n, 0.0)?; xbar.array.mapv_inplace(|v| v / r);
let mut x = xbar.array.clone(); let mut p0x = Array3::<f32>::zeros((nz, n, n)); let mut p0y = Array3::<f32>::zeros((nz, n, n)); let mut pd = Tomo::new(Array3::zeros((nz, nang, ncols)), Layout::Sinogram); let mut ax = Tomo::new(Array3::zeros((nz, nang, ncols)), Layout::Sinogram);
let mut bpv = Volume::new(Array3::zeros((nz, n, n)));
for _ in 0..params.num_iter.max(1) {
proj.project(&xbar, geom, &mut ax)?;
ndarray::Zip::from(&mut pd.array)
.and(&ax.array)
.and(&b.array)
.for_each(|q, &a, &d| *q = (*q + C * r * a - C * d) / (1.0 + C));
bp.backproject(&pd, geom, &mut bpv)?;
for z in 0..nz {
let xb = xbar.array.index_axis(Axis(0), z);
for iy in 0..n.saturating_sub(1) {
for ix in 0..n.saturating_sub(1) {
let px = p0x[[z, iy, ix]] + C * (xb[[iy, ix + 1]] - xb[[iy, ix]]);
let py = p0y[[z, iy, ix]] + C * (xb[[iy + 1, ix]] - xb[[iy, ix]]);
let upd = ((px * px + py * py).sqrt() / lambda).max(1.0);
p0x[[z, iy, ix]] = px / upd;
p0y[[z, iy, ix]] = py / upd;
}
}
for iy in 0..n {
for ix in 0..n {
let x_old = x[[z, iy, ix]];
let mut u = x_old - C * r * bpv.array[[z, iy, ix]];
u += if ix == 0 {
C * p0x[[z, iy, 0]]
} else {
C * (p0x[[z, iy, ix]] - p0x[[z, iy, ix - 1]])
};
u += if iy == 0 {
C * p0y[[z, 0, ix]]
} else {
C * (p0y[[z, iy, ix]] - p0y[[z, iy - 1, ix]])
};
x[[z, iy, ix]] = u;
xbar.array[[z, iy, ix]] = 2.0 * u - x_old;
}
}
}
}
xbar.array.mapv_inplace(|v| v * r); Ok(xbar)
}
fn ray_norms(rows: &[Vec<RayRow>]) -> Vec<Vec<f32>> {
rows.iter()
.map(|ang| {
ang.iter()
.map(|r| r.weights.iter().map(|w| w * w).sum())
.collect()
})
.collect()
}
fn art(
sino: &Tomo<f32>,
geom: &Geometry,
params: &ReconParams,
rp: &dyn RayProject,
) -> Result<Volume<f32>> {
let n = grid_size(sino, params);
let b = sino.as_layout(Layout::Sinogram);
let nz = b.n_rows();
let nang = b.n_angles();
let ncols = b.n_cols();
let rows = rp.ray_rows(geom, n)?;
let norms = ray_norms(&rows);
let bslab = b
.array
.as_slice()
.ok_or_else(|| Error::InvalidParam("non-contiguous sinogram".into()))?;
let npix = n * n;
let mut recon = vec![0.0f32; nz * npix];
for _ in 0..params.num_iter.max(1) {
for ia in 0..nang {
for d in 0..ncols {
let row = &rows[ia][d];
let norm2 = norms[ia][d];
if norm2 == 0.0 {
continue;
}
for s in 0..nz {
let sl = &mut recon[s * npix..(s + 1) * npix];
let mut sim = 0.0f32;
for (k, &pix) in row.pixels.iter().enumerate() {
sim += sl[pix as usize] * row.weights[k];
}
let upd = (bslab[(s * nang + ia) * ncols + d] - sim) / norm2;
for (k, &pix) in row.pixels.iter().enumerate() {
sl[pix as usize] += upd * row.weights[k];
}
}
}
}
}
let array = Array3::from_shape_vec((nz, n, n), recon)
.map_err(|e| Error::InvalidParam(format!("art shape: {e}")))?;
Ok(Volume::new(array))
}
fn bart(
sino: &Tomo<f32>,
geom: &Geometry,
params: &ReconParams,
rp: &dyn RayProject,
) -> Result<Volume<f32>> {
let n = grid_size(sino, params);
let b = sino.as_layout(Layout::Sinogram);
let nz = b.n_rows();
let nang = b.n_angles();
let ncols = b.n_cols();
let rows = rp.ray_rows(geom, n)?;
let norms = ray_norms(&rows);
let subsets = ordered_subsets(nang, params);
let bslab = b
.array
.as_slice()
.ok_or_else(|| Error::InvalidParam("non-contiguous sinogram".into()))?;
let npix = n * n;
let mut recon = vec![0.0f32; nz * npix];
let mut update = vec![0.0f32; npix];
let mut sum_dist = vec![0.0f32; npix];
for _ in 0..params.num_iter.max(1) {
for s in 0..nz {
let sl = &mut recon[s * npix..(s + 1) * npix];
for subset in &subsets {
update.iter_mut().for_each(|u| *u = 0.0);
sum_dist.iter_mut().for_each(|u| *u = 0.0);
for &p in subset {
for d in 0..ncols {
let row = &rows[p][d];
let mut sim = 0.0f32;
for (k, &pix) in row.pixels.iter().enumerate() {
let pix = pix as usize;
sim += sl[pix] * row.weights[k];
sum_dist[pix] += row.weights[k]; }
let norm2 = norms[p][d];
if norm2 != 0.0 {
let upd = (bslab[(s * nang + p) * ncols + d] - sim) / norm2;
for (k, &pix) in row.pixels.iter().enumerate() {
update[pix as usize] += upd * row.weights[k];
}
}
}
}
for pix in 0..npix {
if sum_dist[pix] != 0.0 {
sl[pix] += update[pix] / sum_dist[pix];
}
}
}
}
}
let array = Array3::from_shape_vec((nz, n, n), recon)
.map_err(|e| Error::InvalidParam(format!("bart shape: {e}")))?;
Ok(Volume::new(array))
}
#[cfg(test)]
mod tests {
use super::*;
use crate::backend::{Backend, DeviceKind};
use crate::data::Layout;
use crate::dtype::Dtype;
use crate::geometry::Angles;
struct NullBackend;
impl Backend for NullBackend {
fn name(&self) -> &'static str {
"null"
}
fn device(&self) -> DeviceKind {
DeviceKind::Cpu
}
fn supports(&self, _dt: Dtype) -> bool {
false
}
}
fn tiny_sino() -> (Tomo<f32>, Geometry) {
let s = Tomo::new(Array3::<f32>::zeros((2, 4, 8)), Layout::Sinogram); let g = Geometry::parallel(Angles::uniform(4, 0.0, std::f32::consts::PI), 8, 2, 1.0);
(s, g)
}
#[test]
fn analytic_without_capabilities_reports_missing_capability() {
let (s, g) = tiny_sino();
let err = recon(
&s,
&g,
Algorithm::Fbp,
&ReconParams::default(),
&NullBackend,
)
.unwrap_err();
assert!(matches!(
err,
Error::MissingCapability {
capability: "FbpFilter",
..
}
));
}
#[test]
fn iterative_without_projector_reports_missing_capability() {
let (s, g) = tiny_sino();
let err = recon(
&s,
&g,
Algorithm::Sirt,
&ReconParams::default(),
&NullBackend,
)
.unwrap_err();
assert!(matches!(
err,
Error::MissingCapability {
capability: "ForwardProject",
..
}
));
}
}