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
139
140
141
142
143
144
145
146
147

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

use std::collections::HashMap;

/// A character template with named parameters.
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct CharacterTemplate {
    pub name: String,
    pub params: HashMap<String, f32>,
}

/// Create a new empty character template.
#[allow(dead_code)]
pub fn new_character_template(name: &str) -> CharacterTemplate {
    CharacterTemplate {
        name: name.to_string(),
        params: HashMap::new(),
    }
}

/// Set a parameter on the template.
#[allow(dead_code)]
pub fn template_set_param(t: &mut CharacterTemplate, key: &str, value: f32) {
    t.params.insert(key.to_string(), value);
}

/// Get a parameter from the template.
#[allow(dead_code)]
pub fn template_get_param(t: &CharacterTemplate, key: &str) -> Option<f32> {
    t.params.get(key).copied()
}

/// Return the number of parameters.
#[allow(dead_code)]
pub fn template_param_count(t: &CharacterTemplate) -> usize {
    t.params.len()
}

/// Return the template name.
#[allow(dead_code)]
pub fn template_name(t: &CharacterTemplate) -> &str {
    &t.name
}

/// Serialize to JSON.
#[allow(dead_code)]
pub fn template_to_json(t: &CharacterTemplate) -> String {
    let mut entries: Vec<String> = t
        .params
        .iter()
        .map(|(k, v)| format!("\"{}\":{:.4}", k, v))
        .collect();
    entries.sort();
    format!("{{\"name\":\"{}\",\"params\":{{{}}}}}", t.name, entries.join(","))
}

/// Apply the template by returning its params as a flat HashMap.
#[allow(dead_code)]
pub fn template_apply(t: &CharacterTemplate) -> HashMap<String, f32> {
    t.params.clone()
}

/// Clear all parameters.
#[allow(dead_code)]
pub fn template_clear(t: &mut CharacterTemplate) {
    t.params.clear();
}

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

    #[test]
    fn new_template() {
        let t = new_character_template("hero");
        assert_eq!(template_param_count(&t), 0);
    }

    #[test]
    fn set_and_get() {
        let mut t = new_character_template("hero");
        template_set_param(&mut t, "height", 1.8);
        assert!((template_get_param(&t, "height").expect("should succeed") - 1.8).abs() < 1e-6);
    }

    #[test]
    fn get_missing() {
        let t = new_character_template("hero");
        assert!(template_get_param(&t, "nope").is_none());
    }

    #[test]
    fn param_count() {
        let mut t = new_character_template("hero");
        template_set_param(&mut t, "a", 1.0);
        template_set_param(&mut t, "b", 2.0);
        assert_eq!(template_param_count(&t), 2);
    }

    #[test]
    fn name_accessor() {
        let t = new_character_template("villain");
        assert_eq!(template_name(&t), "villain");
    }

    #[test]
    fn to_json() {
        let mut t = new_character_template("test");
        template_set_param(&mut t, "x", 0.5);
        let j = template_to_json(&t);
        assert!(j.contains("\"test\""));
    }

    #[test]
    fn apply_returns_params() {
        let mut t = new_character_template("t");
        template_set_param(&mut t, "x", 0.5);
        let p = template_apply(&t);
        assert!((p["x"] - 0.5).abs() < 1e-6);
    }

    #[test]
    fn clear_params() {
        let mut t = new_character_template("t");
        template_set_param(&mut t, "x", 0.5);
        template_clear(&mut t);
        assert_eq!(template_param_count(&t), 0);
    }

    #[test]
    fn overwrite_param() {
        let mut t = new_character_template("t");
        template_set_param(&mut t, "x", 0.5);
        template_set_param(&mut t, "x", 0.9);
        assert!((template_get_param(&t, "x").expect("should succeed") - 0.9).abs() < 1e-6);
    }

    #[test]
    fn apply_empty() {
        let t = new_character_template("t");
        let p = template_apply(&t);
        assert!(p.is_empty());
    }
}