depthai 0.1.3

Experimental Rust bindings and idiomatic wrapper for Luxonis DepthAI-Core v3.
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
145
146
147

use std::time::Duration;

use autocxx::c_int;
use depthai_sys::{depthai, DaiRGBDData};

use crate::camera::{ImageFrame, OutputQueue};
use crate::error::{clear_error_flag, last_error, take_error_if_any, Result};

#[repr(i32)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum DepthUnit {
    Meter = 0,
    Centimeter = 1,
    Millimeter = 2,
    Inch = 3,
    Foot = 4,
    Custom = 5,
}

#[allow(non_snake_case)]
#[crate::native_node_wrapper(native = "dai::node::RGBD", inputs(inColor, inDepth), outputs(out))]
pub struct RgbdNode {
    node: crate::pipeline::Node,
}

impl RgbdNode {
    pub fn build(&self) -> Result<()> {
        clear_error_flag();
        let out = unsafe { depthai::dai_rgbd_build(self.node.handle()) };
        if out.is_null() {
            Err(last_error("failed to build RGBD node"))
        } else {
            Ok(())
        }
    }

    /// Build the RGBD node with explicit configuration.
    ///
    /// This maps to the native overload:
    /// `dai::node::RGBD::build(autocreate, mode, size, fps)`.
    ///
    /// Some devices/firmwares produce depth frames at sizes that don't match the requested
    /// RGB frames. Using this builder allows the host node to be configured with the
    /// expected size (and optionally FPS), preventing runtime "Color and depth frame sizes do not match" errors.
    pub fn build_ex(
        &self,
        autocreate: bool,
        mode: crate::stereo_depth::PresetMode,
        size: (i32, i32),
        fps: Option<f32>,
    ) -> Result<()> {
        clear_error_flag();
        let (w, h) = size;
        let fps_val = fps.unwrap_or(-1.0);
        let out = unsafe {
            depthai::dai_rgbd_build_ex(
                self.node.handle(),
                autocreate,
                c_int(mode as i32),
                c_int(w),
                c_int(h),
                fps_val,
            )
        };
        if out.is_null() {
            Err(last_error("failed to build RGBD node (build_ex)"))
        } else {
            Ok(())
        }
    }

    pub fn set_depth_unit(&self, unit: DepthUnit) {
        // setter cannot fail at the C ABI level (will record last_error on exception)
        clear_error_flag();
        unsafe { depthai::dai_rgbd_set_depth_unit(self.node.handle(), c_int(unit as i32)) };
    }
}

pub struct RgbdData {
    handle: DaiRGBDData,
}

impl Drop for RgbdData {
    fn drop(&mut self) {
        if !self.handle.is_null() {
            unsafe { depthai::dai_rgbd_release(self.handle) };
            self.handle = std::ptr::null_mut();
        }
    }
}

impl RgbdData {
    pub(crate) fn from_handle(handle: DaiRGBDData) -> Self {
        Self { handle }
    }

    pub fn rgb_frame(&self) -> Result<ImageFrame> {
        clear_error_flag();
        let frame = unsafe { depthai::dai_rgbd_get_rgb_frame(self.handle) };
        if frame.is_null() {
            Err(last_error("failed to get RGB frame"))
        } else {
            Ok(ImageFrame::from_handle(frame))
        }
    }

    pub fn depth_frame(&self) -> Result<ImageFrame> {
        clear_error_flag();
        let frame = unsafe { depthai::dai_rgbd_get_depth_frame(self.handle) };
        if frame.is_null() {
            Err(last_error("failed to get depth frame"))
        } else {
            Ok(ImageFrame::from_handle(frame))
        }
    }
}

impl OutputQueue {
    pub fn blocking_next_rgbd(&self, timeout: Option<Duration>) -> Result<Option<RgbdData>> {
        clear_error_flag();
        let timeout_ms = timeout.map(|d| d.as_millis() as i32).unwrap_or(-1);
        let msg = unsafe { depthai::dai_queue_get_rgbd(self.handle(), c_int(timeout_ms)) };
        if msg.is_null() {
            if let Some(err) = take_error_if_any("failed to pull rgbd") {
                Err(err)
            } else {
                Ok(None)
            }
        } else {
            Ok(Some(RgbdData::from_handle(msg)))
        }
    }

    pub fn try_next_rgbd(&self) -> Result<Option<RgbdData>> {
        clear_error_flag();
        let msg = unsafe { depthai::dai_queue_try_get_rgbd(self.handle()) };
        if msg.is_null() {
            if let Some(err) = take_error_if_any("failed to poll rgbd") {
                Err(err)
            } else {
                Ok(None)
            }
        } else {
            Ok(Some(RgbdData::from_handle(msg)))
        }
    }
}