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

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

//! Gonion (jaw angle) morph — controls the posterior-inferior corner of the mandible.

/// Gonion morph configuration.
#[derive(Debug, Clone)]
pub struct GonionMorph {
    pub gonial_angle: f32,
    pub flare: f32,
    pub prominence: f32,
    pub rounding: f32,
    pub asymmetry: f32,
}

impl GonionMorph {
    pub fn new() -> Self {
        Self {
            gonial_angle: 0.5,
            flare: 0.0,
            prominence: 0.5,
            rounding: 0.5,
            asymmetry: 0.0,
        }
    }
}

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

/// Create a new gonion morph.
pub fn new_gonion_morph() -> GonionMorph {
    GonionMorph::new()
}

/// Set gonial angle (0 = very acute ~90°, 1 = obtuse ~140°).
pub fn gon_set_gonial_angle(m: &mut GonionMorph, v: f32) {
    m.gonial_angle = v.clamp(0.0, 1.0);
}

/// Set lateral jaw flare.
pub fn gon_set_flare(m: &mut GonionMorph, v: f32) {
    m.flare = v.clamp(-1.0, 1.0);
}

/// Set prominence of the gonion landmark.
pub fn gon_set_prominence(m: &mut GonionMorph, v: f32) {
    m.prominence = v.clamp(0.0, 1.0);
}

/// Set corner rounding (0 = sharp, 1 = smooth).
pub fn gon_set_rounding(m: &mut GonionMorph, v: f32) {
    m.rounding = v.clamp(0.0, 1.0);
}

/// Compute jaw angle in degrees (approximate linear mapping 90–140°).
pub fn gon_angle_degrees(m: &GonionMorph) -> f32 {
    90.0 + m.gonial_angle * 50.0
}

/// Serialize to JSON-like string.
pub fn gonion_morph_to_json(m: &GonionMorph) -> String {
    format!(
        r#"{{"gonial_angle":{:.4},"flare":{:.4},"prominence":{:.4},"rounding":{:.4},"asymmetry":{:.4}}}"#,
        m.gonial_angle, m.flare, m.prominence, m.rounding, m.asymmetry
    )
}

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

    #[test]
    fn test_defaults() {
        let m = new_gonion_morph();
        assert!((m.gonial_angle - 0.5).abs() < 1e-6);
        assert_eq!(m.flare, 0.0);
    }

    #[test]
    fn test_gonial_angle_clamp() {
        let mut m = new_gonion_morph();
        gon_set_gonial_angle(&mut m, 2.0);
        assert_eq!(m.gonial_angle, 1.0);
    }

    #[test]
    fn test_gonial_angle_set() {
        let mut m = new_gonion_morph();
        gon_set_gonial_angle(&mut m, 0.7);
        assert!((m.gonial_angle - 0.7).abs() < 1e-6);
    }

    #[test]
    fn test_flare_clamp_negative() {
        let mut m = new_gonion_morph();
        gon_set_flare(&mut m, -2.0);
        assert_eq!(m.flare, -1.0);
    }

    #[test]
    fn test_prominence_set() {
        let mut m = new_gonion_morph();
        gon_set_prominence(&mut m, 0.8);
        assert!((m.prominence - 0.8).abs() < 1e-6);
    }

    #[test]
    fn test_rounding_clamp() {
        let mut m = new_gonion_morph();
        gon_set_rounding(&mut m, 3.0);
        assert_eq!(m.rounding, 1.0);
    }

    #[test]
    fn test_angle_degrees_range() {
        let m = new_gonion_morph();
        let deg = gon_angle_degrees(&m);
        assert!((90.0..=140.0).contains(&deg));
    }

    #[test]
    fn test_angle_degrees_min() {
        let mut m = new_gonion_morph();
        gon_set_gonial_angle(&mut m, 0.0);
        assert!((gon_angle_degrees(&m) - 90.0).abs() < 1e-4);
    }

    #[test]
    fn test_json_keys() {
        let m = new_gonion_morph();
        let s = gonion_morph_to_json(&m);
        assert!(s.contains("gonial_angle"));
    }

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