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

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

//! Rectangle/straight body figure morph — minimal waist definition.

/// Configuration for the rectangle body morph.
#[derive(Debug, Clone)]
pub struct RectangleBodyConfig {
    pub waist_fullness: f32,
    pub shoulder_hip_balance: f32,
}

impl Default for RectangleBodyConfig {
    fn default() -> Self {
        RectangleBodyConfig {
            waist_fullness: 0.7,
            shoulder_hip_balance: 0.95,
        }
    }
}

/// State for the rectangle body morph.
#[derive(Debug, Clone)]
pub struct RectangleBodyMorph {
    pub intensity: f32,
    pub config: RectangleBodyConfig,
    pub enabled: bool,
}

/// Create a new rectangle body morph.
pub fn new_rectangle_body_morph() -> RectangleBodyMorph {
    RectangleBodyMorph {
        intensity: 0.0,
        config: RectangleBodyConfig::default(),
        enabled: true,
    }
}

/// Set intensity [0, 1].
pub fn rect_set_intensity(m: &mut RectangleBodyMorph, v: f32) {
    m.intensity = v.clamp(0.0, 1.0);
}

/// Waist fullness (reduces waist cinch).
pub fn rect_waist_fullness(m: &RectangleBodyMorph) -> f32 {
    m.intensity * m.config.waist_fullness
}

/// Shoulder-to-hip balance — closer to 1 = more rectangular.
pub fn rect_shoulder_hip_balance(m: &RectangleBodyMorph) -> f32 {
    let base = 0.8_f32;
    base + 0.15 * m.intensity * m.config.shoulder_hip_balance
}

/// Overall straightness score [0, 1].
pub fn rect_straightness(m: &RectangleBodyMorph) -> f32 {
    m.intensity
}

/// Serialise to JSON.
pub fn rect_to_json(m: &RectangleBodyMorph) -> String {
    format!(
        r#"{{"intensity":{:.3},"waist_fullness":{:.3},"enabled":{}}}"#,
        m.intensity,
        rect_waist_fullness(m),
        m.enabled
    )
}

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

    #[test]
    fn default_zero() {
        let m = new_rectangle_body_morph();
        assert!((m.intensity - 0.0).abs() < 1e-6 /* zero */);
    }

    #[test]
    fn clamp() {
        let mut m = new_rectangle_body_morph();
        rect_set_intensity(&mut m, 3.0);
        assert!((m.intensity - 1.0).abs() < 1e-6 /* clamped */);
    }

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

    #[test]
    fn balance_increases() {
        let mut m = new_rectangle_body_morph();
        rect_set_intensity(&mut m, 0.0);
        let b0 = rect_shoulder_hip_balance(&m);
        rect_set_intensity(&mut m, 1.0);
        let b1 = rect_shoulder_hip_balance(&m);
        assert!(b1 > b0 /* more balance at higher intensity */);
    }

    #[test]
    fn straightness_equals_intensity() {
        let mut m = new_rectangle_body_morph();
        rect_set_intensity(&mut m, 0.7);
        assert!((rect_straightness(&m) - 0.7).abs() < 1e-6 /* correct */);
    }

    #[test]
    fn json_has_waist() {
        let m = new_rectangle_body_morph();
        assert!(rect_to_json(&m).contains("waist") /* json has field */);
    }

    #[test]
    fn enabled_default() {
        let m = new_rectangle_body_morph();
        assert!(m.enabled /* enabled */);
    }

    #[test]
    fn config_shoulder_hip_balance_positive() {
        let m = new_rectangle_body_morph();
        assert!(m.config.shoulder_hip_balance > 0.0 /* valid */);
    }
}