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

/// A depth image buffer.
pub struct DepthMap {
    pub width: usize,
    pub height: usize,
    pub data: Vec<f32>,
    pub near_plane: f32,
    pub far_plane: f32,
}

pub fn new_depth_map(width: usize, height: usize, near: f32, far: f32) -> DepthMap {
    DepthMap {
        width,
        height,
        data: vec![far; width * height],
        near_plane: near,
        far_plane: far,
    }
}

pub fn depth_map_set(m: &mut DepthMap, x: usize, y: usize, depth: f32) {
    if x < m.width && y < m.height {
        m.data[y * m.width + x] = depth;
    }
}

pub fn depth_map_get(m: &DepthMap, x: usize, y: usize) -> f32 {
    if x < m.width && y < m.height {
        m.data[y * m.width + x]
    } else {
        m.far_plane
    }
}

pub fn depth_map_to_u16(m: &DepthMap) -> Vec<u16> {
    let range = (m.far_plane - m.near_plane).max(1e-9);
    m.data
        .iter()
        .map(|&d| {
            let t = ((d - m.near_plane) / range).clamp(0.0, 1.0);
            (t * 65535.0) as u16
        })
        .collect()
}

pub fn depth_map_min(m: &DepthMap) -> f32 {
    m.data.iter().cloned().fold(f32::INFINITY, f32::min)
}

pub fn depth_map_max(m: &DepthMap) -> f32 {
    m.data.iter().cloned().fold(f32::NEG_INFINITY, f32::max)
}

pub fn depth_map_normalize(m: &DepthMap) -> Vec<f32> {
    let mn = depth_map_min(m);
    let mx = depth_map_max(m);
    let range = (mx - mn).max(1e-9);
    m.data.iter().map(|&d| (d - mn) / range).collect()
}

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

    #[test]
    fn test_new_depth_map_size() {
        let m = new_depth_map(4, 4, 0.1, 100.0);
        assert_eq!(m.data.len(), 16);
    }

    #[test]
    fn test_depth_map_set_get() {
        let mut m = new_depth_map(4, 4, 0.1, 100.0);
        depth_map_set(&mut m, 2, 1, 5.0);
        assert!((depth_map_get(&m, 2, 1) - 5.0).abs() < 1e-6);
    }

    #[test]
    fn test_depth_map_get_oob() {
        let m = new_depth_map(4, 4, 0.1, 100.0);
        assert!((depth_map_get(&m, 10, 10) - 100.0).abs() < 1e-6);
    }

    #[test]
    fn test_depth_map_to_u16_range() {
        let mut m = new_depth_map(2, 1, 0.0, 1.0);
        depth_map_set(&mut m, 0, 0, 0.0);
        depth_map_set(&mut m, 1, 0, 1.0);
        let u16s = depth_map_to_u16(&m);
        assert_eq!(u16s[0], 0);
        assert_eq!(u16s[1], 65535);
    }

    #[test]
    fn test_depth_map_min() {
        let mut m = new_depth_map(3, 1, 0.0, 10.0);
        depth_map_set(&mut m, 0, 0, 2.0);
        depth_map_set(&mut m, 1, 0, 5.0);
        depth_map_set(&mut m, 2, 0, 8.0);
        assert!((depth_map_min(&m) - 2.0).abs() < 1e-5);
    }

    #[test]
    fn test_depth_map_max() {
        let mut m = new_depth_map(3, 1, 0.0, 10.0);
        depth_map_set(&mut m, 0, 0, 2.0);
        depth_map_set(&mut m, 1, 0, 9.0);
        depth_map_set(&mut m, 2, 0, 4.0);
        assert!((depth_map_max(&m) - 9.0).abs() < 1e-5);
    }

    #[test]
    fn test_depth_map_normalize_range() {
        let mut m = new_depth_map(2, 1, 0.0, 10.0);
        depth_map_set(&mut m, 0, 0, 0.0);
        depth_map_set(&mut m, 1, 0, 10.0);
        let n = depth_map_normalize(&m);
        assert!((n[0] - 0.0).abs() < 1e-5);
        assert!((n[1] - 1.0).abs() < 1e-5);
    }

    #[test]
    fn test_depth_map_default_far() {
        let m = new_depth_map(2, 2, 0.1, 50.0);
        assert!((m.data[0] - 50.0).abs() < 1e-5);
    }
}