oxihuman-viewer 0.2.1

wgpu/WebGPU rendering adapter for OxiHuman
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

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

#[derive(Debug, Clone)]
pub struct CtVolume {
    pub width: u16,
    pub height: u16,
    pub depth: u16,
    pub voxels: Vec<i16>,
    pub voxel_spacing_mm: [f32; 3],
}

pub fn new_ct_volume(w: u16, h: u16, d: u16) -> CtVolume {
    let n = (w as usize) * (h as usize) * (d as usize);
    CtVolume {
        width: w,
        height: h,
        depth: d,
        voxels: vec![0; n],
        voxel_spacing_mm: [1.0, 1.0, 1.0],
    }
}

fn ct_index(v: &CtVolume, x: u16, y: u16, z: u16) -> Option<usize> {
    if x < v.width && y < v.height && z < v.depth {
        Some(
            z as usize * v.height as usize * v.width as usize
                + y as usize * v.width as usize
                + x as usize,
        )
    } else {
        None
    }
}

pub fn ct_set_voxel(v: &mut CtVolume, x: u16, y: u16, z: u16, hu: i16) {
    if let Some(idx) = ct_index(v, x, y, z) {
        v.voxels[idx] = hu;
    }
}

pub fn ct_get_voxel(v: &CtVolume, x: u16, y: u16, z: u16) -> i16 {
    ct_index(v, x, y, z).map(|i| v.voxels[i]).unwrap_or(0)
}

pub fn ct_voxel_count(v: &CtVolume) -> usize {
    v.width as usize * v.height as usize * v.depth as usize
}

pub fn ct_volume_mm3(v: &CtVolume) -> f32 {
    ct_voxel_count(v) as f32 * v.voxel_spacing_mm[0] * v.voxel_spacing_mm[1] * v.voxel_spacing_mm[2]
}

pub fn ct_density_above(v: &CtVolume, threshold_hu: i16) -> usize {
    v.voxels.iter().filter(|&&hu| hu > threshold_hu).count()
}

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

    #[test]
    fn test_new_volume() {
        /* voxel count = w*h*d */
        let v = new_ct_volume(4, 4, 4);
        assert_eq!(ct_voxel_count(&v), 64);
    }

    #[test]
    fn test_set_get_voxel() {
        /* set and get voxel */
        let mut v = new_ct_volume(5, 5, 5);
        ct_set_voxel(&mut v, 1, 2, 3, 400);
        assert_eq!(ct_get_voxel(&v, 1, 2, 3), 400);
    }

    #[test]
    fn test_get_voxel_oob() {
        /* out of bounds returns 0 */
        let v = new_ct_volume(3, 3, 3);
        assert_eq!(ct_get_voxel(&v, 100, 100, 100), 0);
    }

    #[test]
    fn test_volume_mm3() {
        /* volume = voxel_count * spacing product */
        let v = new_ct_volume(2, 2, 2);
        assert!((ct_volume_mm3(&v) - 8.0).abs() < 1e-5);
    }

    #[test]
    fn test_density_above_all_zero() {
        /* all zero, threshold 0 => 0 above */
        let v = new_ct_volume(3, 3, 3);
        assert_eq!(ct_density_above(&v, 0), 0);
    }

    #[test]
    fn test_density_above_some() {
        /* set one voxel high */
        let mut v = new_ct_volume(2, 2, 1);
        ct_set_voxel(&mut v, 0, 0, 0, 1000);
        assert_eq!(ct_density_above(&v, 500), 1);
    }

    #[test]
    fn test_voxel_count_correct() {
        /* voxel count matches */
        let v = new_ct_volume(10, 5, 3);
        assert_eq!(ct_voxel_count(&v), 150);
    }
}