oxihuman-morph 0.1.2

Parametric morphology engine for human body generation — targets, blendshapes, FACS
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

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

//! Rib cage expansion morph — controls thoracic expansion during breathing.

/// Rib cage morph configuration.
#[derive(Debug, Clone)]
pub struct RibCageMorph {
    pub expansion: f32,
    pub upper_chest: f32,
    pub lower_chest: f32,
    pub lateral_flare: f32,
}

impl RibCageMorph {
    pub fn new() -> Self {
        Self {
            expansion: 0.0,
            upper_chest: 0.0,
            lower_chest: 0.0,
            lateral_flare: 0.0,
        }
    }
}

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

/// Create a new rib cage morph.
pub fn new_rib_cage_morph() -> RibCageMorph {
    RibCageMorph::new()
}

/// Set overall thoracic expansion.
pub fn rib_cage_set_expansion(m: &mut RibCageMorph, v: f32) {
    m.expansion = v.clamp(0.0, 1.0);
}

/// Set upper chest contribution.
pub fn rib_cage_set_upper_chest(m: &mut RibCageMorph, v: f32) {
    m.upper_chest = v.clamp(0.0, 1.0);
}

/// Set lower chest contribution.
pub fn rib_cage_set_lower_chest(m: &mut RibCageMorph, v: f32) {
    m.lower_chest = v.clamp(0.0, 1.0);
}

/// Set lateral rib flare.
pub fn rib_cage_set_lateral_flare(m: &mut RibCageMorph, v: f32) {
    m.lateral_flare = v.clamp(0.0, 1.0);
}

/// Weighted average expansion across chest regions.
pub fn rib_cage_mean_expansion(m: &RibCageMorph) -> f32 {
    (m.expansion + m.upper_chest + m.lower_chest) / 3.0
}

/// Serialize to JSON-like string.
pub fn rib_cage_morph_to_json(m: &RibCageMorph) -> String {
    format!(
        r#"{{"expansion":{:.4},"upper_chest":{:.4},"lower_chest":{:.4},"lateral_flare":{:.4}}}"#,
        m.expansion, m.upper_chest, m.lower_chest, m.lateral_flare
    )
}

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

    #[test]
    fn test_defaults() {
        let m = new_rib_cage_morph();
        assert_eq!(m.expansion, 0.0);
    }

    #[test]
    fn test_expansion() {
        let mut m = new_rib_cage_morph();
        rib_cage_set_expansion(&mut m, 0.6);
        assert!((m.expansion - 0.6).abs() < 1e-6);
    }

    #[test]
    fn test_upper_chest() {
        let mut m = new_rib_cage_morph();
        rib_cage_set_upper_chest(&mut m, 0.8);
        assert!((m.upper_chest - 0.8).abs() < 1e-6);
    }

    #[test]
    fn test_lower_chest_clamp() {
        let mut m = new_rib_cage_morph();
        rib_cage_set_lower_chest(&mut m, 2.0);
        assert_eq!(m.lower_chest, 1.0);
    }

    #[test]
    fn test_lateral_flare() {
        let mut m = new_rib_cage_morph();
        rib_cage_set_lateral_flare(&mut m, 0.3);
        assert!((m.lateral_flare - 0.3).abs() < 1e-6);
    }

    #[test]
    fn test_mean_expansion_zero() {
        let m = new_rib_cage_morph();
        assert_eq!(rib_cage_mean_expansion(&m), 0.0);
    }

    #[test]
    fn test_mean_expansion_value() {
        let mut m = new_rib_cage_morph();
        rib_cage_set_expansion(&mut m, 0.6);
        rib_cage_set_upper_chest(&mut m, 0.3);
        rib_cage_set_lower_chest(&mut m, 0.9);
        let mean = rib_cage_mean_expansion(&m);
        assert!((mean - 0.6).abs() < 1e-5);
    }

    #[test]
    fn test_json_keys() {
        let m = new_rib_cage_morph();
        let s = rib_cage_morph_to_json(&m);
        assert!(s.contains("lateral_flare"));
    }

    #[test]
    fn test_clone() {
        let m = new_rib_cage_morph();
        let m2 = m.clone();
        assert!((m2.expansion - m.expansion).abs() < 1e-6);
    }
}