#[cfg(not(feature = "beam-hardening"))]
mod disabled {
use crate::data::Tomo;
use crate::error::{Error, Result};
pub fn beam_correct(_data: &mut Tomo<f32>, _start_row: usize, _end_row: usize) -> Result<()> {
Err(Error::todo(
"hardening::beam_correct (build with the `beam-hardening` feature)",
"tomocupy processing/external/hardening.py:50",
))
}
}
#[cfg(not(feature = "beam-hardening"))]
pub use disabled::beam_correct;
#[cfg(feature = "beam-hardening")]
mod enabled {
use crate::data::Tomo;
use crate::error::{Error, Result};
use ndarray::Array2;
use std::sync::Once;
static XRL_INIT: Once = Once::new();
fn xrl_init() {
XRL_INIT.call_once(xraylib::init);
}
#[derive(Clone, Debug)]
pub struct Spectrum {
pub angle_urad: f64,
pub energies_ev: Vec<f64>,
pub power: Vec<f64>,
}
#[derive(Clone, Debug)]
pub struct Material {
pub formula: String,
pub density: f64,
}
#[derive(Clone, Debug)]
pub struct Layer {
pub material: Material,
pub thickness_um: f64,
}
#[derive(Clone, Debug)]
pub struct BeamHardeningConfig {
pub scintillator: Layer,
pub sample: Material,
pub filters: Vec<Layer>,
pub ref_trans: f64,
pub threshold_trans: f64,
pub d_source_m: f64,
pub pixel_size_um: f64,
}
impl Default for BeamHardeningConfig {
fn default() -> Self {
BeamHardeningConfig {
scintillator: Layer {
material: Material {
formula: "Lu3Al5O12".into(),
density: 6.73,
},
thickness_um: 100.0,
},
sample: Material {
formula: "Fe".into(),
density: 7.87,
},
filters: Vec::new(),
ref_trans: 0.1,
threshold_trans: 1e-5,
d_source_m: 36.0,
pixel_size_um: 10.0,
}
}
}
fn material_mu(
formula: &str,
density: f64,
energies_ev: &[f64],
photo: bool,
) -> Result<Vec<f64>> {
xrl_init();
let mut out = Vec::with_capacity(energies_ev.len());
for &e in energies_ev {
let kev = e / 1000.0;
let cs = if photo {
xraylib::cs_photo_cp(formula, kev)
} else {
xraylib::cs_total_cp(formula, kev)
}
.map_err(|e| {
Error::InvalidParam(format!("xraylib cross section for {formula}: {e}"))
})?;
out.push(cs * density);
}
Ok(out)
}
fn simpson(y: &[f64], x: &[f64]) -> f64 {
let n = y.len();
assert_eq!(n, x.len(), "simpson: y and x length mismatch");
if n < 2 {
return 0.0;
}
if n == 2 {
return 0.5 * (x[1] - x[0]) * (y[0] + y[1]);
}
let basic = |stop: usize| -> f64 {
let mut acc = 0.0f64;
let mut i = 0usize;
while i < stop {
let h0 = x[i + 1] - x[i];
let h1 = x[i + 2] - x[i + 1];
let hsum = h0 + h1;
let hprod = h0 * h1;
let h0divh1 = h0 / h1;
let tmp = hsum / 6.0
* (y[i] * (2.0 - 1.0 / h0divh1)
+ y[i + 1] * (hsum * (hsum / hprod))
+ y[i + 2] * (2.0 - h0divh1));
acc += tmp;
i += 2;
}
acc
};
if n % 2 == 1 {
basic(n - 2)
} else {
let mut r = if n > 3 { basic(n - 3) } else { 0.0 };
r += 0.5 * (x[n - 1] - x[n - 2]) * (y[n - 1] + y[n - 2]);
r
}
}
fn np_interp_scalar(xq: f64, xp: &[f64], fp: &[f64]) -> f64 {
let n = xp.len();
if n == 0 {
return f64::NAN;
}
if xq <= xp[0] {
return fp[0];
}
if xq >= xp[n - 1] {
return fp[n - 1];
}
let mut lo = 0usize;
let mut hi = n - 1;
while hi - lo > 1 {
let mid = (lo + hi) / 2;
if xp[mid] <= xq {
lo = mid;
} else {
hi = mid;
}
}
let slope = (fp[lo + 1] - fp[lo]) / (xp[lo + 1] - xp[lo]);
fp[lo] + slope * (xq - xp[lo])
}
fn logspace(start: f64, stop: f64, num: usize) -> Vec<f64> {
(0..num)
.map(|i| {
let t = if num == 1 {
start
} else {
start + (stop - start) * (i as f64) / ((num - 1) as f64)
};
10f64.powf(t)
})
.collect()
}
fn sample_thickness_grid() -> Vec<f64> {
let mut v = Vec::with_capacity(41 + 1 + 111);
for t in logspace(1.0, -1.0, 41) {
v.push(-t);
}
v.push(0.0);
v.extend(logspace(-1.0, 4.5, 111));
v.sort_by(|a, b| a.total_cmp(b));
v
}
fn find_interp_values_one_angle(
cfg: &BeamHardeningConfig,
energies: &[f64],
power: &[f64],
) -> Result<(Vec<f64>, Vec<f64>)> {
let thicknesses = sample_thickness_grid();
let sample_ext = material_mu(&cfg.sample.formula, cfg.sample.density, energies, false)?
.iter()
.map(|mu| mu * 1.0 * 1e-4) .collect::<Vec<_>>();
let scint_ext = material_mu(
&cfg.scintillator.material.formula,
cfg.scintillator.material.density,
energies,
true,
)?
.iter()
.map(|mu| mu * cfg.scintillator.thickness_um * 1e-4)
.collect::<Vec<_>>();
let scint_abs: Vec<f64> = scint_ext.iter().map(|e| 1.0 - (-e).exp()).collect();
let scint_spec: Vec<f64> = power.iter().zip(&scint_abs).map(|(p, a)| p * a).collect();
let absorbed = simpson(&scint_spec, energies);
let mut ext = Vec::new();
let mut thk = Vec::new();
let mut buf = vec![0.0f64; energies.len()];
for &t in &thicknesses {
for k in 0..energies.len() {
let trans = (-sample_ext[k] * t).exp();
buf[k] = power[k] * trans * scint_abs[k];
}
let detected = simpson(&buf, energies);
let eff_trans = detected / absorbed;
if eff_trans > cfg.threshold_trans {
ext.push(-eff_trans.ln());
thk.push(t);
}
}
let mut idx: Vec<usize> = (0..ext.len()).collect();
idx.sort_by(|&a, &b| ext[a].total_cmp(&ext[b]));
let ext_s = idx.iter().map(|&i| ext[i]).collect();
let thk_s = idx.iter().map(|&i| thk[i]).collect();
Ok((ext_s, thk_s))
}
#[derive(Clone, Debug)]
pub struct BeamCorrector {
centerline_ext: Vec<f64>,
centerline_path: Vec<f64>,
angular_angles: Vec<f64>,
angular_corr: Vec<f64>,
row_angles: Vec<f64>,
d_source_m: f64,
pixel_size_um: f64,
}
impl BeamCorrector {
pub fn new(cfg: &BeamHardeningConfig, spectra: &[Spectrum]) -> Result<Self> {
if spectra.is_empty() {
return Err(Error::InvalidParam(
"beam hardening: no source spectra".into(),
));
}
let mut order: Vec<usize> = (0..spectra.len()).collect();
order.sort_by(|&a, &b| spectra[a].angle_urad.total_cmp(&spectra[b].angle_urad));
let mut centerline: Option<(Vec<f64>, Vec<f64>)> = None;
let mut angles = Vec::with_capacity(spectra.len());
let mut cal_curve = Vec::with_capacity(spectra.len());
for &i in &order {
let s = &spectra[i];
let mut power = s.power.clone();
for f in &cfg.filters {
let att = material_mu(
&f.material.formula,
f.material.density,
&s.energies_ev,
false,
)?;
for k in 0..power.len() {
power[k] *= (-(att[k] * f.thickness_um * 1e-4)).exp();
}
}
let iv = find_interp_values_one_angle(cfg, &s.energies_ev, &power)?;
if s.angle_urad == 0.0 {
centerline = Some(iv.clone());
}
cal_curve.push(np_interp_scalar(cfg.ref_trans, &iv.0, &iv.1));
angles.push(s.angle_urad);
}
let (centerline_ext, centerline_path) = centerline.ok_or_else(|| {
Error::InvalidParam("beam hardening: no angle-0 (centerline) spectrum".into())
})?;
let c0 = cal_curve[0];
let angular_corr: Vec<f64> = cal_curve.iter().map(|c| c / c0).collect();
Ok(BeamCorrector {
centerline_ext,
centerline_path,
angular_angles: angles,
angular_corr,
row_angles: Vec::new(),
d_source_m: cfg.d_source_m,
pixel_size_um: cfg.pixel_size_um,
})
}
pub fn centerline_lut(&self) -> (&[f64], &[f64]) {
(&self.centerline_ext, &self.centerline_path)
}
pub fn angular_lut(&self) -> (&[f64], &[f64]) {
(&self.angular_angles, &self.angular_corr)
}
pub fn row_angles(&self) -> &[f64] {
&self.row_angles
}
pub fn find_angles(&mut self, flat: &Array2<f32>) {
let (nrows, _ncols) = flat.dim();
let vslice: Vec<f64> = (0..nrows)
.map(|r| flat.row(r).iter().map(|&v| v as f64).sum())
.collect();
let g = gaussian_window(200, 20.0);
let filtered = convolve_same(&vslice, &g);
let center_row = argmax(&filtered) as f64;
self.row_angles = (0..nrows)
.map(|r| (r as f64 - center_row).abs() * self.pixel_size_um / self.d_source_m)
.collect();
}
pub fn correct(
&self,
data: &mut Tomo<f32>,
start_row: usize,
end_row: usize,
) -> Result<()> {
use crate::data::Layout;
if data.layout != Layout::Projection {
return Err(Error::InvalidParam(
"beam hardening: data must be in projection layout".into(),
));
}
let (_nproj, nrows, _ncols) = data.array.dim();
if end_row.saturating_sub(start_row) != nrows {
return Err(Error::InvalidParam(format!(
"beam hardening: row chunk [{start_row},{end_row}) has {} rows, data has {nrows}",
end_row.saturating_sub(start_row)
)));
}
if self.row_angles.is_empty() {
return Err(Error::InvalidParam(
"beam hardening: call find_angles(flat) before correct()".into(),
));
}
if end_row > self.row_angles.len() {
return Err(Error::InvalidParam(format!(
"beam hardening: end_row {end_row} exceeds detector rows {}",
self.row_angles.len()
)));
}
let corr: Vec<f32> = (start_row..end_row)
.map(|r| {
np_interp_scalar(self.row_angles[r], &self.angular_angles, &self.angular_corr)
as f32
})
.collect();
for ((_p, row, _c), v) in data.array.indexed_iter_mut() {
let path =
np_interp_scalar(*v as f64, &self.centerline_ext, &self.centerline_path) as f32;
*v = path * corr[row];
}
Ok(())
}
}
fn gaussian_window(m: usize, std: f64) -> Vec<f64> {
let c = (m as f64 - 1.0) / 2.0;
(0..m)
.map(|n| {
let x = n as f64 - c;
(-0.5 * (x / std) * (x / std)).exp()
})
.collect()
}
fn convolve_same(a: &[f64], v: &[f64]) -> Vec<f64> {
let (na, nv) = (a.len(), v.len());
if na == 0 || nv == 0 {
return vec![0.0; na];
}
let full = na + nv - 1;
let start = (full - na) / 2; (0..na)
.map(|i| {
let k = i + start; let mut acc = 0.0f64;
let jlo = k.saturating_sub(nv - 1);
let jhi = k.min(na - 1);
for j in jlo..=jhi {
acc += a[j] * v[k - j];
}
acc
})
.collect()
}
fn argmax(v: &[f64]) -> usize {
let mut best = 0usize;
for i in 1..v.len() {
if v[i] > v[best] {
best = i;
}
}
best
}
fn parse_spectrum(angle_urad: f64, text: &str) -> Spectrum {
let mut energies_ev = Vec::new();
let mut power = Vec::new();
for line in text.lines() {
let line = line.split('!').next().unwrap_or("").trim();
if line.is_empty() {
continue;
}
let mut it = line.split_whitespace();
if let (Some(a), Some(b)) = (it.next(), it.next()) {
if let (Ok(e), Ok(p)) = (a.parse::<f64>(), b.parse::<f64>()) {
energies_ev.push(e);
power.push(p);
}
}
}
Spectrum {
angle_urad,
energies_ev,
power,
}
}
pub fn default_aps_bm_spectra() -> Vec<Spectrum> {
vec![
parse_spectrum(0.0, include_str!("../../data/Psi_00urad.dat")),
parse_spectrum(5.0, include_str!("../../data/Psi_05urad.dat")),
parse_spectrum(10.0, include_str!("../../data/Psi_10urad.dat")),
parse_spectrum(15.0, include_str!("../../data/Psi_15urad.dat")),
parse_spectrum(20.0, include_str!("../../data/Psi_20urad.dat")),
parse_spectrum(30.0, include_str!("../../data/Psi_30urad.dat")),
parse_spectrum(40.0, include_str!("../../data/Psi_40urad.dat")),
]
}
}
#[cfg(feature = "beam-hardening")]
pub use enabled::{
default_aps_bm_spectra, BeamCorrector, BeamHardeningConfig, Layer, Material, Spectrum,
};