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

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

#[derive(Debug, Clone)]
pub struct NasalSpineMorph {
    pub projection: f32,
    pub angulation: f32,
    pub prominence: f32,
    pub base_width: f32,
}

pub fn new_nasal_spine_morph() -> NasalSpineMorph {
    NasalSpineMorph {
        projection: 0.0,
        angulation: 0.0,
        prominence: 0.0,
        base_width: 0.0,
    }
}

pub fn nspine_set_projection(m: &mut NasalSpineMorph, v: f32) {
    m.projection = v.clamp(0.0, 1.0);
}

pub fn nspine_set_angulation(m: &mut NasalSpineMorph, v: f32) {
    m.angulation = v.clamp(0.0, 1.0);
}

pub fn nspine_set_prominence(m: &mut NasalSpineMorph, v: f32) {
    m.prominence = v.clamp(0.0, 1.0);
}

pub fn nspine_set_base_width(m: &mut NasalSpineMorph, v: f32) {
    m.base_width = v.clamp(0.0, 1.0);
}

pub fn nspine_volume_estimate(m: &NasalSpineMorph) -> f32 {
    m.projection * m.base_width
}

pub fn nasal_spine_morph_to_json(m: &NasalSpineMorph) -> String {
    format!(
        r#"{{"projection":{:.4},"angulation":{:.4},"prominence":{:.4},"base_width":{:.4}}}"#,
        m.projection, m.angulation, m.prominence, m.base_width
    )
}

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

    #[test]
    fn test_new_defaults() {
        /* all zero */
        let m = new_nasal_spine_morph();
        assert_eq!(m.projection, 0.0);
        assert_eq!(m.angulation, 0.0);
    }

    #[test]
    fn test_set_projection() {
        /* valid projection */
        let mut m = new_nasal_spine_morph();
        nspine_set_projection(&mut m, 0.6);
        assert!((m.projection - 0.6).abs() < 1e-6);
    }

    #[test]
    fn test_set_projection_clamp_high() {
        /* clamp high */
        let mut m = new_nasal_spine_morph();
        nspine_set_projection(&mut m, 5.0);
        assert_eq!(m.projection, 1.0);
    }

    #[test]
    fn test_set_angulation() {
        /* valid angulation */
        let mut m = new_nasal_spine_morph();
        nspine_set_angulation(&mut m, 0.4);
        assert!((m.angulation - 0.4).abs() < 1e-6);
    }

    #[test]
    fn test_set_prominence_clamp_low() {
        /* clamp low */
        let mut m = new_nasal_spine_morph();
        nspine_set_prominence(&mut m, -1.0);
        assert_eq!(m.prominence, 0.0);
    }

    #[test]
    fn test_set_base_width() {
        /* valid base width */
        let mut m = new_nasal_spine_morph();
        nspine_set_base_width(&mut m, 0.5);
        assert!((m.base_width - 0.5).abs() < 1e-6);
    }

    #[test]
    fn test_volume_estimate() {
        /* volume is projection * base_width */
        let m = NasalSpineMorph {
            projection: 0.5,
            angulation: 0.0,
            prominence: 0.0,
            base_width: 0.4,
        };
        assert!((nspine_volume_estimate(&m) - 0.2).abs() < 1e-6);
    }

    #[test]
    fn test_volume_estimate_zero() {
        /* default volume is zero */
        let m = new_nasal_spine_morph();
        assert_eq!(nspine_volume_estimate(&m), 0.0);
    }

    #[test]
    fn test_to_json() {
        /* JSON has projection */
        let m = new_nasal_spine_morph();
        assert!(nasal_spine_morph_to_json(&m).contains("projection"));
    }

    #[test]
    fn test_clone() {
        /* clone is independent */
        let m = NasalSpineMorph {
            projection: 0.3,
            angulation: 0.5,
            prominence: 0.7,
            base_width: 0.2,
        };
        let m2 = m.clone();
        assert_eq!(m.base_width, m2.base_width);
    }
}