use crate::psf::{convolve, gaussian_blur, gaussian_kernel};
pub const APERTURE_UM: f64 = 48.0;
#[derive(Debug, Clone, Copy)]
pub struct Scanner {
pub texture_um: f64,
pub texture_density: f64,
pub shared: f64,
pub optics_um: f64,
pub seed: u64,
}
impl Scanner {
#[must_use]
pub fn measured() -> Self {
Self {
texture_um: 3.25,
texture_density: 0.0060,
shared: 0.70,
optics_um: 0.0,
seed: 0,
}
}
#[must_use]
pub fn is_idle(&self) -> bool {
self.optics_um <= 0.0 && (self.texture_density <= 0.0 || self.texture_um <= 0.0)
}
pub fn apply(&self, pixels: &mut [[f64; 3]], width: usize, height: usize, pixel_um: f64) {
if width == 0 || height == 0 || pixel_um <= 0.0 {
return;
}
if self.optics_um > 0.0 {
let sigma_px = self.optics_um / pixel_um;
let mut planes = vec![vec![0.0; width * height]; 3];
for (index, pixel) in pixels.iter().enumerate() {
for (plane, value) in planes.iter_mut().zip(pixel) {
plane[index] = *value;
}
}
let blurred: Vec<Vec<f64>> = planes
.iter()
.map(|plane| gaussian_blur(plane, width, height, sigma_px))
.collect();
for (index, pixel) in pixels.iter_mut().enumerate() {
for (value, plane) in pixel.iter_mut().zip(&blurred) {
*value = plane[index];
}
}
}
if self.texture_density <= 0.0 || self.texture_um <= 0.0 {
return;
}
let sigma_px = self.texture_um / (std::f64::consts::SQRT_2 * pixel_um);
let kernel = l2_normalised(sigma_px);
let radius = kernel.len() / 2;
let mut per_axis = 0.0;
for lag in 0..=radius {
let mut pair = 0.0;
for tap in 0..(kernel.len() - lag) {
pair += kernel[tap] * kernel[tap + lag];
}
per_axis += if lag == 0 { pair } else { 2.0 * pair };
}
let sigma =
self.texture_density * APERTURE_UM / (pixel_um * per_axis.max(f64::MIN_POSITIVE));
let shared = self.shared.clamp(0.0, 1.0);
let spread = (1.0 - shared).sqrt();
let common_scale = shared.sqrt() * sigma;
let own_scale = spread * sigma;
let common = convolve(&self.white(width, height, 0), width, height, &kernel);
let mut own = Vec::with_capacity(3);
for channel in 0..3 {
own.push(convolve(
&self.white(width, height, 1 + channel),
width,
height,
&kernel,
));
}
for (index, pixel) in pixels.iter_mut().enumerate() {
for (channel, value) in pixel.iter_mut().enumerate() {
let density = common_scale * common[index] + own_scale * own[channel][index];
*value *= 10.0_f64.powf(-density);
}
}
}
fn white(&self, width: usize, height: usize, lane: usize) -> Vec<f64> {
let mut plane = Vec::with_capacity(width * height);
for y in 0..height {
for x in 0..width {
plane.push(self.unit_normal(x, y, lane));
}
}
plane
}
fn unit_normal(&self, x: usize, y: usize, lane: usize) -> f64 {
let u1 = self.uniform(x, y, lane, 0);
let u2 = self.uniform(x, y, lane, 1);
(-2.0 * u1.ln()).sqrt() * (std::f64::consts::TAU * u2).cos()
}
fn uniform(&self, x: usize, y: usize, lane: usize, draw: usize) -> f64 {
let mut state = self.seed.wrapping_mul(0xD6E8_FEB8_6659_FD93)
^ (x as u64).wrapping_mul(0x9E37_79B9_7F4A_7C15)
^ (y as u64).wrapping_mul(0xC2B2_AE3D_27D4_EB4F)
^ (lane as u64).wrapping_mul(0x1656_67B1_9E37_79F9)
^ (draw as u64).wrapping_mul(0x2545_F491_4F6C_DD1D);
let bits = splitmix64(&mut state) >> 41;
(bits as f64 + 0.5) * (1.0 / 8_388_608.0)
}
}
fn l2_normalised(sigma_px: f64) -> Vec<f64> {
let mut kernel = gaussian_kernel(sigma_px.max(1e-3));
let norm = kernel
.iter()
.map(|weight| weight * weight)
.sum::<f64>()
.sqrt();
if norm > 0.0 {
for weight in &mut kernel {
*weight /= norm;
}
}
kernel
}
fn splitmix64(state: &mut u64) -> u64 {
*state = state.wrapping_add(0x9E37_79B9_7F4A_7C15);
let mut z = *state;
z = (z ^ (z >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9);
z = (z ^ (z >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB);
z ^ (z >> 31)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_flat_print_scans_at_the_measured_granularity() {
let scanner = Scanner::measured();
let mut pixels = vec![[0.5; 3]; 400 * 400];
scanner.apply(&mut pixels, 400, 400, 4.8);
let mut means = Vec::new();
for y in (10..390).step_by(10) {
for x in (10..390).step_by(10) {
let mut sum = 0.0;
for dy in 0..10 {
for dx in 0..10 {
let value = pixels[(y + dy) * 400 + x + dx][1];
sum += -value.log10();
}
}
means.push(sum / 100.0);
}
}
let mean = means.iter().sum::<f64>() / means.len() as f64;
let aperture =
(means.iter().map(|m| (m - mean).powi(2)).sum::<f64>() / means.len() as f64).sqrt();
assert!(
(aperture - scanner.texture_density).abs() < 0.0015,
"48 µm granularity {aperture:.4}, expected {:.4}",
scanner.texture_density
);
let per_pixel = {
let values: Vec<f64> = pixels
.iter()
.skip(10 * 400)
.take(380 * 400)
.map(|p| -p[1].log10())
.collect();
let mean = values.iter().sum::<f64>() / values.len() as f64;
(values.iter().map(|v| (v - mean).powi(2)).sum::<f64>() / values.len() as f64).sqrt()
};
assert!(
per_pixel > 2.0 * aperture,
"the texture is too smooth: {per_pixel:.4} per pixel against {aperture:.4} at 48 µm"
);
}
#[test]
fn the_texture_is_shared_by_the_channels() {
let scanner = Scanner::measured();
let mut pixels = vec![[0.5; 3]; 256 * 256];
scanner.apply(&mut pixels, 256, 256, 4.8);
let density: Vec<[f64; 3]> = pixels
.iter()
.map(|p| [0usize, 1, 2].map(|c| -p[c].log10()))
.collect();
let mean = [
density.iter().map(|d| d[0]).sum::<f64>() / density.len() as f64,
density.iter().map(|d| d[1]).sum::<f64>() / density.len() as f64,
density.iter().map(|d| d[2]).sum::<f64>() / density.len() as f64,
];
let mut worst = 0.0_f64;
for (a, b) in [(0usize, 1usize), (0, 2), (1, 2)] {
let mut cov = 0.0;
let mut va = 0.0;
let mut vb = 0.0;
for d in &density {
let da = d[a] - mean[a];
let db = d[b] - mean[b];
cov += da * db;
va += da * da;
vb += db * db;
}
let rho = cov / (va * vb).sqrt();
worst = worst.max((rho - scanner.shared).abs());
}
assert!(
worst < 0.1,
"cross-channel correlation missed `shared` by {worst:.2}"
);
}
#[test]
fn the_optics_blur_the_print_and_nothing_else() {
let idle = Scanner {
texture_density: 0.0,
optics_um: 0.0,
..Scanner::measured()
};
assert!(idle.is_idle());
let mut pixels = vec![[0.2; 3]; 32 * 8];
for pixel in pixels.iter_mut().skip(16) {
*pixel = [0.8; 3];
}
let original = pixels.clone();
idle.apply(&mut pixels, 32, 8, 4.8);
assert_eq!(pixels, original, "an idle scan changed the print");
let mut blurred = original.clone();
Scanner {
optics_um: 4.8,
..idle
}
.apply(&mut blurred, 32, 8, 4.8);
let ramp = blurred[4 * 32 + 12][0];
assert!(ramp > 0.2 && ramp < 0.8, "no ramp: {ramp}");
assert!(
(blurred[4 * 32 + 24][0] - 0.8).abs() < 0.05,
"the flat kept its value"
);
}
#[test]
fn the_same_seed_scans_the_same_frame() {
let scanner = Scanner::measured();
let mut a = vec![[0.4; 3]; 64 * 64];
let mut b = a.clone();
scanner.apply(&mut a, 64, 64, 3.555);
scanner.apply(&mut b, 64, 64, 3.555);
assert_eq!(a, b);
let mut other = vec![[0.4; 3]; 64 * 64];
Scanner { seed: 7, ..scanner }.apply(&mut other, 64, 64, 3.555);
assert_ne!(a, other);
}
}