use super::normals::compute_face_normal;
use crate::{Point3, Result, UnitVec3};
pub fn compute_face_normals(points: &[Point3], faces: &[[u32; 3]]) -> Result<Vec<UnitVec3>> {
faces
.iter()
.enumerate()
.map(|(i, face)| {
let p = face_points(points, face, i)?;
compute_face_normal(&p).ok_or_else(|| {
format!("Face {i} has no normal, because its points are coincident or collinear")
.into()
})
})
.collect()
}
pub fn compute_face_areas(points: &[Point3], faces: &[[u32; 3]]) -> Result<Vec<f64>> {
faces
.iter()
.enumerate()
.map(|(i, face)| {
let p = face_points(points, face, i)?;
Ok((p[1] - p[0]).cross(&(p[2] - p[0])).norm() * 0.5)
})
.collect()
}
pub fn compute_face_centers(points: &[Point3], faces: &[[u32; 3]]) -> Result<Vec<Point3>> {
faces
.iter()
.enumerate()
.map(|(i, face)| {
let p = face_points(points, face, i)?;
Ok(Point3::from(
(p[0].coords + p[1].coords + p[2].coords) / 3.0,
))
})
.collect()
}
pub(super) fn face_points(points: &[Point3], face: &[u32; 3], index: usize) -> Result<[Point3; 3]> {
let mut out = [Point3::origin(); 3];
for (slot, i) in out.iter_mut().zip(face.iter()) {
*slot = *points.get(*i as usize).ok_or_else(|| {
format!(
"Face {index} refers to point {i}, but the mesh has only {} points",
points.len()
)
})?;
}
Ok(out)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::Vector3;
use approx::assert_relative_eq;
fn triangle() -> (Vec<Point3>, Vec<[u32; 3]>) {
let points = vec![
Point3::new(0.0, 0.0, 0.0),
Point3::new(3.0, 0.0, 0.0),
Point3::new(0.0, 4.0, 0.0),
];
(points, vec![[0, 1, 2]])
}
#[test]
fn a_right_triangle_has_the_expected_normal_area_and_center() -> Result<()> {
let (points, faces) = triangle();
assert_relative_eq!(
compute_face_normals(&points, &faces)?[0].into_inner(),
Vector3::z(),
epsilon = 1.0e-12
);
assert_relative_eq!(
compute_face_areas(&points, &faces)?[0],
6.0,
epsilon = 1.0e-12
);
assert_relative_eq!(
compute_face_centers(&points, &faces)?[0],
Point3::new(1.0, 4.0 / 3.0, 0.0),
epsilon = 1.0e-12
);
Ok(())
}
#[test]
fn reversing_the_winding_reverses_the_normal() -> Result<()> {
let (points, _) = triangle();
let normals = compute_face_normals(&points, &[[1, 0, 2]])?;
assert_relative_eq!(normals[0].into_inner(), -Vector3::z(), epsilon = 1.0e-12);
Ok(())
}
#[test]
fn a_collinear_face_has_no_normal_but_does_have_an_area() -> Result<()> {
let points = vec![
Point3::new(0.0, 0.0, 0.0),
Point3::new(1.0, 0.0, 0.0),
Point3::new(2.0, 0.0, 0.0),
];
let faces = vec![[0, 1, 2]];
assert!(compute_face_normals(&points, &faces).is_err());
assert_relative_eq!(compute_face_areas(&points, &faces)?[0], 0.0);
assert_relative_eq!(
compute_face_centers(&points, &faces)?[0],
Point3::new(1.0, 0.0, 0.0),
epsilon = 1.0e-12
);
Ok(())
}
#[test]
fn an_out_of_range_index_is_an_error() {
let (points, _) = triangle();
let faces = vec![[0, 1, 7]];
assert!(compute_face_normals(&points, &faces).is_err());
assert!(compute_face_areas(&points, &faces).is_err());
assert!(compute_face_centers(&points, &faces).is_err());
}
}