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

// Copyright (C) 2026 COOLJAPAN OU (Team KitaSan)
// SPDX-License-Identifier: Apache-2.0

//! Predefined ParamState presets for common body types.

use crate::params::ParamState;

/// Named body type presets.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
pub enum BodyPreset {
    /// Average adult (all params at 0.5).
    Average,
    /// Athletic build: high muscle, moderate weight, young adult.
    Athletic,
    /// Slender build: low weight, low muscle.
    Slender,
    /// Heavy build: high weight, moderate muscle.
    Heavy,
    /// Tall build: high height, average everything else.
    Tall,
    /// Petite build: low height, low weight.
    Petite,
    /// Older adult: high age param, moderate everything else.
    Senior,
    /// Child-proportioned: very young, low height, low muscle.
    Child,
}

impl BodyPreset {
    /// Return the ParamState for this preset.
    pub fn params(&self) -> ParamState {
        match self {
            BodyPreset::Average => ParamState::new(0.50, 0.50, 0.50, 0.50),
            BodyPreset::Athletic => ParamState::new(0.65, 0.45, 0.80, 0.30),
            BodyPreset::Slender => ParamState::new(0.55, 0.20, 0.25, 0.35),
            BodyPreset::Heavy => ParamState::new(0.50, 0.85, 0.40, 0.50),
            BodyPreset::Tall => ParamState::new(0.85, 0.45, 0.55, 0.35),
            BodyPreset::Petite => ParamState::new(0.20, 0.30, 0.30, 0.30),
            BodyPreset::Senior => ParamState::new(0.45, 0.55, 0.35, 0.85),
            BodyPreset::Child => ParamState::new(0.15, 0.25, 0.15, 0.05),
        }
    }

    /// Parse a preset by name (case-insensitive).
    pub fn from_name(name: &str) -> Option<Self> {
        match name.to_lowercase().as_str() {
            "average" => Some(BodyPreset::Average),
            "athletic" => Some(BodyPreset::Athletic),
            "slender" => Some(BodyPreset::Slender),
            "heavy" => Some(BodyPreset::Heavy),
            "tall" => Some(BodyPreset::Tall),
            "petite" => Some(BodyPreset::Petite),
            "senior" => Some(BodyPreset::Senior),
            "child" => Some(BodyPreset::Child),
            _ => None,
        }
    }

    /// All available preset names.
    pub fn all_names() -> &'static [&'static str] {
        &[
            "average", "athletic", "slender", "heavy", "tall", "petite", "senior", "child",
        ]
    }
}

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

    #[test]
    fn average_preset_is_midpoint() {
        let p = BodyPreset::Average.params();
        assert!((p.height - 0.5).abs() < 1e-6);
        assert!((p.weight - 0.5).abs() < 1e-6);
        assert!((p.muscle - 0.5).abs() < 1e-6);
        assert!((p.age - 0.5).abs() < 1e-6);
    }

    #[test]
    fn athletic_has_high_muscle() {
        let p = BodyPreset::Athletic.params();
        assert!(p.muscle > 0.7);
    }

    #[test]
    fn child_has_low_age() {
        let p = BodyPreset::Child.params();
        assert!(p.age < 0.1);
        assert!(p.height < 0.3);
    }

    #[test]
    fn all_params_in_range() {
        for name in BodyPreset::all_names() {
            let preset = BodyPreset::from_name(name).expect("should succeed");
            let p = preset.params();
            assert!(
                (0.0..=1.0).contains(&p.height),
                "{} height out of range",
                name
            );
            assert!(
                (0.0..=1.0).contains(&p.weight),
                "{} weight out of range",
                name
            );
            assert!(
                (0.0..=1.0).contains(&p.muscle),
                "{} muscle out of range",
                name
            );
            assert!((0.0..=1.0).contains(&p.age), "{} age out of range", name);
        }
    }

    #[test]
    fn from_name_case_insensitive() {
        assert_eq!(
            BodyPreset::from_name("ATHLETIC"),
            Some(BodyPreset::Athletic)
        );
        assert_eq!(BodyPreset::from_name("Average"), Some(BodyPreset::Average));
        assert_eq!(BodyPreset::from_name("unknown"), None);
    }
}