use crate::data::{Dataset, Layout, Tomo, Volume};
use crate::error::Result;
use crate::geometry::Geometry;
use crate::params::{Algorithm, PhaseMethod, ReconParams, StripeMethod};
use crate::engine::Engine;
#[derive(Clone, Copy, Debug, Default)]
pub struct PrepOptions {
pub stripe: StripeMethod,
pub phase: PhaseMethod,
}
pub fn reconstruct(
mut ds: Dataset<f32>,
geom: &Geometry,
algorithm: Algorithm,
params: &ReconParams,
prep: &PrepOptions,
engine: &Engine,
) -> Result<Volume<f32>> {
let backend = engine.backend();
crate::prep::normalize_dataset(&mut ds, backend)?;
crate::prep::retrieve_phase(&mut ds.data, prep.phase, backend)?;
let mut sino = ds.data.to_layout(Layout::Sinogram);
crate::prep::remove_stripe(&mut sino, prep.stripe)?;
crate::recon::recon(&sino, geom, algorithm, params, backend)
}
pub struct ReconSteps {
pub chunk_rows: usize,
}
impl ReconSteps {
pub fn new(chunk_rows: usize) -> Self {
ReconSteps {
chunk_rows: chunk_rows.max(1),
}
}
#[allow(clippy::too_many_arguments)]
pub fn run(
&self,
reader: &mut dyn crate::io::DatasetReader,
writer: &mut dyn crate::io::VolumeWriter,
geom: &Geometry,
algorithm: Algorithm,
params: &ReconParams,
prep: &PrepOptions,
engine: &Engine,
) -> Result<()> {
let backend = engine.backend();
let mut ds = reader.read_all()?;
crate::prep::normalize_dataset(&mut ds, backend)?;
crate::prep::retrieve_phase(&mut ds.data, prep.phase, backend)?;
let sino = ds.data.to_layout(Layout::Sinogram); let nz = sino.n_rows();
let chunk = self.chunk_rows.max(1);
let mut r0 = 0;
while r0 < nz {
let r1 = (r0 + chunk).min(nz);
let sub = sino
.array
.slice_axis(ndarray::Axis(0), ndarray::Slice::from(r0..r1))
.to_owned();
let mut sub = Tomo::new(sub, Layout::Sinogram);
crate::prep::remove_stripe(&mut sub, prep.stripe)?;
let chunk_geom = chunk_geometry(geom, r0, r1);
let vol = crate::recon::recon(&sub, &chunk_geom, algorithm, params, backend)?;
writer.write_chunk(&vol, r0, r1)?;
r0 = r1;
}
Ok(())
}
}
impl ReconSteps {
#[allow(clippy::too_many_arguments)]
pub fn run_streaming(
&self,
reader: &mut dyn crate::io::DatasetReader,
writer: &mut dyn crate::io::VolumeWriter,
geom: &Geometry,
algorithm: Algorithm,
params: &ReconParams,
prep: &PrepOptions,
engine: &Engine,
) -> Result<()> {
if prep.phase != PhaseMethod::None {
return Err(crate::error::Error::InvalidParam(
"ReconSteps::run_streaming does not support phase retrieval (row-coupled); \
use run() for a phase pipeline"
.into(),
));
}
let backend = engine.backend();
let (_nproj, nz, _nx, _nflat, _ndark) = reader.read_sizes()?;
let chunk = self.chunk_rows.max(1);
let mut r0 = 0;
while r0 < nz {
let r1 = (r0 + chunk).min(nz);
let mut ds = reader.read_chunk(r0, r1)?;
crate::prep::normalize_dataset(&mut ds, backend)?;
let mut sino = ds.data.to_layout(Layout::Sinogram);
sino.array = sino.array.as_standard_layout().to_owned();
crate::prep::remove_stripe(&mut sino, prep.stripe)?;
let chunk_geom = chunk_geometry(geom, r0, r1);
let vol = crate::recon::recon(&sino, &chunk_geom, algorithm, params, backend)?;
writer.write_chunk(&vol, r0, r1)?;
r0 = r1;
}
Ok(())
}
}
fn chunk_geometry(geom: &Geometry, r0: usize, r1: usize) -> Geometry {
use crate::geometry::Center;
let center = match &geom.center {
Center::Scalar(c) => Center::Scalar(*c),
Center::PerRow(v) => Center::PerRow(v[r0..r1].to_vec()),
};
Geometry {
center,
..geom.clone()
}
}