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

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

//! Chin raise and dimple morph control (FACS AU17 area).

/// State for chin raise control.
#[derive(Debug, Clone, Default)]
pub struct ChinRaiseState {
    pub raise: f32,
    pub dimple: f32,
    pub lip_chin_couple: f32,
}

/// Set the chin raise amount.
pub fn cr_set_raise(state: &mut ChinRaiseState, amount: f32) {
    state.raise = amount.clamp(0.0, 1.0);
}

/// Set the chin dimple intensity.
pub fn cr_set_dimple(state: &mut ChinRaiseState, amount: f32) {
    state.dimple = amount.clamp(0.0, 1.0);
}

/// Return the lower-lip push weight driven by chin raise.
pub fn cr_lower_lip_push(state: &ChinRaiseState) -> f32 {
    state.raise * state.lip_chin_couple.max(0.25)
}

/// Return true if the chin is near neutral.
pub fn cr_is_neutral(state: &ChinRaiseState) -> bool {
    state.raise < 0.05 && state.dimple < 0.05
}

/// Reset chin to neutral.
pub fn cr_reset(state: &mut ChinRaiseState) {
    state.raise = 0.0;
    state.dimple = 0.0;
}

/// Blend chin raise toward a target.
pub fn cr_blend_toward(state: &mut ChinRaiseState, target_raise: f32, t: f32) {
    let t = t.clamp(0.0, 1.0);
    let target = target_raise.clamp(0.0, 1.0);
    state.raise += (target - state.raise) * t;
}

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

    #[test]
    fn test_default_neutral() {
        /* default state should be neutral */
        let s = ChinRaiseState::default();
        assert!(cr_is_neutral(&s));
    }

    #[test]
    fn test_set_raise() {
        /* raise should be set correctly */
        let mut s = ChinRaiseState::default();
        cr_set_raise(&mut s, 0.7);
        assert!((s.raise - 0.7).abs() < 1e-6);
    }

    #[test]
    fn test_set_dimple() {
        /* dimple should be set correctly */
        let mut s = ChinRaiseState::default();
        cr_set_dimple(&mut s, 0.4);
        assert!((s.dimple - 0.4).abs() < 1e-6);
    }

    #[test]
    fn test_lower_lip_push_nonzero() {
        /* lower lip push should be nonzero when raised */
        let mut s = ChinRaiseState::default();
        cr_set_raise(&mut s, 1.0);
        assert!(cr_lower_lip_push(&s) > 0.0);
    }

    #[test]
    fn test_not_neutral_when_raised() {
        /* raised chin should not be neutral */
        let mut s = ChinRaiseState::default();
        cr_set_raise(&mut s, 0.5);
        assert!(!cr_is_neutral(&s));
    }

    #[test]
    fn test_reset() {
        /* reset should restore neutral */
        let mut s = ChinRaiseState::default();
        cr_set_raise(&mut s, 0.8);
        cr_set_dimple(&mut s, 0.5);
        cr_reset(&mut s);
        assert!(cr_is_neutral(&s));
    }

    #[test]
    fn test_blend_toward() {
        /* blend should move toward target */
        let mut s = ChinRaiseState::default();
        cr_blend_toward(&mut s, 1.0, 0.5);
        assert!(s.raise > 0.0 && s.raise < 1.0);
    }

    #[test]
    fn test_clamp_above_one() {
        /* raise above 1.0 should be clamped */
        let mut s = ChinRaiseState::default();
        cr_set_raise(&mut s, 9.9);
        assert!((s.raise - 1.0).abs() < 1e-6);
    }

    #[test]
    fn test_lower_lip_zero_when_relaxed() {
        /* lower lip push should be zero at rest */
        let s = ChinRaiseState::default();
        assert_eq!(cr_lower_lip_push(&s), 0.0);
    }
}