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

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

//! Sacrum tilt morph — adjusts sacral base angle and width.

/// Sacrum morph configuration.
#[derive(Debug, Clone)]
pub struct SacrumMorph {
    pub tilt: f32,
    pub width: f32,
    pub curvature: f32,
    pub promontory_depth: f32,
}

impl SacrumMorph {
    pub fn new() -> Self {
        Self {
            tilt: 0.5,
            width: 0.5,
            curvature: 0.5,
            promontory_depth: 0.5,
        }
    }
}

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

/// Create a new sacrum morph.
pub fn new_sacrum_morph() -> SacrumMorph {
    SacrumMorph::new()
}

/// Set sacral tilt (0 = anterior, 1 = posterior).
pub fn sac_set_tilt(m: &mut SacrumMorph, v: f32) {
    m.tilt = v.clamp(0.0, 1.0);
}

/// Set sacrum width.
pub fn sac_set_width(m: &mut SacrumMorph, v: f32) {
    m.width = v.clamp(0.0, 1.0);
}

/// Set sacral curvature.
pub fn sac_set_curvature(m: &mut SacrumMorph, v: f32) {
    m.curvature = v.clamp(0.0, 1.0);
}

/// Set sacral promontory depth.
pub fn sac_set_promontory_depth(m: &mut SacrumMorph, v: f32) {
    m.promontory_depth = v.clamp(0.0, 1.0);
}

/// Compute pelvic inlet estimate based on tilt and width.
pub fn sac_pelvic_inlet(m: &SacrumMorph) -> f32 {
    m.width * (1.0 - (m.tilt - 0.5).abs() * 0.3)
}

/// Serialize to JSON-like string.
pub fn sacrum_morph_to_json(m: &SacrumMorph) -> String {
    format!(
        r#"{{"tilt":{:.4},"width":{:.4},"curvature":{:.4},"promontory_depth":{:.4}}}"#,
        m.tilt, m.width, m.curvature, m.promontory_depth
    )
}

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

    #[test]
    fn test_defaults() {
        let m = new_sacrum_morph();
        assert!((m.tilt - 0.5).abs() < 1e-6);
    }

    #[test]
    fn test_tilt_clamp() {
        let mut m = new_sacrum_morph();
        sac_set_tilt(&mut m, -1.0);
        assert_eq!(m.tilt, 0.0);
    }

    #[test]
    fn test_width_set() {
        let mut m = new_sacrum_morph();
        sac_set_width(&mut m, 0.7);
        assert!((m.width - 0.7).abs() < 1e-6);
    }

    #[test]
    fn test_curvature_clamp() {
        let mut m = new_sacrum_morph();
        sac_set_curvature(&mut m, 3.0);
        assert_eq!(m.curvature, 1.0);
    }

    #[test]
    fn test_promontory_depth() {
        let mut m = new_sacrum_morph();
        sac_set_promontory_depth(&mut m, 0.6);
        assert!((m.promontory_depth - 0.6).abs() < 1e-6);
    }

    #[test]
    fn test_pelvic_inlet_range() {
        let m = new_sacrum_morph();
        let pi = sac_pelvic_inlet(&m);
        assert!((0.0..=1.0).contains(&pi));
    }

    #[test]
    fn test_json_keys() {
        let m = new_sacrum_morph();
        let s = sacrum_morph_to_json(&m);
        assert!(s.contains("promontory_depth"));
    }

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

    #[test]
    fn test_pelvic_inlet_wide() {
        let mut m = new_sacrum_morph();
        sac_set_width(&mut m, 1.0);
        sac_set_tilt(&mut m, 0.5); /* neutral tilt = maximum inlet */
        assert!(sac_pelvic_inlet(&m) > 0.9);
    }
}