azure-kinect 0.1.1

Rust Bindings for Azure Kinect Sensor SDK
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
148
149
150
151
152
153
154
155

use super::utility::*;
use super::*;
use std::ptr;

pub struct Device<'a> {
    pub(crate) factory: &'a Factory,
    pub(crate) handle: k4a_device_t,
}

#[derive(Copy, Clone, Default)]
pub struct ColorControlCapabilities {
    supports_auto: bool,
    min_value: i32,
    max_value: i32,
    step_value: i32,
    default_value: i32,
    default_mode: k4a_color_control_mode_t,
}

impl Device<'_> {
    pub(crate) fn from_handle(factory: &Factory, handle: k4a_device_t) -> Device {
        Device {
            factory: factory,
            handle: handle,
        }
    }

    /// Starts the K4A device's cameras
    pub fn start_cameras(
        &self,
        configuration: &k4a_device_configuration_t,
    ) -> Result<Camera, Error> {
        Camera::new(&self, configuration)
    }

    /// Get the K4A device serial number
    pub fn get_serialnum(&self) -> Result<String, Error> {
        get_k4a_string(&|serialnum, buffer| {
            (self.factory.k4a_device_get_serialnum)(self.handle, serialnum, buffer)
        })
    }

    /// Get the K4A color sensor control value
    pub fn get_color_control(
        &self,
        command: k4a_color_control_command_t,
    ) -> Result<(k4a_color_control_mode_t, i32), Error> {
        let mut mode: k4a_color_control_mode_t =
            k4a_color_control_mode_t::K4A_COLOR_CONTROL_MODE_AUTO;
        let mut value: i32 = 0;
        Error::from((self.factory.k4a_device_get_color_control)(
            self.handle,
            command,
            &mut mode,
            &mut value,
        ))
        .to_result((mode, value))
    }

    /// Set the K4A color sensor control value
    pub fn set_color_control(
        &self,
        command: k4a_color_control_command_t,
        mode: k4a_color_control_mode_t,
        value: i32,
    ) -> Result<(), Error> {
        Error::from((self.factory.k4a_device_set_color_control)(
            self.handle,
            command,
            mode,
            value,
        ))
        .to_result(())
    }

    pub fn get_color_control_capabilities(
        &self,
        command: k4a_color_control_command_t,
    ) -> Result<ColorControlCapabilities, Error> {
        let mut capabilties = ColorControlCapabilities::default();
        Error::from((self.factory.k4a_device_get_color_control_capabilities)(
            self.handle,
            command,
            &mut capabilties.supports_auto,
            &mut capabilties.min_value,
            &mut capabilties.max_value,
            &mut capabilties.step_value,
            &mut capabilties.default_value,
            &mut capabilties.default_mode,
        ))
        .to_result(capabilties)
    }

    /// Get the raw calibration blob for the entire K4A device.
    pub fn get_raw_calibration(&self) -> Result<Vec<u8>, Error> {
        get_k4a_binary_data(&|calibration, buffer| {
            (self.factory.k4a_device_get_raw_calibration)(self.handle, calibration, buffer)
        })
    }

    /// Get the camera calibration for the entire K4A device, which is used for all transformation functions.
    pub fn get_calibration(
        &self,
        depth_mode: k4a_depth_mode_t,
        color_resolution: k4a_color_resolution_t,
    ) -> Result<Calibration, Error> {
        let mut calibaraion = k4a_calibration_t::default();
        Error::from((self.factory.k4a_device_get_calibration)(
            self.handle,
            depth_mode,
            color_resolution,
            &mut calibaraion,
        ))
        .to_result_fn(&|| Calibration::from_handle(self.factory, calibaraion))
    }

    /// Get the device jack status for the synchronization connectors
    pub fn is_sync_connected(&self) -> Result<(bool, bool), Error> {
        let mut sync_in_jack_connected = false;
        let mut sync_out_jack_connected = false;
        Error::from((self.factory.k4a_device_get_sync_jack)(
            self.handle,
            &mut sync_in_jack_connected,
            &mut sync_out_jack_connected,
        ))
        .to_result((sync_in_jack_connected, sync_out_jack_connected))
    }

    /// Get the device jack status for the synchronization in connector
    pub fn is_sync_in_connected(&self) -> Result<bool, Error> {
        Ok(self.is_sync_connected()?.0)
    }

    /// Get the device jack status for the synchronization out connector
    pub fn is_sync_out_connected(&self) -> Result<bool, Error> {
        Ok(self.is_sync_connected()?.1)
    }

    /// Get the version numbers of the K4A subsystems' firmware
    pub fn get_version(&self) -> Result<k4a_hardware_version_t, Error> {
        let mut version = k4a_hardware_version_t::default();
        Error::from((self.factory.k4a_device_get_version)(
            self.handle,
            &mut version,
        ))
        .to_result(version)
    }
}

impl Drop for Device<'_> {
    fn drop(&mut self) {
        (self.factory.k4a_device_close)(self.handle);
        self.handle = ptr::null_mut();
    }
}