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
148
149
150
151

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

//! Hip tilt / pelvic obliquity morph.

/// Hip tilt configuration.
#[derive(Debug, Clone)]
pub struct HipTiltMorphConfig {
    pub lateral_tilt: f32,
    pub anterior_tilt: f32,
    pub pelvic_rotation: f32,
}

impl Default for HipTiltMorphConfig {
    fn default() -> Self {
        Self {
            lateral_tilt: 0.0,
            anterior_tilt: 0.0,
            pelvic_rotation: 0.0,
        }
    }
}

/// Hip tilt morph state.
#[derive(Debug, Clone)]
pub struct HipTiltMorph {
    pub config: HipTiltMorphConfig,
    pub intensity: f32,
    pub enabled: bool,
}

impl HipTiltMorph {
    pub fn new() -> Self {
        Self {
            config: HipTiltMorphConfig::default(),
            intensity: 0.0,
            enabled: true,
        }
    }
}

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

/// Create a new HipTiltMorph.
pub fn new_hip_tilt_morph() -> HipTiltMorph {
    HipTiltMorph::new()
}

/// Set lateral tilt factor (-1.0 left, 1.0 right).
pub fn hip_tilt_set_lateral(morph: &mut HipTiltMorph, v: f32) {
    morph.config.lateral_tilt = v.clamp(-1.0, 1.0);
}

/// Set anterior tilt factor.
pub fn hip_tilt_set_anterior(morph: &mut HipTiltMorph, v: f32) {
    morph.config.anterior_tilt = v.clamp(-1.0, 1.0);
}

/// Set pelvic rotation factor.
pub fn hip_tilt_set_rotation(morph: &mut HipTiltMorph, v: f32) {
    morph.config.pelvic_rotation = v.clamp(-1.0, 1.0);
}

/// Compute total tilt magnitude.
pub fn hip_tilt_magnitude(morph: &HipTiltMorph) -> f32 {
    let l = morph.config.lateral_tilt;
    let a = morph.config.anterior_tilt;
    ((l * l + a * a).sqrt() * morph.intensity).min(1.0)
}

/// Serialize to JSON.
pub fn hip_tilt_to_json(morph: &HipTiltMorph) -> String {
    format!(
        r#"{{"intensity":{},"lateral_tilt":{},"anterior_tilt":{},"pelvic_rotation":{}}}"#,
        morph.intensity,
        morph.config.lateral_tilt,
        morph.config.anterior_tilt,
        morph.config.pelvic_rotation,
    )
}

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

    #[test]
    fn test_new() {
        let m = new_hip_tilt_morph();
        assert!((m.config.lateral_tilt - 0.0).abs() < 1e-6 /* default zero */);
    }

    #[test]
    fn test_lateral_clamp() {
        let mut m = new_hip_tilt_morph();
        hip_tilt_set_lateral(&mut m, 5.0);
        assert!((m.config.lateral_tilt - 1.0).abs() < 1e-6 /* clamped */);
    }

    #[test]
    fn test_anterior_negative() {
        let mut m = new_hip_tilt_morph();
        hip_tilt_set_anterior(&mut m, -0.4);
        assert!((m.config.anterior_tilt - (-0.4)).abs() < 1e-6 /* negative stored */);
    }

    #[test]
    fn test_rotation() {
        let mut m = new_hip_tilt_morph();
        hip_tilt_set_rotation(&mut m, 0.5);
        assert!((m.config.pelvic_rotation - 0.5).abs() < 1e-6 /* stored */);
    }

    #[test]
    fn test_magnitude_zero() {
        let m = new_hip_tilt_morph();
        assert!((hip_tilt_magnitude(&m) - 0.0).abs() < 1e-6 /* zero */);
    }

    #[test]
    fn test_magnitude_nonzero() {
        let mut m = new_hip_tilt_morph();
        hip_tilt_set_lateral(&mut m, 1.0);
        m.intensity = 1.0;
        assert!(hip_tilt_magnitude(&m) > 0.0 /* positive */);
    }

    #[test]
    fn test_json_key() {
        let m = new_hip_tilt_morph();
        let j = hip_tilt_to_json(&m);
        assert!(j.contains("lateral_tilt") /* key */);
    }

    #[test]
    fn test_default_enabled() {
        let m = HipTiltMorph::default();
        assert!(m.enabled /* enabled */);
    }

    #[test]
    fn test_clone() {
        let m = new_hip_tilt_morph();
        let c = m.clone();
        assert!((c.intensity - m.intensity).abs() < 1e-6 /* equal */);
    }
}