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

#![allow(dead_code)]
// Copyright (C) 2026 COOLJAPAN OU (Team KitaSan)
// SPDX-License-Identifier: Apache-2.0

//! Apply morph target (shape key) to base mesh.

#[allow(dead_code)]
pub struct MorphApplyResult {
    pub verts: Vec<[f32; 3]>,
}

#[allow(dead_code)]
pub fn apply_morph(
    base: &[[f32; 3]],
    offsets: &[[f32; 3]],
    weight: f32,
) -> MorphApplyResult {
    let n = base.len().min(offsets.len());
    let mut verts = base.to_vec();
    for i in 0..n {
        verts[i][0] += weight * offsets[i][0];
        verts[i][1] += weight * offsets[i][1];
        verts[i][2] += weight * offsets[i][2];
    }
    MorphApplyResult { verts }
}

#[allow(dead_code)]
pub fn apply_multiple_morphs(
    base: &[[f32; 3]],
    morphs: &[(&[[f32; 3]], f32)],
) -> MorphApplyResult {
    let mut verts = base.to_vec();
    for (offsets, weight) in morphs {
        let n = verts.len().min(offsets.len());
        for i in 0..n {
            verts[i][0] += weight * offsets[i][0];
            verts[i][1] += weight * offsets[i][1];
            verts[i][2] += weight * offsets[i][2];
        }
    }
    MorphApplyResult { verts }
}

#[allow(dead_code)]
pub fn morph_magnitude(offsets: &[[f32; 3]]) -> f32 {
    if offsets.is_empty() {
        return 0.0;
    }
    let mut sum = 0.0f32;
    for o in offsets {
        sum += (o[0] * o[0] + o[1] * o[1] + o[2] * o[2]).sqrt();
    }
    sum / offsets.len() as f32
}

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

    fn base() -> Vec<[f32; 3]> {
        vec![[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]]
    }

    fn offsets() -> Vec<[f32; 3]> {
        vec![[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]]
    }

    #[test]
    fn apply_morph_weight_one() {
        let result = apply_morph(&base(), &offsets(), 1.0);
        assert!((result.verts[0][0] - 1.0).abs() < 1e-6);
        assert!((result.verts[1][1] - 1.0).abs() < 1e-6);
        assert!((result.verts[2][2] - 1.0).abs() < 1e-6);
    }

    #[test]
    fn apply_morph_weight_zero_unchanged() {
        let result = apply_morph(&base(), &offsets(), 0.0);
        assert!((result.verts[0][0]).abs() < 1e-6);
    }

    #[test]
    fn apply_morph_half_weight() {
        let result = apply_morph(&base(), &offsets(), 0.5);
        assert!((result.verts[0][0] - 0.5).abs() < 1e-6);
    }

    #[test]
    fn apply_morph_preserves_count() {
        let result = apply_morph(&base(), &offsets(), 1.0);
        assert_eq!(result.verts.len(), base().len());
    }

    #[test]
    fn apply_multiple_morphs_additive() {
        let off1: Vec<[f32; 3]> = vec![[1.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]];
        let off2: Vec<[f32; 3]> = vec![[0.0, 1.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]];
        let result = apply_multiple_morphs(&base(), &[(&off1, 1.0), (&off2, 1.0)]);
        assert!((result.verts[0][0] - 1.0).abs() < 1e-6);
        assert!((result.verts[0][1] - 1.0).abs() < 1e-6);
    }

    #[test]
    fn apply_multiple_morphs_empty_list() {
        let result = apply_multiple_morphs(&base(), &[]);
        assert_eq!(result.verts.len(), base().len());
        assert!((result.verts[0][0]).abs() < 1e-6);
    }

    #[test]
    fn morph_magnitude_zero_offsets() {
        let offs = vec![[0.0f32; 3]; 3];
        assert!((morph_magnitude(&offs)).abs() < 1e-6);
    }

    #[test]
    fn morph_magnitude_unit_offsets() {
        let offs = vec![[1.0f32, 0.0, 0.0]; 3];
        assert!((morph_magnitude(&offs) - 1.0).abs() < 1e-6);
    }

    #[test]
    fn morph_magnitude_empty() {
        assert!((morph_magnitude(&[])).abs() < 1e-6);
    }
}