draco_oxide_core/mesh/

mod.rs

pub mod builder;
pub mod ds;

use crate::attribute::{Attribute, AttributeType, ComponentDataType};
use crate::types::{Float, Vector};
use crate::types::{NdVector, PointIdx};
use crate::utils::geom::point_to_face_distance_3d;

/// Represents a 3D mesh.
/// It consists of a list of faces, where each face is defined by three vertex indices,
/// and a list of attributes ([Attribute]) that can be associated with the mesh.
#[derive(Clone, Debug)]
pub struct Mesh {
    /// The faces as point-index triples.
    pub faces: Vec<[PointIdx; 3]>,
    /// The attributes attached to the mesh.
    pub attributes: Vec<Attribute>,

    name: String,
}

impl Default for Mesh {
    fn default() -> Self {
        Self::new()
    }
}

impl Mesh {
    /// Returns the attributes of the mesh.
    pub fn get_attributes(&self) -> &[Attribute] {
        &self.attributes
    }

    /// Returns the faces of the mesh as point-index triples.
    pub fn get_faces(&self) -> &[[PointIdx; 3]] {
        &self.faces
    }

    /// Returns the attributes of the mesh mutably.
    pub fn get_attributes_mut(&mut self) -> &mut [Attribute] {
        &mut self.attributes
    }

    /// Returns mutable references to the attributes at the given indices.
    ///
    /// The indices must be pairwise distinct; duplicate indices would produce
    /// two mutable references to the same attribute. Panics if any index is
    /// out of bounds.
    pub fn get_attributes_mut_by_indices<'a>(
        &'a mut self,
        indices: &[usize],
    ) -> Vec<&'a mut Attribute> {
        let out = indices
            .iter()
            .map(|i| &mut self.attributes[*i] as *mut Attribute)
            .collect::<Vec<_>>();

        // Safety: the indices are pairwise distinct per the documented
        // contract, so the resulting mutable references do not alias.
        unsafe {
            let out = out.to_vec();
            std::mem::transmute::<Vec<*mut Attribute>, Vec<&mut Attribute>>(out)
        }
    }

    /// Returns the name of the mesh, or an empty string if unset.
    pub fn get_name(&self) -> &str {
        &self.name
    }

    /// Sets the name of the mesh.
    pub fn set_name(&mut self, name: &str) {
        self.name = name.to_owned();
    }

    /// Creates an empty mesh with no faces and no attributes.
    pub fn new() -> Self {
        Self {
            faces: Vec::new(),
            attributes: Vec::new(),

            name: String::new(),
        }
    }

    /// Computes a symmetric point-to-surface L2 distance between the position
    /// attributes of `self` and `other`, normalized by the total number of
    /// points. Panics if a position attribute does not have three float
    /// components.
    pub fn diff_l2_norm(&self, other: &Self) -> f64 {
        let pos_att_iter = self
            .attributes
            .iter()
            .enumerate()
            .filter(|(_, att)| att.get_attribute_type() == AttributeType::Position);
        let other_pos_att_iter = other
            .attributes
            .iter()
            .enumerate()
            .filter(|(_, att)| att.get_attribute_type() == AttributeType::Position);

        let mut num_points = 0;
        let mut sum_of_squared_dist = 0.0;
        for ((_, pos_att), (_, other_pos_att)) in pos_att_iter.zip(other_pos_att_iter) {
            if pos_att.get_num_components() != 3 {
                panic!("Position attribute must have 3 components, but the first mesh has {} components", pos_att.get_num_components());
            }

            // Faces are now stored directly in the mesh
            let faces = &self.faces;
            let other_faces = &other.faces;

            num_points += pos_att.len();
            num_points += other_pos_att.len();
            sum_of_squared_dist +=
                sum_of_squared_dist_unpack_datatype(pos_att, faces, other_pos_att, other_faces);
        }

        sum_of_squared_dist.sqrt() / num_points as f64
    }
}

fn sum_of_squared_dist_unpack_datatype(
    position_att: &Attribute,
    faces: &[[PointIdx; 3]],
    other_position_att: &Attribute,
    other_faces: &[[PointIdx; 3]],
) -> f64 {
    // Safety:
    // 1. The number of components is checked to be 3.
    // 2. The component type is checked to be f32 or f64.
    unsafe {
        match position_att.get_component_type() {
            ComponentDataType::F32 => sum_of_squared_dist_impl::<f32>(
                position_att,
                faces,
                other_position_att,
                other_faces,
            ) as f64,
            ComponentDataType::F64 => sum_of_squared_dist_impl::<f64>(
                position_att,
                faces,
                other_position_att,
                other_faces,
            ),
            _ => panic!("Position Attribute is not of type f32 or f64"),
        }
    }
}

// # Safety: it must be safe to cast the first argument to &[Data]
unsafe fn sum_of_squared_dist_impl<F>(
    self_pos_att: &Attribute,
    self_faces: &[[PointIdx; 3]],
    other_pos_att: &Attribute,
    other_faces: &[[PointIdx; 3]],
) -> F
where
    F: Float,
    NdVector<3, F>: Vector<3, Component = F>,
{
    assert!(
        other_pos_att.get_component_type() == self_pos_att.get_component_type(),
        "Component types must match, but the first mesh has {:?} and the second mesh has {:?}",
        self_pos_att.get_component_type(),
        other_pos_att.get_component_type()
    );

    if other_pos_att.get_num_components() != 3 {
        panic!(
            "Position attribute must have 3 components, but the second mesh has {} components",
            other_pos_att.get_num_components()
        );
    }

    // Faces reference points; resolve them to unique-value indices so the value
    // slices below can be indexed directly (the point-to-value map need not be
    // the identity).
    let resolve = |att: &Attribute, faces: &[[PointIdx; 3]]| -> Vec<[usize; 3]> {
        faces
            .iter()
            .map(|f| {
                [
                    usize::from(att.get_unique_val_idx(f[0])),
                    usize::from(att.get_unique_val_idx(f[1])),
                    usize::from(att.get_unique_val_idx(f[2])),
                ]
            })
            .collect()
    };
    let self_face_vals = resolve(self_pos_att, self_faces);
    let other_face_vals = resolve(other_pos_att, other_faces);

    // Safety: upheld
    let self_pos_att = self_pos_att.unique_vals_as_slice_unchecked::<NdVector<3, F>>();
    // Satety: Just checked
    let other_pos_att = unsafe { other_pos_att.unique_vals_as_slice_unchecked::<NdVector<3, F>>() };

    let mut sum_of_squared_dist = F::zero();
    for pos in self_pos_att.iter() {
        let min_dist = min_dist_point_to_faces(*pos, &other_face_vals, other_pos_att);
        sum_of_squared_dist += min_dist * min_dist;
    }
    for pos in other_pos_att.iter() {
        let min_dist = min_dist_point_to_faces(*pos, &self_face_vals, self_pos_att);
        sum_of_squared_dist += min_dist * min_dist;
    }

    sum_of_squared_dist.sqrt()
}

fn min_dist_point_to_faces<F>(
    p: NdVector<3, F>,
    face_vals: &[[usize; 3]],
    pos_att: &[NdVector<3, F>],
) -> F
where
    F: Float,
{
    let mut min_dist = F::MAX_VALUE;
    for face in face_vals {
        let v0 = pos_att[face[0]];
        let v1 = pos_att[face[1]];
        let v2 = pos_att[face[2]];
        let dist = point_to_face_distance_3d(p, [v0, v1, v2]);
        if dist < min_dist {
            min_dist = dist;
        }
    }
    min_dist
}