#[must_use]
pub fn release(density: &[f64; 3], half_saturation: f64) -> [f64; 3] {
let half = half_saturation.max(1e-9);
std::array::from_fn(|layer| {
let value = density[layer].max(0.0);
value / (value + half)
})
}
#[must_use]
pub fn inhibit(density: &[f64; 3], release: &[f64; 3], matrix: &[[f64; 3]; 3]) -> [f64; 3] {
std::array::from_fn(|layer| {
let suppressed: f64 = (0..3)
.map(|other| matrix[layer][other] * release[other])
.sum();
(density[layer] * (1.0 - suppressed).max(0.0)).max(0.0)
})
}
#[derive(Debug, Clone, Copy)]
pub struct Couplers {
pub inhibition: [[f64; 3]; 3],
pub half_saturation: f64,
pub sigma_um: f64,
pub pixel_um: f64,
}
impl Couplers {
#[must_use]
pub fn typical(pixel_um: f64) -> Self {
Self {
inhibition: [
[0.020, 0.030, 0.020],
[0.030, 0.020, 0.030],
[0.020, 0.030, 0.020],
],
half_saturation: 0.5,
sigma_um: 20.0,
pixel_um,
}
}
#[must_use]
pub fn is_noop(&self) -> bool {
self.inhibition
.iter()
.all(|row| row.iter().all(|&value| value <= 0.0))
}
pub fn apply(&self, density: &mut [[f64; 3]], width: usize, height: usize) {
if self.is_noop() || width == 0 || height == 0 {
return;
}
let pixels = (width * height).min(density.len());
let height = pixels / width;
if height == 0 {
return;
}
let mut planes: [Vec<f64>; 3] = [vec![0.0; pixels], vec![0.0; pixels], vec![0.0; pixels]];
for (index, pixel) in density[..pixels].iter().enumerate() {
let released = release(pixel, self.half_saturation);
for layer in 0..3 {
planes[layer][index] = released[layer];
}
}
let sigma_px = self.sigma_um / self.pixel_um.max(1e-9);
let diffused: [Vec<f64>; 3] = std::array::from_fn(|layer| {
crate::psf::gaussian_blur(&planes[layer], width, height, sigma_px)
});
for (index, pixel) in density.iter_mut().enumerate().take(pixels) {
let released = [diffused[0][index], diffused[1][index], diffused[2][index]];
*pixel = inhibit(pixel, &released, &self.inhibition);
}
}
}
#[must_use]
pub fn fit_inhibition(
uninhibited: &[[f64; 3]],
measured: &[[f64; 3]],
half_saturation: f64,
) -> [[f64; 3]; 3] {
let mut matrix = [[0.0; 3]; 3];
for layer in 0..3 {
let mut normal = [[0.0; 3]; 3];
let mut rhs = [0.0; 3];
for (predicted, observed) in uninhibited.iter().zip(measured) {
let density = predicted[layer].max(0.0);
if density <= 1e-9 {
continue;
}
let released = release(predicted, half_saturation);
let target = density - observed[layer].max(0.0);
for row in 0..3 {
let x_row = density * released[row];
rhs[row] += x_row * target;
for column in 0..3 {
normal[row][column] += x_row * density * released[column];
}
}
}
for (index, row) in normal.iter_mut().enumerate() {
row[index] += 1e-9;
}
if let Some(solution) = crate::scan::solve3(normal, rhs) {
for column in 0..3 {
matrix[layer][column] = solution[column].clamp(0.0, 1.0);
}
}
}
matrix
}
#[cfg(test)]
mod tests {
use super::*;
fn patches() -> Vec<[f64; 3]> {
let mut out = Vec::new();
for r in [0.1, 0.4, 0.9, 1.6, 2.2] {
out.push([r, 0.3 * r, 0.2 * r]);
out.push([0.3 * r, r, 0.25 * r]);
out.push([0.2 * r, 0.3 * r, r]);
}
out
}
#[test]
fn release_saturates() {
assert!(release(&[0.0; 3], 0.5)[0] < 1e-12);
assert!((release(&[0.5; 3], 0.5)[0] - 0.5).abs() < 1e-12);
assert!(release(&[50.0; 3], 0.5)[0] > 0.98);
}
#[test]
fn the_fit_recovers_the_matrix_that_made_the_data() {
let truth = [[0.10, 0.22, 0.10], [0.22, 0.10, 0.22], [0.10, 0.22, 0.10]];
let half = 0.5;
let uninhibited = patches();
let measured: Vec<[f64; 3]> = uninhibited
.iter()
.map(|density| inhibit(density, &release(density, half), &truth))
.collect();
let fitted = fit_inhibition(&uninhibited, &measured, half);
for layer in 0..3 {
for other in 0..3 {
assert!(
(fitted[layer][other] - truth[layer][other]).abs() < 1e-6,
"layer {layer} from {other}: {} vs {}",
fitted[layer][other],
truth[layer][other]
);
}
}
}
#[test]
fn a_strong_layer_pulls_the_others_back() {
let couplers = Couplers::typical(6.0);
let mut buffer = vec![[0.0; 3]; 16 * 16];
buffer[8 * 16 + 8] = [1.5, 0.2, 0.2];
let before = buffer.clone();
couplers.apply(&mut buffer, 16, 16);
let centre = buffer[8 * 16 + 8];
assert!(
centre[0] < before[8 * 16 + 8][0],
"self-inhibition {centre:?}"
);
assert!(centre[1] < before[8 * 16 + 8][1], "interimage on green");
}
#[test]
fn the_suppression_falls_off_with_distance() {
let couplers = Couplers::typical(6.0);
let mut buffer = vec![[1.0; 3]; 64 * 64];
buffer[32 * 64 + 32] = [3.0; 3];
let before = buffer.clone();
couplers.apply(&mut buffer, 64, 64);
let loss =
|offset: usize| before[32 * 64 + 32 + offset][0] - buffer[32 * 64 + 32 + offset][0];
assert!(loss(1) > loss(6), "near {} far {}", loss(1), loss(6));
assert!(loss(6) > loss(20), "mid {} far {}", loss(6), loss(20));
}
#[test]
fn a_zero_matrix_is_a_no_op() {
let mut couplers = Couplers::typical(6.0);
couplers.inhibition = [[0.0; 3]; 3];
assert!(couplers.is_noop());
let mut buffer = vec![[1.0, 0.5, 0.2]; 8 * 8];
let before = buffer.clone();
couplers.apply(&mut buffer, 8, 8);
assert_eq!(buffer, before);
}
}