use super::{
Attr3, check_both_or_neither, check_keys_match, check_len, check_reserved, check_same_variant,
clone_indexed, clone_masked, extend_option,
};
use crate::common::IndexMask;
use crate::{Iso3, Result};
use std::collections::HashMap;
#[derive(Debug, Clone, Default, PartialEq)]
pub struct FaceAttrSet3 {
colors: Option<Vec<[u8; 3]>>,
labels: Option<Vec<u32>>,
open: HashMap<String, Attr3>,
}
impl FaceAttrSet3 {
pub fn empty() -> Self {
Self::default()
}
pub fn is_empty(&self) -> bool {
self.colors.is_none() && self.labels.is_none() && self.open.is_empty()
}
pub fn attr_labels(&self) -> Vec<&str> {
let mut names = Vec::new();
if self.colors.is_some() {
names.push("face_colors");
}
if self.labels.is_some() {
names.push("face_labels");
}
names.extend(self.open.keys().map(|k| k.as_str()));
names
}
pub fn colors(&self) -> Option<&[[u8; 3]]> {
self.colors.as_deref()
}
pub fn labels(&self) -> Option<&[u32]> {
self.labels.as_deref()
}
pub fn attr(&self, name: &str) -> Option<&Attr3> {
self.open.get(name)
}
pub fn attr_names(&self) -> impl Iterator<Item = &str> {
self.open.keys().map(|k| k.as_str())
}
}
impl FaceAttrSet3 {
pub fn set_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.colors = values;
Ok(())
}
pub fn set_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.labels = values;
Ok(())
}
pub fn insert_attr(&mut self, name: &str, attr: Attr3, n_faces: usize) -> Result<()> {
check_reserved(name)?;
check_len(Some(attr.len()), n_faces, name)?;
self.open.insert(name.to_string(), attr);
Ok(())
}
pub fn remove_attr(&mut self, name: &str) -> Option<Attr3> {
self.open.remove(name)
}
}
impl FaceAttrSet3 {
pub fn validate(&self, n_faces: usize) -> Result<()> {
check_len(
self.colors.as_ref().map(|v| v.len()),
n_faces,
"face_colors",
)?;
check_len(
self.labels.as_ref().map(|v| v.len()),
n_faces,
"face_labels",
)?;
for (name, attr) in self.open.iter() {
check_len(Some(attr.len()), n_faces, name)?;
}
Ok(())
}
pub fn subset(&self, mask: &IndexMask) -> Result<Self> {
let mut open = HashMap::with_capacity(self.open.len());
for (name, attr) in self.open.iter() {
open.insert(name.clone(), attr.clone_indices_of(mask)?);
}
Ok(Self {
colors: clone_masked(self.colors.as_deref(), mask)?,
labels: clone_masked(self.labels.as_deref(), mask)?,
open,
})
}
pub fn subset_indices(&self, indices: &[usize]) -> Result<Self> {
let mut open = HashMap::with_capacity(self.open.len());
for (name, attr) in self.open.iter() {
open.insert(name.clone(), attr.clone_indices(indices)?);
}
Ok(Self {
colors: clone_indexed(self.colors.as_deref(), indices)?,
labels: clone_indexed(self.labels.as_deref(), indices)?,
open,
})
}
pub fn extend_from(&mut self, other: &Self) -> Result<()> {
self.check_extend_from(other)?;
self.apply_extend_from(other)
}
pub(crate) fn check_extend_from(&self, other: &Self) -> Result<()> {
check_both_or_neither(self.colors.is_some(), other.colors.is_some(), "face_colors")?;
check_both_or_neither(self.labels.is_some(), other.labels.is_some(), "face_labels")?;
check_keys_match(&self.open, &other.open, "face")?;
for (name, attr) in self.open.iter() {
check_same_variant(attr, &other.open[name], name)?;
}
Ok(())
}
pub(crate) fn apply_extend_from(&mut self, other: &Self) -> Result<()> {
extend_option(&mut self.colors, other.colors.as_deref());
extend_option(&mut self.labels, other.labels.as_deref());
for (name, attr) in self.open.iter_mut() {
attr.extend_from(&other.open[name])?;
}
Ok(())
}
}
impl FaceAttrSet3 {
pub fn transform_in_place(&mut self, iso: &Iso3) {
for attr in self.open.values_mut() {
attr.transform_in_place(iso);
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::Vector3;
use crate::geom3::attributes3::RESERVED_ATTR_NAMES;
use approx::assert_relative_eq;
use std::f64::consts::FRAC_PI_2;
const N: usize = 4;
fn full_attrs() -> FaceAttrSet3 {
let mut attrs = FaceAttrSet3::empty();
attrs
.set_colors(Some(vec![[0, 0, 0], [1, 1, 1], [2, 2, 2], [3, 3, 3]]), N)
.unwrap();
attrs.set_labels(Some(vec![10, 11, 12, 13]), N).unwrap();
attrs
.insert_attr("material_index", Attr3::Label(vec![1, 2, 3, 4]), N)
.unwrap();
attrs
}
#[test]
fn empty_set_reports_empty() {
let attrs = FaceAttrSet3::empty();
assert!(attrs.is_empty());
assert!(attrs.colors().is_none());
assert!(attrs.labels().is_none());
assert_eq!(attrs.attr_names().count(), 0);
assert!(!full_attrs().is_empty());
}
#[test]
fn attr_labels_names_every_present_attribute() {
let attrs = full_attrs();
let labels = attrs.attr_labels();
for expected in ["face_colors", "face_labels", "material_index"] {
assert!(
labels.contains(&expected),
"missing '{expected}' in {labels:?}"
);
}
assert!(FaceAttrSet3::empty().attr_labels().is_empty());
}
#[test]
fn setters_reject_a_length_mismatch() {
let mut attrs = FaceAttrSet3::empty();
assert!(attrs.set_colors(Some(vec![[0, 0, 0]]), N).is_err());
assert!(attrs.set_labels(Some(Vec::new()), N).is_err());
assert!(attrs.insert_attr("q", Attr3::Scalar(vec![1.0]), N).is_err());
assert!(attrs.is_empty());
}
#[test]
fn setters_accept_none_regardless_of_count() -> Result<()> {
let mut attrs = full_attrs();
attrs.set_colors(None, N)?;
assert!(attrs.colors().is_none());
attrs.set_labels(None, 0)?;
assert!(attrs.labels().is_none());
Ok(())
}
#[test]
fn open_map_rejects_reserved_names() {
let mut attrs = FaceAttrSet3::empty();
for name in RESERVED_ATTR_NAMES {
assert!(
attrs
.insert_attr(name, Attr3::Scalar(vec![0.0; N]), N)
.is_err(),
"expected '{name}' to be rejected as an attribute name"
);
}
assert!(
attrs
.insert_attr("label_confidence", Attr3::Scalar(vec![0.0; N]), N)
.is_ok()
);
}
#[test]
fn remove_attr_returns_what_was_stored() {
let mut attrs = full_attrs();
let taken = attrs.remove_attr("material_index").unwrap();
assert_eq!(taken.as_label().unwrap(), &[1, 2, 3, 4]);
assert!(attrs.attr("material_index").is_none());
assert!(attrs.remove_attr("material_index").is_none());
}
#[test]
fn validate_catches_a_mismatch() -> Result<()> {
let attrs = full_attrs();
attrs.validate(N)?;
assert!(attrs.validate(N + 1).is_err());
assert!(attrs.validate(0).is_err());
FaceAttrSet3::empty().validate(0)?;
FaceAttrSet3::empty().validate(9999)?;
Ok(())
}
#[test]
fn subset_selects_the_masked_faces() -> Result<()> {
let attrs = full_attrs();
let mask = IndexMask::try_from_indices(&[1, 3], N)?;
let sub = attrs.subset(&mask)?;
sub.validate(2)?;
assert_eq!(sub.colors().unwrap(), &[[1, 1, 1], [3, 3, 3]]);
assert_eq!(sub.labels().unwrap(), &[11, 13]);
assert_eq!(
sub.attr("material_index").unwrap().as_label().unwrap(),
&[2, 4]
);
Ok(())
}
#[test]
fn subset_indices_preserves_order_and_allows_repeats() -> Result<()> {
let attrs = full_attrs();
let sub = attrs.subset_indices(&[3, 0, 3])?;
sub.validate(3)?;
assert_eq!(sub.labels().unwrap(), &[13, 10, 13]);
assert_eq!(sub.colors().unwrap(), &[[3, 3, 3], [0, 0, 0], [3, 3, 3]]);
assert_eq!(
sub.attr("material_index").unwrap().as_label().unwrap(),
&[4, 1, 4]
);
assert!(attrs.subset_indices(&[0, N]).is_err());
Ok(())
}
#[test]
fn extend_from_unions_matching_sets() -> Result<()> {
let mut attrs = full_attrs();
attrs.extend_from(&full_attrs())?;
attrs.validate(N * 2)?;
assert_eq!(attrs.labels().unwrap(), &[10, 11, 12, 13, 10, 11, 12, 13]);
assert_eq!(attrs.attr("material_index").unwrap().len(), N * 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_labels(None, N).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_attr("material_index");
assert!(attrs.extend_from(&other).is_err());
assert_eq!(attrs, full_attrs());
let mut attrs = full_attrs();
attrs.remove_attr("material_index");
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_attr("material_index");
other
.insert_attr("material_index", Attr3::Scalar(vec![1.0, 2.0, 3.0, 4.0]), N)
.unwrap();
assert!(attrs.extend_from(&other).is_err());
assert_eq!(attrs, full_attrs());
}
#[test]
fn transform_rotates_vector_attrs_only() -> Result<()> {
let mut attrs = full_attrs();
attrs.insert_attr(
"face_dir",
Attr3::Vector(vec![Vector3::new(1.0, 0.0, 0.0); N]),
N,
)?;
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.attr("face_dir").unwrap().as_vector().unwrap()[0],
Vector3::new(0.0, 1.0, 0.0),
epsilon = 1.0e-12
);
assert_eq!(attrs.colors(), full_attrs().colors());
assert_eq!(attrs.labels(), full_attrs().labels());
assert_eq!(
attrs.attr("material_index"),
full_attrs().attr("material_index")
);
Ok(())
}
}