use rayon::prelude::*;
use super::traverse::Geom;
use super::{RayVoxels, F, I};
use crate::Point;
pub(crate) fn update_peaks(peaks: &mut [f64], echoes: &[Point], geom: &Geom) {
for p in echoes {
let v = geom.to_vox(p);
let (i, j) = (v[0].floor(), v[1].floor());
if i >= 0.0 && j >= 0.0 && (i as usize) < geom.shape[0] && (j as usize) < geom.shape[1] {
let c = i as usize + geom.shape[0] * j as usize;
peaks[c] = peaks[c].max(v[2]);
}
}
}
fn shells() -> [Vec<[i64; 3]>; 3] {
let mut s = [Vec::new(), Vec::new(), Vec::new()];
for dz in -1i64..=1 {
for dy in -1i64..=1 {
for dx in -1i64..=1 {
let order = (dx.abs() + dy.abs() + dz.abs()) as usize;
if order > 0 {
s[order - 1].push([dx, dy, dz]);
}
}
}
}
s
}
pub(crate) fn apply_neighbour_priors(vox: &mut RayVoxels, min_rays: f32) {
let [nx, ny, nz] = vox.shape;
if nx < 3 || ny < 3 || nz < 3 {
return;
}
let shells = shells();
let stride = [1i64, nx as i64, (nx * ny) as i64];
let offsets: Vec<Vec<i64>> = shells.iter().map(|s| s.iter().map(|d| d[0] * stride[0] + d[1] * stride[1] + d[2] * stride[2]).collect()).collect();
let nbw = &vox.f[F::NumBeamsWeighted as usize];
let hits = &vox.i[I::NumHits as usize];
let plan: Vec<(usize, [f64; 3])> = (1..nz - 1)
.into_par_iter()
.flat_map_iter(|k| {
let offsets = &offsets;
(1..ny - 1).flat_map(move |j| (1..nx - 1).map(move |i| i + nx * (j + ny * k))).filter_map(move |idx| {
if hits[idx] == 0 && nbw[idx] == 0.0 {
return None;
}
let mut needed = (min_rays - nbw[idx]) as f64;
if needed <= 0.0 {
return None;
}
let mut share = [0.0; 3];
for (s, offs) in offsets.iter().enumerate() {
let sum: f64 = offs.iter().map(|&o| nbw[(idx as i64 + o) as usize] as f64).sum();
if sum > 0.0 {
share[s] = (needed / sum).min(1.0);
needed -= sum * share[s];
}
if needed <= 0.0 {
break;
}
}
Some((idx, share))
})
})
.collect();
if plan.is_empty() {
return;
}
for field in vox.f.iter_mut().filter(|f| !f.is_empty()) {
let old = field.clone();
for (idx, share) in &plan {
for (s, offs) in offsets.iter().enumerate() {
if share[s] > 0.0 {
let sum: f64 = offs.iter().map(|&o| old[(*idx as i64 + o) as usize] as f64).sum();
field[*idx] += (sum * share[s]) as f32;
}
}
}
}
for field in vox.i.iter_mut() {
let old = field.clone();
for (idx, share) in &plan {
for (s, offs) in offsets.iter().enumerate() {
if share[s] > 0.0 {
let sum: i64 = offs.iter().map(|&o| old[(*idx as i64 + o) as usize] as i64).sum();
field[*idx] += (sum as f64 * share[s]) as i32;
}
}
}
}
}