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

#![allow(dead_code)]
//! Morph weight clamp: restricts morph weights to a configurable range.

/// A clamp for morph weights.
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct MorphWeightClamp {
    min: f32,
    max: f32,
}

/// Create a new clamp with the given range.
#[allow(dead_code)]
pub fn new_weight_clamp(min: f32, max: f32) -> MorphWeightClamp {
    MorphWeightClamp { min, max }
}

/// Clamp a weight value.
#[allow(dead_code)]
pub fn clamp_weight(clamp: &MorphWeightClamp, value: f32) -> f32 {
    value.clamp(clamp.min, clamp.max)
}

/// Return the minimum.
#[allow(dead_code)]
pub fn clamp_min(clamp: &MorphWeightClamp) -> f32 {
    clamp.min
}

/// Return the maximum.
#[allow(dead_code)]
pub fn clamp_max(clamp: &MorphWeightClamp) -> f32 {
    clamp.max
}

/// Check if a value would be clamped.
#[allow(dead_code)]
pub fn is_clamped(clamp: &MorphWeightClamp, value: f32) -> bool {
    !(clamp.min..=clamp.max).contains(&value)
}

/// Return the clamp range as (min, max).
#[allow(dead_code)]
pub fn clamp_range(clamp: &MorphWeightClamp) -> (f32, f32) {
    (clamp.min, clamp.max)
}

/// Serialize to JSON-like string.
#[allow(dead_code)]
pub fn clamp_to_json(clamp: &MorphWeightClamp) -> String {
    format!("{{\"min\":{},\"max\":{}}}", clamp.min, clamp.max)
}

/// Reset to default range [0, 1].
#[allow(dead_code)]
pub fn reset_clamp(clamp: &mut MorphWeightClamp) {
    clamp.min = 0.0;
    clamp.max = 1.0;
}

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

    #[test]
    fn test_new_clamp() {
        let c = new_weight_clamp(0.0, 1.0);
        assert!((clamp_min(&c) - 0.0).abs() < 1e-6);
        assert!((clamp_max(&c) - 1.0).abs() < 1e-6);
    }

    #[test]
    fn test_clamp_weight_within() {
        let c = new_weight_clamp(0.0, 1.0);
        assert!((clamp_weight(&c, 0.5) - 0.5).abs() < 1e-6);
    }

    #[test]
    fn test_clamp_weight_below() {
        let c = new_weight_clamp(0.0, 1.0);
        assert!((clamp_weight(&c, -1.0) - 0.0).abs() < 1e-6);
    }

    #[test]
    fn test_clamp_weight_above() {
        let c = new_weight_clamp(0.0, 1.0);
        assert!((clamp_weight(&c, 2.0) - 1.0).abs() < 1e-6);
    }

    #[test]
    fn test_is_clamped() {
        let c = new_weight_clamp(0.0, 1.0);
        assert!(is_clamped(&c, 1.5));
        assert!(!is_clamped(&c, 0.5));
    }

    #[test]
    fn test_clamp_range() {
        let c = new_weight_clamp(-1.0, 2.0);
        assert_eq!(clamp_range(&c), (-1.0, 2.0));
    }

    #[test]
    fn test_clamp_to_json() {
        let c = new_weight_clamp(0.0, 1.0);
        let json = clamp_to_json(&c);
        assert!(json.contains("\"min\":0"));
    }

    #[test]
    fn test_reset_clamp() {
        let mut c = new_weight_clamp(-5.0, 5.0);
        reset_clamp(&mut c);
        assert!((clamp_min(&c) - 0.0).abs() < 1e-6);
        assert!((clamp_max(&c) - 1.0).abs() < 1e-6);
    }

    #[test]
    fn test_boundary_not_clamped() {
        let c = new_weight_clamp(0.0, 1.0);
        assert!(!is_clamped(&c, 0.0));
        assert!(!is_clamped(&c, 1.0));
    }

    #[test]
    fn test_negative_range() {
        let c = new_weight_clamp(-2.0, -1.0);
        assert!((clamp_weight(&c, 0.0) - (-1.0)).abs() < 1e-6);
    }
}