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)]

//! Subsurface scattering depth morph control.

/// Skin subsurface morph configuration.
#[derive(Debug, Clone)]
pub struct SkinSubsurfaceMorph {
    pub scatter_depth: f32,
    pub red_depth: f32,
    pub green_depth: f32,
    pub blue_depth: f32,
}

impl SkinSubsurfaceMorph {
    pub fn new() -> Self {
        Self {
            scatter_depth: 0.5,
            red_depth: 0.8,
            green_depth: 0.4,
            blue_depth: 0.2,
        }
    }
}

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

/// Create a new skin subsurface morph.
pub fn new_skin_subsurface_morph() -> SkinSubsurfaceMorph {
    SkinSubsurfaceMorph::new()
}

/// Set global scatter depth.
pub fn skin_sss_set_depth(morph: &mut SkinSubsurfaceMorph, depth: f32) {
    morph.scatter_depth = depth.clamp(0.0, 1.0);
}

/// Set per-channel depths for spectral scattering.
pub fn skin_sss_set_rgb_depths(morph: &mut SkinSubsurfaceMorph, r: f32, g: f32, b: f32) {
    morph.red_depth = r.clamp(0.0, 1.0);
    morph.green_depth = g.clamp(0.0, 1.0);
    morph.blue_depth = b.clamp(0.0, 1.0);
}

/// Set red channel depth.
pub fn skin_sss_set_red_depth(morph: &mut SkinSubsurfaceMorph, depth: f32) {
    morph.red_depth = depth.clamp(0.0, 1.0);
}

/// Compute mean chromatic depth across channels.
pub fn skin_sss_mean_depth(morph: &SkinSubsurfaceMorph) -> f32 {
    (morph.red_depth + morph.green_depth + morph.blue_depth) / 3.0
}

/// Serialize to JSON-like string.
pub fn skin_subsurface_morph_to_json(morph: &SkinSubsurfaceMorph) -> String {
    format!(
        r#"{{"scatter_depth":{:.4},"red_depth":{:.4},"green_depth":{:.4},"blue_depth":{:.4}}}"#,
        morph.scatter_depth, morph.red_depth, morph.green_depth, morph.blue_depth
    )
}

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

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

    #[test]
    fn test_depth_clamp() {
        let mut m = new_skin_subsurface_morph();
        skin_sss_set_depth(&mut m, 2.0);
        assert_eq!(m.scatter_depth, 1.0);
    }

    #[test]
    fn test_rgb_depths_set() {
        let mut m = new_skin_subsurface_morph();
        skin_sss_set_rgb_depths(&mut m, 0.9, 0.5, 0.1);
        assert!((m.red_depth - 0.9).abs() < 1e-6);
        assert!((m.blue_depth - 0.1).abs() < 1e-6);
    }

    #[test]
    fn test_red_depth_clamp() {
        let mut m = new_skin_subsurface_morph();
        skin_sss_set_red_depth(&mut m, -1.0);
        assert_eq!(m.red_depth, 0.0);
    }

    #[test]
    fn test_mean_depth() {
        let mut m = new_skin_subsurface_morph();
        skin_sss_set_rgb_depths(&mut m, 0.9, 0.6, 0.3);
        let mean = skin_sss_mean_depth(&m);
        assert!((mean - 0.6).abs() < 1e-5);
    }

    #[test]
    fn test_json() {
        let m = new_skin_subsurface_morph();
        let s = skin_subsurface_morph_to_json(&m);
        assert!(s.contains("scatter_depth"));
        assert!(s.contains("red_depth"));
    }

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

    #[test]
    fn test_default_trait() {
        let m: SkinSubsurfaceMorph = Default::default();
        assert!((m.green_depth - 0.4).abs() < 1e-6);
    }

    #[test]
    fn test_json_blue() {
        let m = new_skin_subsurface_morph();
        let s = skin_subsurface_morph_to_json(&m);
        assert!(s.contains("blue_depth"));
    }
}