viewercloud 0.2.1

Cross-platform 3D viewer to display autonomous driving poincloud datasets and annotations
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
131
132
133
134
135
136
137
138
139
140
141
142
143
144

//! KITTI Annotation file parsing.
use anyhow::Result;
use std::ffi::OsStr;
use std::fs::File;
use std::io::prelude::*;
use std::io::BufReader;
use std::path::Path;
/// Struct to reprensent every KITTI annotation.
#[derive(Debug, Default, PartialEq)]
pub struct KittiAnnotation {
    /// Describes the type of object:
    /// 'Car', 'Van', 'Truck',
    /// 'Pedestrian', 'Person_sitting',
    /// 'Cyclist', 'Tram',
    /// 'Misc' or 'DontCare'.
    pub category: String,
    /// Float from 0 (non-truncated)
    /// to 1 (truncated), where truncated refers
    /// to the object leaving image boundaries
    pub truncation: f32,
    /// Integer (0,1,2,3) indicating occlusion state:
    /// 0 = fully visible,
    /// 1 = partly occluded,
    /// 2 = largely occluded,
    /// 3 = unknown
    pub occlusion: i16,
    /// Observation angle of object, ranging [-pi..pi]
    pub alpha: f32,
    /// 2D bounding box xmin of object in the image
    pub xmin: f32,
    /// 2D bounding box ymin of object in the image
    pub ymin: f32,
    /// 2D bounding box xmax of object in the image
    pub xmax: f32,
    /// 2D bounding box ymax of object in the image
    pub ymax: f32,
    /// 3D object dimensions  height(in meters)
    pub h: f32,
    /// 3D object dimensions width (in meters)
    pub w: f32,
    /// 3D object dimensions length (in meters)
    pub l: f32,
    /// 3D object location x in camera coordinates (in meters)
    pub x: f32,
    /// 3D object location y in camera coordinates (in meters)
    pub y: f32,
    /// 3D object location z in camera coordinates (in meters)
    pub z: f32,
    /// Rotation ry around Y-axis in camera coordinates [-pi..pi]
    pub ry: f32,
    /// Score indicating confidence in detection [0..1]
    /// If coming from gound truth score is 1.0
    pub score: f32,
}

impl KittiAnnotation {
    /// Create a KittiAnnotation
    #[allow(clippy::too_many_arguments)]
    pub fn new(
        category: String,
        truncation: f32,
        occlusion: i16,
        alpha: f32,
        xmin: f32,
        ymin: f32,
        xmax: f32,
        ymax: f32,
        height: f32,
        width: f32,
        length: f32,
        xc: f32,
        yc: f32,
        zc: f32,
        ry: f32,
        score: f32,
    ) -> Self {
        Self {
            category,
            truncation,
            occlusion,
            alpha,
            xmin,
            ymin,
            xmax,
            ymax,
            h: height,
            w: width,
            l: length,
            x: xc,
            y: yc,
            z: zc,
            ry,
            score,
        }
    }
    /// Return the 2D BoundingBox in image coordinates system
    pub fn get_2d_bounding_box(self) -> [f32; 4] {
        [self.xmin, self.ymin, self.xmax, self.ymax]
    }
    /// Return the 3D BoundingBox in the Lidar coordinates system
    pub fn get_3d_bounding_box(self) -> [f32; 7] {
        [self.x, self.y, self.z, self.h, self.w, self.l, self.ry]
    }
}

/// Parse a KITTI annotation file describe in the DevKit
pub fn read_annotation_file(kitti_annotations_path: String) -> Result<Vec<KittiAnnotation>> {
    let extension = Path::new(&kitti_annotations_path).extension();
    if extension != Some(OsStr::new("txt")) {
        panic!(
            "KITTI annotation file are in txt format and it received an got {:?}.",
            extension
        );
    }
    let file = File::open(kitti_annotations_path).expect("This file does not exist");
    let file = BufReader::new(file);
    let mut annotation: Vec<KittiAnnotation> = vec![];
    for line in file.lines() {
        let line = line?;
        let data: Vec<&str> = line.split_whitespace().collect();
        if data[0] != "DontCare" {
            let anno = KittiAnnotation::new(
                data[0].to_string(),
                data[1].parse()?,
                data[2].parse()?,
                data[3].parse()?,
                data[4].parse()?,
                data[5].parse()?,
                data[6].parse()?,
                data[7].parse()?,
                data[8].parse()?,
                data[9].parse()?,
                data[10].parse()?,
                data[11].parse()?,
                data[12].parse()?,
                data[13].parse()?,
                data[14].parse()?,
                1.0,
            );
            annotation.push(anno);
        }
    }
    Ok(annotation)
}