use crate::common::IndexMask;
use crate::geom3::attributes3::{
Attr3, PointAttrSet3, check_both_or_neither, check_keys_match, check_len, check_reserved,
check_same_variant, clone_masked, extend_option,
};
use crate::{Iso3, Result, UnitVec3};
use std::collections::HashMap;
#[derive(Debug, Clone, Default, PartialEq)]
pub struct MeshAttrSet3 {
points: PointAttrSet3,
face_colors: Option<Vec<[u8; 3]>>,
face_labels: Option<Vec<u32>>,
face_attrs: HashMap<String, Attr3>,
}
impl MeshAttrSet3 {
pub fn empty() -> Self {
Self::default()
}
pub fn is_empty(&self) -> bool {
self.points.is_empty()
&& self.face_colors.is_none()
&& self.face_labels.is_none()
&& self.face_attrs.is_empty()
}
pub fn points(&self) -> &PointAttrSet3 {
&self.points
}
pub fn point_attr_labels(&self) -> Vec<&str> {
self.points.attr_labels()
}
pub fn face_attr_labels(&self) -> Vec<&str> {
let mut names = Vec::new();
if self.face_colors.is_some() {
names.push("face_colors");
}
if self.face_labels.is_some() {
names.push("face_labels");
}
names.extend(self.face_attrs.keys().map(|k| k.as_str()));
names
}
pub fn point_normals(&self) -> Option<&[UnitVec3]> {
self.points.normals()
}
pub fn point_colors(&self) -> Option<&[[u8; 3]]> {
self.points.colors()
}
pub fn point_stdev(&self) -> Option<&[f64]> {
self.points.stdev()
}
pub fn face_colors(&self) -> Option<&[[u8; 3]]> {
self.face_colors.as_deref()
}
pub fn face_labels(&self) -> Option<&[u32]> {
self.face_labels.as_deref()
}
pub fn point_attr(&self, name: &str) -> Option<&Attr3> {
self.points.attr(name)
}
pub fn face_attr(&self, name: &str) -> Option<&Attr3> {
self.face_attrs.get(name)
}
pub fn point_attr_names(&self) -> impl Iterator<Item = &str> {
self.points.attr_names()
}
pub fn face_attr_names(&self) -> impl Iterator<Item = &str> {
self.face_attrs.keys().map(|k| k.as_str())
}
}
impl MeshAttrSet3 {
pub fn set_point_normals(
&mut self,
values: Option<Vec<UnitVec3>>,
n_points: usize,
) -> Result<()> {
self.points.set_normals(values, n_points)
}
pub fn set_point_colors(
&mut self,
values: Option<Vec<[u8; 3]>>,
n_points: usize,
) -> Result<()> {
self.points.set_colors(values, n_points)
}
pub fn set_point_stdev(&mut self, values: Option<Vec<f64>>, n_points: usize) -> Result<()> {
self.points.set_stdev(values, n_points)
}
pub fn set_face_colors(&mut self, values: Option<Vec<[u8; 3]>>, n_faces: usize) -> Result<()> {
check_len(values.as_deref().map(|v| v.len()), n_faces, "face_colors")?;
self.face_colors = values;
Ok(())
}
pub fn set_face_labels(&mut self, values: Option<Vec<u32>>, n_faces: usize) -> Result<()> {
check_len(values.as_deref().map(|v| v.len()), n_faces, "face_labels")?;
self.face_labels = values;
Ok(())
}
pub fn insert_point_attr(&mut self, name: &str, attr: Attr3, n_points: usize) -> Result<()> {
self.points.insert_attr(name, attr, n_points)
}
pub fn insert_face_attr(&mut self, name: &str, attr: Attr3, n_faces: usize) -> Result<()> {
check_reserved(name)?;
check_len(Some(attr.len()), n_faces, name)?;
self.face_attrs.insert(name.to_string(), attr);
Ok(())
}
pub fn remove_point_attr(&mut self, name: &str) -> Option<Attr3> {
self.points.remove_attr(name)
}
pub fn remove_face_attr(&mut self, name: &str) -> Option<Attr3> {
self.face_attrs.remove(name)
}
pub fn set_points(&mut self, points: PointAttrSet3, n_points: usize) -> Result<()> {
points.validate(n_points)?;
self.points = points;
Ok(())
}
}
impl MeshAttrSet3 {
pub fn validate(&self, n_points: usize, n_faces: usize) -> Result<()> {
self.points.validate(n_points)?;
check_len(
self.face_colors.as_ref().map(|v| v.len()),
n_faces,
"face_colors",
)?;
check_len(
self.face_labels.as_ref().map(|v| v.len()),
n_faces,
"face_labels",
)?;
for (name, attr) in self.face_attrs.iter() {
check_len(Some(attr.len()), n_faces, name)?;
}
Ok(())
}
pub fn subset(&self, point_mask: &IndexMask, face_mask: &IndexMask) -> Result<Self> {
let mut face_attrs = HashMap::with_capacity(self.face_attrs.len());
for (name, attr) in self.face_attrs.iter() {
face_attrs.insert(name.clone(), attr.clone_indices_of(face_mask)?);
}
Ok(Self {
points: self.points.subset(point_mask)?,
face_colors: clone_masked(self.face_colors.as_deref(), face_mask)?,
face_labels: clone_masked(self.face_labels.as_deref(), face_mask)?,
face_attrs,
})
}
pub fn extend_from(&mut self, other: &Self) -> Result<()> {
self.points.check_extend_from(&other.points)?;
check_both_or_neither(
self.face_colors.is_some(),
other.face_colors.is_some(),
"face_colors",
)?;
check_both_or_neither(
self.face_labels.is_some(),
other.face_labels.is_some(),
"face_labels",
)?;
check_keys_match(&self.face_attrs, &other.face_attrs, "face")?;
for (name, attr) in self.face_attrs.iter() {
check_same_variant(attr, &other.face_attrs[name], name)?;
}
self.points.apply_extend_from(&other.points)?;
extend_option(&mut self.face_colors, other.face_colors.as_deref());
extend_option(&mut self.face_labels, other.face_labels.as_deref());
for (name, attr) in self.face_attrs.iter_mut() {
attr.extend_from(&other.face_attrs[name])?;
}
Ok(())
}
}
impl MeshAttrSet3 {
pub fn transform_in_place(&mut self, iso: &Iso3) {
self.points.transform_in_place(iso);
for attr in self.face_attrs.values_mut() {
attr.transform_in_place(iso);
}
}
pub fn scale_in_place(&mut self, scale: f64) {
self.points.scale_in_place(scale);
}
pub fn flip_in_place(&mut self) {
self.points.flip_in_place();
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::Vector3;
use crate::geom3::attributes3::RESERVED_ATTR_NAMES;
use approx::assert_relative_eq;
const N_POINTS: usize = 4;
const N_FACES: usize = 2;
fn full_attrs() -> MeshAttrSet3 {
let mut attrs = MeshAttrSet3::empty();
attrs
.set_point_normals(
Some(vec![
UnitVec3::new_normalize(Vector3::new(1.0, 0.0, 0.0)),
UnitVec3::new_normalize(Vector3::new(0.0, 1.0, 0.0)),
UnitVec3::new_normalize(Vector3::new(0.0, 0.0, 1.0)),
UnitVec3::new_normalize(Vector3::new(1.0, 1.0, 1.0)),
]),
N_POINTS,
)
.unwrap();
attrs
.set_point_colors(
Some(vec![[0, 0, 0], [1, 1, 1], [2, 2, 2], [3, 3, 3]]),
N_POINTS,
)
.unwrap();
attrs
.set_point_stdev(Some(vec![0.1, 0.2, 0.3, 0.4]), N_POINTS)
.unwrap();
attrs
.set_face_colors(Some(vec![[10, 10, 10], [20, 20, 20]]), N_FACES)
.unwrap();
attrs.set_face_labels(Some(vec![7, 8]), N_FACES).unwrap();
attrs
.insert_point_attr(
"confidence",
Attr3::Scalar(vec![0.5, 0.6, 0.7, 0.8]),
N_POINTS,
)
.unwrap();
attrs
.insert_face_attr("material_index", Attr3::Label(vec![1, 2]), N_FACES)
.unwrap();
attrs
}
#[test]
fn empty_set_reports_empty() {
let attrs = MeshAttrSet3::empty();
assert!(attrs.is_empty());
assert!(attrs.point_normals().is_none());
assert!(attrs.face_labels().is_none());
assert_eq!(attrs.point_attr_names().count(), 0);
assert!(!full_attrs().is_empty());
}
#[test]
fn a_face_only_set_is_not_empty() -> Result<()> {
let mut attrs = MeshAttrSet3::empty();
attrs.set_face_labels(Some(vec![1, 2]), N_FACES)?;
assert!(!attrs.is_empty());
assert!(attrs.points().is_empty());
Ok(())
}
#[test]
fn setters_reject_a_length_mismatch() {
let mut attrs = MeshAttrSet3::empty();
assert!(
attrs
.set_point_colors(Some(vec![[0, 0, 0]]), N_POINTS)
.is_err()
);
assert!(attrs.set_face_labels(Some(vec![1, 2, 3]), N_FACES).is_err());
assert!(
attrs
.insert_point_attr("q", Attr3::Scalar(vec![1.0]), N_POINTS)
.is_err()
);
assert!(attrs.is_empty());
}
#[test]
fn setters_accept_none_regardless_of_count() -> Result<()> {
let mut attrs = full_attrs();
attrs.set_point_colors(None, N_POINTS)?;
assert!(attrs.point_colors().is_none());
Ok(())
}
#[test]
fn stdev_rejects_negative_and_nan() {
let mut attrs = MeshAttrSet3::empty();
assert!(
attrs
.set_point_stdev(Some(vec![0.1, -0.2, 0.3, 0.4]), N_POINTS)
.is_err()
);
assert!(
attrs
.set_point_stdev(Some(vec![0.1, f64::NAN, 0.3, 0.4]), N_POINTS)
.is_err()
);
assert!(
attrs
.set_point_stdev(Some(vec![0.0, 0.2, 0.3, 0.4]), N_POINTS)
.is_ok()
);
}
#[test]
fn open_maps_reject_reserved_names() {
let mut attrs = MeshAttrSet3::empty();
for name in RESERVED_ATTR_NAMES {
assert!(
attrs
.insert_point_attr(name, Attr3::Scalar(vec![0.0; N_POINTS]), N_POINTS)
.is_err(),
"expected '{name}' to be rejected as a point attribute name"
);
assert!(
attrs
.insert_face_attr(name, Attr3::Scalar(vec![0.0; N_FACES]), N_FACES)
.is_err(),
"expected '{name}' to be rejected as a face attribute name"
);
}
assert!(
attrs
.insert_point_attr(
"scanner_color_temp",
Attr3::Scalar(vec![0.0; N_POINTS]),
N_POINTS
)
.is_ok()
);
}
#[test]
fn validate_catches_a_mismatch_in_either_domain() -> Result<()> {
let attrs = full_attrs();
attrs.validate(N_POINTS, N_FACES)?;
assert!(attrs.validate(N_POINTS + 1, N_FACES).is_err());
assert!(attrs.validate(N_POINTS, N_FACES + 1).is_err());
Ok(())
}
#[test]
fn subset_selects_from_the_correct_domain() -> Result<()> {
let attrs = full_attrs();
let point_mask = IndexMask::try_from_indices(&[1, 3], N_POINTS)?;
let face_mask = IndexMask::try_from_indices(&[0], N_FACES)?;
let sub = attrs.subset(&point_mask, &face_mask)?;
sub.validate(2, 1)?;
assert_eq!(sub.point_colors().unwrap(), &[[1, 1, 1], [3, 3, 3]]);
assert_eq!(sub.point_stdev().unwrap(), &[0.2, 0.4]);
assert_eq!(sub.face_colors().unwrap(), &[[10, 10, 10]]);
assert_eq!(sub.face_labels().unwrap(), &[7]);
assert_eq!(
sub.point_attr("confidence").unwrap().as_scalar().unwrap(),
&[0.6, 0.8]
);
assert_eq!(
sub.face_attr("material_index").unwrap().as_label().unwrap(),
&[1]
);
Ok(())
}
#[test]
fn extend_from_unions_matching_sets() -> Result<()> {
let mut attrs = full_attrs();
attrs.extend_from(&full_attrs())?;
attrs.validate(N_POINTS * 2, N_FACES * 2)?;
assert_eq!(attrs.point_stdev().unwrap().len(), N_POINTS * 2);
assert_eq!(attrs.face_labels().unwrap(), &[7, 8, 7, 8]);
assert_eq!(attrs.point_attr("confidence").unwrap().len(), N_POINTS * 2);
Ok(())
}
#[test]
fn extend_from_rejects_a_typed_field_on_only_one_side() {
let mut attrs = full_attrs();
let mut other = full_attrs();
other.set_point_stdev(None, N_POINTS).unwrap();
assert!(attrs.extend_from(&other).is_err());
assert_eq!(attrs, full_attrs());
}
#[test]
fn extend_from_rejects_an_open_key_on_only_one_side() {
let mut attrs = full_attrs();
let mut other = full_attrs();
other.remove_point_attr("confidence");
assert!(attrs.extend_from(&other).is_err());
assert_eq!(attrs, full_attrs());
let mut attrs = full_attrs();
attrs.remove_point_attr("confidence");
assert!(attrs.extend_from(&full_attrs()).is_err());
}
#[test]
fn extend_from_rejects_a_variant_mismatch_under_the_same_name() {
let mut attrs = full_attrs();
let mut other = full_attrs();
other.remove_point_attr("confidence");
other
.insert_point_attr("confidence", Attr3::Label(vec![1, 2, 3, 4]), N_POINTS)
.unwrap();
assert!(attrs.extend_from(&other).is_err());
assert_eq!(attrs, full_attrs());
}
#[test]
fn a_face_domain_rejection_leaves_the_point_domain_untouched() {
let mut attrs = full_attrs();
let mut other = full_attrs();
other.remove_face_attr("material_index");
assert!(attrs.extend_from(&other).is_err());
assert_eq!(attrs, full_attrs());
assert_eq!(attrs.point_stdev().unwrap().len(), N_POINTS);
assert_eq!(attrs.point_attr("confidence").unwrap().len(), N_POINTS);
}
#[test]
fn transform_rotates_vector_attrs_in_both_domains() -> Result<()> {
use std::f64::consts::FRAC_PI_2;
let mut attrs = full_attrs();
attrs.insert_point_attr(
"principal_dir",
Attr3::Vector(vec![Vector3::new(1.0, 0.0, 0.0); N_POINTS]),
N_POINTS,
)?;
attrs.insert_face_attr(
"face_dir",
Attr3::Vector(vec![Vector3::new(1.0, 0.0, 0.0); N_FACES]),
N_FACES,
)?;
let iso = Iso3::new(Vector3::new(5.0, 6.0, 7.0), Vector3::z() * FRAC_PI_2);
attrs.transform_in_place(&iso);
assert_relative_eq!(
attrs.point_normals().unwrap()[0].into_inner(),
Vector3::new(0.0, 1.0, 0.0),
epsilon = 1.0e-12
);
assert_relative_eq!(
attrs
.point_attr("principal_dir")
.unwrap()
.as_vector()
.unwrap()[0],
Vector3::new(0.0, 1.0, 0.0),
epsilon = 1.0e-12
);
assert_relative_eq!(
attrs.face_attr("face_dir").unwrap().as_vector().unwrap()[0],
Vector3::new(0.0, 1.0, 0.0),
epsilon = 1.0e-12
);
Ok(())
}
#[test]
fn scale_affects_only_the_standard_deviations() {
let mut attrs = full_attrs();
attrs.scale_in_place(25.4);
for (actual, expected) in attrs
.point_stdev()
.unwrap()
.iter()
.zip([0.1, 0.2, 0.3, 0.4].iter())
{
assert_relative_eq!(*actual, expected * 25.4, epsilon = 1.0e-12);
}
assert_eq!(
attrs.point_attr("confidence").unwrap().as_scalar().unwrap(),
&[0.5, 0.6, 0.7, 0.8]
);
}
#[test]
fn flip_negates_the_point_normals() {
let original = full_attrs();
let mut attrs = full_attrs();
attrs.flip_in_place();
for (flipped, source) in attrs
.point_normals()
.unwrap()
.iter()
.zip(original.point_normals().unwrap().iter())
{
assert_relative_eq!(
flipped.into_inner(),
-source.into_inner(),
epsilon = 1.0e-12
);
}
assert_eq!(attrs.point_colors(), original.point_colors());
assert_eq!(attrs.face_colors(), original.face_colors());
}
}