use isomesh::construct::{signed_distance_field, signed_distance_field_swept};
use isomesh::fields::ReferenceField;
use isomesh::{RuntimeShape3, Sdf, Shape3};
use super::JumpFlood;
use crate::{FieldBuffer, GridParams, headless};
#[test]
fn strides_halve_from_half_the_longest_axis() {
let p = GridParams::new([65, 33, 17], [-1.0; 3], 0.03125).expect("valid grid");
assert_eq!(JumpFlood::strides(p), std::vec![32, 16, 8, 4, 2, 1]);
let odd = GridParams::new([50; 3], [-1.0; 3], 0.04).expect("valid grid");
let s = JumpFlood::strides(odd);
assert_eq!(s.first(), Some(&25));
assert_eq!(s.last(), Some(&1));
}
#[test]
fn jump_flood_error_against_the_exact_transform() {
let Ok(gpu) = headless::Gpu::new() else {
std::eprintln!("no GPU adapter; skipping");
return;
};
let flood = JumpFlood::new(gpu.device()).expect("compiles");
let mut csv = std::string::String::from(
"field,samples,vs_exact,vs_swept,near_swept,flood_err,swept_err,xform_err\n",
);
std::println!(
"{:<16} {:>7} {:>9} {:>9} {:>10} {:>10} {:>10} {:>10}",
"field",
"samples",
"vs_exact",
"vs_swept",
"near_swept",
"flood_err",
"swept_err",
"xform_err"
);
isomesh::for_each_reference_field!(f32, |name, field| {
if field.bound().is_exact() {
for samples in [17u32, 33, 65] {
let (lo, hi) = field.domain();
let h = (hi[0] - lo[0]) / (samples - 1) as f32;
let params = GridParams::new([samples; 3], lo, h).expect("valid grid");
let shape = RuntimeShape3::new([samples; 3]).expect("valid shape");
let mut grid = std::vec::Vec::with_capacity(shape.element_count());
for z in 0..samples {
for y in 0..samples {
for x in 0..samples {
grid.push(field.sample([
lo[0] + h * x as f32,
lo[1] + h * y as f32,
lo[2] + h * z as f32,
]));
}
}
}
let buffer = FieldBuffer::uploaded(gpu.device(), gpu.queue(), params, &grid)
.expect("upload");
let flooded = flood
.build(gpu.device(), gpu.queue(), &buffer)
.expect("flood");
let exact = signed_distance_field(&grid, &shape, h).expect("transform");
let swept = signed_distance_field_swept(&grid, &shape, h).expect("sweep");
let mut vs_exact = 0.0f32;
let mut vs_swept = 0.0f32;
let mut near_swept = 0.0f32;
let mut flood_err = 0.0f32;
let mut swept_err = 0.0f32;
let mut xform_err = 0.0f32;
for z in 0..samples {
for y in 0..samples {
for x in 0..samples {
let i = ((z * samples + y) * samples + x) as usize;
let truth = field.sample([
lo[0] + h * x as f32,
lo[1] + h * y as f32,
lo[2] + h * z as f32,
]);
vs_exact = vs_exact.max((flooded[i] - exact[i]).abs());
let gap = (flooded[i] - swept[i]).abs();
vs_swept = vs_swept.max(gap);
if truth.abs() <= 2.0 * h {
near_swept = near_swept.max(gap);
}
flood_err = flood_err.max((flooded[i] - truth).abs());
swept_err = swept_err.max((swept[i] - truth).abs());
xform_err = xform_err.max((exact[i] - truth).abs());
}
}
}
let total = shape.element_count();
std::println!(
"{name:<16} {samples:>7} {vs_exact:>9.5} {vs_swept:>9.5} \
{near_swept:>10.5} {flood_err:>10.5} {swept_err:>10.5} {xform_err:>10.5}"
);
csv.push_str(&std::format!(
"{name},{samples},{vs_exact:.8},{vs_swept:.8},{near_swept:.8},\
{flood_err:.8},{swept_err:.8},{xform_err:.8}\n"
));
for i in 0..total {
assert_eq!(
flooded[i] < 0.0,
exact[i] < 0.0,
"{name} at {samples}³ sample {i}: flood {} vs transform {}",
flooded[i],
exact[i]
);
}
assert!(
flood_err <= xform_err,
"{name} at {samples}³: flood is {flood_err} from truth against \
the transform's {xform_err}"
);
assert!(
flood_err <= swept_err,
"{name} at {samples}³: flood is {flood_err} from truth against \
the sweep's {swept_err}"
);
}
}
});
let path = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
.join("../../docs/measurements/jump_flood.csv");
if let Some(dir) = path.parent() {
let _ = std::fs::create_dir_all(dir);
}
let _ = std::fs::write(&path, csv);
std::println!("\nwrote {}", path.display());
}
#[test]
fn a_field_with_no_surface_stays_finite() {
let Ok(gpu) = headless::Gpu::new() else {
std::eprintln!("no GPU adapter; skipping");
return;
};
let flood = JumpFlood::new(gpu.device()).expect("compiles");
let params = GridParams::new([9; 3], [0.0; 3], 0.1).expect("valid grid");
let grid = std::vec![1.0f32; params.sample_count() as usize];
let buffer = FieldBuffer::uploaded(gpu.device(), gpu.queue(), params, &grid).expect("upload");
let out = flood
.build(gpu.device(), gpu.queue(), &buffer)
.expect("flood");
assert!(out.iter().all(|v| v.is_finite() && *v > 0.0));
}