use super::faces::face_points;
use crate::common::IndexMask;
use crate::geom3::Aabb3;
use crate::{Point3, Result};
use parry3d_f64::query::details::intersection_test_aabb_triangle;
use parry3d_f64::shape::Triangle;
pub fn compute_point_mask_in_aabb(points: &[Point3], aabb: &Aabb3) -> IndexMask {
let mut mask = IndexMask::new(points.len(), false);
for (i, point) in points.iter().enumerate() {
mask.set(i, aabb.contains_local_point(point));
}
mask
}
pub fn compute_face_mask_in_aabb(
points: &[Point3],
faces: &[[u32; 3]],
aabb: &Aabb3,
all_vertices: bool,
) -> Result<IndexMask> {
let inside = compute_point_mask_in_aabb(points, aabb);
let mut mask = IndexMask::new(faces.len(), false);
for (i, face) in faces.iter().enumerate() {
let corners = face_points(points, face, i)?;
let count = face
.iter()
.filter(|index| inside.get(**index as usize))
.count();
let keep = match (count, all_vertices) {
(3, _) => true,
(_, true) => false,
(0, false) => {
let triangle = Triangle::new(corners[0], corners[1], corners[2]);
intersection_test_aabb_triangle(aabb, &triangle)
}
(_, false) => true,
};
mask.set(i, keep);
}
Ok(mask)
}
#[cfg(test)]
mod tests {
use super::*;
fn unit_box() -> Aabb3 {
Aabb3::new(Point3::new(0.0, 0.0, 0.0), Point3::new(1.0, 1.0, 1.0))
}
fn one_face(a: Point3, b: Point3, c: Point3) -> (Vec<Point3>, Vec<[u32; 3]>) {
(vec![a, b, c], vec![[0, 1, 2]])
}
#[test]
fn a_point_on_the_boundary_is_inside() {
let points = vec![
Point3::new(0.5, 0.5, 0.5),
Point3::new(0.0, 0.5, 0.5),
Point3::new(1.0, 1.0, 1.0),
Point3::new(1.0 + 1e-9, 0.5, 0.5),
];
let mask = compute_point_mask_in_aabb(&points, &unit_box());
assert_eq!(mask.to_indices(), vec![0, 1, 2]);
}
#[test]
fn a_face_entirely_inside_is_selected_either_way() -> Result<()> {
let (points, faces) = one_face(
Point3::new(0.1, 0.1, 0.5),
Point3::new(0.9, 0.1, 0.5),
Point3::new(0.5, 0.9, 0.5),
);
for all_vertices in [true, false] {
let mask = compute_face_mask_in_aabb(&points, &faces, &unit_box(), all_vertices)?;
assert_eq!(mask.to_indices(), vec![0]);
}
Ok(())
}
#[test]
fn a_face_entirely_outside_is_selected_neither_way() -> Result<()> {
let (points, faces) = one_face(
Point3::new(5.0, 5.0, 5.0),
Point3::new(6.0, 5.0, 5.0),
Point3::new(5.0, 6.0, 5.0),
);
for all_vertices in [true, false] {
let mask = compute_face_mask_in_aabb(&points, &faces, &unit_box(), all_vertices)?;
assert!(mask.to_indices().is_empty());
}
Ok(())
}
#[test]
fn a_face_with_one_vertex_inside_splits_the_two_meanings() -> Result<()> {
let (points, faces) = one_face(
Point3::new(0.5, 0.5, 0.5),
Point3::new(5.0, 0.5, 0.5),
Point3::new(0.5, 5.0, 0.5),
);
let strict = compute_face_mask_in_aabb(&points, &faces, &unit_box(), true)?;
let loose = compute_face_mask_in_aabb(&points, &faces, &unit_box(), false)?;
assert!(strict.to_indices().is_empty());
assert_eq!(loose.to_indices(), vec![0]);
Ok(())
}
#[test]
fn a_face_straddling_the_box_with_no_vertex_inside_is_selected() -> Result<()> {
let (points, faces) = one_face(
Point3::new(-1.0, 0.5, 0.5),
Point3::new(2.0, 0.5, 0.5),
Point3::new(0.5, 0.5, 3.0),
);
let strict = compute_face_mask_in_aabb(&points, &faces, &unit_box(), true)?;
let loose = compute_face_mask_in_aabb(&points, &faces, &unit_box(), false)?;
assert!(strict.to_indices().is_empty());
assert_eq!(loose.to_indices(), vec![0]);
Ok(())
}
#[test]
fn a_face_which_only_its_bounding_box_overlaps_is_not_selected() -> Result<()> {
let (points, faces) = one_face(
Point3::new(0.5, 2.0, 0.5),
Point3::new(2.0, 0.5, 0.5),
Point3::new(2.0, 2.0, 0.5),
);
let loose = compute_face_mask_in_aabb(&points, &faces, &unit_box(), false)?;
assert!(loose.to_indices().is_empty());
Ok(())
}
#[test]
fn an_out_of_range_face_index_is_an_error() {
let (points, _) = one_face(
Point3::new(0.1, 0.1, 0.5),
Point3::new(0.9, 0.1, 0.5),
Point3::new(0.5, 0.9, 0.5),
);
let faces = vec![[0, 1, 3]];
assert!(compute_face_mask_in_aabb(&points, &faces, &unit_box(), false).is_err());
}
#[test]
fn empty_buffers_produce_empty_masks() -> Result<()> {
let mask = compute_point_mask_in_aabb(&[], &unit_box());
assert_eq!(mask.len(), 0);
let mask = compute_face_mask_in_aabb(&[], &[], &unit_box(), false)?;
assert_eq!(mask.len(), 0);
Ok(())
}
}