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

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

//! Lip corner stretch morph control (FACS AU20 area).

/// State for lip stretch (lip corner puller) control.
#[derive(Debug, Clone, Default)]
pub struct LipStretchState {
    pub left: f32,
    pub right: f32,
    pub upper_retract: f32,
    pub lower_retract: f32,
}

/// Set lip stretch symmetrically.
pub fn ls_set_both(state: &mut LipStretchState, amount: f32) {
    let a = amount.clamp(0.0, 1.0);
    state.left = a;
    state.right = a;
}

/// Set left corner stretch.
pub fn ls_set_left(state: &mut LipStretchState, amount: f32) {
    state.left = amount.clamp(0.0, 1.0);
}

/// Set right corner stretch.
pub fn ls_set_right(state: &mut LipStretchState, amount: f32) {
    state.right = amount.clamp(0.0, 1.0);
}

/// Derive the upper lip retraction from the mean stretch.
pub fn ls_upper_retract(state: &LipStretchState) -> f32 {
    let mean = (state.left + state.right) * 0.5;
    mean * state.upper_retract.max(0.2)
}

/// Derive the lower lip retraction from the mean stretch.
pub fn ls_lower_retract(state: &LipStretchState) -> f32 {
    let mean = (state.left + state.right) * 0.5;
    mean * state.lower_retract.max(0.15)
}

/// Return the asymmetry between left and right corners.
pub fn ls_asymmetry(state: &LipStretchState) -> f32 {
    state.left - state.right
}

/// Reset all lip stretch weights.
pub fn ls_reset(state: &mut LipStretchState) {
    state.left = 0.0;
    state.right = 0.0;
}

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

    #[test]
    fn test_default_zero() {
        /* default should be zero */
        let s = LipStretchState::default();
        assert_eq!(s.left, 0.0);
        assert_eq!(s.right, 0.0);
    }

    #[test]
    fn test_set_both() {
        /* set_both should update both corners */
        let mut s = LipStretchState::default();
        ls_set_both(&mut s, 0.6);
        assert!((s.left - 0.6).abs() < 1e-6);
        assert!((s.right - 0.6).abs() < 1e-6);
    }

    #[test]
    fn test_set_left_only() {
        /* left set should not affect right */
        let mut s = LipStretchState::default();
        ls_set_left(&mut s, 0.4);
        assert_eq!(s.right, 0.0);
    }

    #[test]
    fn test_set_right_only() {
        /* right set should not affect left */
        let mut s = LipStretchState::default();
        ls_set_right(&mut s, 0.5);
        assert_eq!(s.left, 0.0);
    }

    #[test]
    fn test_upper_retract_nonzero() {
        /* upper retract should be nonzero when stretch is active */
        let mut s = LipStretchState::default();
        ls_set_both(&mut s, 1.0);
        assert!(ls_upper_retract(&s) > 0.0);
    }

    #[test]
    fn test_lower_retract_nonzero() {
        /* lower retract should be nonzero when stretch is active */
        let mut s = LipStretchState::default();
        ls_set_both(&mut s, 1.0);
        assert!(ls_lower_retract(&s) > 0.0);
    }

    #[test]
    fn test_asymmetry() {
        /* asymmetry should reflect left minus right */
        let mut s = LipStretchState::default();
        ls_set_left(&mut s, 0.8);
        ls_set_right(&mut s, 0.2);
        assert!((ls_asymmetry(&s) - 0.6).abs() < 1e-6);
    }

    #[test]
    fn test_reset() {
        /* reset should zero both corners */
        let mut s = LipStretchState::default();
        ls_set_both(&mut s, 0.9);
        ls_reset(&mut s);
        assert_eq!(s.left, 0.0);
        assert_eq!(s.right, 0.0);
    }

    #[test]
    fn test_clamp_negative() {
        /* negative values should be clamped to zero */
        let mut s = LipStretchState::default();
        ls_set_both(&mut s, -1.0);
        assert_eq!(s.left, 0.0);
    }
}