openmesh 0.1.0

Vertex-face mesh validation
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

use crate::Face;
use rustc_hash::FxHashMap;

#[derive(Debug, Clone, PartialEq, Eq)]
/// Map of edges to their counts and directions.
pub struct EdgeMap {
    /// Key: (v1, v2) sorted, Value: number of faces sharing this edge
    pub counts: FxHashMap<(usize, usize), u8>,
    /// Key: (v1, v2) directed, Value: number of times this specific direction occurs
    pub directions: FxHashMap<(usize, usize), u8>,
}

#[cfg(feature = "rayon")]
use rayon::prelude::*;

impl EdgeMap {
    pub fn from_faces(faces: &[Face]) -> Self {
        #[cfg(feature = "rayon")]
        {
            let (counts, directions) = faces
                .par_iter()
                .fold(
                    || (FxHashMap::default(), FxHashMap::default()),
                    |(mut counts, mut directions), f| {
                        Self::update_maps(&mut counts, &mut directions, f);
                        (counts, directions)
                    },
                )
                .reduce(
                    || (FxHashMap::default(), FxHashMap::default()),
                    |(mut c1, mut d1), (c2, d2)| {
                        for (k, v) in c2 {
                            *c1.entry(k).or_insert(0) += v;
                        }
                        for (k, v) in d2 {
                            *d1.entry(k).or_insert(0) += v;
                        }
                        (c1, d1)
                    },
                );
            Self { counts, directions }
        }
        #[cfg(not(feature = "rayon"))]
        {
            let mut counts = FxHashMap::default();
            let mut directions = FxHashMap::default();

            for f in faces {
                Self::update_maps(&mut counts, &mut directions, f);
            }
            Self { counts, directions }
        }
    }

    fn update_maps(
        counts: &mut FxHashMap<(usize, usize), u8>,
        directions: &mut FxHashMap<(usize, usize), u8>,
        f: &Face,
    ) {
        let edges = [(f.0, f.1), (f.1, f.2), (f.2, f.0)];
        for &(v1, v2) in &edges {
            // Directed: track the winding order
            *directions.entry((v1, v2)).or_insert(0) += 1;

            // Undirected: track topological connectivity
            let key = if v1 < v2 { (v1, v2) } else { (v2, v1) };
            *counts.entry(key).or_insert(0) += 1;
        }
    }
}