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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

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

#[derive(Debug, Clone)]
pub struct LidarPointCloud {
    pub points: Vec<[f32; 3]>,
    pub intensities: Vec<f32>,
    pub return_number: Vec<u8>,
}

pub fn new_lidar_point_cloud() -> LidarPointCloud {
    LidarPointCloud {
        points: Vec::new(),
        intensities: Vec::new(),
        return_number: Vec::new(),
    }
}

pub fn lidar_push_point(pc: &mut LidarPointCloud, pos: [f32; 3], intensity: f32, ret: u8) {
    pc.points.push(pos);
    pc.intensities.push(intensity);
    pc.return_number.push(ret);
}

pub fn lidar_point_count(pc: &LidarPointCloud) -> usize {
    pc.points.len()
}

pub fn lidar_bounding_box(pc: &LidarPointCloud) -> ([f32; 3], [f32; 3]) {
    if pc.points.is_empty() {
        return ([0.0; 3], [0.0; 3]);
    }
    let mut mn = pc.points[0];
    let mut mx = pc.points[0];
    for p in &pc.points {
        for i in 0..3 {
            if p[i] < mn[i] {
                mn[i] = p[i];
            }
            if p[i] > mx[i] {
                mx[i] = p[i];
            }
        }
    }
    (mn, mx)
}

pub fn lidar_mean_intensity(pc: &LidarPointCloud) -> f32 {
    if pc.intensities.is_empty() {
        return 0.0;
    }
    pc.intensities.iter().sum::<f32>() / pc.intensities.len() as f32
}

pub fn lidar_filter_by_return(pc: &LidarPointCloud, ret: u8) -> Vec<usize> {
    pc.return_number
        .iter()
        .enumerate()
        .filter(|(_, &r)| r == ret)
        .map(|(i, _)| i)
        .collect()
}

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

    #[test]
    fn test_new_empty() {
        /* empty on creation */
        let pc = new_lidar_point_cloud();
        assert_eq!(lidar_point_count(&pc), 0);
    }

    #[test]
    fn test_push_point() {
        /* push adds a point */
        let mut pc = new_lidar_point_cloud();
        lidar_push_point(&mut pc, [1.0, 2.0, 3.0], 0.5, 1);
        assert_eq!(lidar_point_count(&pc), 1);
    }

    #[test]
    fn test_bounding_box_empty() {
        /* empty cloud returns zeros */
        let pc = new_lidar_point_cloud();
        let (mn, mx) = lidar_bounding_box(&pc);
        assert_eq!(mn, [0.0; 3]);
        assert_eq!(mx, [0.0; 3]);
    }

    #[test]
    fn test_bounding_box_single() {
        /* single point => min == max */
        let mut pc = new_lidar_point_cloud();
        lidar_push_point(&mut pc, [5.0, 6.0, 7.0], 1.0, 1);
        let (mn, mx) = lidar_bounding_box(&pc);
        assert_eq!(mn, [5.0, 6.0, 7.0]);
        assert_eq!(mx, [5.0, 6.0, 7.0]);
    }

    #[test]
    fn test_mean_intensity() {
        /* mean of [0.5, 1.0] = 0.75 */
        let mut pc = new_lidar_point_cloud();
        lidar_push_point(&mut pc, [0.0; 3], 0.5, 1);
        lidar_push_point(&mut pc, [1.0; 3], 1.0, 1);
        assert!((lidar_mean_intensity(&pc) - 0.75).abs() < 1e-5);
    }

    #[test]
    fn test_filter_by_return() {
        /* filter keeps matching return numbers */
        let mut pc = new_lidar_point_cloud();
        lidar_push_point(&mut pc, [0.0; 3], 1.0, 1);
        lidar_push_point(&mut pc, [1.0; 3], 1.0, 2);
        lidar_push_point(&mut pc, [2.0; 3], 1.0, 1);
        let indices = lidar_filter_by_return(&pc, 1);
        assert_eq!(indices, vec![0, 2]);
    }

    #[test]
    fn test_mean_intensity_empty() {
        /* empty returns 0 */
        let pc = new_lidar_point_cloud();
        assert!((lidar_mean_intensity(&pc) - 0.0).abs() < 1e-6);
    }
}