kinect 0.0.6

A high level interface for Azure Kinect
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

#![allow(unused)]

use crate::Image;
use k4a_sys_temp as k4a_sys;
use std::ptr::null_mut;

/// Represents a single capture.
#[derive(Debug)]
pub struct Capture(pub k4a_sys::k4a_capture_t);

// These are ref-counted handles and are safe to Send.
unsafe impl Send for Capture{}

// Remove a libk4a capture refcount on every drop.
// When the refcount drops to zero, the capture goes away.
impl Drop for Capture {
    fn drop(&mut self) {
        unsafe {
            k4a_sys::k4a_capture_release(self.0);
            self.0 = null_mut();
        }
    }
}

// Handles are refcounted by libk4a. The final reference is destroyed.
impl Clone for Capture {
    fn clone(&self) -> Self {
        // We must increment the refcount.
        let handle = self.get_handle();
        unsafe {
            k4a_sys::k4a_capture_reference(handle);
        }
        Self {
            0: handle,
        }
    }

    fn clone_from(&mut self, source: &Self) {
        let handle = source.get_handle();
        unsafe {
            k4a_sys::k4a_capture_reference(handle);
        }
        unsafe {
            // drop refcount, potentially releasing if reached zero
            k4a_sys::k4a_capture_release(self.0);
        }
        self.0 = handle;
    }
}

impl Capture {
    /// Get the depth image from the capture (if any).
    pub fn get_depth_image(&self) -> Option<Image> {
        let image = unsafe {
            k4a_sys::k4a_capture_get_depth_image(self.0)
        };
        if image.is_null() {
            return None;
        }
        Some(Image(image))
    }

    /// Get the color image from the capture (if any).
    pub fn get_color_image(&self) -> Option<Image> {
        let image = unsafe {
            k4a_sys::k4a_capture_get_color_image(self.0)
        };
        if image.is_null() {
            return None;
        }
        Some(Image(image))
    }

    /// Get the IR image from the capture (if any).
    pub fn get_ir_image(&self) -> Option<Image> {
        let image = unsafe {
            k4a_sys::k4a_capture_get_ir_image(self.0)
        };
        if image.is_null() {
            return None;
        }
        Some(Image(image))
    }

    /// Returns the underlying opaque handle *without* an additional refcount.
    /// Do not deallocate it.
    pub fn get_handle(&self) -> k4a_sys::k4a_capture_t {
        self.0
    }
}