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

// Copyright (C) 2026 COOLJAPAN OU (Team KitaSan)
// SPDX-License-Identifier: Apache-2.0
#![allow(dead_code)]
//! Procedural morph: compute weights from analytical function.

use std::f32::consts::PI;

#[allow(dead_code)]
pub enum ProceduralMorphKind {
    Sine,
    Square,
    Triangle,
    Sawtooth,
}

#[allow(dead_code)]
pub struct ProceduralMorph {
    pub kind: ProceduralMorphKind,
    pub frequency: f32,
    pub amplitude: f32,
    pub phase: f32,
}

#[allow(dead_code)]
pub fn new_procedural_morph(kind: ProceduralMorphKind, frequency: f32, amplitude: f32) -> ProceduralMorph {
    ProceduralMorph { kind, frequency, amplitude, phase: 0.0 }
}

#[allow(dead_code)]
pub fn pm_evaluate(m: &ProceduralMorph, t: f32) -> f32 {
    let x = m.frequency * t + m.phase;
    let raw = match m.kind {
        ProceduralMorphKind::Sine => (2.0 * PI * x).sin(),
        ProceduralMorphKind::Square => if x.fract() < 0.5 { 1.0 } else { -1.0 },
        ProceduralMorphKind::Triangle => {
            let frac = x.fract();
            if frac < 0.5 { 4.0 * frac - 1.0 } else { 3.0 - 4.0 * frac }
        }
        ProceduralMorphKind::Sawtooth => 2.0 * x.fract() - 1.0,
    };
    raw * m.amplitude
}

#[allow(dead_code)]
pub fn pm_set_phase(m: &mut ProceduralMorph, phase: f32) {
    m.phase = phase;
}

#[allow(dead_code)]
pub fn pm_frequency(m: &ProceduralMorph) -> f32 {
    m.frequency
}

#[allow(dead_code)]
pub fn pm_period(m: &ProceduralMorph) -> f32 {
    if m.frequency.abs() < 1e-7 { f32::INFINITY } else { 1.0 / m.frequency }
}

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

    #[test]
    fn test_sine_at_zero() {
        let m = new_procedural_morph(ProceduralMorphKind::Sine, 1.0, 1.0);
        let v = pm_evaluate(&m, 0.0);
        assert!(v.abs() < 1e-5);
    }

    #[test]
    fn test_square_positive() {
        let m = new_procedural_morph(ProceduralMorphKind::Square, 1.0, 1.0);
        let v = pm_evaluate(&m, 0.1);
        assert!(v > 0.0);
    }

    #[test]
    fn test_square_negative() {
        let m = new_procedural_morph(ProceduralMorphKind::Square, 1.0, 1.0);
        let v = pm_evaluate(&m, 0.6);
        assert!(v < 0.0);
    }

    #[test]
    fn test_triangle_midpoint() {
        let m = new_procedural_morph(ProceduralMorphKind::Triangle, 1.0, 1.0);
        let v = pm_evaluate(&m, 0.25);
        assert!((v - 0.0).abs() < 1e-5);
    }

    #[test]
    fn test_sawtooth_at_zero() {
        let m = new_procedural_morph(ProceduralMorphKind::Sawtooth, 1.0, 1.0);
        let v = pm_evaluate(&m, 0.0);
        assert!((v - (-1.0)).abs() < 1e-5);
    }

    #[test]
    fn test_frequency_getter() {
        let m = new_procedural_morph(ProceduralMorphKind::Sine, 2.0, 1.0);
        assert!((pm_frequency(&m) - 2.0).abs() < 1e-5);
    }

    #[test]
    fn test_period() {
        let m = new_procedural_morph(ProceduralMorphKind::Sine, 2.0, 1.0);
        assert!((pm_period(&m) - 0.5).abs() < 1e-5);
    }

    #[test]
    fn test_set_phase() {
        let mut m = new_procedural_morph(ProceduralMorphKind::Sine, 1.0, 1.0);
        pm_set_phase(&mut m, 0.25);
        assert!((m.phase - 0.25).abs() < 1e-5);
    }
}