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

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

//! Mustache shape and density morph control.

/// Mustache morph configuration.
#[derive(Debug, Clone)]
pub struct MustacheMorph {
    pub density: f32,
    pub width: f32,
    pub droop: f32,
    pub thickness: f32,
}

impl MustacheMorph {
    pub fn new() -> Self {
        Self {
            density: 0.5,
            width: 0.5,
            droop: 0.0,
            thickness: 0.5,
        }
    }
}

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

/// Create a new mustache morph.
pub fn new_mustache_morph() -> MustacheMorph {
    MustacheMorph::new()
}

/// Set strand density.
pub fn mustache_set_density(morph: &mut MustacheMorph, density: f32) {
    morph.density = density.clamp(0.0, 1.0);
}

/// Set mustache width in normalized range [0, 1].
pub fn mustache_set_width(morph: &mut MustacheMorph, width: f32) {
    morph.width = width.clamp(0.0, 1.0);
}

/// Set downward droop factor in normalized range [0, 1].
pub fn mustache_set_droop(morph: &mut MustacheMorph, droop: f32) {
    morph.droop = droop.clamp(0.0, 1.0);
}

/// Compute a combined style score as a simple heuristic.
pub fn mustache_style_score(morph: &MustacheMorph) -> f32 {
    (morph.density + morph.width + morph.thickness) / 3.0
}

/// Serialize to JSON-like string.
pub fn mustache_morph_to_json(morph: &MustacheMorph) -> String {
    format!(
        r#"{{"density":{:.4},"width":{:.4},"droop":{:.4},"thickness":{:.4}}}"#,
        morph.density, morph.width, morph.droop, morph.thickness
    )
}

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

    #[test]
    fn test_new_defaults() {
        let m = new_mustache_morph();
        assert!((m.droop - 0.0).abs() < 1e-6);
    }

    #[test]
    fn test_density_clamp() {
        let mut m = new_mustache_morph();
        mustache_set_density(&mut m, 5.0);
        assert_eq!(m.density, 1.0);
    }

    #[test]
    fn test_width_set() {
        let mut m = new_mustache_morph();
        mustache_set_width(&mut m, 0.75);
        assert!((m.width - 0.75).abs() < 1e-6);
    }

    #[test]
    fn test_droop_set() {
        let mut m = new_mustache_morph();
        mustache_set_droop(&mut m, 0.6);
        assert!((m.droop - 0.6).abs() < 1e-6);
    }

    #[test]
    fn test_style_score_range() {
        let m = new_mustache_morph();
        let s = mustache_style_score(&m);
        assert!((0.0..=1.0).contains(&s));
    }

    #[test]
    fn test_json() {
        let m = new_mustache_morph();
        let s = mustache_morph_to_json(&m);
        assert!(s.contains("droop"));
    }

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

    #[test]
    fn test_droop_clamp() {
        let mut m = new_mustache_morph();
        mustache_set_droop(&mut m, -2.0);
        assert_eq!(m.droop, 0.0);
    }

    #[test]
    fn test_default_trait() {
        let m: MustacheMorph = Default::default();
        assert!((m.thickness - 0.5).abs() < 1e-6);
    }
}