use crate::backend::{AnalyticReconstruct, FbpFilter, StreamingAnalytic};
use crate::data::{Dataset, Frames, Layout, Tomo, Volume};
use crate::error::Result;
use crate::geometry::Geometry;
use crate::params::{Algorithm, ReconParams, StripeMethod};
use super::kernels::WgpuLprecGrids;
use super::WgpuBackend;
impl WgpuBackend {
pub(crate) fn share(&self) -> WgpuBackend {
WgpuBackend {
device: self.device.clone(),
queue: self.queue.clone(),
pipelines: std::sync::Mutex::new(std::collections::HashMap::new()),
f32_atomics: self.f32_atomics,
}
}
}
pub(crate) struct WgpuFbpStream {
be: WgpuBackend,
algorithm: Algorithm,
params: ReconParams,
lprec_grids: Option<WgpuLprecGrids>,
}
impl WgpuFbpStream {
pub(crate) fn new(be: WgpuBackend, algorithm: Algorithm, params: ReconParams) -> Self {
WgpuFbpStream {
be,
algorithm,
params,
lprec_grids: None,
}
}
fn recon_sino(&mut self, sino: &Tomo<f32>, geom: &Geometry) -> Result<Volume<f32>> {
if self.algorithm != Algorithm::Lprec {
return self
.be
.reconstruct(sino, geom, self.algorithm, &self.params);
}
let n = self.params.num_gridx.unwrap_or(sino.n_cols());
if self.lprec_grids.is_none() {
self.lprec_grids = Some(self.be.build_lprec_grids(geom, n)?);
}
let kernel = self
.be
.make_filter(self.params.filter_name, sino.n_cols())?;
let mut filtered = sino.clone();
self.be.apply(&mut filtered, &kernel, geom)?;
let grids = self.lprec_grids.as_ref().expect("lprec grids built above");
self.be.lprec_run(&filtered, grids)
}
}
impl StreamingAnalytic for WgpuFbpStream {
fn reconstruct_chunk(&mut self, sino: &Tomo<f32>, geom: &Geometry) -> Result<Volume<f32>> {
self.recon_sino(sino, geom)
}
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>>> {
if stripe != StripeMethod::None {
return Ok(None);
}
let (nproj, nz, ncols) = dims;
let need = nproj * nz * ncols;
let arr = ndarray::Array3::from_shape_vec((nproj, nz, ncols), data[..need].to_vec())
.map_err(|e| crate::error::Error::ShapeMismatch {
expected: format!("[{nproj}, {nz}, {ncols}]"),
found: e.to_string(),
})?;
let mut ds = Dataset {
data: Tomo::new(arr, Layout::Projection),
flat: flat.cloned(),
dark: dark.cloned(),
theta: vec![0.0; nproj], };
let cpu = crate::cpu::CpuBackend::new();
crate::prep::normalize_dataset(&mut ds, &cpu)?;
let mut sino = ds.data.to_layout(Layout::Sinogram);
sino.array = sino.array.as_standard_layout().to_owned();
let vol = self.recon_sino(&sino, geom)?;
Ok(Some(vol))
}
}