oxihuman-mesh 0.2.1

Mesh processing, topology, and geometry algorithms for OxiHuman
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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

#![allow(dead_code)]
//! Per-vertex displacement vectors.

/// Per-vertex displacement data.
#[allow(dead_code)]
#[derive(Debug, Clone, PartialEq)]
pub struct VertexDisplacement {
    pub displacements: Vec<[f32; 3]>,
}

/// Create a new displacement set for N vertices.
#[allow(dead_code)]
pub fn new_displacement(count: usize) -> VertexDisplacement {
    VertexDisplacement {
        displacements: vec![[0.0; 3]; count],
    }
}

/// Set displacement at a vertex.
#[allow(dead_code)]
pub fn set_displacement(disp: &mut VertexDisplacement, index: usize, value: [f32; 3]) {
    if index < disp.displacements.len() {
        disp.displacements[index] = value;
    }
}

/// Get displacement at a vertex.
#[allow(dead_code)]
pub fn get_displacement(disp: &VertexDisplacement, index: usize) -> [f32; 3] {
    if index < disp.displacements.len() {
        disp.displacements[index]
    } else {
        [0.0; 3]
    }
}

/// Apply displacements to positions in-place.
#[allow(dead_code)]
pub fn apply_displacement(disp: &VertexDisplacement, positions: &mut [[f32; 3]]) {
    for (pos, d) in positions.iter_mut().zip(disp.displacements.iter()) {
        pos[0] += d[0];
        pos[1] += d[1];
        pos[2] += d[2];
    }
}

/// Compute the magnitude of displacement at a vertex.
#[allow(dead_code)]
pub fn displacement_magnitude(disp: &VertexDisplacement, index: usize) -> f32 {
    if index >= disp.displacements.len() {
        return 0.0;
    }
    let d = disp.displacements[index];
    (d[0] * d[0] + d[1] * d[1] + d[2] * d[2]).sqrt()
}

/// Return number of displacement entries.
#[allow(dead_code)]
pub fn displacement_count(disp: &VertexDisplacement) -> usize {
    disp.displacements.len()
}

/// Clear all displacements to zero.
#[allow(dead_code)]
pub fn clear_displacement(disp: &mut VertexDisplacement) {
    for d in &mut disp.displacements {
        *d = [0.0; 3];
    }
}

/// Serialize displacements to bytes.
#[allow(dead_code)]
pub fn displacement_to_bytes(disp: &VertexDisplacement) -> Vec<u8> {
    let mut buf = Vec::new();
    for d in &disp.displacements {
        for &f in d {
            buf.extend_from_slice(&f.to_le_bytes());
        }
    }
    buf
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_new_displacement() {
        let d = new_displacement(5);
        assert_eq!(displacement_count(&d), 5);
    }

    #[test]
    fn test_set_get_displacement() {
        let mut d = new_displacement(2);
        set_displacement(&mut d, 0, [1.0, 2.0, 3.0]);
        assert_eq!(get_displacement(&d, 0), [1.0, 2.0, 3.0]);
    }

    #[test]
    fn test_get_oob() {
        let d = new_displacement(1);
        assert_eq!(get_displacement(&d, 10), [0.0; 3]);
    }

    #[test]
    fn test_apply_displacement() {
        let mut d = new_displacement(1);
        set_displacement(&mut d, 0, [1.0, 0.0, 0.0]);
        let mut pos = [[5.0, 5.0, 5.0]];
        apply_displacement(&d, &mut pos);
        assert_eq!(pos[0], [6.0, 5.0, 5.0]);
    }

    #[test]
    fn test_displacement_magnitude() {
        let mut d = new_displacement(1);
        set_displacement(&mut d, 0, [3.0, 4.0, 0.0]);
        assert!((displacement_magnitude(&d, 0) - 5.0).abs() < 0.001);
    }

    #[test]
    fn test_displacement_magnitude_oob() {
        let d = new_displacement(1);
        assert_eq!(displacement_magnitude(&d, 5), 0.0);
    }

    #[test]
    fn test_clear_displacement() {
        let mut d = new_displacement(2);
        set_displacement(&mut d, 0, [1.0, 1.0, 1.0]);
        clear_displacement(&mut d);
        assert_eq!(get_displacement(&d, 0), [0.0; 3]);
    }

    #[test]
    fn test_displacement_to_bytes() {
        let d = new_displacement(1);
        let bytes = displacement_to_bytes(&d);
        assert_eq!(bytes.len(), 12); // 3 floats * 4 bytes
    }

    #[test]
    fn test_empty_displacement() {
        let d = new_displacement(0);
        assert_eq!(displacement_count(&d), 0);
    }

    #[test]
    fn test_set_oob() {
        let mut d = new_displacement(1);
        set_displacement(&mut d, 100, [1.0; 3]); // should not panic
        assert_eq!(displacement_count(&d), 1);
    }
}