use crate::data::{Layout, Tomo};
use crate::error::{Error, Result};
use ndarray::{Array2, Array3};
struct SplitMix64 {
state: u64,
}
impl SplitMix64 {
fn new(seed: u64) -> Self {
Self { state: seed }
}
fn next_u64(&mut self) -> u64 {
self.state = self.state.wrapping_add(0x9E37_79B9_7F4A_7C15);
let mut z = self.state;
z = (z ^ (z >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9);
z = (z ^ (z >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB);
z ^ (z >> 31)
}
fn next_open01(&mut self) -> f64 {
((self.next_u64() >> 11) as f64 + 0.5) * (1.0 / (1u64 << 53) as f64)
}
fn standard_normal(&mut self) -> f64 {
let u1 = self.next_open01();
let u2 = self.next_open01();
(-2.0 * u1.ln()).sqrt() * (std::f64::consts::TAU * u2).cos()
}
fn poisson(&mut self, lam: f64) -> i64 {
if lam == 0.0 {
return 0;
}
if lam < 10.0 {
self.poisson_mult(lam)
} else {
self.poisson_ptrs(lam)
}
}
fn poisson_mult(&mut self, lam: f64) -> i64 {
let enlam = (-lam).exp();
let mut x = 0i64;
let mut prod = 1.0;
loop {
prod *= self.next_open01();
if prod > enlam {
x += 1;
} else {
return x;
}
}
}
fn poisson_ptrs(&mut self, lam: f64) -> i64 {
let slam = lam.sqrt();
let loglam = lam.ln();
let b = 0.931 + 2.53 * slam;
let a = -0.059 + 0.02483 * b;
let inv_alpha = 1.1239 + 1.1328 / (b - 3.4);
let vr = 0.9277 - 3.6224 / (b - 2.0);
loop {
let u = self.next_open01() - 0.5;
let v = self.next_open01();
let us = 0.5 - u.abs();
let k = ((2.0 * a / us + b) * u + lam + 0.43).floor() as i64;
if us >= 0.07 && v <= vr {
return k;
}
if k < 0 || (us < 0.013 && v > us) {
continue;
}
if (v.ln() + inv_alpha.ln() - (a / (us * us) + b).ln())
<= -lam + (k as f64) * loglam - loggam((k + 1) as f64)
{
return k;
}
}
}
}
fn loggam(x: f64) -> f64 {
const A: [f64; 10] = [
8.333_333_333_333_333e-2,
-2.777_777_777_777_778e-3,
7.936_507_936_507_937e-4,
-5.952_380_952_380_953e-4,
8.417_508_417_508_417e-4,
-1.917_526_917_526_918e-3,
6.410_256_410_256_41e-3,
-2.955_065_359_477_124e-2,
1.796_443_723_688_307e-1,
-1.392_432_216_905_9e0,
];
if x == 1.0 || x == 2.0 {
return 0.0;
}
let mut x0 = x;
let mut n = 0i64;
if x <= 7.0 {
n = (7.0 - x) as i64;
x0 = x + n as f64;
}
let x2 = 1.0 / (x0 * x0);
let mut gl0 = A[9];
for k in (0..9).rev() {
gl0 = gl0 * x2 + A[k];
}
let mut gl = gl0 / x0 + 0.5 * std::f64::consts::TAU.ln() + (x0 - 0.5) * x0.ln() - x0;
if x <= 7.0 {
let mut xx = x0;
for _ in 0..n {
gl -= (xx - 1.0).ln();
xx -= 1.0;
}
}
gl
}
pub fn add_gaussian(data: &mut Tomo<f32>, mean: f32, std: Option<f32>, seed: u64) -> Result<()> {
let std = std.unwrap_or_else(|| array_max(&data.array) * 0.05);
let (std, mean) = (std as f64, mean as f64);
let mut rng = SplitMix64::new(seed);
for v in data.array.iter_mut() {
*v += (std * rng.standard_normal() + mean) as f32;
}
Ok(())
}
pub fn add_poisson(data: &mut Tomo<f32>, seed: u64) -> Result<()> {
if let Some(neg) = data.array.iter().copied().find(|&v| v < 0.0) {
return Err(Error::InvalidParam(format!(
"add_poisson: negative intensity {neg} (a Poisson mean must be >= 0)"
)));
}
let mut rng = SplitMix64::new(seed);
for v in data.array.iter_mut() {
*v = rng.poisson(*v as f64) as f32;
}
Ok(())
}
pub fn add_rings(data: &mut Tomo<f32>, std: f32, seed: u64) -> Result<()> {
let (n_rows, n_cols) = (data.n_rows(), data.n_cols());
let std = std as f64;
let mut rng = SplitMix64::new(seed);
let mut sens = Array2::<f64>::zeros((n_rows, n_cols));
for s in sens.iter_mut() {
*s = 1.0 + std * rng.standard_normal();
}
let layout = data.layout;
for ((a0, a1, col), v) in data.array.indexed_iter_mut() {
let row = match layout {
Layout::Projection => a1, Layout::Sinogram => a0, };
*v = (*v as f64 * sens[[row, col]]) as f32;
}
Ok(())
}
pub fn add_zingers(data: &mut Tomo<f32>, f: f32, sat: f32, seed: u64) -> Result<()> {
let f = f as f64;
let mut rng = SplitMix64::new(seed);
for v in data.array.iter_mut() {
if rng.next_open01() <= f {
*v = sat;
}
}
Ok(())
}
pub fn add_salt_pepper(data: &mut Tomo<f32>, prob: f32, val: Option<f32>, seed: u64) -> Result<()> {
let val = val.unwrap_or_else(|| array_max(&data.array));
let prob = prob as f64;
let mut rng = SplitMix64::new(seed);
for v in data.array.iter_mut() {
if rng.next_open01() < prob {
*v = val;
}
}
Ok(())
}
fn array_max(a: &Array3<f32>) -> f32 {
a.iter().copied().fold(f32::NEG_INFINITY, f32::max)
}
pub fn add_drift(data: &mut Tomo<f32>, amp: f32, period: f32, mean: f32) -> Result<()> {
let n_ang = data.n_angles();
if n_ang == 0 {
return Ok(());
}
let (amp, period, mean) = (amp as f64, period as f64, mean as f64);
let lin = linspace01(n_ang);
let w = 2.0 * std::f64::consts::PI / period;
let drift: Vec<f64> = (0..n_ang)
.map(|i| amp * (w * i as f64).sin() + mean + lin[i])
.collect();
let layout = data.layout;
for ((a0, a1, _col), v) in data.array.indexed_iter_mut() {
let ang = match layout {
Layout::Projection => a0, Layout::Sinogram => a1, };
*v = (*v as f64 * drift[ang]) as f32;
}
Ok(())
}
fn linspace01(n: usize) -> Vec<f64> {
if n == 1 {
return vec![0.0];
}
let step = 1.0 / (n - 1) as f64;
let mut v: Vec<f64> = (0..n).map(|i| i as f64 * step).collect();
if let Some(last) = v.last_mut() {
*last = 1.0;
}
v
}