oxihuman-export 0.1.2

Export pipeline for OxiHuman — glTF, COLLADA, STL, and streaming formats
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

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

pub struct VeinMap {
    pub paths: Vec<Vec<[f32; 3]>>,
    pub widths: Vec<f32>,
    pub depths: Vec<f32>,
}

pub fn new_vein_map() -> VeinMap {
    VeinMap {
        paths: vec![],
        widths: vec![],
        depths: vec![],
    }
}

pub fn vein_add_path(m: &mut VeinMap, points: Vec<[f32; 3]>, width: f32, depth: f32) {
    m.paths.push(points);
    m.widths.push(width);
    m.depths.push(depth);
}

pub fn vein_path_count(m: &VeinMap) -> usize {
    m.paths.len()
}

pub fn vein_total_length(m: &VeinMap) -> f32 {
    m.paths.iter().map(|path| path_length(path)).sum()
}

fn path_length(pts: &[[f32; 3]]) -> f32 {
    if pts.len() < 2 {
        return 0.0;
    }
    let mut total = 0.0_f32;
    for i in 1..pts.len() {
        let a = pts[i - 1];
        let b = pts[i];
        let dx = b[0] - a[0];
        let dy = b[1] - a[1];
        let dz = b[2] - a[2];
        total += (dx * dx + dy * dy + dz * dz).sqrt();
    }
    total
}

pub fn vein_to_json(m: &VeinMap) -> String {
    let mut paths_json = String::new();
    for (i, (path, (&w, &d))) in m
        .paths
        .iter()
        .zip(m.widths.iter().zip(m.depths.iter()))
        .enumerate()
    {
        if i > 0 {
            paths_json.push(',');
        }
        let pts: Vec<String> = path
            .iter()
            .map(|p| format!("[{:.4},{:.4},{:.4}]", p[0], p[1], p[2]))
            .collect();
        paths_json.push_str(&format!(
            "{{\"width\":{w:.4},\"depth\":{d:.4},\"points\":[{}]}}",
            pts.join(",")
        ));
    }
    format!("{{\"veins\":[{paths_json}]}}")
}

pub fn vein_mean_depth(m: &VeinMap) -> f32 {
    if m.depths.is_empty() {
        return 0.0;
    }
    m.depths.iter().sum::<f32>() / m.depths.len() as f32
}

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

    #[test]
    fn test_new_vein_map() {
        /* empty on construction */
        let m = new_vein_map();
        assert_eq!(vein_path_count(&m), 0);
    }

    #[test]
    fn test_add_path() {
        /* add and count */
        let mut m = new_vein_map();
        vein_add_path(&mut m, vec![[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]], 0.5, 0.1);
        assert_eq!(vein_path_count(&m), 1);
    }

    #[test]
    fn test_total_length() {
        /* single path of length 1 */
        let mut m = new_vein_map();
        vein_add_path(&mut m, vec![[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]], 0.5, 0.1);
        assert!((vein_total_length(&m) - 1.0).abs() < 1e-6);
    }

    #[test]
    fn test_to_json() {
        /* JSON contains veins key */
        let mut m = new_vein_map();
        vein_add_path(&mut m, vec![[0.0; 3]], 0.5, 0.1);
        let json = vein_to_json(&m);
        assert!(json.contains("veins"));
    }

    #[test]
    fn test_mean_depth() {
        /* mean depth */
        let mut m = new_vein_map();
        vein_add_path(&mut m, vec![], 0.5, 0.2);
        vein_add_path(&mut m, vec![], 0.5, 0.4);
        assert!((vein_mean_depth(&m) - 0.3).abs() < 1e-6);
    }

    #[test]
    fn test_empty_mean_depth() {
        /* empty => 0 */
        let m = new_vein_map();
        assert!((vein_mean_depth(&m)).abs() < 1e-6);
    }
}