pub const K4A_VERSION_MAJOR: u32 = 1;
pub const K4A_VERSION_MINOR: u32 = 3;
pub const K4A_VERSION_PATCH: u32 = 0;
pub const K4A_VERSION_PRERELEASE: &'static [u8; 8usize] = b"private\0";
pub const K4A_VERSION_BUILD_METADATA: &'static [u8; 1usize] = b"\0";
pub const K4A_VERSION_STR: &'static [u8; 14usize] = b"1.3.0-private\0";
pub const K4A_DEVICE_DEFAULT: u32 = 0;
pub const K4A_WAIT_INFINITE: i32 = -1;
pub type __uint8_t = ::std::os::raw::c_uchar;
pub type __int32_t = ::std::os::raw::c_int;
pub type __uint32_t = ::std::os::raw::c_uint;
pub type __uint64_t = ::std::os::raw::c_ulong;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _k4a_device_t {
pub _rsvd: usize,
}
#[test]
fn bindgen_test_layout__k4a_device_t() {
assert_eq!(
::std::mem::size_of::<_k4a_device_t>(),
8usize,
concat!("Size of: ", stringify!(_k4a_device_t))
);
assert_eq!(
::std::mem::align_of::<_k4a_device_t>(),
8usize,
concat!("Alignment of ", stringify!(_k4a_device_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_k4a_device_t>()))._rsvd as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_k4a_device_t),
"::",
stringify!(_rsvd)
)
);
}
pub type k4a_device_t = *mut _k4a_device_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _k4a_capture_t {
pub _rsvd: usize,
}
#[test]
fn bindgen_test_layout__k4a_capture_t() {
assert_eq!(
::std::mem::size_of::<_k4a_capture_t>(),
8usize,
concat!("Size of: ", stringify!(_k4a_capture_t))
);
assert_eq!(
::std::mem::align_of::<_k4a_capture_t>(),
8usize,
concat!("Alignment of ", stringify!(_k4a_capture_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_k4a_capture_t>()))._rsvd as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_k4a_capture_t),
"::",
stringify!(_rsvd)
)
);
}
pub type k4a_capture_t = *mut _k4a_capture_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _k4a_image_t {
pub _rsvd: usize,
}
#[test]
fn bindgen_test_layout__k4a_image_t() {
assert_eq!(
::std::mem::size_of::<_k4a_image_t>(),
8usize,
concat!("Size of: ", stringify!(_k4a_image_t))
);
assert_eq!(
::std::mem::align_of::<_k4a_image_t>(),
8usize,
concat!("Alignment of ", stringify!(_k4a_image_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_k4a_image_t>()))._rsvd as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_k4a_image_t),
"::",
stringify!(_rsvd)
)
);
}
pub type k4a_image_t = *mut _k4a_image_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _k4a_transformation_t {
pub _rsvd: usize,
}
#[test]
fn bindgen_test_layout__k4a_transformation_t() {
assert_eq!(
::std::mem::size_of::<_k4a_transformation_t>(),
8usize,
concat!("Size of: ", stringify!(_k4a_transformation_t))
);
assert_eq!(
::std::mem::align_of::<_k4a_transformation_t>(),
8usize,
concat!("Alignment of ", stringify!(_k4a_transformation_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_k4a_transformation_t>()))._rsvd as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_k4a_transformation_t),
"::",
stringify!(_rsvd)
)
);
}
pub type k4a_transformation_t = *mut _k4a_transformation_t;
#[doc = "< The result was successful"]
pub const k4a_result_t_K4A_RESULT_SUCCEEDED: k4a_result_t = 0;
#[doc = "< The result was a failure"]
pub const k4a_result_t_K4A_RESULT_FAILED: k4a_result_t = 1;
#[doc = " Result code returned by Azure Kinect APIs."]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4atypes.h (include k4a/k4a.h)</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub type k4a_result_t = u32;
#[doc = "< The result was successful"]
pub const k4a_buffer_result_t_K4A_BUFFER_RESULT_SUCCEEDED: k4a_buffer_result_t = 0;
#[doc = "< The result was a failure"]
pub const k4a_buffer_result_t_K4A_BUFFER_RESULT_FAILED: k4a_buffer_result_t = 1;
#[doc = "< The input buffer was too small"]
pub const k4a_buffer_result_t_K4A_BUFFER_RESULT_TOO_SMALL: k4a_buffer_result_t = 2;
#[doc = " Result code returned by Azure Kinect APIs."]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4atypes.h (include k4a/k4a.h)</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub type k4a_buffer_result_t = u32;
#[doc = "< The result was successful"]
pub const k4a_wait_result_t_K4A_WAIT_RESULT_SUCCEEDED: k4a_wait_result_t = 0;
#[doc = "< The result was a failure"]
pub const k4a_wait_result_t_K4A_WAIT_RESULT_FAILED: k4a_wait_result_t = 1;
#[doc = "< The operation timed out"]
pub const k4a_wait_result_t_K4A_WAIT_RESULT_TIMEOUT: k4a_wait_result_t = 2;
#[doc = " Result code returned by Azure Kinect APIs."]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4atypes.h (include k4a/k4a.h)</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub type k4a_wait_result_t = u32;
#[doc = "< Most severe level of debug messaging."]
pub const k4a_log_level_t_K4A_LOG_LEVEL_CRITICAL: k4a_log_level_t = 0;
#[doc = "< 2nd most severe level of debug messaging."]
pub const k4a_log_level_t_K4A_LOG_LEVEL_ERROR: k4a_log_level_t = 1;
#[doc = "< 3nd most severe level of debug messaging."]
pub const k4a_log_level_t_K4A_LOG_LEVEL_WARNING: k4a_log_level_t = 2;
#[doc = "< 2nd least severe level of debug messaging."]
pub const k4a_log_level_t_K4A_LOG_LEVEL_INFO: k4a_log_level_t = 3;
#[doc = "< Least severe level of debug messaging."]
pub const k4a_log_level_t_K4A_LOG_LEVEL_TRACE: k4a_log_level_t = 4;
#[doc = "< No logging is performed"]
pub const k4a_log_level_t_K4A_LOG_LEVEL_OFF: k4a_log_level_t = 5;
#[doc = " Verbosity levels of debug messaging"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4atypes.h (include k4a/k4a.h)</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub type k4a_log_level_t = u32;
#[doc = "< Depth sensor will be turned off with this setting."]
pub const k4a_depth_mode_t_K4A_DEPTH_MODE_OFF: k4a_depth_mode_t = 0;
#[doc = "< Depth captured at 320x288. Passive IR is also captured at 320x288."]
pub const k4a_depth_mode_t_K4A_DEPTH_MODE_NFOV_2X2BINNED: k4a_depth_mode_t = 1;
#[doc = "< Depth captured at 640x576. Passive IR is also captured at 640x576."]
pub const k4a_depth_mode_t_K4A_DEPTH_MODE_NFOV_UNBINNED: k4a_depth_mode_t = 2;
#[doc = "< Depth captured at 512x512. Passive IR is also captured at 512x512."]
pub const k4a_depth_mode_t_K4A_DEPTH_MODE_WFOV_2X2BINNED: k4a_depth_mode_t = 3;
#[doc = "< Depth captured at 1024x1024. Passive IR is also captured at 1024x1024."]
pub const k4a_depth_mode_t_K4A_DEPTH_MODE_WFOV_UNBINNED: k4a_depth_mode_t = 4;
#[doc = "< Passive IR only, captured at 1024x1024."]
pub const k4a_depth_mode_t_K4A_DEPTH_MODE_PASSIVE_IR: k4a_depth_mode_t = 5;
#[doc = " Depth sensor capture modes."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " See the hardware specification for additional details on the field of view, and supported frame rates"]
#[doc = " for each mode."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " NFOV and WFOV denote Narrow and Wide Field Of View configurations."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Binned modes reduce the captured camera resolution by combining adjacent sensor pixels into a bin."]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4atypes.h (include k4a/k4a.h)</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub type k4a_depth_mode_t = u32;
#[doc = "< Color camera will be turned off with this setting"]
pub const k4a_color_resolution_t_K4A_COLOR_RESOLUTION_OFF: k4a_color_resolution_t = 0;
#[doc = "< 1280 * 720 16:9"]
pub const k4a_color_resolution_t_K4A_COLOR_RESOLUTION_720P: k4a_color_resolution_t = 1;
#[doc = "< 1920 * 1080 16:9"]
pub const k4a_color_resolution_t_K4A_COLOR_RESOLUTION_1080P: k4a_color_resolution_t = 2;
#[doc = "< 2560 * 1440 16:9"]
pub const k4a_color_resolution_t_K4A_COLOR_RESOLUTION_1440P: k4a_color_resolution_t = 3;
#[doc = "< 2048 * 1536 4:3"]
pub const k4a_color_resolution_t_K4A_COLOR_RESOLUTION_1536P: k4a_color_resolution_t = 4;
#[doc = "< 3840 * 2160 16:9"]
pub const k4a_color_resolution_t_K4A_COLOR_RESOLUTION_2160P: k4a_color_resolution_t = 5;
#[doc = "< 4096 * 3072 4:3"]
pub const k4a_color_resolution_t_K4A_COLOR_RESOLUTION_3072P: k4a_color_resolution_t = 6;
#[doc = " Color sensor resolutions."]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4atypes.h (include k4a/k4a.h)</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub type k4a_color_resolution_t = u32;
#[doc = " Color image type MJPG."]
#[doc = ""]
#[doc = " \\details"]
#[doc = " The buffer for each image is encoded as a JPEG and can be decoded by a JPEG decoder."]
#[doc = ""]
#[doc = " \\details"]
#[doc = " Because the image is compressed, the stride parameter for the \\ref k4a_image_t is not applicable."]
#[doc = ""]
#[doc = " \\details"]
#[doc = " Each MJPG encoded image in a stream may be of differing size depending on the compression efficiency."]
pub const k4a_image_format_t_K4A_IMAGE_FORMAT_COLOR_MJPG: k4a_image_format_t = 0;
#[doc = " Color image type NV12."]
#[doc = ""]
#[doc = " \\details"]
#[doc = " NV12 images separate the luminance and chroma data such that all the luminance is at the"]
#[doc = " beginning of the buffer, and the chroma lines follow immediately after."]
#[doc = ""]
#[doc = " \\details"]
#[doc = " Stride indicates the length of each line in bytes and should be used to determine the start location of each line"]
#[doc = " of the image in memory. Chroma has half as many lines of height and half the width in pixels of the luminance."]
#[doc = " Each chroma line has the same width in bytes as a luminance line."]
pub const k4a_image_format_t_K4A_IMAGE_FORMAT_COLOR_NV12: k4a_image_format_t = 1;
#[doc = " Color image type YUY2."]
#[doc = ""]
#[doc = " \\details"]
#[doc = " YUY2 stores chroma and luminance data in interleaved pixels."]
#[doc = ""]
#[doc = " \\details"]
#[doc = " Stride indicates the length of each line in bytes and should be used to determine the start location of each"]
#[doc = " line of the image in memory."]
pub const k4a_image_format_t_K4A_IMAGE_FORMAT_COLOR_YUY2: k4a_image_format_t = 2;
#[doc = " Color image type BGRA32."]
#[doc = ""]
#[doc = " \\details"]
#[doc = " Each pixel of BGRA32 data is four bytes. The first three bytes represent Blue, Green,"]
#[doc = " and Red data. The fourth byte is the alpha channel and is unused in the Azure Kinect APIs."]
#[doc = ""]
#[doc = " \\details"]
#[doc = " Stride indicates the length of each line in bytes and should be used to determine the start location of each"]
#[doc = " line of the image in memory."]
#[doc = ""]
#[doc = " \\details"]
#[doc = " The Azure Kinect device does not natively capture in this format. Requesting images of this format"]
#[doc = " requires additional computation in the API."]
#[doc = ""]
pub const k4a_image_format_t_K4A_IMAGE_FORMAT_COLOR_BGRA32: k4a_image_format_t = 3;
#[doc = " Depth image type DEPTH16."]
#[doc = ""]
#[doc = " \\details"]
#[doc = " Each pixel of DEPTH16 data is two bytes of little endian unsigned depth data. The unit of the data is in"]
#[doc = " millimeters from the origin of the camera."]
#[doc = ""]
#[doc = " \\details"]
#[doc = " Stride indicates the length of each line in bytes and should be used to determine the start location of each"]
#[doc = " line of the image in memory."]
pub const k4a_image_format_t_K4A_IMAGE_FORMAT_DEPTH16: k4a_image_format_t = 4;
#[doc = " Image type IR16."]
#[doc = ""]
#[doc = " \\details"]
#[doc = " Each pixel of IR16 data is two bytes of little endian unsigned depth data. The value of the data represents"]
#[doc = " brightness."]
#[doc = ""]
#[doc = " \\details"]
#[doc = " This format represents infrared light and is captured by the depth camera."]
#[doc = ""]
#[doc = " \\details"]
#[doc = " Stride indicates the length of each line in bytes and should be used to determine the start location of each"]
#[doc = " line of the image in memory."]
pub const k4a_image_format_t_K4A_IMAGE_FORMAT_IR16: k4a_image_format_t = 5;
#[doc = " Single channel image type CUSTOM8."]
#[doc = ""]
#[doc = " \\details"]
#[doc = " Each pixel of CUSTOM8 is a single channel one byte of unsigned data."]
#[doc = ""]
#[doc = " \\details"]
#[doc = " Stride indicates the length of each line in bytes and should be used to determine the start location of each"]
#[doc = " line of the image in memory."]
pub const k4a_image_format_t_K4A_IMAGE_FORMAT_CUSTOM8: k4a_image_format_t = 6;
#[doc = " Single channel image type CUSTOM16."]
#[doc = ""]
#[doc = " \\details"]
#[doc = " Each pixel of CUSTOM16 is a single channel two bytes of little endian unsigned data."]
#[doc = ""]
#[doc = " \\details"]
#[doc = " Stride indicates the length of each line in bytes and should be used to determine the start location of each"]
#[doc = " line of the image in memory."]
pub const k4a_image_format_t_K4A_IMAGE_FORMAT_CUSTOM16: k4a_image_format_t = 7;
#[doc = " Custom image format."]
#[doc = ""]
#[doc = " \\details"]
#[doc = " Used in conjunction with user created images or images packing non-standard data."]
#[doc = ""]
#[doc = " \\details"]
#[doc = " See the originator of the custom formatted image for information on how to interpret the data."]
pub const k4a_image_format_t_K4A_IMAGE_FORMAT_CUSTOM: k4a_image_format_t = 8;
#[doc = " Image format type."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " The image format indicates how the \\ref k4a_image_t buffer data is interpreted."]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4atypes.h (include k4a/k4a.h)</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub type k4a_image_format_t = u32;
#[doc = "< Nearest neighbor interpolation"]
pub const k4a_transformation_interpolation_type_t_K4A_TRANSFORMATION_INTERPOLATION_TYPE_NEAREST:
k4a_transformation_interpolation_type_t = 0;
#[doc = "< Linear interpolation"]
pub const k4a_transformation_interpolation_type_t_K4A_TRANSFORMATION_INTERPOLATION_TYPE_LINEAR:
k4a_transformation_interpolation_type_t = 1;
#[doc = " Transformation interpolation type."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Interpolation type used with k4a_transformation_depth_image_to_color_camera_custom."]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4atypes.h (include k4a/k4a.h)</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub type k4a_transformation_interpolation_type_t = u32;
#[doc = "< 5 FPS"]
pub const k4a_fps_t_K4A_FRAMES_PER_SECOND_5: k4a_fps_t = 0;
#[doc = "< 15 FPS"]
pub const k4a_fps_t_K4A_FRAMES_PER_SECOND_15: k4a_fps_t = 1;
#[doc = "< 30 FPS"]
pub const k4a_fps_t_K4A_FRAMES_PER_SECOND_30: k4a_fps_t = 2;
#[doc = " Color and depth sensor frame rate."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " This enumeration is used to select the desired frame rate to operate the cameras. The actual"]
#[doc = " frame rate may vary slightly due to dropped data, synchronization variation between devices,"]
#[doc = " clock accuracy, or if the camera exposure priority mode causes reduced frame rate."]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4atypes.h (include k4a/k4a.h)</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub type k4a_fps_t = u32;
#[doc = " Exposure time setting."]
#[doc = ""]
#[doc = " \\details"]
#[doc = " May be set to ::K4A_COLOR_CONTROL_MODE_AUTO or ::K4A_COLOR_CONTROL_MODE_MANUAL."]
#[doc = ""]
#[doc = " \\details"]
#[doc = " The Azure Kinect supports a limited number of fixed expsore settings. When setting this, expect the exposure to"]
#[doc = " be rounded up to the nearest setting. Exceptions are 1) The last value in the table is the upper limit, so a"]
#[doc = " value larger than this will be overridden to the largest entry in the table. 2) The exposure time cannot be"]
#[doc = " larger than the equivelent FPS. So expect 100ms exposure time to be reduced to 30ms or 33.33ms when the camera is"]
#[doc = " started. The most recent copy of the table 'device_exposure_mapping' is in"]
#[doc = " https://github.com/microsoft/Azure-Kinect-Sensor-SDK/blob/develop/src/color/color_priv.h"]
#[doc = ""]
#[doc = " \\details"]
#[doc = " Exposure time is measured in microseconds."]
pub const k4a_color_control_command_t_K4A_COLOR_CONTROL_EXPOSURE_TIME_ABSOLUTE:
k4a_color_control_command_t = 0;
#[doc = " Exposure or Framerate priority setting."]
#[doc = ""]
#[doc = " \\details"]
#[doc = " May only be set to ::K4A_COLOR_CONTROL_MODE_MANUAL."]
#[doc = ""]
#[doc = " \\details"]
#[doc = " Value of 0 means framerate priority. Value of 1 means exposure priority."]
#[doc = ""]
#[doc = " \\details"]
#[doc = " Using exposure priority may impact the framerate of both the color and depth cameras."]
#[doc = ""]
#[doc = " \\details"]
#[doc = " Deprecated starting in 1.2.0. Please discontinue usage, firmware does not support this."]
pub const k4a_color_control_command_t_K4A_COLOR_CONTROL_AUTO_EXPOSURE_PRIORITY:
k4a_color_control_command_t = 1;
#[doc = " Brightness setting."]
#[doc = ""]
#[doc = " \\details"]
#[doc = " May only be set to ::K4A_COLOR_CONTROL_MODE_MANUAL."]
#[doc = ""]
#[doc = " \\details"]
#[doc = " The valid range is 0 to 255. The default value is 128."]
pub const k4a_color_control_command_t_K4A_COLOR_CONTROL_BRIGHTNESS: k4a_color_control_command_t = 2;
#[doc = " Contrast setting."]
#[doc = ""]
#[doc = " \\details"]
#[doc = " May only be set to ::K4A_COLOR_CONTROL_MODE_MANUAL."]
pub const k4a_color_control_command_t_K4A_COLOR_CONTROL_CONTRAST: k4a_color_control_command_t = 3;
#[doc = " Saturation setting."]
#[doc = ""]
#[doc = " \\details"]
#[doc = " May only be set to ::K4A_COLOR_CONTROL_MODE_MANUAL."]
pub const k4a_color_control_command_t_K4A_COLOR_CONTROL_SATURATION: k4a_color_control_command_t = 4;
#[doc = " Sharpness setting."]
#[doc = ""]
#[doc = " \\details"]
#[doc = " May only be set to ::K4A_COLOR_CONTROL_MODE_MANUAL."]
pub const k4a_color_control_command_t_K4A_COLOR_CONTROL_SHARPNESS: k4a_color_control_command_t = 5;
#[doc = " White balance setting."]
#[doc = ""]
#[doc = " \\details"]
#[doc = " May be set to ::K4A_COLOR_CONTROL_MODE_AUTO or ::K4A_COLOR_CONTROL_MODE_MANUAL."]
#[doc = ""]
#[doc = " \\details"]
#[doc = " The unit is degrees Kelvin. The setting must be set to a value evenly divisible by 10 degrees."]
pub const k4a_color_control_command_t_K4A_COLOR_CONTROL_WHITEBALANCE: k4a_color_control_command_t =
6;
#[doc = " Backlight compensation setting."]
#[doc = ""]
#[doc = " \\details"]
#[doc = " May only be set to ::K4A_COLOR_CONTROL_MODE_MANUAL."]
#[doc = ""]
#[doc = " \\details"]
#[doc = " Value of 0 means backlight compensation is disabled. Value of 1 means backlight compensation is enabled."]
pub const k4a_color_control_command_t_K4A_COLOR_CONTROL_BACKLIGHT_COMPENSATION:
k4a_color_control_command_t = 7;
#[doc = " Gain setting."]
#[doc = ""]
#[doc = " \\details"]
#[doc = " May only be set to ::K4A_COLOR_CONTROL_MODE_MANUAL."]
pub const k4a_color_control_command_t_K4A_COLOR_CONTROL_GAIN: k4a_color_control_command_t = 8;
#[doc = " Powerline frequency setting."]
#[doc = ""]
#[doc = " \\details"]
#[doc = " May only be set to ::K4A_COLOR_CONTROL_MODE_MANUAL."]
#[doc = ""]
#[doc = " \\details"]
#[doc = " Value of 1 sets the powerline compensation to 50 Hz. Value of 2 sets the powerline compensation to 60 Hz."]
pub const k4a_color_control_command_t_K4A_COLOR_CONTROL_POWERLINE_FREQUENCY:
k4a_color_control_command_t = 9;
#[doc = " Color sensor control commands"]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " The current settings can be read with k4a_device_get_color_control(). The settings can be set with"]
#[doc = " k4a_device_set_color_control()."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Control values set on a device are reset only when the device is power cycled. The device will retain the settings"]
#[doc = " even if the \\ref k4a_device_t is closed or the application is restarted."]
#[doc = ""]
#[doc = " \\see k4a_color_control_mode_t"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4atypes.h (include k4a/k4a.h)</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub type k4a_color_control_command_t = u32;
#[doc = "< set the associated k4a_color_control_command_t to auto"]
pub const k4a_color_control_mode_t_K4A_COLOR_CONTROL_MODE_AUTO: k4a_color_control_mode_t = 0;
#[doc = "< set the associated k4a_color_control_command_t to manual"]
pub const k4a_color_control_mode_t_K4A_COLOR_CONTROL_MODE_MANUAL: k4a_color_control_mode_t = 1;
#[doc = " Color sensor control mode"]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " The current settings can be read with k4a_device_get_color_control(). The settings can be set with"]
#[doc = " k4a_device_set_color_control()."]
#[doc = ""]
#[doc = " \\see k4a_color_control_command_t"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4atypes.h (include k4a/k4a.h)</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub type k4a_color_control_mode_t = u32;
#[doc = "< Neither 'Sync In' or 'Sync Out' connections are used."]
pub const k4a_wired_sync_mode_t_K4A_WIRED_SYNC_MODE_STANDALONE: k4a_wired_sync_mode_t = 0;
#[doc = "< The 'Sync Out' jack is enabled and synchronization data it driven out the"]
#[doc = "connected wire. While in master mode the color camera must be enabled as part of the"]
#[doc = "multi device sync signalling logic. Even if the color image is not needed, the color"]
#[doc = "camera must be running."]
pub const k4a_wired_sync_mode_t_K4A_WIRED_SYNC_MODE_MASTER: k4a_wired_sync_mode_t = 1;
#[doc = "< The 'Sync In' jack is used for synchronization and 'Sync Out' is driven for the"]
#[doc = "next device in the chain. 'Sync Out' is a mirror of 'Sync In' for this mode."]
pub const k4a_wired_sync_mode_t_K4A_WIRED_SYNC_MODE_SUBORDINATE: k4a_wired_sync_mode_t = 2;
#[doc = " Synchronization mode when connecting two or more devices together."]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4atypes.h (include k4a/k4a.h)</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub type k4a_wired_sync_mode_t = u32;
#[doc = "< Calibration type is unknown"]
pub const k4a_calibration_type_t_K4A_CALIBRATION_TYPE_UNKNOWN: k4a_calibration_type_t = -1;
#[doc = "< Depth sensor"]
pub const k4a_calibration_type_t_K4A_CALIBRATION_TYPE_DEPTH: k4a_calibration_type_t = 0;
#[doc = "< Color sensor"]
pub const k4a_calibration_type_t_K4A_CALIBRATION_TYPE_COLOR: k4a_calibration_type_t = 1;
#[doc = "< Gyroscope sensor"]
pub const k4a_calibration_type_t_K4A_CALIBRATION_TYPE_GYRO: k4a_calibration_type_t = 2;
#[doc = "< Accelerometer sensor"]
pub const k4a_calibration_type_t_K4A_CALIBRATION_TYPE_ACCEL: k4a_calibration_type_t = 3;
#[doc = "< Number of types excluding unknown type"]
pub const k4a_calibration_type_t_K4A_CALIBRATION_TYPE_NUM: k4a_calibration_type_t = 4;
#[doc = " Calibration types."]
#[doc = ""]
#[doc = " Specifies a type of calibration."]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4atypes.h (include k4a/k4a.h)</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub type k4a_calibration_type_t = i32;
#[doc = "< Calibration model is unknown"]
pub const k4a_calibration_model_type_t_K4A_CALIBRATION_LENS_DISTORTION_MODEL_UNKNOWN:
k4a_calibration_model_type_t = 0;
#[doc = "< Deprecated (not supported). Calibration model is Theta (arctan)."]
pub const k4a_calibration_model_type_t_K4A_CALIBRATION_LENS_DISTORTION_MODEL_THETA:
k4a_calibration_model_type_t = 1;
#[doc = "< Deprecated (not supported). Calibration model is"]
#[doc = "Polynomial 3K."]
pub const k4a_calibration_model_type_t_K4A_CALIBRATION_LENS_DISTORTION_MODEL_POLYNOMIAL_3K:
k4a_calibration_model_type_t = 2;
#[doc = "< Deprecated (only supported early internal devices)."]
#[doc = "Calibration model is Rational 6KT."]
pub const k4a_calibration_model_type_t_K4A_CALIBRATION_LENS_DISTORTION_MODEL_RATIONAL_6KT:
k4a_calibration_model_type_t = 3;
#[doc = "< Calibration model is Brown Conrady (compatible with"]
#[doc = " OpenCV)"]
pub const k4a_calibration_model_type_t_K4A_CALIBRATION_LENS_DISTORTION_MODEL_BROWN_CONRADY:
k4a_calibration_model_type_t = 4;
#[doc = " Calibration model type."]
#[doc = ""]
#[doc = " The model used interpret the calibration parameters."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Azure Kinect devices are calibrated with Brown Conrady."]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4atypes.h (include k4a/k4a.h)</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub type k4a_calibration_model_type_t = u32;
#[doc = "< Production firmware."]
pub const k4a_firmware_build_t_K4A_FIRMWARE_BUILD_RELEASE: k4a_firmware_build_t = 0;
#[doc = "< Pre-production firmware."]
pub const k4a_firmware_build_t_K4A_FIRMWARE_BUILD_DEBUG: k4a_firmware_build_t = 1;
#[doc = " Firmware build type."]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4atypes.h (include k4a/k4a.h)</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub type k4a_firmware_build_t = u32;
#[doc = "< Microsoft signed firmware."]
pub const k4a_firmware_signature_t_K4A_FIRMWARE_SIGNATURE_MSFT: k4a_firmware_signature_t = 0;
#[doc = "< Test signed firmware."]
pub const k4a_firmware_signature_t_K4A_FIRMWARE_SIGNATURE_TEST: k4a_firmware_signature_t = 1;
#[doc = "< Unsigned firmware."]
pub const k4a_firmware_signature_t_K4A_FIRMWARE_SIGNATURE_UNSIGNED: k4a_firmware_signature_t = 2;
#[doc = " Firmware signature type."]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4atypes.h (include k4a/k4a.h)</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub type k4a_firmware_signature_t = u32;
#[doc = " Callback function for debug messages being generated by the Azure Kinect SDK."]
#[doc = ""]
#[doc = " \\param context"]
#[doc = " The context of the callback function. This is the context that was supplied by the caller to \\p"]
#[doc = " k4a_set_debug_message_handler."]
#[doc = ""]
#[doc = " \\param level"]
#[doc = " The level of the message that has been created."]
#[doc = ""]
#[doc = " \\param file"]
#[doc = " The file name of the source file that generated the message."]
#[doc = ""]
#[doc = " \\param line"]
#[doc = " The line number of the source file that generated the message."]
#[doc = ""]
#[doc = " \\param message"]
#[doc = " The messaged generated by the Azure Kinect SDK."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " The callback is called asynchronously when the Azure Kinext SDK generates a message at a \\p level that is equal to"]
#[doc = " or more critical than the level specified when calling \\ref k4a_set_debug_message_handler() to register the callback."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " This callback can occur from any thread and blocks the calling thread. The k4a_logging_message_cb_t function user"]
#[doc = " must protect it's logging resources from concurrent calls. All care should be made to minimize the amount of time"]
#[doc = " locks are held."]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4atypes.h (include k4a/k4a.h)</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
#[doc = ""]
pub type k4a_logging_message_cb_t = ::std::option::Option<
unsafe extern "C" fn(
context: *mut ::std::os::raw::c_void,
level: k4a_log_level_t,
file: *const ::std::os::raw::c_char,
line: ::std::os::raw::c_int,
message: *const ::std::os::raw::c_char,
),
>;
#[doc = " Callback function for a memory object being destroyed."]
#[doc = ""]
#[doc = " \\param buffer"]
#[doc = " The buffer pointer that was supplied by the caller as \\p buffer_release_cb to \\ref k4a_image_create_from_buffer()."]
#[doc = ""]
#[doc = " \\param context"]
#[doc = " The context for the memory object that needs to be destroyed that was supplied by the caller as \\p"]
#[doc = " buffer_release_cb_context to \\ref k4a_image_create_from_buffer()."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " When all references for the memory object are released, this callback will be invoked as the final destroy for the"]
#[doc = " given memory."]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4atypes.h (include k4a/k4a.h)</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
#[doc = ""]
pub type k4a_memory_destroy_cb_t = ::std::option::Option<
unsafe extern "C" fn(buffer: *mut ::std::os::raw::c_void, context: *mut ::std::os::raw::c_void),
>;
#[doc = " Callback function for a memory allocation."]
#[doc = ""]
#[doc = " \\param size"]
#[doc = " Minimum size in bytes needed for the buffer."]
#[doc = ""]
#[doc = " \\param context"]
#[doc = " Output parameter for a context that will be provided in the subsequent call to the \\ref k4a_memory_destroy_cb_t"]
#[doc = " callback."]
#[doc = ""]
#[doc = " \\return"]
#[doc = " A pointer to the newly allocated memory."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " A callback of this type is provided when there is an application defined allocator."]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4atypes.h (include k4a/k4a.h)</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
#[doc = ""]
pub type k4a_memory_allocate_cb_t = ::std::option::Option<
unsafe extern "C" fn(
size: ::std::os::raw::c_int,
context: *mut *mut ::std::os::raw::c_void,
) -> *mut u8,
>;
#[doc = " Configuration parameters for an Azure Kinect device."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Used by k4a_device_start_cameras() to specify the configuration of the data capture."]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4atypes.h (include k4a/k4a.h)</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _k4a_device_configuration_t {
#[doc = " Image format to capture with the color camera."]
#[doc = ""]
#[doc = " The color camera does not natively produce BGRA32 images."]
#[doc = " Setting ::K4A_IMAGE_FORMAT_COLOR_BGRA32 for color_format will result in higher CPU utilization."]
pub color_format: k4a_image_format_t,
#[doc = " Image resolution to capture with the color camera."]
pub color_resolution: k4a_color_resolution_t,
#[doc = " Capture mode for the depth camera."]
pub depth_mode: k4a_depth_mode_t,
#[doc = " Desired frame rate for the color and depth camera."]
pub camera_fps: k4a_fps_t,
#[doc = " Only produce k4a_capture_t objects if they contain synchronized color and depth images."]
#[doc = ""]
#[doc = " \\details"]
#[doc = " This setting controls the behavior in which images are dropped when images are produced faster than they can be"]
#[doc = " read, or if there are errors in reading images from the device."]
#[doc = ""]
#[doc = " \\details"]
#[doc = " If set to true, \\ref k4a_capture_t objects will only be produced with both color and depth images."]
#[doc = " If set to false, \\ref k4a_capture_t objects may be produced only a single image when the corresponding image is"]
#[doc = " dropped."]
#[doc = ""]
#[doc = " \\details"]
#[doc = " Setting this to false ensures that the caller receives all of the images received from the camera, regardless of"]
#[doc = " whether the corresponding images expected in the capture are available."]
#[doc = ""]
#[doc = " \\details"]
#[doc = " If either the color or depth camera are disabled, this setting has no effect."]
pub synchronized_images_only: bool,
#[doc = " Desired delay between the capture of the color image and the capture of the depth image."]
#[doc = ""]
#[doc = " \\details"]
#[doc = " A negative value indicates that the depth image should be captured before the color image."]
#[doc = ""]
#[doc = " \\details"]
#[doc = " Any value between negative and positive one capture period is valid."]
pub depth_delay_off_color_usec: i32,
#[doc = " The external synchronization mode."]
pub wired_sync_mode: k4a_wired_sync_mode_t,
#[doc = " The external synchronization timing."]
#[doc = ""]
#[doc = " If this camera is a subordinate, this sets the capture delay between the color camera capture and the external"]
#[doc = " input pulse. A setting of zero indicates that the master and subordinate color images should be aligned."]
#[doc = ""]
#[doc = " This setting does not effect the 'Sync out' connection."]
#[doc = ""]
#[doc = " This value must be positive and range from zero to one capture period."]
#[doc = ""]
#[doc = " If this is not a subordinate, then this value is ignored."]
pub subordinate_delay_off_master_usec: u32,
#[doc = " Streaming indicator automatically turns on when the color or depth camera's are in use."]
#[doc = ""]
#[doc = " This setting disables that behavior and keeps the LED in an off state."]
pub disable_streaming_indicator: bool,
}
#[test]
fn bindgen_test_layout__k4a_device_configuration_t() {
assert_eq!(
::std::mem::size_of::<_k4a_device_configuration_t>(),
36usize,
concat!("Size of: ", stringify!(_k4a_device_configuration_t))
);
assert_eq!(
::std::mem::align_of::<_k4a_device_configuration_t>(),
4usize,
concat!("Alignment of ", stringify!(_k4a_device_configuration_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_k4a_device_configuration_t>())).color_format as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_k4a_device_configuration_t),
"::",
stringify!(color_format)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_k4a_device_configuration_t>())).color_resolution as *const _
as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(_k4a_device_configuration_t),
"::",
stringify!(color_resolution)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_k4a_device_configuration_t>())).depth_mode as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_k4a_device_configuration_t),
"::",
stringify!(depth_mode)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_k4a_device_configuration_t>())).camera_fps as *const _ as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(_k4a_device_configuration_t),
"::",
stringify!(camera_fps)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_k4a_device_configuration_t>())).synchronized_images_only
as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_k4a_device_configuration_t),
"::",
stringify!(synchronized_images_only)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_k4a_device_configuration_t>())).depth_delay_off_color_usec
as *const _ as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(_k4a_device_configuration_t),
"::",
stringify!(depth_delay_off_color_usec)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_k4a_device_configuration_t>())).wired_sync_mode as *const _
as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_k4a_device_configuration_t),
"::",
stringify!(wired_sync_mode)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_k4a_device_configuration_t>()))
.subordinate_delay_off_master_usec as *const _ as usize
},
28usize,
concat!(
"Offset of field: ",
stringify!(_k4a_device_configuration_t),
"::",
stringify!(subordinate_delay_off_master_usec)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_k4a_device_configuration_t>())).disable_streaming_indicator
as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_k4a_device_configuration_t),
"::",
stringify!(disable_streaming_indicator)
)
);
}
#[doc = " Configuration parameters for an Azure Kinect device."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Used by k4a_device_start_cameras() to specify the configuration of the data capture."]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4atypes.h (include k4a/k4a.h)</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub type k4a_device_configuration_t = _k4a_device_configuration_t;
#[doc = " Extrinsic calibration data."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Extrinsic calibration defines the physical relationship between two separate devices."]
#[doc = ""]
#[doc = " \\relates k4a_calibration_camera_t"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4atypes.h (include k4a/k4a.h)</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _k4a_calibration_extrinsics_t {
#[doc = "< 3x3 Rotation matrix stored in row major order"]
pub rotation: [f32; 9usize],
#[doc = "< Translation vector, x,y,z (in millimeters)"]
pub translation: [f32; 3usize],
}
#[test]
fn bindgen_test_layout__k4a_calibration_extrinsics_t() {
assert_eq!(
::std::mem::size_of::<_k4a_calibration_extrinsics_t>(),
48usize,
concat!("Size of: ", stringify!(_k4a_calibration_extrinsics_t))
);
assert_eq!(
::std::mem::align_of::<_k4a_calibration_extrinsics_t>(),
4usize,
concat!("Alignment of ", stringify!(_k4a_calibration_extrinsics_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_k4a_calibration_extrinsics_t>())).rotation as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_k4a_calibration_extrinsics_t),
"::",
stringify!(rotation)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_k4a_calibration_extrinsics_t>())).translation as *const _
as usize
},
36usize,
concat!(
"Offset of field: ",
stringify!(_k4a_calibration_extrinsics_t),
"::",
stringify!(translation)
)
);
}
#[doc = " Extrinsic calibration data."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Extrinsic calibration defines the physical relationship between two separate devices."]
#[doc = ""]
#[doc = " \\relates k4a_calibration_camera_t"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4atypes.h (include k4a/k4a.h)</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub type k4a_calibration_extrinsics_t = _k4a_calibration_extrinsics_t;
#[doc = " Camera intrinsic calibration data."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Intrinsic calibration represents the internal optical properties of the camera."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Azure Kinect devices are calibrated with Brown Conrady which is compatible"]
#[doc = " with OpenCV."]
#[doc = ""]
#[doc = " \\relates k4a_calibration_camera_t"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4atypes.h (include k4a/k4a.h)</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
#[repr(C)]
#[derive(Copy, Clone)]
pub union k4a_calibration_intrinsic_parameters_t {
#[doc = "< Individual parameter representation of intrinsic model"]
pub param: k4a_calibration_intrinsic_parameters_t__param,
#[doc = "< Array representation of intrinsic model parameters"]
pub v: [f32; 15usize],
_bindgen_union_align: [u32; 15usize],
}
#[doc = " individual parameter or array representation of intrinsic model."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct k4a_calibration_intrinsic_parameters_t__param {
#[doc = "< Principal point in image, x"]
pub cx: f32,
#[doc = "< Principal point in image, y"]
pub cy: f32,
#[doc = "< Focal length x"]
pub fx: f32,
#[doc = "< Focal length y"]
pub fy: f32,
#[doc = "< k1 radial distortion coefficient"]
pub k1: f32,
#[doc = "< k2 radial distortion coefficient"]
pub k2: f32,
#[doc = "< k3 radial distortion coefficient"]
pub k3: f32,
#[doc = "< k4 radial distortion coefficient"]
pub k4: f32,
#[doc = "< k5 radial distortion coefficient"]
pub k5: f32,
#[doc = "< k6 radial distortion coefficient"]
pub k6: f32,
#[doc = "< Center of distortion in Z=1 plane, x (only used for Rational6KT)"]
pub codx: f32,
#[doc = "< Center of distortion in Z=1 plane, y (only used for Rational6KT)"]
pub cody: f32,
#[doc = "< Tangential distortion coefficient 2"]
pub p2: f32,
#[doc = "< Tangential distortion coefficient 1"]
pub p1: f32,
#[doc = "< Metric radius"]
pub metric_radius: f32,
}
#[test]
fn bindgen_test_layout_k4a_calibration_intrinsic_parameters_t__param() {
assert_eq!(
::std::mem::size_of::<k4a_calibration_intrinsic_parameters_t__param>(),
60usize,
concat!(
"Size of: ",
stringify!(k4a_calibration_intrinsic_parameters_t__param)
)
);
assert_eq!(
::std::mem::align_of::<k4a_calibration_intrinsic_parameters_t__param>(),
4usize,
concat!(
"Alignment of ",
stringify!(k4a_calibration_intrinsic_parameters_t__param)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<k4a_calibration_intrinsic_parameters_t__param>())).cx as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(k4a_calibration_intrinsic_parameters_t__param),
"::",
stringify!(cx)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<k4a_calibration_intrinsic_parameters_t__param>())).cy as *const _
as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(k4a_calibration_intrinsic_parameters_t__param),
"::",
stringify!(cy)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<k4a_calibration_intrinsic_parameters_t__param>())).fx as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(k4a_calibration_intrinsic_parameters_t__param),
"::",
stringify!(fx)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<k4a_calibration_intrinsic_parameters_t__param>())).fy as *const _
as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(k4a_calibration_intrinsic_parameters_t__param),
"::",
stringify!(fy)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<k4a_calibration_intrinsic_parameters_t__param>())).k1 as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(k4a_calibration_intrinsic_parameters_t__param),
"::",
stringify!(k1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<k4a_calibration_intrinsic_parameters_t__param>())).k2 as *const _
as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(k4a_calibration_intrinsic_parameters_t__param),
"::",
stringify!(k2)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<k4a_calibration_intrinsic_parameters_t__param>())).k3 as *const _
as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(k4a_calibration_intrinsic_parameters_t__param),
"::",
stringify!(k3)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<k4a_calibration_intrinsic_parameters_t__param>())).k4 as *const _
as usize
},
28usize,
concat!(
"Offset of field: ",
stringify!(k4a_calibration_intrinsic_parameters_t__param),
"::",
stringify!(k4)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<k4a_calibration_intrinsic_parameters_t__param>())).k5 as *const _
as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(k4a_calibration_intrinsic_parameters_t__param),
"::",
stringify!(k5)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<k4a_calibration_intrinsic_parameters_t__param>())).k6 as *const _
as usize
},
36usize,
concat!(
"Offset of field: ",
stringify!(k4a_calibration_intrinsic_parameters_t__param),
"::",
stringify!(k6)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<k4a_calibration_intrinsic_parameters_t__param>())).codx
as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(k4a_calibration_intrinsic_parameters_t__param),
"::",
stringify!(codx)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<k4a_calibration_intrinsic_parameters_t__param>())).cody
as *const _ as usize
},
44usize,
concat!(
"Offset of field: ",
stringify!(k4a_calibration_intrinsic_parameters_t__param),
"::",
stringify!(cody)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<k4a_calibration_intrinsic_parameters_t__param>())).p2 as *const _
as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(k4a_calibration_intrinsic_parameters_t__param),
"::",
stringify!(p2)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<k4a_calibration_intrinsic_parameters_t__param>())).p1 as *const _
as usize
},
52usize,
concat!(
"Offset of field: ",
stringify!(k4a_calibration_intrinsic_parameters_t__param),
"::",
stringify!(p1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<k4a_calibration_intrinsic_parameters_t__param>())).metric_radius
as *const _ as usize
},
56usize,
concat!(
"Offset of field: ",
stringify!(k4a_calibration_intrinsic_parameters_t__param),
"::",
stringify!(metric_radius)
)
);
}
#[test]
fn bindgen_test_layout_k4a_calibration_intrinsic_parameters_t() {
assert_eq!(
::std::mem::size_of::<k4a_calibration_intrinsic_parameters_t>(),
60usize,
concat!(
"Size of: ",
stringify!(k4a_calibration_intrinsic_parameters_t)
)
);
assert_eq!(
::std::mem::align_of::<k4a_calibration_intrinsic_parameters_t>(),
4usize,
concat!(
"Alignment of ",
stringify!(k4a_calibration_intrinsic_parameters_t)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<k4a_calibration_intrinsic_parameters_t>())).param as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(k4a_calibration_intrinsic_parameters_t),
"::",
stringify!(param)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<k4a_calibration_intrinsic_parameters_t>())).v as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(k4a_calibration_intrinsic_parameters_t),
"::",
stringify!(v)
)
);
}
#[doc = " Camera sensor intrinsic calibration data."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Intrinsic calibration represents the internal optical properties of the camera."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Azure Kinect devices are calibrated with Brown Conrady which is compatible"]
#[doc = " with OpenCV."]
#[doc = ""]
#[doc = " \\relates k4a_calibration_camera_t"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4atypes.h (include k4a/k4a.h)</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _k4a_calibration_intrinsics_t {
#[doc = "< Type of calibration model used"]
pub type_: k4a_calibration_model_type_t,
#[doc = "< Number of valid entries in parameters"]
pub parameter_count: ::std::os::raw::c_uint,
#[doc = "< Calibration parameters"]
pub parameters: k4a_calibration_intrinsic_parameters_t,
}
#[test]
fn bindgen_test_layout__k4a_calibration_intrinsics_t() {
assert_eq!(
::std::mem::size_of::<_k4a_calibration_intrinsics_t>(),
68usize,
concat!("Size of: ", stringify!(_k4a_calibration_intrinsics_t))
);
assert_eq!(
::std::mem::align_of::<_k4a_calibration_intrinsics_t>(),
4usize,
concat!("Alignment of ", stringify!(_k4a_calibration_intrinsics_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_k4a_calibration_intrinsics_t>())).type_ as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_k4a_calibration_intrinsics_t),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_k4a_calibration_intrinsics_t>())).parameter_count as *const _
as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(_k4a_calibration_intrinsics_t),
"::",
stringify!(parameter_count)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_k4a_calibration_intrinsics_t>())).parameters as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_k4a_calibration_intrinsics_t),
"::",
stringify!(parameters)
)
);
}
#[doc = " Camera sensor intrinsic calibration data."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Intrinsic calibration represents the internal optical properties of the camera."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Azure Kinect devices are calibrated with Brown Conrady which is compatible"]
#[doc = " with OpenCV."]
#[doc = ""]
#[doc = " \\relates k4a_calibration_camera_t"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4atypes.h (include k4a/k4a.h)</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub type k4a_calibration_intrinsics_t = _k4a_calibration_intrinsics_t;
#[doc = " Camera calibration contains intrinsic and extrinsic calibration information for a camera."]
#[doc = ""]
#[doc = " \\relates k4a_calibration_camera_t"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4atypes.h (include k4a/k4a.h)</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _k4a_calibration_camera_t {
#[doc = "< Extrinsic calibration data."]
pub extrinsics: k4a_calibration_extrinsics_t,
#[doc = "< Intrinsic calibration data."]
pub intrinsics: k4a_calibration_intrinsics_t,
#[doc = "< Resolution width of the calibration sensor."]
pub resolution_width: ::std::os::raw::c_int,
#[doc = "< Resolution height of the calibration sensor."]
pub resolution_height: ::std::os::raw::c_int,
#[doc = "< Max FOV of the camera."]
pub metric_radius: f32,
}
#[test]
fn bindgen_test_layout__k4a_calibration_camera_t() {
assert_eq!(
::std::mem::size_of::<_k4a_calibration_camera_t>(),
128usize,
concat!("Size of: ", stringify!(_k4a_calibration_camera_t))
);
assert_eq!(
::std::mem::align_of::<_k4a_calibration_camera_t>(),
4usize,
concat!("Alignment of ", stringify!(_k4a_calibration_camera_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_k4a_calibration_camera_t>())).extrinsics as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_k4a_calibration_camera_t),
"::",
stringify!(extrinsics)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_k4a_calibration_camera_t>())).intrinsics as *const _ as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(_k4a_calibration_camera_t),
"::",
stringify!(intrinsics)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_k4a_calibration_camera_t>())).resolution_width as *const _
as usize
},
116usize,
concat!(
"Offset of field: ",
stringify!(_k4a_calibration_camera_t),
"::",
stringify!(resolution_width)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_k4a_calibration_camera_t>())).resolution_height as *const _
as usize
},
120usize,
concat!(
"Offset of field: ",
stringify!(_k4a_calibration_camera_t),
"::",
stringify!(resolution_height)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_k4a_calibration_camera_t>())).metric_radius as *const _ as usize
},
124usize,
concat!(
"Offset of field: ",
stringify!(_k4a_calibration_camera_t),
"::",
stringify!(metric_radius)
)
);
}
#[doc = " Camera calibration contains intrinsic and extrinsic calibration information for a camera."]
#[doc = ""]
#[doc = " \\relates k4a_calibration_camera_t"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4atypes.h (include k4a/k4a.h)</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub type k4a_calibration_camera_t = _k4a_calibration_camera_t;
#[doc = " Calibration type representing device calibration."]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4atypes.h (include k4a/k4a.h)</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _k4a_calibration_t {
#[doc = "< Depth camera calibration."]
pub depth_camera_calibration: k4a_calibration_camera_t,
#[doc = "< Color camera calibration."]
pub color_camera_calibration: k4a_calibration_camera_t,
#[doc = " Extrinsic transformation parameters."]
#[doc = ""]
#[doc = " The extrinsic parameters allow 3D coordinate conversions between depth camera, color camera, the IMU's gyroscope"]
#[doc = " and accelerometer. To transform from a source to a target 3D coordinate system, use the parameters stored"]
#[doc = " under extrinsics[source][target]."]
pub extrinsics: [[k4a_calibration_extrinsics_t; 4usize]; 4usize],
#[doc = "< Depth camera mode for which calibration was obtained."]
pub depth_mode: k4a_depth_mode_t,
#[doc = "< Color camera resolution for which calibration was obtained."]
pub color_resolution: k4a_color_resolution_t,
}
#[test]
fn bindgen_test_layout__k4a_calibration_t() {
assert_eq!(
::std::mem::size_of::<_k4a_calibration_t>(),
1032usize,
concat!("Size of: ", stringify!(_k4a_calibration_t))
);
assert_eq!(
::std::mem::align_of::<_k4a_calibration_t>(),
4usize,
concat!("Alignment of ", stringify!(_k4a_calibration_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_k4a_calibration_t>())).depth_camera_calibration as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_k4a_calibration_t),
"::",
stringify!(depth_camera_calibration)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_k4a_calibration_t>())).color_camera_calibration as *const _
as usize
},
128usize,
concat!(
"Offset of field: ",
stringify!(_k4a_calibration_t),
"::",
stringify!(color_camera_calibration)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_k4a_calibration_t>())).extrinsics as *const _ as usize },
256usize,
concat!(
"Offset of field: ",
stringify!(_k4a_calibration_t),
"::",
stringify!(extrinsics)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_k4a_calibration_t>())).depth_mode as *const _ as usize },
1024usize,
concat!(
"Offset of field: ",
stringify!(_k4a_calibration_t),
"::",
stringify!(depth_mode)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_k4a_calibration_t>())).color_resolution as *const _ as usize
},
1028usize,
concat!(
"Offset of field: ",
stringify!(_k4a_calibration_t),
"::",
stringify!(color_resolution)
)
);
}
#[doc = " Calibration type representing device calibration."]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4atypes.h (include k4a/k4a.h)</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub type k4a_calibration_t = _k4a_calibration_t;
#[doc = " Version information."]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4atypes.h (include k4a/k4a.h)</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _k4a_version_t {
#[doc = "< Major version; represents a breaking change."]
pub major: u32,
#[doc = "< Minor version; represents additional features, no regression from lower versions with same"]
#[doc = "major version."]
pub minor: u32,
#[doc = "< Reserved."]
pub iteration: u32,
}
#[test]
fn bindgen_test_layout__k4a_version_t() {
assert_eq!(
::std::mem::size_of::<_k4a_version_t>(),
12usize,
concat!("Size of: ", stringify!(_k4a_version_t))
);
assert_eq!(
::std::mem::align_of::<_k4a_version_t>(),
4usize,
concat!("Alignment of ", stringify!(_k4a_version_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_k4a_version_t>())).major as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_k4a_version_t),
"::",
stringify!(major)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_k4a_version_t>())).minor as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_k4a_version_t),
"::",
stringify!(minor)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_k4a_version_t>())).iteration as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_k4a_version_t),
"::",
stringify!(iteration)
)
);
}
#[doc = " Version information."]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4atypes.h (include k4a/k4a.h)</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub type k4a_version_t = _k4a_version_t;
#[doc = " Structure to define hardware version."]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4atypes.h (include k4a/k4a.h)</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _k4a_hardware_version_t {
#[doc = "< Color camera firmware version."]
pub rgb: k4a_version_t,
#[doc = "< Depth camera firmware version."]
pub depth: k4a_version_t,
#[doc = "< Audio device firmware version."]
pub audio: k4a_version_t,
#[doc = "< Depth sensor firmware version."]
pub depth_sensor: k4a_version_t,
#[doc = "< Build type reported by the firmware."]
pub firmware_build: k4a_firmware_build_t,
#[doc = "< Signature type of the firmware."]
pub firmware_signature: k4a_firmware_signature_t,
}
#[test]
fn bindgen_test_layout__k4a_hardware_version_t() {
assert_eq!(
::std::mem::size_of::<_k4a_hardware_version_t>(),
56usize,
concat!("Size of: ", stringify!(_k4a_hardware_version_t))
);
assert_eq!(
::std::mem::align_of::<_k4a_hardware_version_t>(),
4usize,
concat!("Alignment of ", stringify!(_k4a_hardware_version_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_k4a_hardware_version_t>())).rgb as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_k4a_hardware_version_t),
"::",
stringify!(rgb)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_k4a_hardware_version_t>())).depth as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(_k4a_hardware_version_t),
"::",
stringify!(depth)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_k4a_hardware_version_t>())).audio as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_k4a_hardware_version_t),
"::",
stringify!(audio)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_k4a_hardware_version_t>())).depth_sensor as *const _ as usize
},
36usize,
concat!(
"Offset of field: ",
stringify!(_k4a_hardware_version_t),
"::",
stringify!(depth_sensor)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_k4a_hardware_version_t>())).firmware_build as *const _ as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(_k4a_hardware_version_t),
"::",
stringify!(firmware_build)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_k4a_hardware_version_t>())).firmware_signature as *const _
as usize
},
52usize,
concat!(
"Offset of field: ",
stringify!(_k4a_hardware_version_t),
"::",
stringify!(firmware_signature)
)
);
}
#[doc = " Structure to define hardware version."]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4atypes.h (include k4a/k4a.h)</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub type k4a_hardware_version_t = _k4a_hardware_version_t;
#[doc = " Two dimensional floating point vector."]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4atypes.h (include k4a/k4a.h)</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
#[repr(C)]
#[derive(Copy, Clone)]
pub union k4a_float2_t {
#[doc = "< X, Y representation of a vector"]
pub xy: k4a_float2_t__xy,
#[doc = "< Array representation of a vector"]
pub v: [f32; 2usize],
_bindgen_union_align: [u32; 2usize],
}
#[doc = " XY or array representation of vector"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct k4a_float2_t__xy {
#[doc = "< X component of a vector"]
pub x: f32,
#[doc = "< Y component of a vector"]
pub y: f32,
}
#[test]
fn bindgen_test_layout_k4a_float2_t__xy() {
assert_eq!(
::std::mem::size_of::<k4a_float2_t__xy>(),
8usize,
concat!("Size of: ", stringify!(k4a_float2_t__xy))
);
assert_eq!(
::std::mem::align_of::<k4a_float2_t__xy>(),
4usize,
concat!("Alignment of ", stringify!(k4a_float2_t__xy))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<k4a_float2_t__xy>())).x as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(k4a_float2_t__xy),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<k4a_float2_t__xy>())).y as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(k4a_float2_t__xy),
"::",
stringify!(y)
)
);
}
#[test]
fn bindgen_test_layout_k4a_float2_t() {
assert_eq!(
::std::mem::size_of::<k4a_float2_t>(),
8usize,
concat!("Size of: ", stringify!(k4a_float2_t))
);
assert_eq!(
::std::mem::align_of::<k4a_float2_t>(),
4usize,
concat!("Alignment of ", stringify!(k4a_float2_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<k4a_float2_t>())).xy as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(k4a_float2_t),
"::",
stringify!(xy)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<k4a_float2_t>())).v as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(k4a_float2_t),
"::",
stringify!(v)
)
);
}
#[doc = " Three dimensional floating point vector."]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4atypes.h (include k4a/k4a.h)</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
#[repr(C)]
#[derive(Copy, Clone)]
pub union k4a_float3_t {
#[doc = "< X, Y, Z representation of a vector."]
pub xyz: k4a_float3_t__xyz,
#[doc = "< Array representation of a vector."]
pub v: [f32; 3usize],
_bindgen_union_align: [u32; 3usize],
}
#[doc = " XYZ or array representation of vector."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct k4a_float3_t__xyz {
#[doc = "< X component of a vector."]
pub x: f32,
#[doc = "< Y component of a vector."]
pub y: f32,
#[doc = "< Z component of a vector."]
pub z: f32,
}
#[test]
fn bindgen_test_layout_k4a_float3_t__xyz() {
assert_eq!(
::std::mem::size_of::<k4a_float3_t__xyz>(),
12usize,
concat!("Size of: ", stringify!(k4a_float3_t__xyz))
);
assert_eq!(
::std::mem::align_of::<k4a_float3_t__xyz>(),
4usize,
concat!("Alignment of ", stringify!(k4a_float3_t__xyz))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<k4a_float3_t__xyz>())).x as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(k4a_float3_t__xyz),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<k4a_float3_t__xyz>())).y as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(k4a_float3_t__xyz),
"::",
stringify!(y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<k4a_float3_t__xyz>())).z as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(k4a_float3_t__xyz),
"::",
stringify!(z)
)
);
}
#[test]
fn bindgen_test_layout_k4a_float3_t() {
assert_eq!(
::std::mem::size_of::<k4a_float3_t>(),
12usize,
concat!("Size of: ", stringify!(k4a_float3_t))
);
assert_eq!(
::std::mem::align_of::<k4a_float3_t>(),
4usize,
concat!("Alignment of ", stringify!(k4a_float3_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<k4a_float3_t>())).xyz as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(k4a_float3_t),
"::",
stringify!(xyz)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<k4a_float3_t>())).v as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(k4a_float3_t),
"::",
stringify!(v)
)
);
}
#[doc = " IMU sample."]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4atypes.h (include k4a/k4a.h)</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _k4a_imu_sample_t {
#[doc = "< Temperature reading of this sample (Celsius)."]
pub temperature: f32,
#[doc = "< Accelerometer sample in meters per second squared."]
pub acc_sample: k4a_float3_t,
#[doc = "< Timestamp of the accelerometer in microseconds."]
pub acc_timestamp_usec: u64,
#[doc = "< Gyro sample in radians per second."]
pub gyro_sample: k4a_float3_t,
#[doc = "< Timestamp of the gyroscope in microseconds"]
pub gyro_timestamp_usec: u64,
}
#[test]
fn bindgen_test_layout__k4a_imu_sample_t() {
assert_eq!(
::std::mem::size_of::<_k4a_imu_sample_t>(),
48usize,
concat!("Size of: ", stringify!(_k4a_imu_sample_t))
);
assert_eq!(
::std::mem::align_of::<_k4a_imu_sample_t>(),
8usize,
concat!("Alignment of ", stringify!(_k4a_imu_sample_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_k4a_imu_sample_t>())).temperature as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_k4a_imu_sample_t),
"::",
stringify!(temperature)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_k4a_imu_sample_t>())).acc_sample as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_k4a_imu_sample_t),
"::",
stringify!(acc_sample)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_k4a_imu_sample_t>())).acc_timestamp_usec as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_k4a_imu_sample_t),
"::",
stringify!(acc_timestamp_usec)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_k4a_imu_sample_t>())).gyro_sample as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_k4a_imu_sample_t),
"::",
stringify!(gyro_sample)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_k4a_imu_sample_t>())).gyro_timestamp_usec as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(_k4a_imu_sample_t),
"::",
stringify!(gyro_timestamp_usec)
)
);
}
#[doc = " IMU sample."]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4atypes.h (include k4a/k4a.h)</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub type k4a_imu_sample_t = _k4a_imu_sample_t;
extern "C" {
pub static K4A_DEVICE_CONFIG_INIT_DISABLE_ALL: k4a_device_configuration_t;
}
extern "C" {
#[doc = " Gets the number of connected devices"]
#[doc = ""]
#[doc = " \\returns Number of sensors connected to the PC."]
#[doc = ""]
#[doc = " \\relates k4a_device_t"]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " This API counts the number of Azure Kinect devices connected to the host PC."]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_device_get_installed_count() -> u32;
}
extern "C" {
#[doc = " Sets and clears the callback function to receive debug messages from the Azure Kinect device."]
#[doc = ""]
#[doc = " \\param message_cb"]
#[doc = " The callback function to receive messages from. Set to NULL to unregister the callback function."]
#[doc = ""]
#[doc = " \\param message_cb_context"]
#[doc = " The callback functions context."]
#[doc = ""]
#[doc = " \\param min_level"]
#[doc = " The least critical error the user wants to be notified about."]
#[doc = ""]
#[doc = " \\return ::K4A_RESULT_SUCCEEDED if the callback function was set or cleared successfully. ::K4A_RESULT_FAILED if an"]
#[doc = " error is encountered or the callback function has already been set."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Call this function to set or clear the callback function that is used to deliver debug messages to the caller. This"]
#[doc = " callback may be called concurrently, it is up to the implementation of the callback function to ensure the"]
#[doc = " parallelization is handled."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Clearing the callback function will block until all pending calls to the callback function have completed."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " To update \\p min_level, \\p k4a_set_debug_message_handler can be called with the same value \\p message_cb and by"]
#[doc = " specifying a new \\p min_level."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Logging provided via this API is independent of the logging controlled by the environmental variable controls \\p"]
#[doc = " K4A_ENABLE_LOG_TO_STDOUT, \\p K4A_ENABLE_LOG_TO_A_FILE, and \\p K4A_LOG_LEVEL. However there is a slight change in"]
#[doc = " default behavior when using this function. By default, when \\p k4a_set_debug_message_handler() has not been used to"]
#[doc = " register a message callback, the default for environmental variable controls is to send debug messages as if"]
#[doc = " K4A_ENABLE_LOG_TO_STDOUT=1 were set. If \\p k4a_set_debug_message_handler registers a callback function before"]
#[doc = " k4a_device_open() is called, then the default for environmental controls is as if K4A_ENABLE_LOG_TO_STDOUT=0 was"]
#[doc = " specified. Physically specifying the environmental control will override the default."]
#[doc = ""]
#[doc = " \\p min_level"]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_set_debug_message_handler(
message_cb: k4a_logging_message_cb_t,
message_cb_context: *mut ::std::os::raw::c_void,
min_level: k4a_log_level_t,
) -> k4a_result_t;
}
extern "C" {
#[doc = " Sets the callback functions for the SDK allocator"]
#[doc = ""]
#[doc = " \\param allocate"]
#[doc = " The callback function to allocate memory. When the SDK requires memory allocation this callback will be"]
#[doc = " called and the application can provide a buffer and a context."]
#[doc = ""]
#[doc = " \\param free"]
#[doc = " The callback function to free memory. The SDK will call this function when memory allocated by \\p allocate"]
#[doc = " is no longer needed."]
#[doc = ""]
#[doc = " \\return ::K4A_RESULT_SUCCEEDED if the callback function was set or cleared successfully. ::K4A_RESULT_FAILED if an"]
#[doc = " error is encountered or the callback function has already been set."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Call this function to hook memory allocation by the SDK. Calling with both \\p allocate and \\p free as NULL will"]
#[doc = " clear the hook and reset to the default allocator."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " If this function is called after memory has been allocated, the previous version of \\p free function may still be"]
#[doc = " called in the future. The SDK will always call the \\p free function that was set at the time that the memory"]
#[doc = " was allocated."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Not all memory allocation by the SDK is performed by this allocate function. Small allocations or allocations"]
#[doc = " from special pools may come from other sources."]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_set_allocator(
allocate: k4a_memory_allocate_cb_t,
free: k4a_memory_destroy_cb_t,
) -> k4a_result_t;
}
extern "C" {
#[doc = " Open an Azure Kinect device."]
#[doc = ""]
#[doc = " \\param index"]
#[doc = " The index of the device to open, starting with 0. Optionally pass in #K4A_DEVICE_DEFAULT."]
#[doc = ""]
#[doc = " \\param device_handle"]
#[doc = " Output parameter which on success will return a handle to the device."]
#[doc = ""]
#[doc = " \\relates k4a_device_t"]
#[doc = ""]
#[doc = " \\return ::K4A_RESULT_SUCCEEDED if the device was opened successfully."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " If successful, k4a_device_open() will return a device handle in the device_handle parameter."]
#[doc = " This handle grants exclusive access to the device and may be used in the other Azure Kinect API calls."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " When done with the device, close the handle with k4a_device_close()"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_device_open(index: u32, device_handle: *mut k4a_device_t) -> k4a_result_t;
}
extern "C" {
#[doc = " Closes an Azure Kinect device."]
#[doc = ""]
#[doc = " \\param device_handle"]
#[doc = " Handle obtained by k4a_device_open()."]
#[doc = ""]
#[doc = " \\relates k4a_device_t"]
#[doc = ""]
#[doc = " \\remarks Once closed, the handle is no longer valid."]
#[doc = ""]
#[doc = " \\remarks Before closing the handle to the device, ensure that all \\ref k4a_capture_t captures have been released with"]
#[doc = " k4a_capture_release()."]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_device_close(device_handle: k4a_device_t);
}
extern "C" {
#[doc = " Reads a sensor capture."]
#[doc = ""]
#[doc = " \\param device_handle"]
#[doc = " Handle obtained by k4a_device_open()."]
#[doc = ""]
#[doc = " \\param capture_handle"]
#[doc = " If successful this contains a handle to a capture object. Caller must call k4a_capture_release() when its done using"]
#[doc = " this capture."]
#[doc = ""]
#[doc = " \\param timeout_in_ms"]
#[doc = " Specifies the time in milliseconds the function should block waiting for the capture. If set to 0, the function will"]
#[doc = " return without blocking. Passing a value of #K4A_WAIT_INFINITE will block indefinitely until data is available, the"]
#[doc = " device is disconnected, or another error occurs."]
#[doc = ""]
#[doc = " \\returns"]
#[doc = " ::K4A_WAIT_RESULT_SUCCEEDED if a capture is returned. If a capture is not available before the timeout elapses, the"]
#[doc = " function will return ::K4A_WAIT_RESULT_TIMEOUT. All other failures will return ::K4A_WAIT_RESULT_FAILED."]
#[doc = ""]
#[doc = " \\relates k4a_device_t"]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Gets the next capture in the streamed sequence of captures from the camera. If a new capture is not currently"]
#[doc = " available, this function will block until the timeout is reached. The SDK will buffer at least two captures worth"]
#[doc = " of data before dropping the oldest capture. Callers needing to capture all data need to ensure they read the data as"]
#[doc = " fast as the data is being produced on average."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Upon successfully reading a capture this function will return success and populate \\p capture."]
#[doc = " If a capture is not available in the configured \\p timeout_in_ms, then the API will return ::K4A_WAIT_RESULT_TIMEOUT."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " If the call is successful and a capture is returned, callers must call k4a_capture_release() to return the allocated"]
#[doc = " memory."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " This function needs to be called while the device is in a running state;"]
#[doc = " after k4a_device_start_cameras() is called and before k4a_device_stop_cameras() is called."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " This function returns an error when an internal problem is encountered; such as loss of the USB connection, inability"]
#[doc = " to allocate enough memory, and other unexpected issues. Any error returned by this function signals the end of"]
#[doc = " streaming data, and caller should stop the stream using k4a_device_stop_cameras()."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " If this function is waiting for data (non-zero timeout) when k4a_device_stop_cameras() or k4a_device_close() is"]
#[doc = " called on another thread, this function will return an error."]
#[doc = ""]
#[doc = " \\returns ::K4A_WAIT_RESULT_SUCCEEDED if a capture is returned. If a capture is not available before the timeout"]
#[doc = " elapses, the function will return ::K4A_WAIT_RESULT_TIMEOUT. All other failures will return ::K4A_WAIT_RESULT_FAILED."]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
#[doc = ""]
pub fn k4a_device_get_capture(
device_handle: k4a_device_t,
capture_handle: *mut k4a_capture_t,
timeout_in_ms: i32,
) -> k4a_wait_result_t;
}
extern "C" {
#[doc = " Reads an IMU sample."]
#[doc = ""]
#[doc = " \\param device_handle"]
#[doc = " Handle obtained by k4a_device_open()."]
#[doc = ""]
#[doc = " \\param imu_sample"]
#[doc = " Pointer to the location for the API to write the IMU sample."]
#[doc = ""]
#[doc = " \\param timeout_in_ms"]
#[doc = " Specifies the time in milliseconds the function should block waiting for the sample. If set to 0, the function will"]
#[doc = " return without blocking. Passing a value of #K4A_WAIT_INFINITE will block indefinitely until data is available, the"]
#[doc = " device is disconnected, or another error occurs."]
#[doc = ""]
#[doc = " \\returns"]
#[doc = " ::K4A_WAIT_RESULT_SUCCEEDED if a sample is returned. If a sample is not available before the timeout elapses, the"]
#[doc = " function will return ::K4A_WAIT_RESULT_TIMEOUT. All other failures will return ::K4A_WAIT_RESULT_FAILED."]
#[doc = ""]
#[doc = " \\relates k4a_device_t"]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Gets the next sample in the streamed sequence of IMU samples from the device. If a new sample is not currently"]
#[doc = " available, this function will block until the timeout is reached. The API will buffer at least two camera capture"]
#[doc = " intervals worth of samples before dropping the oldest sample. Callers needing to capture all data need to ensure they"]
#[doc = " read the data as fast as the data is being produced on average."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Upon successfully reading a sample this function will return success and populate \\p imu_sample."]
#[doc = " If a sample is not available in the configured \\p timeout_in_ms, then the API will return ::K4A_WAIT_RESULT_TIMEOUT."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " This function needs to be called while the device is in a running state;"]
#[doc = " after k4a_device_start_imu() is called and before k4a_device_stop_imu() is called."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " This function returns an error when an internal problem is encountered; such as loss of the USB connection, inability"]
#[doc = " to allocate enough memory, and other unexpected issues. Any error returned by this function signals the end of"]
#[doc = " streaming data, and caller should stop the stream using k4a_device_stop_imu()."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " If this function is waiting for data (non-zero timeout) when k4a_device_stop_imu() or k4a_device_close() is"]
#[doc = " called on another thread, this function will return an error."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " The memory the IMU sample is written to is allocated and owned by the caller, so there is no need to call an Azure"]
#[doc = " Kinect API to free or release the sample."]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_device_get_imu_sample(
device_handle: k4a_device_t,
imu_sample: *mut k4a_imu_sample_t,
timeout_in_ms: i32,
) -> k4a_wait_result_t;
}
extern "C" {
#[doc = " Create an empty capture object."]
#[doc = ""]
#[doc = " \\param capture_handle"]
#[doc = " Pointer to a location to store the handle."]
#[doc = ""]
#[doc = " \\relates k4a_capture_t"]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Call this function to create a \\ref k4a_capture_t handle for a new capture. Release it with k4a_capture_release()."]
#[doc = ""]
#[doc = " The new capture is created with a reference count of 1."]
#[doc = ""]
#[doc = " \\returns"]
#[doc = " Returns #K4A_RESULT_SUCCEEDED on success. Errors are indicated with #K4A_RESULT_FAILED and error specific data can be"]
#[doc = " found in the log."]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_capture_create(capture_handle: *mut k4a_capture_t) -> k4a_result_t;
}
extern "C" {
#[doc = " Release a capture."]
#[doc = ""]
#[doc = " \\param capture_handle"]
#[doc = " Capture to release."]
#[doc = ""]
#[doc = " \\relates k4a_capture_t"]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Call this function when finished using the capture."]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_capture_release(capture_handle: k4a_capture_t);
}
extern "C" {
#[doc = " Add a reference to a capture."]
#[doc = ""]
#[doc = " \\param capture_handle"]
#[doc = " Capture to add a reference to."]
#[doc = ""]
#[doc = " \\relates k4a_capture_t"]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Call this function to add an additional reference to a capture. This reference must be removed with"]
#[doc = " k4a_capture_release()."]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_capture_reference(capture_handle: k4a_capture_t);
}
extern "C" {
#[doc = " Get the color image associated with the given capture."]
#[doc = ""]
#[doc = " \\param capture_handle"]
#[doc = " Capture handle containing the image."]
#[doc = ""]
#[doc = " \\relates k4a_capture_t"]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Call this function to access the color image part of this capture. Release the \\ref k4a_image_t with"]
#[doc = " k4a_image_release();"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_capture_get_color_image(capture_handle: k4a_capture_t) -> k4a_image_t;
}
extern "C" {
#[doc = " Get the depth image associated with the given capture."]
#[doc = ""]
#[doc = " \\param capture_handle"]
#[doc = " Capture handle containing the image."]
#[doc = ""]
#[doc = " \\relates k4a_capture_t"]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Call this function to access the depth image part of this capture. Release the \\ref k4a_image_t with"]
#[doc = " k4a_image_release();"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_capture_get_depth_image(capture_handle: k4a_capture_t) -> k4a_image_t;
}
extern "C" {
#[doc = " Get the IR image associated with the given capture."]
#[doc = ""]
#[doc = " \\param capture_handle"]
#[doc = " Capture handle containing the image."]
#[doc = ""]
#[doc = " \\relates k4a_capture_t"]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Call this function to access the IR image part of this capture. Release the \\ref k4a_image_t with"]
#[doc = " k4a_image_release();"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_capture_get_ir_image(capture_handle: k4a_capture_t) -> k4a_image_t;
}
extern "C" {
#[doc = " Set or add a color image to the associated capture."]
#[doc = ""]
#[doc = " \\param capture_handle"]
#[doc = " Capture handle to hold the image."]
#[doc = ""]
#[doc = " \\param image_handle"]
#[doc = " Image handle containing the image."]
#[doc = ""]
#[doc = " \\relates k4a_capture_t"]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " When a \\ref k4a_image_t is added to a \\ref k4a_capture_t, the \\ref k4a_capture_t will automatically add a reference"]
#[doc = " to the \\ref k4a_image_t."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " If there is already a color image contained in the capture, the existing image will be dereferenced and replaced with"]
#[doc = " the new image."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " To remove a color image to the capture without adding a new image, this function can be called with a NULL"]
#[doc = " image_handle."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Any \\ref k4a_image_t contained in this \\ref k4a_capture_t will automatically be dereferenced when all references to"]
#[doc = " the \\ref k4a_capture_t are released with k4a_capture_release()."]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_capture_set_color_image(capture_handle: k4a_capture_t, image_handle: k4a_image_t);
}
extern "C" {
#[doc = " Set or add a depth image to the associated capture."]
#[doc = ""]
#[doc = " \\param capture_handle"]
#[doc = " Capture handle to hold the image."]
#[doc = ""]
#[doc = " \\param image_handle"]
#[doc = " Image handle containing the image."]
#[doc = ""]
#[doc = " \\relates k4a_capture_t"]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " When a \\ref k4a_image_t is added to a \\ref k4a_capture_t, the \\ref k4a_capture_t will automatically add a reference"]
#[doc = " to the \\ref k4a_image_t."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " If there is already an image depth image contained in the capture, the existing image will be dereferenced and"]
#[doc = " replaced with the new image."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " To remove a depth image to the capture without adding a new image, this function can be called with a NULL"]
#[doc = " image_handle."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Any \\ref k4a_image_t contained in this \\ref k4a_capture_t will automatically be dereferenced when all references to"]
#[doc = " the \\ref k4a_capture_t are released with k4a_capture_release()."]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_capture_set_depth_image(capture_handle: k4a_capture_t, image_handle: k4a_image_t);
}
extern "C" {
#[doc = " Set or add an IR image to the associated capture."]
#[doc = ""]
#[doc = " \\param capture_handle"]
#[doc = " Capture handle to hold the image."]
#[doc = ""]
#[doc = " \\param image_handle"]
#[doc = " Image handle containing the image."]
#[doc = ""]
#[doc = " \\relates k4a_capture_t"]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " When a \\ref k4a_image_t is added to a \\ref k4a_capture_t, the \\ref k4a_capture_t will automatically add a reference"]
#[doc = " to the \\ref k4a_image_t."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " If there is already an IR image contained in the capture, the existing image will be dereferenced and replaced with"]
#[doc = " the new image."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " To remove a IR image to the capture without adding a new image, this function can be called with a NULL image_handle."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Any \\ref k4a_image_t contained in this \\ref k4a_capture_t will automatically be dereferenced when all references to"]
#[doc = " the \\ref k4a_capture_t are released with k4a_capture_release()."]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_capture_set_ir_image(capture_handle: k4a_capture_t, image_handle: k4a_image_t);
}
extern "C" {
#[doc = " Set the temperature associated with the capture."]
#[doc = ""]
#[doc = " \\param capture_handle"]
#[doc = " Capture handle to set the temperature on."]
#[doc = ""]
#[doc = " \\param temperature_c"]
#[doc = " Temperature in Celsius to store."]
#[doc = ""]
#[doc = " \\relates k4a_capture_t"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_capture_set_temperature_c(capture_handle: k4a_capture_t, temperature_c: f32);
}
extern "C" {
#[doc = " Get the temperature associated with the capture."]
#[doc = ""]
#[doc = " \\param capture_handle"]
#[doc = " Capture handle to retrieve the temperature from."]
#[doc = ""]
#[doc = " \\return"]
#[doc = " This function returns the temperature of the device at the time of the capture in Celsius. If"]
#[doc = " the temperature is unavailable, the function will return NAN."]
#[doc = ""]
#[doc = " \\relates k4a_capture_t"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_capture_get_temperature_c(capture_handle: k4a_capture_t) -> f32;
}
extern "C" {
#[doc = " Create an image."]
#[doc = ""]
#[doc = " \\param format"]
#[doc = " The format of the image that will be stored in this image container."]
#[doc = ""]
#[doc = " \\param width_pixels"]
#[doc = " Width in pixels."]
#[doc = ""]
#[doc = " \\param height_pixels"]
#[doc = " Height in pixels."]
#[doc = ""]
#[doc = " \\param stride_bytes"]
#[doc = " The number of bytes per horizontal line of the image."]
#[doc = ""]
#[doc = " \\param image_handle"]
#[doc = " Pointer to store image handle in."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " This function is used to create images of formats that have consistent stride. The function is not suitable for"]
#[doc = " compressed formats that may not be represented by the same number of bytes per line."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " For most image formats, the function will allocate an image buffer of size \\p height_pixels * \\p stride_bytes."]
#[doc = " Buffers #K4A_IMAGE_FORMAT_COLOR_NV12 format will allocate an additional \\p height_pixels / 2 set of lines (each of \\p"]
#[doc = " stride_bytes). This function cannot be used to allocate #K4A_IMAGE_FORMAT_COLOR_MJPG buffers."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " To create an image object without the API allocating memory, or to represent an image that has a non-deterministic"]
#[doc = " stride, use k4a_image_create_from_buffer()."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " The \\ref k4a_image_t is created with a reference count of 1."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " When finished using the created image, release it with k4a_image_release."]
#[doc = ""]
#[doc = " \\returns"]
#[doc = " Returns #K4A_RESULT_SUCCEEDED on success. Errors are indicated with #K4A_RESULT_FAILED."]
#[doc = ""]
#[doc = " \\relates k4a_image_t"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_image_create(
format: k4a_image_format_t,
width_pixels: ::std::os::raw::c_int,
height_pixels: ::std::os::raw::c_int,
stride_bytes: ::std::os::raw::c_int,
image_handle: *mut k4a_image_t,
) -> k4a_result_t;
}
extern "C" {
#[doc = " Create an image from a pre-allocated buffer."]
#[doc = ""]
#[doc = " \\param format"]
#[doc = " The format of the image that will be stored in this image container."]
#[doc = ""]
#[doc = " \\param width_pixels"]
#[doc = " Width in pixels."]
#[doc = ""]
#[doc = " \\param height_pixels"]
#[doc = " Height in pixels."]
#[doc = ""]
#[doc = " \\param stride_bytes"]
#[doc = " The number of bytes per horizontal line of the image."]
#[doc = ""]
#[doc = " \\param buffer"]
#[doc = " Pointer to a pre-allocated image buffer."]
#[doc = ""]
#[doc = " \\param buffer_size"]
#[doc = " Size in bytes of the pre-allocated image buffer."]
#[doc = ""]
#[doc = " \\param buffer_release_cb"]
#[doc = " Callback to the buffer free function, called when all references to the buffer have been released. This parameter is"]
#[doc = " optional."]
#[doc = ""]
#[doc = " \\param buffer_release_cb_context"]
#[doc = " Context for the buffer free function. This value will be called as a parameter to \\p buffer_release_cb when"]
#[doc = " the callback is invoked."]
#[doc = ""]
#[doc = " \\param image_handle"]
#[doc = " Pointer to store image handle in."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " This function creates a \\ref k4a_image_t from a pre-allocated buffer. When all references to this object reach zero"]
#[doc = " the provided \\p buffer_release_cb callback function is called so that the memory can be released. If this function"]
#[doc = " fails, the API will not use the memory provided in \\p buffer, and the API will not call \\p buffer_release_cb."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " The \\ref k4a_image_t is created with a reference count of 1."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Release the reference on this function with k4a_image_release()."]
#[doc = ""]
#[doc = " \\returns"]
#[doc = " Returns #K4A_RESULT_SUCCEEDED on success. Errors are indicated with #K4A_RESULT_FAILED and error specific data can be"]
#[doc = " found in the log."]
#[doc = ""]
#[doc = " \\relates k4a_image_t"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_image_create_from_buffer(
format: k4a_image_format_t,
width_pixels: ::std::os::raw::c_int,
height_pixels: ::std::os::raw::c_int,
stride_bytes: ::std::os::raw::c_int,
buffer: *mut u8,
buffer_size: usize,
buffer_release_cb: k4a_memory_destroy_cb_t,
buffer_release_cb_context: *mut ::std::os::raw::c_void,
image_handle: *mut k4a_image_t,
) -> k4a_result_t;
}
extern "C" {
#[doc = " Get the image buffer."]
#[doc = ""]
#[doc = " \\param image_handle"]
#[doc = " Handle of the image for which the get operation is performed on."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Use this buffer to access the raw image data."]
#[doc = ""]
#[doc = " \\returns"]
#[doc = " The function will return NULL if there is an error, and will normally return a pointer to the image buffer."]
#[doc = " Since all \\ref k4a_image_t instances are created with an image buffer, this function should only return NULL if the"]
#[doc = " \\p image_handle is invalid."]
#[doc = ""]
#[doc = " \\relates k4a_image_t"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_image_get_buffer(image_handle: k4a_image_t) -> *mut u8;
}
extern "C" {
#[doc = " Get the image buffer size."]
#[doc = ""]
#[doc = " \\param image_handle"]
#[doc = " Handle of the image for which the get operation is performed on."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Use this function to know what the size of the image buffer is returned by k4a_image_get_buffer()."]
#[doc = ""]
#[doc = " \\returns"]
#[doc = " The function will return 0 if there is an error, and will normally return the image size."]
#[doc = " Since all \\ref k4a_image_t instances are created with an image buffer, this function should only return 0 if the"]
#[doc = " \\p image_handle is invalid."]
#[doc = ""]
#[doc = " \\relates k4a_image_t"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_image_get_size(image_handle: k4a_image_t) -> usize;
}
extern "C" {
#[doc = " Get the format of the image."]
#[doc = ""]
#[doc = " \\param image_handle"]
#[doc = " Handle of the image for which the get operation is performed on."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Use this function to determine the format of the image buffer."]
#[doc = ""]
#[doc = " \\returns"]
#[doc = " This function is not expected to fail, all \\ref k4a_image_t's are created with a known format. If the"]
#[doc = " \\p image_handle is invalid, the function will return ::K4A_IMAGE_FORMAT_CUSTOM."]
#[doc = ""]
#[doc = " \\relates k4a_image_t"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_image_get_format(image_handle: k4a_image_t) -> k4a_image_format_t;
}
extern "C" {
#[doc = " Get the image width in pixels."]
#[doc = ""]
#[doc = " \\param image_handle"]
#[doc = " Handle of the image for which the get operation is performed on."]
#[doc = ""]
#[doc = " \\returns"]
#[doc = " This function is not expected to fail, all \\ref k4a_image_t's are created with a known width. If the \\p"]
#[doc = " image_handle is invalid, the function will return 0."]
#[doc = ""]
#[doc = " \\relates k4a_image_t"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_image_get_width_pixels(image_handle: k4a_image_t) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " Get the image height in pixels."]
#[doc = ""]
#[doc = " \\param image_handle"]
#[doc = " Handle of the image for which the get operation is performed on."]
#[doc = ""]
#[doc = " \\returns"]
#[doc = " This function is not expected to fail, all \\ref k4a_image_t's are created with a known height. If the \\p"]
#[doc = " image_handle is invalid, the function will return 0."]
#[doc = ""]
#[doc = " \\relates k4a_image_t"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_image_get_height_pixels(image_handle: k4a_image_t) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " Get the image stride in bytes."]
#[doc = ""]
#[doc = " \\param image_handle"]
#[doc = " Handle of the image for which the get operation is performed on."]
#[doc = ""]
#[doc = " \\returns"]
#[doc = " This function is not expected to fail, all \\ref k4a_image_t's are created with a known stride. If the"]
#[doc = " \\p image_handle is invalid, or the image's format does not have a stride, the function will return 0."]
#[doc = ""]
#[doc = " \\relates k4a_image_t"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_image_get_stride_bytes(image_handle: k4a_image_t) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " Get the image's device timestamp in microseconds."]
#[doc = ""]
#[doc = " \\param image_handle"]
#[doc = " Handle of the image for which the get operation is performed on."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Returns the device timestamp of the image. Timestamps are recorded by the device and represent the mid-point of"]
#[doc = " exposure. They may be used for relative comparison, but their absolute value has no defined meaning."]
#[doc = ""]
#[doc = " \\returns"]
#[doc = " If the \\p image_handle is invalid or if no timestamp was set for the image,"]
#[doc = " this function will return 0. It is also possible for 0 to be a valid timestamp originating from the beginning"]
#[doc = " of a recording or the start of streaming."]
#[doc = ""]
#[doc = " \\deprecated"]
#[doc = " Deprecated starting in 1.2.0. Please use k4a_image_get_device_timestamp_usec()."]
#[doc = ""]
#[doc = " \\relates k4a_image_t"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_image_get_timestamp_usec(image_handle: k4a_image_t) -> u64;
}
extern "C" {
#[doc = " Get the image's device timestamp in microseconds."]
#[doc = ""]
#[doc = " \\param image_handle"]
#[doc = " Handle of the image for which the get operation is performed on."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Returns the device timestamp of the image, as captured by the hardware. Timestamps are recorded by the device and"]
#[doc = " represent the mid-point of exposure. They may be used for relative comparison, but their absolute value has no"]
#[doc = " defined meaning."]
#[doc = ""]
#[doc = " \\returns"]
#[doc = " If the \\p image_handle is invalid or if no timestamp was set for the image, this function will return 0. It is also"]
#[doc = " possible for 0 to be a valid timestamp originating from the beginning of a recording or the start of streaming."]
#[doc = ""]
#[doc = " \\relates k4a_image_t"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_image_get_device_timestamp_usec(image_handle: k4a_image_t) -> u64;
}
extern "C" {
#[doc = " Get the image's system timestamp in nanoseconds."]
#[doc = ""]
#[doc = " \\param image_handle"]
#[doc = " Handle of the image for which the get operation is performed on."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Returns the system timestamp of the image. Timestamps are recorded by the host. They may be used for relative"]
#[doc = " comparision, as they are relative to the corresponding system clock. The absolute value is a monotonic count from"]
#[doc = " an arbitrary point in the past."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " The system timestamp is captured at the moment host PC finishes receiving the image."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " On Linux the system timestamp is read from clock_gettime(CLOCK_MONOTONIC), which measures realtime and is not"]
#[doc = " impacted by adjustments to the system clock. It starts from an arbitrary point in the past. On Windows the system"]
#[doc = " timestamp is read from QueryPerformanceCounter(), it also measures realtime and is not impacted by adjustments to the"]
#[doc = " system clock. It also starts from an arbitrary point in the past."]
#[doc = ""]
#[doc = " \\returns"]
#[doc = " If the \\p image_handle is invalid or if no timestamp was set for the image, this function will return 0. It is also"]
#[doc = " possible for 0 to be a valid timestamp originating from the beginning of a recording or the start of streaming."]
#[doc = ""]
#[doc = " \\relates k4a_image_t"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_image_get_system_timestamp_nsec(image_handle: k4a_image_t) -> u64;
}
extern "C" {
#[doc = " Get the image exposure in microseconds."]
#[doc = ""]
#[doc = " \\param image_handle"]
#[doc = " Handle of the image for which the get operation is performed on."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Returns an exposure time in microseconds. This is only supported on color image formats."]
#[doc = ""]
#[doc = " \\returns"]
#[doc = " If the \\p image_handle is invalid, or no exposure was set on the image, the function will return 0. Otherwise,"]
#[doc = " it will return the image exposure time in microseconds."]
#[doc = ""]
#[doc = " \\relates k4a_image_t"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_image_get_exposure_usec(image_handle: k4a_image_t) -> u64;
}
extern "C" {
#[doc = " Get the image white balance."]
#[doc = ""]
#[doc = " \\param image_handle"]
#[doc = " Handle of the image for which the get operation is performed on."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Returns the image's white balance. This function is only valid for color captures, and not for depth or IR captures."]
#[doc = ""]
#[doc = " \\returns"]
#[doc = " Returns the image white balance in Kelvin. If \\p image_handle is invalid, or the white balance was not set or"]
#[doc = " not applicable to the image, the function will return 0."]
#[doc = ""]
#[doc = " \\relates k4a_image_t"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_image_get_white_balance(image_handle: k4a_image_t) -> u32;
}
extern "C" {
#[doc = " Get the image ISO speed."]
#[doc = ""]
#[doc = " \\param image_handle"]
#[doc = " Handle of the image for which the get operation is performed on."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " This function is only valid for color captures, and not for depth or IR captures."]
#[doc = ""]
#[doc = " \\returns"]
#[doc = " Returns the ISO speed of the image. 0 indicates the ISO speed was not available or an error occurred."]
#[doc = ""]
#[doc = " \\relates k4a_image_t"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_image_get_iso_speed(image_handle: k4a_image_t) -> u32;
}
extern "C" {
#[doc = " Set the device time stamp, in microseconds, of the image."]
#[doc = ""]
#[doc = " \\param image_handle"]
#[doc = " Handle of the image to set the timestamp on."]
#[doc = ""]
#[doc = " \\param timestamp_usec"]
#[doc = " Device timestamp of the image in microseconds."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Use this function in conjunction with k4a_image_create() or k4a_image_create_from_buffer() to construct a"]
#[doc = " \\ref k4a_image_t."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " The device timestamp represents the mid-point of exposure of the image, as captured by the hardware."]
#[doc = ""]
#[doc = " \\relates k4a_image_t"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_image_set_device_timestamp_usec(image_handle: k4a_image_t, timestamp_usec: u64);
}
extern "C" {
#[doc = " Set the device time stamp, in microseconds, of the image."]
#[doc = ""]
#[doc = " \\param image_handle"]
#[doc = " Handle of the image to set the timestamp on."]
#[doc = ""]
#[doc = " \\param timestamp_usec"]
#[doc = " Device timestamp of the image in microseconds."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Use this function in conjunction with k4a_image_create() or k4a_image_create_from_buffer() to construct a"]
#[doc = " \\ref k4a_image_t."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " The device timestamp represents the mid-point of exposure of the image, as captured by the hardware."]
#[doc = ""]
#[doc = " \\relates k4a_image_t"]
#[doc = ""]
#[doc = " \\deprecated"]
#[doc = " Deprecated starting in 1.2.0. Please use k4a_image_set_device_timestamp_usec()."]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_image_set_timestamp_usec(image_handle: k4a_image_t, timestamp_usec: u64);
}
extern "C" {
#[doc = " Set the system time stamp, in nanoseconds, of the image."]
#[doc = ""]
#[doc = " \\param image_handle"]
#[doc = " Handle of the image to set the timestamp on."]
#[doc = ""]
#[doc = " \\param timestamp_nsec"]
#[doc = " Timestamp of the image in nanoseconds."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Use this function in conjunction with k4a_image_create() or k4a_image_create_from_buffer() to construct a"]
#[doc = " \\ref k4a_image_t."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " The system timestamp is a high performance and increasing clock (from boot). The timestamp represents the time"]
#[doc = " immediately after the image buffer was read by the host PC."]
#[doc = ""]
#[doc = " \\relates k4a_image_t"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_image_set_system_timestamp_nsec(image_handle: k4a_image_t, timestamp_nsec: u64);
}
extern "C" {
#[doc = " Set the exposure time, in microseconds, of the image."]
#[doc = ""]
#[doc = " \\param image_handle"]
#[doc = " Handle of the image to set the exposure time on."]
#[doc = ""]
#[doc = " \\param exposure_usec"]
#[doc = " Exposure time of the image in microseconds."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Use this function in conjunction with k4a_image_create() or k4a_image_create_from_buffer() to construct a"]
#[doc = " \\ref k4a_image_t. An exposure time of 0 is considered invalid. Only color image formats are expected to have a valid"]
#[doc = " exposure time."]
#[doc = ""]
#[doc = " \\relates k4a_image_t"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_image_set_exposure_usec(image_handle: k4a_image_t, exposure_usec: u64);
}
extern "C" {
#[doc = " Set the exposure time, in microseconds, of the image."]
#[doc = ""]
#[doc = " \\param image_handle"]
#[doc = " Handle of the image to set the exposure time on."]
#[doc = ""]
#[doc = " \\param exposure_usec"]
#[doc = " Exposure time of the image in microseconds."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Use this function in conjunction with k4a_image_create() or k4a_image_create_from_buffer() to construct a"]
#[doc = " \\ref k4a_image_t. An exposure time of 0 is considered invalid. Only color image formats are expected to have a valid"]
#[doc = " exposure time."]
#[doc = ""]
#[doc = " \\deprecated"]
#[doc = " Deprecated starting in 1.2.0. Please use k4a_image_set_exposure_usec()."]
#[doc = ""]
#[doc = " \\relates k4a_image_t"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_image_set_exposure_time_usec(image_handle: k4a_image_t, exposure_usec: u64);
}
extern "C" {
#[doc = " Set the white balance of the image."]
#[doc = ""]
#[doc = " \\param image_handle"]
#[doc = " Handle of the image to set the white balance on."]
#[doc = ""]
#[doc = " \\param white_balance"]
#[doc = " White balance of the image in degrees Kelvin."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Use this function in conjunction with k4a_image_create() or k4a_image_create_from_buffer() to construct a"]
#[doc = " \\ref k4a_image_t. A white balance of 0 is considered invalid. White balance is only meaningful for color images,"]
#[doc = " and not expected on depth or IR images."]
#[doc = ""]
#[doc = " \\relates k4a_image_t"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_image_set_white_balance(image_handle: k4a_image_t, white_balance: u32);
}
extern "C" {
#[doc = " Set the ISO speed of the image."]
#[doc = ""]
#[doc = " \\param image_handle"]
#[doc = " Handle of the image to set the ISO speed on."]
#[doc = ""]
#[doc = " \\param iso_speed"]
#[doc = " ISO speed of the image."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Use this function in conjunction with k4a_image_create() or k4a_image_create_from_buffer() to construct a"]
#[doc = " \\ref k4a_image_t. An ISO speed of 0 is considered invalid. Only color images are expected to have a valid ISO speed."]
#[doc = ""]
#[doc = " \\relates k4a_image_t"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_image_set_iso_speed(image_handle: k4a_image_t, iso_speed: u32);
}
extern "C" {
#[doc = " Add a reference to the k4a_image_t."]
#[doc = ""]
#[doc = " \\param image_handle"]
#[doc = " Handle of the image for which the get operation is performed on."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " References manage the lifetime of the object. When the references reach zero the object is destroyed. A caller must"]
#[doc = " not access the object after its reference is released."]
#[doc = ""]
#[doc = " \\relates k4a_image_t"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_image_reference(image_handle: k4a_image_t);
}
extern "C" {
#[doc = " Remove a reference from the k4a_image_t."]
#[doc = ""]
#[doc = " \\param image_handle"]
#[doc = " Handle of the image for which the get operation is performed on."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " References manage the lifetime of the object. When the references reach zero the object is destroyed. A caller must"]
#[doc = " not access the object after its reference is released."]
#[doc = ""]
#[doc = " \\relates k4a_image_t"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_image_release(image_handle: k4a_image_t);
}
extern "C" {
#[doc = " Starts color and depth camera capture."]
#[doc = ""]
#[doc = " \\param device_handle"]
#[doc = " Handle obtained by k4a_device_open()."]
#[doc = ""]
#[doc = " \\param config"]
#[doc = " The configuration we want to run the device in. This can be initialized with ::K4A_DEVICE_CONFIG_INIT_DISABLE_ALL."]
#[doc = ""]
#[doc = " \\returns"]
#[doc = " ::K4A_RESULT_SUCCEEDED is returned on success."]
#[doc = ""]
#[doc = " \\relates k4a_device_t"]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Individual sensors configured to run will now start to stream captured data."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " It is not valid to call k4a_device_start_cameras() a second time on the same \\ref k4a_device_t until"]
#[doc = " k4a_device_stop_cameras() has been called."]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_device_start_cameras(
device_handle: k4a_device_t,
config: *const k4a_device_configuration_t,
) -> k4a_result_t;
}
extern "C" {
#[doc = " Stops the color and depth camera capture."]
#[doc = ""]
#[doc = " \\param device_handle"]
#[doc = " Handle obtained by k4a_device_open()."]
#[doc = ""]
#[doc = " \\relates k4a_device_t"]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " The streaming of individual sensors stops as a result of this call. Once called, k4a_device_start_cameras() may"]
#[doc = " be called again to resume sensor streaming."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " This function may be called while another thread is blocking in k4a_device_get_capture()."]
#[doc = " Calling this function while another thread is in that function will result in that function returning a failure."]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_device_stop_cameras(device_handle: k4a_device_t);
}
extern "C" {
#[doc = " Starts the IMU sample stream."]
#[doc = ""]
#[doc = " \\param device_handle"]
#[doc = " Handle obtained by k4a_device_open()."]
#[doc = ""]
#[doc = " \\returns"]
#[doc = " ::K4A_RESULT_SUCCEEDED is returned on success. ::K4A_RESULT_FAILED if the sensor is already running or a failure is"]
#[doc = " encountered"]
#[doc = ""]
#[doc = " \\relates k4a_device_t"]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Call this API to start streaming IMU data. It is not valid to call this function a second time on the same"]
#[doc = " \\ref k4a_device_t until k4a_device_stop_imu() has been called."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " This function is dependent on the state of the cameras. The color or depth camera must be started before the IMU."]
#[doc = " ::K4A_RESULT_FAILED will be returned if one of the cameras is not running."]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_device_start_imu(device_handle: k4a_device_t) -> k4a_result_t;
}
extern "C" {
#[doc = " Stops the IMU capture."]
#[doc = ""]
#[doc = " \\param device_handle"]
#[doc = " Handle obtained by k4a_device_open()."]
#[doc = ""]
#[doc = " \\relates k4a_device_t"]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " The streaming of the IMU stops as a result of this call. Once called, k4a_device_start_imu() may"]
#[doc = " be called again to resume sensor streaming, so long as the cameras are running."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " This function may be called while another thread is blocking in k4a_device_get_imu_sample()."]
#[doc = " Calling this function while another thread is in that function will result in that function returning a failure."]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_device_stop_imu(device_handle: k4a_device_t);
}
extern "C" {
#[doc = " Get the Azure Kinect device serial number."]
#[doc = ""]
#[doc = " \\param device_handle"]
#[doc = " Handle obtained by k4a_device_open()."]
#[doc = ""]
#[doc = " \\param serial_number"]
#[doc = " Location to write the serial number to. If the function returns ::K4A_BUFFER_RESULT_SUCCEEDED, this will be a NULL"]
#[doc = " terminated string of ASCII characters. If this input is NULL \\p serial_number_size will still be updated to return"]
#[doc = " the size of the buffer needed to store the string."]
#[doc = ""]
#[doc = " \\param serial_number_size"]
#[doc = " On input, the size of the \\p serial_number buffer if that pointer is not NULL. On output, this value is set to the"]
#[doc = " actual number of bytes in the serial number (including the null terminator)."]
#[doc = ""]
#[doc = " \\returns"]
#[doc = " A return of ::K4A_BUFFER_RESULT_SUCCEEDED means that the \\p serial_number has been filled in. If the buffer is too"]
#[doc = " small the function returns ::K4A_BUFFER_RESULT_TOO_SMALL and the size of the serial number is"]
#[doc = " returned in the \\p serial_number_size parameter. All other failures return ::K4A_BUFFER_RESULT_FAILED."]
#[doc = ""]
#[doc = " \\relates k4a_device_t"]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Queries the device for its serial number. If the caller needs to know the size of the serial number to allocate"]
#[doc = " memory, the function should be called once with a NULL \\p serial_number to get the needed size in the \\p"]
#[doc = " serial_number_size output, and then again with the allocated buffer."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Only a complete serial number will be returned. If the caller's buffer is too small, the function will return"]
#[doc = " ::K4A_BUFFER_RESULT_TOO_SMALL without returning any data in \\p serial_number."]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_device_get_serialnum(
device_handle: k4a_device_t,
serial_number: *mut ::std::os::raw::c_char,
serial_number_size: *mut usize,
) -> k4a_buffer_result_t;
}
extern "C" {
#[doc = " Get the version numbers of the device's subsystems."]
#[doc = ""]
#[doc = " \\param device_handle"]
#[doc = " Handle obtained by k4a_device_open()."]
#[doc = ""]
#[doc = " \\param version"]
#[doc = " Location to write the version info to."]
#[doc = ""]
#[doc = " \\returns A return of ::K4A_RESULT_SUCCEEDED means that the version structure has been filled in."]
#[doc = " All other failures return ::K4A_RESULT_FAILED."]
#[doc = ""]
#[doc = " \\relates k4a_device_t"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_device_get_version(
device_handle: k4a_device_t,
version: *mut k4a_hardware_version_t,
) -> k4a_result_t;
}
extern "C" {
#[doc = " Get the Azure Kinect color sensor control capabilities."]
#[doc = ""]
#[doc = " \\param device_handle"]
#[doc = " Handle obtained by k4a_device_open()."]
#[doc = ""]
#[doc = " \\param command"]
#[doc = " Color sensor control command."]
#[doc = ""]
#[doc = " \\param supports_auto"]
#[doc = " Location to store whether the color sensor's control support auto mode or not."]
#[doc = " true if it supports auto mode, otherwise false."]
#[doc = ""]
#[doc = " \\param min_value"]
#[doc = " Location to store the color sensor's control minimum value of /p command."]
#[doc = ""]
#[doc = " \\param max_value"]
#[doc = " Location to store the color sensor's control maximum value of /p command."]
#[doc = ""]
#[doc = " \\param step_value"]
#[doc = " Location to store the color sensor's control step value of /p command."]
#[doc = ""]
#[doc = " \\param default_value"]
#[doc = " Location to store the color sensor's control default value of /p command."]
#[doc = ""]
#[doc = " \\param default_mode"]
#[doc = " Location to store the color sensor's control default mode of /p command."]
#[doc = ""]
#[doc = " \\returns"]
#[doc = " ::K4A_RESULT_SUCCEEDED if the value was successfully returned, ::K4A_RESULT_FAILED if an error occurred"]
#[doc = ""]
#[doc = " \\relates k4a_device_t"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_device_get_color_control_capabilities(
device_handle: k4a_device_t,
command: k4a_color_control_command_t,
supports_auto: *mut bool,
min_value: *mut i32,
max_value: *mut i32,
step_value: *mut i32,
default_value: *mut i32,
default_mode: *mut k4a_color_control_mode_t,
) -> k4a_result_t;
}
extern "C" {
#[doc = " Get the Azure Kinect color sensor control"]
#[doc = " value."]
#[doc = ""]
#[doc = " \\param device_handle"]
#[doc = " Handle obtained by k4a_device_open()."]
#[doc = ""]
#[doc = " \\param command"]
#[doc = " Color sensor control command."]
#[doc = ""]
#[doc = " \\param mode"]
#[doc = " Location to store the color sensor's control mode. This mode represents whether the command is in automatic or"]
#[doc = " manual mode."]
#[doc = ""]
#[doc = " \\param value"]
#[doc = " Location to store the color sensor's control value. This value is always written, but is only valid when the \\p"]
#[doc = " mode returned is ::K4A_COLOR_CONTROL_MODE_MANUAL for the current \\p command."]
#[doc = ""]
#[doc = " \\returns"]
#[doc = " ::K4A_RESULT_SUCCEEDED if the value was successfully returned, ::K4A_RESULT_FAILED if an error occurred"]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Each control command may be set to manual or automatic. See the definition of \\ref k4a_color_control_command_t on"]
#[doc = " how to interpret the \\p value for each command."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Some control commands are only supported in manual mode. When a command is in automatic mode, the \\p value for"]
#[doc = " that command is not valid."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Control values set on a device are reset only when the device is power cycled. The device will retain the"]
#[doc = " settings even if the \\ref k4a_device_t is closed or the application is restarted."]
#[doc = ""]
#[doc = " \\relates k4a_device_t"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_device_get_color_control(
device_handle: k4a_device_t,
command: k4a_color_control_command_t,
mode: *mut k4a_color_control_mode_t,
value: *mut i32,
) -> k4a_result_t;
}
extern "C" {
#[doc = " Set the Azure Kinect color sensor control value."]
#[doc = ""]
#[doc = " \\param device_handle"]
#[doc = " Handle obtained by k4a_device_open()."]
#[doc = ""]
#[doc = " \\param command"]
#[doc = " Color sensor control command."]
#[doc = ""]
#[doc = " \\param mode"]
#[doc = " Color sensor control mode to set. This mode represents whether the command is in automatic or manual mode."]
#[doc = ""]
#[doc = " \\param value"]
#[doc = " Value to set the color sensor's control to. The value is only valid if \\p mode"]
#[doc = " is set to ::K4A_COLOR_CONTROL_MODE_MANUAL, and is otherwise ignored."]
#[doc = ""]
#[doc = " \\returns"]
#[doc = " ::K4A_RESULT_SUCCEEDED if the value was successfully set, ::K4A_RESULT_FAILED if an error occurred"]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Each control command may be set to manual or automatic. See the definition of \\ref k4a_color_control_command_t on how"]
#[doc = " to interpret the \\p value for each command."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Some control commands are only supported in manual mode. When a command is in automatic mode, the \\p value for that"]
#[doc = " command is not valid."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Control values set on a device are reset only when the device is power cycled. The device will retain the settings"]
#[doc = " even if the \\ref k4a_device_t is closed or the application is restarted."]
#[doc = ""]
#[doc = " \\relates k4a_device_t"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_device_set_color_control(
device_handle: k4a_device_t,
command: k4a_color_control_command_t,
mode: k4a_color_control_mode_t,
value: i32,
) -> k4a_result_t;
}
extern "C" {
#[doc = " Get the raw calibration blob for the entire Azure Kinect device."]
#[doc = ""]
#[doc = " \\param device_handle"]
#[doc = " Handle obtained by k4a_device_open()."]
#[doc = ""]
#[doc = " \\param data"]
#[doc = " Location to write the calibration data to. This field may optionally be set to NULL for the caller to query for"]
#[doc = " the needed data size."]
#[doc = ""]
#[doc = " \\param data_size"]
#[doc = " On passing \\p data_size into the function this variable represents the available size of the \\p data"]
#[doc = " buffer. On return this variable is updated with the amount of data actually written to the buffer, or the size"]
#[doc = " required to store the calibration buffer if \\p data is NULL."]
#[doc = ""]
#[doc = " \\returns"]
#[doc = " ::K4A_BUFFER_RESULT_SUCCEEDED if \\p data was successfully written. If \\p data_size points to a buffer size that is"]
#[doc = " too small to hold the output or \\p data is NULL, ::K4A_BUFFER_RESULT_TOO_SMALL is returned and \\p data_size is"]
#[doc = " updated to contain the minimum buffer size needed to capture the calibration data."]
#[doc = ""]
#[doc = " \\relates k4a_device_t"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_device_get_raw_calibration(
device_handle: k4a_device_t,
data: *mut u8,
data_size: *mut usize,
) -> k4a_buffer_result_t;
}
extern "C" {
#[doc = " Get the camera calibration for the entire Azure Kinect device."]
#[doc = ""]
#[doc = " \\param device_handle"]
#[doc = " Handle obtained by k4a_device_open()."]
#[doc = ""]
#[doc = " \\param depth_mode"]
#[doc = " Mode in which depth camera is operated."]
#[doc = ""]
#[doc = " \\param color_resolution"]
#[doc = " Resolution in which color camera is operated."]
#[doc = ""]
#[doc = " \\param calibration"]
#[doc = " Location to write the calibration"]
#[doc = ""]
#[doc = " \\returns"]
#[doc = " ::K4A_RESULT_SUCCEEDED if \\p calibration was successfully written. ::K4A_RESULT_FAILED otherwise."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " The \\p calibration represents the data needed to transform between the camera views and may be"]
#[doc = " different for each operating \\p depth_mode and \\p color_resolution the device is configured to operate in."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " The \\p calibration output is used as input to all calibration and transformation functions."]
#[doc = ""]
#[doc = " \\see k4a_calibration_2d_to_2d()"]
#[doc = " \\see k4a_calibration_2d_to_3d()"]
#[doc = " \\see k4a_calibration_3d_to_2d()"]
#[doc = " \\see k4a_calibration_3d_to_3d()"]
#[doc = ""]
#[doc = " \\relates k4a_device_t"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_device_get_calibration(
device_handle: k4a_device_t,
depth_mode: k4a_depth_mode_t,
color_resolution: k4a_color_resolution_t,
calibration: *mut k4a_calibration_t,
) -> k4a_result_t;
}
extern "C" {
#[doc = " Get the device jack status for the synchronization in and synchronization out connectors."]
#[doc = ""]
#[doc = " \\param device_handle"]
#[doc = " Handle obtained by k4a_device_open()."]
#[doc = ""]
#[doc = " \\param sync_in_jack_connected"]
#[doc = " Upon successful return this value will be set to true if a cable is connected to this sync in jack."]
#[doc = ""]
#[doc = " \\param sync_out_jack_connected"]
#[doc = " Upon successful return this value will be set to true if a cable is connected to this sync out jack."]
#[doc = ""]
#[doc = " \\returns"]
#[doc = " ::K4A_RESULT_SUCCEEDED if the connector status was successfully read."]
#[doc = ""]
#[doc = " \\relates k4a_device_t"]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " If \\p sync_out_jack_connected is true then \\ref k4a_device_configuration_t wired_sync_mode mode can be set to \\ref"]
#[doc = " K4A_WIRED_SYNC_MODE_STANDALONE or \\ref K4A_WIRED_SYNC_MODE_MASTER. If \\p sync_in_jack_connected is true then \\ref"]
#[doc = " k4a_device_configuration_t wired_sync_mode mode can be set to \\ref K4A_WIRED_SYNC_MODE_STANDALONE or \\ref"]
#[doc = " K4A_WIRED_SYNC_MODE_SUBORDINATE."]
#[doc = ""]
#[doc = " \\see k4a_device_start_cameras()"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_device_get_sync_jack(
device_handle: k4a_device_t,
sync_in_jack_connected: *mut bool,
sync_out_jack_connected: *mut bool,
) -> k4a_result_t;
}
extern "C" {
#[doc = " Get the camera calibration for a device from a raw calibration blob."]
#[doc = ""]
#[doc = " \\param raw_calibration"]
#[doc = " Raw calibration blob obtained from a device or recording. The raw calibration must be NULL terminated."]
#[doc = ""]
#[doc = " \\param raw_calibration_size"]
#[doc = " The size, in bytes, of raw_calibration including the NULL termination."]
#[doc = ""]
#[doc = " \\param depth_mode"]
#[doc = " Mode in which depth camera is operated."]
#[doc = ""]
#[doc = " \\param color_resolution"]
#[doc = " Resolution in which color camera is operated."]
#[doc = ""]
#[doc = " \\param calibration"]
#[doc = " Location to write the calibration."]
#[doc = ""]
#[doc = " \\returns"]
#[doc = " ::K4A_RESULT_SUCCEEDED if \\p calibration was successfully written. ::K4A_RESULT_FAILED otherwise."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " The \\p calibration represents the data needed to transform between the camera views and is"]
#[doc = " different for each operating \\p depth_mode and \\p color_resolution the device is configured to operate in."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " The \\p calibration output is used as input to all transformation functions."]
#[doc = ""]
#[doc = " \\see k4a_calibration_2d_to_2d()"]
#[doc = " \\see k4a_calibration_2d_to_3d()"]
#[doc = " \\see k4a_calibration_3d_to_2d()"]
#[doc = " \\see k4a_calibration_3d_to_3d()"]
#[doc = ""]
#[doc = " \\relates k4a_device_t"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_calibration_get_from_raw(
raw_calibration: *mut ::std::os::raw::c_char,
raw_calibration_size: usize,
depth_mode: k4a_depth_mode_t,
color_resolution: k4a_color_resolution_t,
calibration: *mut k4a_calibration_t,
) -> k4a_result_t;
}
extern "C" {
#[doc = " Transform a 3D point of a source coordinate system into a 3D point of the target coordinate system"]
#[doc = ""]
#[doc = " \\param calibration"]
#[doc = " Location to read the camera calibration data."]
#[doc = ""]
#[doc = " \\param source_point3d_mm"]
#[doc = " The 3D coordinates in millimeters representing a point in \\p source_camera."]
#[doc = ""]
#[doc = " \\param source_camera"]
#[doc = " The current camera."]
#[doc = ""]
#[doc = " \\param target_camera"]
#[doc = " The target camera."]
#[doc = ""]
#[doc = " \\param target_point3d_mm"]
#[doc = " Pointer to the output where the new 3D coordinates of the input point in the coordinate space of \\p target_camera is"]
#[doc = " stored in millimeters."]
#[doc = ""]
#[doc = " \\returns"]
#[doc = " ::K4A_RESULT_SUCCEEDED if \\p target_point3d_mm was successfully written. ::K4A_RESULT_FAILED if \\p calibration"]
#[doc = " contained invalid transformation parameters."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " This function is used to transform 3D points between depth and color camera coordinate systems. The function uses the"]
#[doc = " extrinsic camera calibration. It computes the output via multiplication with a precomputed matrix encoding a 3D"]
#[doc = " rotation and a 3D translation. If \\p source_camera and \\p target_camera are the same, then \\p target_point3d_mm will"]
#[doc = " be identical to \\p source_point3d_mm."]
#[doc = ""]
#[doc = " \\relates k4a_calibration_t"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_calibration_3d_to_3d(
calibration: *const k4a_calibration_t,
source_point3d_mm: *const k4a_float3_t,
source_camera: k4a_calibration_type_t,
target_camera: k4a_calibration_type_t,
target_point3d_mm: *mut k4a_float3_t,
) -> k4a_result_t;
}
extern "C" {
#[doc = " Transform a 2D pixel coordinate with an associated depth value of the source camera into a 3D point of the target"]
#[doc = " coordinate system."]
#[doc = ""]
#[doc = " \\param calibration"]
#[doc = " Location to read the camera calibration obtained by k4a_device_get_calibration()."]
#[doc = ""]
#[doc = " \\param source_point2d"]
#[doc = " The 2D pixel in \\p source_camera coordinates."]
#[doc = ""]
#[doc = " \\param source_depth_mm"]
#[doc = " The depth of \\p source_point2d in millimeters. One way to derive the depth value in the color camera geometry is to"]
#[doc = " use the function k4a_transformation_depth_image_to_color_camera()."]
#[doc = ""]
#[doc = " \\param source_camera"]
#[doc = " The current camera."]
#[doc = ""]
#[doc = " \\param target_camera"]
#[doc = " The target camera."]
#[doc = ""]
#[doc = " \\param target_point3d_mm"]
#[doc = " Pointer to the output where the 3D coordinates of the input pixel in the coordinate system of \\p target_camera is"]
#[doc = " stored in millimeters."]
#[doc = ""]
#[doc = " \\param valid"]
#[doc = " The output parameter returns a value of 1 if the \\p source_point2d is a valid coordinate, and will return 0 if"]
#[doc = " the coordinate is not valid in the calibration model."]
#[doc = ""]
#[doc = " \\returns"]
#[doc = " ::K4A_RESULT_SUCCEEDED if \\p target_point3d_mm was successfully written. ::K4A_RESULT_FAILED if \\p calibration"]
#[doc = " contained invalid transformation parameters. If the function returns ::K4A_RESULT_SUCCEEDED, but \\p valid is 0,"]
#[doc = " the transformation was computed, but the results in \\p target_point3d_mm are outside of the range of valid"]
#[doc = " calibration and should be ignored."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " This function applies the intrinsic calibration of \\p source_camera to compute the 3D ray from the focal point of the"]
#[doc = " camera through pixel \\p source_point2d. The 3D point on this ray is then found using \\p source_depth_mm. If \\p"]
#[doc = " target_camera is different from \\p source_camera, the 3D point is transformed to \\p target_camera using"]
#[doc = " k4a_calibration_3d_to_3d(). In practice, \\p source_camera and \\p target_camera will often be identical. In this"]
#[doc = " case, no 3D to 3D transformation is applied."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " If \\p source_point2d is not considered as valid pixel coordinate"]
#[doc = " according to the intrinsic camera model, \\p valid is set to 0. If it is valid, \\p valid will be set to 1. The user"]
#[doc = " should not use the value of \\p target_point3d_mm if \\p valid was set to 0."]
#[doc = ""]
#[doc = " \\relates k4a_calibration_t"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_calibration_2d_to_3d(
calibration: *const k4a_calibration_t,
source_point2d: *const k4a_float2_t,
source_depth_mm: f32,
source_camera: k4a_calibration_type_t,
target_camera: k4a_calibration_type_t,
target_point3d_mm: *mut k4a_float3_t,
valid: *mut ::std::os::raw::c_int,
) -> k4a_result_t;
}
extern "C" {
#[doc = " Transform a 3D point of a source coordinate system into a 2D pixel coordinate of the target camera."]
#[doc = ""]
#[doc = " \\param calibration"]
#[doc = " Location to read the camera calibration obtained by k4a_device_get_calibration()."]
#[doc = ""]
#[doc = " \\param source_point3d_mm"]
#[doc = " The 3D coordinates in millimeters representing a point in \\p source_camera"]
#[doc = ""]
#[doc = " \\param source_camera"]
#[doc = " The current camera."]
#[doc = ""]
#[doc = " \\param target_camera"]
#[doc = " The target camera."]
#[doc = ""]
#[doc = " \\param target_point2d"]
#[doc = " Pointer to the output where the 2D pixel in \\p target_camera coordinates is stored."]
#[doc = ""]
#[doc = " \\param valid"]
#[doc = " The output parameter returns a value of 1 if the \\p source_point3d_mm is a valid coordinate in the \\p target_camera"]
#[doc = " coordinate system, and will return 0 if the coordinate is not valid in the calibration model."]
#[doc = ""]
#[doc = " \\returns"]
#[doc = " ::K4A_RESULT_SUCCEEDED if \\p target_point2d was successfully written. ::K4A_RESULT_FAILED if \\p calibration"]
#[doc = " contained invalid transformation parameters. If the function returns ::K4A_RESULT_SUCCEEDED, but \\p valid is 0,"]
#[doc = " the transformation was computed, but the results in \\p target_point2d are outside of the range of valid calibration"]
#[doc = " and should be ignored."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " If \\p target_camera is different from \\p source_camera, \\p source_point3d_mm is transformed to \\p target_camera using"]
#[doc = " k4a_calibration_3d_to_3d(). In practice, \\p source_camera and \\p target_camera will often be identical. In this"]
#[doc = " case, no 3D to 3D transformation is applied. The 3D point in the coordinate system of \\p target_camera is then"]
#[doc = " projected onto the image plane using the intrinsic calibration of \\p target_camera."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " If \\p source_point3d_mm does not map to a valid 2D coordinate in the \\p target_camera coordinate system, \\p valid is"]
#[doc = " set to 0. If it is valid, \\p valid will be set to 1. The user should not use the value of \\p target_point2d if \\p"]
#[doc = " valid was set to 0."]
#[doc = ""]
#[doc = " \\relates k4a_calibration_t"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_calibration_3d_to_2d(
calibration: *const k4a_calibration_t,
source_point3d_mm: *const k4a_float3_t,
source_camera: k4a_calibration_type_t,
target_camera: k4a_calibration_type_t,
target_point2d: *mut k4a_float2_t,
valid: *mut ::std::os::raw::c_int,
) -> k4a_result_t;
}
extern "C" {
#[doc = " Transform a 2D pixel coordinate with an associated depth value of the source camera into a 2D pixel coordinate of"]
#[doc = " the target camera."]
#[doc = ""]
#[doc = " \\param calibration"]
#[doc = " Location to read the camera calibration obtained by k4a_device_get_calibration()."]
#[doc = ""]
#[doc = " \\param source_point2d"]
#[doc = " The 2D pixel in \\p source_camera coordinates."]
#[doc = ""]
#[doc = " \\param source_depth_mm"]
#[doc = " The depth of \\p source_point2d in millimeters. One way to derive the depth value in the color camera geometry is to"]
#[doc = " use the function k4a_transformation_depth_image_to_color_camera()."]
#[doc = ""]
#[doc = " \\param source_camera"]
#[doc = " The current camera."]
#[doc = ""]
#[doc = " \\param target_camera"]
#[doc = " The target camera."]
#[doc = ""]
#[doc = " \\param target_point2d"]
#[doc = " The 2D pixel in \\p target_camera coordinates."]
#[doc = ""]
#[doc = " \\param valid"]
#[doc = " The output parameter returns a value of 1 if the \\p source_point2d is a valid coordinate in the \\p target_camera"]
#[doc = " coordinate system, and will return 0 if the coordinate is not valid in the calibration model."]
#[doc = ""]
#[doc = " \\returns"]
#[doc = " ::K4A_RESULT_SUCCEEDED if \\p target_point2d was successfully written. ::K4A_RESULT_FAILED if \\p calibration"]
#[doc = " contained invalid transformation parameters. If the function returns ::K4A_RESULT_SUCCEEDED, but \\p valid is 0,"]
#[doc = " the transformation was computed, but the results in \\p target_point2d are outside of the range of valid calibration"]
#[doc = " and should be ignored."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " This function maps a pixel between the coordinate systems of the depth and color cameras. It is equivalent to calling"]
#[doc = " k4a_calibration_2d_to_3d() to compute the 3D point corresponding to \\p source_point2d and then using"]
#[doc = " k4a_calibration_3d_to_2d() to map the 3D point into the coordinate system of the \\p target_camera."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " If \\p source_camera and \\p target_camera are identical, the function immediately sets \\p target_point2d to \\p"]
#[doc = " source_point2d and returns without computing any transformations."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " If \\p source_point2d does not map to a valid 2D coordinate in the \\p target_camera coordinate system, \\p valid is set"]
#[doc = " to 0. If it is valid, \\p valid will be set to 1. The user should not use the value of \\p target_point2d if \\p valid"]
#[doc = " was set to 0."]
#[doc = ""]
#[doc = " \\relates k4a_calibration_t"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_calibration_2d_to_2d(
calibration: *const k4a_calibration_t,
source_point2d: *const k4a_float2_t,
source_depth_mm: f32,
source_camera: k4a_calibration_type_t,
target_camera: k4a_calibration_type_t,
target_point2d: *mut k4a_float2_t,
valid: *mut ::std::os::raw::c_int,
) -> k4a_result_t;
}
extern "C" {
#[doc = " Transform a 2D pixel coordinate from color camera into a 2D pixel coordinate of"]
#[doc = " the depth camera."]
#[doc = ""]
#[doc = " \\param calibration"]
#[doc = " Location to read the camera calibration obtained by k4a_device_get_calibration()."]
#[doc = ""]
#[doc = " \\param source_point2d"]
#[doc = " The 2D pixel in \\p color camera coordinates."]
#[doc = ""]
#[doc = " \\param depth_image"]
#[doc = " Handle to input depth image."]
#[doc = ""]
#[doc = " \\param target_point2d"]
#[doc = " The 2D pixel in \\p depth camera coordinates."]
#[doc = ""]
#[doc = " \\param valid"]
#[doc = " The output parameter returns a value of 1 if the \\p source_point2d is a valid coordinate in the \\p target_camera"]
#[doc = " coordinate system, and will return 0 if the coordinate is not valid in the calibration model."]
#[doc = ""]
#[doc = " \\returns"]
#[doc = " ::K4A_RESULT_SUCCEEDED if \\p target_point2d was successfully written. ::K4A_RESULT_FAILED if \\p calibration"]
#[doc = " contained invalid transformation parameters. If the function returns ::K4A_RESULT_SUCCEEDED, but \\p valid is 0,"]
#[doc = " the transformation was computed, but the results in \\p target_point2d are outside of the range of valid calibration"]
#[doc = " and should be ignored."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " This function represents an alternative to k4a_calibration_2d_to_2d() if the number of pixels that need to be"]
#[doc = " transformed is small. This function searches along an epipolar line in the depth image to find the corresponding"]
#[doc = " depth pixel. If a larger number of pixels need to be transformed, it might be computationally cheaper to call"]
#[doc = " k4a_transformation_depth_image_to_color_camera() to get correspondence depth values for these color pixels, then call"]
#[doc = " the function k4a_calibration_2d_to_2d()."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " If \\p source_point2d does not map to a valid 2D coordinate in the \\p target_camera coordinate system, \\p valid is set"]
#[doc = " to 0. If it is valid, \\p valid will be set to 1. The user should not use the value of \\p target_point2d if \\p valid"]
#[doc = " was set to 0."]
#[doc = ""]
#[doc = " \\relates k4a_calibration_t"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_calibration_color_2d_to_depth_2d(
calibration: *const k4a_calibration_t,
source_point2d: *const k4a_float2_t,
depth_image: k4a_image_t,
target_point2d: *mut k4a_float2_t,
valid: *mut ::std::os::raw::c_int,
) -> k4a_result_t;
}
extern "C" {
#[doc = " Get handle to transformation handle."]
#[doc = ""]
#[doc = " \\param calibration"]
#[doc = " A calibration structure obtained by k4a_device_get_calibration()."]
#[doc = ""]
#[doc = " \\returns"]
#[doc = " A transformation handle. A NULL is returned if creation fails."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " The transformation handle is used to transform images from the coordinate system of one camera into the other. Each"]
#[doc = " transformation handle requires some pre-computed resources to be allocated, which are retained until the handle is"]
#[doc = " destroyed."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " The transformation handle must be destroyed with k4a_transformation_destroy() when it is no longer to be used."]
#[doc = ""]
#[doc = " \\relates k4a_calibration_t"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_transformation_create(calibration: *const k4a_calibration_t)
-> k4a_transformation_t;
}
extern "C" {
#[doc = " Destroy transformation handle."]
#[doc = ""]
#[doc = " \\param transformation_handle"]
#[doc = " Transformation handle to destroy."]
#[doc = ""]
#[doc = " \\relates k4a_transformation_t"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_transformation_destroy(transformation_handle: k4a_transformation_t);
}
extern "C" {
#[doc = " Transforms the depth map into the geometry of the color camera."]
#[doc = ""]
#[doc = " \\param transformation_handle"]
#[doc = " Transformation handle."]
#[doc = ""]
#[doc = " \\param depth_image"]
#[doc = " Handle to input depth image."]
#[doc = ""]
#[doc = " \\param transformed_depth_image"]
#[doc = " Handle to output transformed depth image."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " This produces a depth image for which each pixel matches the corresponding pixel coordinates of the color camera."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " \\p depth_image and \\p transformed_depth_image must be of format ::K4A_IMAGE_FORMAT_DEPTH16."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " \\p transformed_depth_image must have a width and height matching the width and height of the color camera in the mode"]
#[doc = " specified by the \\ref k4a_calibration_t used to create the \\p transformation_handle with k4a_transformation_create()."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " The contents \\p transformed_depth_image will be filled with the depth values derived from \\p depth_image in the color"]
#[doc = " camera's coordinate space."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " \\p transformed_depth_image should be created by the caller using k4a_image_create() or"]
#[doc = " k4a_image_create_from_buffer()."]
#[doc = ""]
#[doc = " \\returns"]
#[doc = " ::K4A_RESULT_SUCCEEDED if \\p transformed_depth_image was successfully written and ::K4A_RESULT_FAILED otherwise."]
#[doc = ""]
#[doc = " \\relates k4a_transformation_t"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_transformation_depth_image_to_color_camera(
transformation_handle: k4a_transformation_t,
depth_image: k4a_image_t,
transformed_depth_image: k4a_image_t,
) -> k4a_result_t;
}
extern "C" {
#[doc = " Transforms depth map and a custom image into the geometry of the color camera."]
#[doc = ""]
#[doc = " \\param transformation_handle"]
#[doc = " Transformation handle."]
#[doc = ""]
#[doc = " \\param depth_image"]
#[doc = " Handle to input depth image."]
#[doc = ""]
#[doc = " \\param custom_image"]
#[doc = " Handle to input custom image."]
#[doc = ""]
#[doc = " \\param transformed_depth_image"]
#[doc = " Handle to output transformed depth image."]
#[doc = ""]
#[doc = " \\param transformed_custom_image"]
#[doc = " Handle to output transformed custom image."]
#[doc = ""]
#[doc = " \\param interpolation_type"]
#[doc = " Parameter that controls how pixels in \\p custom_image should be interpolated when transformed to color camera space."]
#[doc = " K4A_TRANSFORMATION_INTERPOLATION_TYPE_LINEAR if linear interpolation should be used."]
#[doc = " K4A_TRANSFORMATION_INTERPOLATION_TYPE_NEAREST if nearest neighbor interpolation should be used."]
#[doc = ""]
#[doc = " \\param invalid_custom_value"]
#[doc = " Defines the custom image pixel value that should be written to \\p transformed_custom_image in case the corresponding"]
#[doc = " depth pixel can not be transformed into the color camera space."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " This produces a depth image and a corresponding custom image for which each pixel matches the corresponding"]
#[doc = " pixel coordinates of the color camera."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " \\p depth_image and \\p transformed_depth_image must be of format ::K4A_IMAGE_FORMAT_DEPTH16."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " \\p custom_image and \\p transformed_custom_image must be of format ::K4A_IMAGE_FORMAT_CUSTOM8 or"]
#[doc = " ::K4A_IMAGE_FORMAT_CUSTOM16."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " \\p transformed_depth_image and \\p transformed_custom_image must have a width and height matching the width and"]
#[doc = " height of the color camera in the mode specified by the \\ref k4a_calibration_t used to create the"]
#[doc = " \\p transformation_handle with k4a_transformation_create()."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " \\p custom_image must have a width and height matching the width and height of \\p depth_image."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " The contents \\p transformed_depth_image will be filled with the depth values derived from \\p depth_image in the color"]
#[doc = " camera's coordinate space."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " The contents \\p transformed_custom_image will be filled with the values derived from \\p custom_image in the color"]
#[doc = " camera's coordinate space."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " \\p transformed_depth_image and \\p transformed_custom_image should be created by the caller using k4a_image_create()"]
#[doc = " or k4a_image_create_from_buffer()."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Using linear interpolation could create new values to \\p transformed_custom_image which do no exist in \\p"]
#[doc = " custom_image. Setting \\p use_linear_interpolation to false will prevent this from happenning but will result in less"]
#[doc = " smooth image."]
#[doc = ""]
#[doc = " \\returns"]
#[doc = " ::K4A_RESULT_SUCCEEDED if \\p transformed_depth_image and \\p transformed_custom_image were successfully written and"]
#[doc = " ::K4A_RESULT_FAILED otherwise."]
#[doc = ""]
#[doc = " \\relates k4a_transformation_t"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_transformation_depth_image_to_color_camera_custom(
transformation_handle: k4a_transformation_t,
depth_image: k4a_image_t,
custom_image: k4a_image_t,
transformed_depth_image: k4a_image_t,
transformed_custom_image: k4a_image_t,
interpolation_type: k4a_transformation_interpolation_type_t,
invalid_custom_value: u32,
) -> k4a_result_t;
}
extern "C" {
#[doc = " Transforms a color image into the geometry of the depth camera."]
#[doc = ""]
#[doc = " \\param transformation_handle"]
#[doc = " Transformation handle."]
#[doc = ""]
#[doc = " \\param depth_image"]
#[doc = " Handle to input depth image."]
#[doc = ""]
#[doc = " \\param color_image"]
#[doc = " Handle to input color image."]
#[doc = ""]
#[doc = " \\param transformed_color_image"]
#[doc = " Handle to output transformed color image."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " This produces a color image for which each pixel matches the corresponding pixel coordinates of the depth camera."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " \\p depth_image and \\p color_image need to represent the same moment in time. The depth data will be applied to the"]
#[doc = " color image to properly warp the color data to the perspective of the depth camera."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " \\p depth_image must be of type ::K4A_IMAGE_FORMAT_DEPTH16. \\p color_image must be of format"]
#[doc = " ::K4A_IMAGE_FORMAT_COLOR_BGRA32."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " \\p transformed_color_image image must be of format ::K4A_IMAGE_FORMAT_COLOR_BGRA32. \\p transformed_color_image must"]
#[doc = " have the width and height of the depth camera in the mode specified by the \\ref k4a_calibration_t used to create"]
#[doc = " the \\p transformation_handle with k4a_transformation_create()."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " \\p transformed_color_image should be created by the caller using k4a_image_create() or"]
#[doc = " k4a_image_create_from_buffer()."]
#[doc = ""]
#[doc = " \\returns"]
#[doc = " ::K4A_RESULT_SUCCEEDED if \\p transformed_color_image was successfully written and ::K4A_RESULT_FAILED otherwise."]
#[doc = ""]
#[doc = " \\relates k4a_transformation_t"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_transformation_color_image_to_depth_camera(
transformation_handle: k4a_transformation_t,
depth_image: k4a_image_t,
color_image: k4a_image_t,
transformed_color_image: k4a_image_t,
) -> k4a_result_t;
}
extern "C" {
#[doc = " Transforms the depth image into 3 planar images representing X, Y and Z-coordinates of corresponding 3D points."]
#[doc = ""]
#[doc = " \\param transformation_handle"]
#[doc = " Transformation handle."]
#[doc = ""]
#[doc = " \\param depth_image"]
#[doc = " Handle to input depth image."]
#[doc = ""]
#[doc = " \\param camera"]
#[doc = " Geometry in which depth map was computed."]
#[doc = ""]
#[doc = " \\param xyz_image"]
#[doc = " Handle to output xyz image."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " \\p depth_image must be of format ::K4A_IMAGE_FORMAT_DEPTH16."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " The \\p camera parameter tells the function what the perspective of the \\p depth_image is. If the \\p depth_image was"]
#[doc = " captured directly from the depth camera, the value should be ::K4A_CALIBRATION_TYPE_DEPTH. If the \\p depth_image is"]
#[doc = " the result of a transformation into the color camera's coordinate space using"]
#[doc = " k4a_transformation_depth_image_to_color_camera(), the value should be ::K4A_CALIBRATION_TYPE_COLOR."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " The format of \\p xyz_image must be ::K4A_IMAGE_FORMAT_CUSTOM. The width and height of \\p xyz_image must match the"]
#[doc = " width and height of \\p depth_image. \\p xyz_image must have a stride in bytes of at least 6 times its width in pixels."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Each pixel of the \\p xyz_image consists of three int16_t values, totaling 6 bytes. The three int16_t values are the"]
#[doc = " X, Y, and Z values of the point."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " \\p xyz_image should be created by the caller using k4a_image_create() or k4a_image_create_from_buffer()."]
#[doc = ""]
#[doc = " \\returns"]
#[doc = " ::K4A_RESULT_SUCCEEDED if \\p xyz_image was successfully written and ::K4A_RESULT_FAILED otherwise."]
#[doc = ""]
#[doc = " \\relates k4a_transformation_t"]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4a.h (include k4a/k4a.h)</requirement>"]
#[doc = " <requirement name=\"Library\">k4a.lib</requirement>"]
#[doc = " <requirement name=\"DLL\">k4a.dll</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub fn k4a_transformation_depth_image_to_point_cloud(
transformation_handle: k4a_transformation_t,
depth_image: k4a_image_t,
camera: k4a_calibration_type_t,
xyz_image: k4a_image_t,
) -> k4a_result_t;
}