pub const K4A_VERSION_MAJOR: u32 = 1;
pub const K4A_VERSION_MINOR: u32 = 4;
pub const K4A_VERSION_PATCH: u32 = 1;
pub const K4A_VERSION_PRERELEASE: &'static [u8; 1usize] = b"\0";
pub const K4A_VERSION_BUILD_METADATA: &'static [u8; 1usize] = b"\0";
pub const K4A_VERSION_STR: &'static [u8; 6usize] = b"1.4.1\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, Default, 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, Default, 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, Default, 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, Default, 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 = ::std::os::raw::c_uint;
#[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 = ::std::os::raw::c_uint;
#[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 = ::std::os::raw::c_uint;
#[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 = ::std::os::raw::c_uint;
#[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 = ::std::os::raw::c_uint;
#[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 = ::std::os::raw::c_uint;
#[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 = ::std::os::raw::c_uint;
#[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 = ::std::os::raw::c_uint;
#[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 = ::std::os::raw::c_uint;
#[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 = ::std::os::raw::c_uint;
#[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 = ::std::os::raw::c_uint;
#[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 = ::std::os::raw::c_uint;
#[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 = ::std::os::raw::c_int;
#[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 = ::std::os::raw::c_uint;
#[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 = ::std::os::raw::c_uint;
#[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 = ::std::os::raw::c_uint;
#[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)
)
);
}
impl Default for _k4a_device_configuration_t {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[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, Default, 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],
}
#[doc = " individual parameter or array representation of intrinsic model."]
#[repr(C)]
#[derive(Debug, Default, 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)
)
);
}
impl Default for k4a_calibration_intrinsic_parameters_t {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[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)
)
);
}
impl Default for _k4a_calibration_intrinsics_t {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[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)
)
);
}
impl Default for _k4a_calibration_camera_t {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[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)
)
);
}
impl Default for _k4a_calibration_t {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[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, Default, 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)
)
);
}
impl Default for _k4a_hardware_version_t {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[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],
}
#[doc = " XY or array representation of vector"]
#[repr(C)]
#[derive(Debug, Default, 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)
)
);
}
impl Default for k4a_float2_t {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[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],
}
#[doc = " XYZ or array representation of vector."]
#[repr(C)]
#[derive(Debug, Default, 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)
)
);
}
impl Default for k4a_float3_t {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[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)
)
);
}
impl Default for _k4a_imu_sample_t {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[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" {
#[doc = " Initial configuration setting for disabling all sensors."]
#[doc = ""]
#[doc = " \\remarks"]
#[doc = " Use this setting to initialize a \\ref k4a_device_configuration_t to a disabled state."]
#[doc = ""]
#[doc = " \\xmlonly"]
#[doc = " <requirements>"]
#[doc = " <requirement name=\"Header\">k4atypes.h (include k4a/k4a.h)</requirement>"]
#[doc = " </requirements>"]
#[doc = " \\endxmlonly"]
pub static K4A_DEVICE_CONFIG_INIT_DISABLE_ALL: k4a_device_configuration_t;
}
pub struct Funcs {
pub k4a_device_get_installed_count: unsafe extern "C" fn() -> u32,
pub k4a_set_debug_message_handler: unsafe extern "C" fn(
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,
pub k4a_set_allocator: unsafe extern "C" fn(
allocate: k4a_memory_allocate_cb_t,
free: k4a_memory_destroy_cb_t,
) -> k4a_result_t,
pub k4a_device_open:
unsafe extern "C" fn(index: u32, device_handle: *mut k4a_device_t) -> k4a_result_t,
pub k4a_device_close: unsafe extern "C" fn(device_handle: k4a_device_t),
pub k4a_device_get_capture: unsafe extern "C" fn(
device_handle: k4a_device_t,
capture_handle: *mut k4a_capture_t,
timeout_in_ms: i32,
) -> k4a_wait_result_t,
pub k4a_device_get_imu_sample: unsafe extern "C" fn(
device_handle: k4a_device_t,
imu_sample: *mut k4a_imu_sample_t,
timeout_in_ms: i32,
) -> k4a_wait_result_t,
pub k4a_capture_create:
unsafe extern "C" fn(capture_handle: *mut k4a_capture_t) -> k4a_result_t,
pub k4a_capture_release: unsafe extern "C" fn(capture_handle: k4a_capture_t),
pub k4a_capture_reference: unsafe extern "C" fn(capture_handle: k4a_capture_t),
pub k4a_capture_get_color_image:
unsafe extern "C" fn(capture_handle: k4a_capture_t) -> k4a_image_t,
pub k4a_capture_get_depth_image:
unsafe extern "C" fn(capture_handle: k4a_capture_t) -> k4a_image_t,
pub k4a_capture_get_ir_image:
unsafe extern "C" fn(capture_handle: k4a_capture_t) -> k4a_image_t,
pub k4a_capture_set_color_image:
unsafe extern "C" fn(capture_handle: k4a_capture_t, image_handle: k4a_image_t),
pub k4a_capture_set_depth_image:
unsafe extern "C" fn(capture_handle: k4a_capture_t, image_handle: k4a_image_t),
pub k4a_capture_set_ir_image:
unsafe extern "C" fn(capture_handle: k4a_capture_t, image_handle: k4a_image_t),
pub k4a_capture_set_temperature_c:
unsafe extern "C" fn(capture_handle: k4a_capture_t, temperature_c: f32),
pub k4a_capture_get_temperature_c: unsafe extern "C" fn(capture_handle: k4a_capture_t) -> f32,
pub k4a_image_create: unsafe extern "C" fn(
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,
pub k4a_image_create_from_buffer: unsafe extern "C" fn(
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,
pub k4a_image_get_buffer: unsafe extern "C" fn(image_handle: k4a_image_t) -> *mut u8,
pub k4a_image_get_size: unsafe extern "C" fn(image_handle: k4a_image_t) -> usize,
pub k4a_image_get_format: unsafe extern "C" fn(image_handle: k4a_image_t) -> k4a_image_format_t,
pub k4a_image_get_width_pixels:
unsafe extern "C" fn(image_handle: k4a_image_t) -> ::std::os::raw::c_int,
pub k4a_image_get_height_pixels:
unsafe extern "C" fn(image_handle: k4a_image_t) -> ::std::os::raw::c_int,
pub k4a_image_get_stride_bytes:
unsafe extern "C" fn(image_handle: k4a_image_t) -> ::std::os::raw::c_int,
pub k4a_image_get_timestamp_usec: unsafe extern "C" fn(image_handle: k4a_image_t) -> u64,
pub k4a_image_get_device_timestamp_usec: unsafe extern "C" fn(image_handle: k4a_image_t) -> u64,
pub k4a_image_get_system_timestamp_nsec: unsafe extern "C" fn(image_handle: k4a_image_t) -> u64,
pub k4a_image_get_exposure_usec: unsafe extern "C" fn(image_handle: k4a_image_t) -> u64,
pub k4a_image_get_white_balance: unsafe extern "C" fn(image_handle: k4a_image_t) -> u32,
pub k4a_image_get_iso_speed: unsafe extern "C" fn(image_handle: k4a_image_t) -> u32,
pub k4a_image_set_device_timestamp_usec:
unsafe extern "C" fn(image_handle: k4a_image_t, timestamp_usec: u64),
pub k4a_image_set_timestamp_usec:
unsafe extern "C" fn(image_handle: k4a_image_t, timestamp_usec: u64),
pub k4a_image_set_system_timestamp_nsec:
unsafe extern "C" fn(image_handle: k4a_image_t, timestamp_nsec: u64),
pub k4a_image_set_exposure_usec:
unsafe extern "C" fn(image_handle: k4a_image_t, exposure_usec: u64),
pub k4a_image_set_exposure_time_usec:
unsafe extern "C" fn(image_handle: k4a_image_t, exposure_usec: u64),
pub k4a_image_set_white_balance:
unsafe extern "C" fn(image_handle: k4a_image_t, white_balance: u32),
pub k4a_image_set_iso_speed: unsafe extern "C" fn(image_handle: k4a_image_t, iso_speed: u32),
pub k4a_image_reference: unsafe extern "C" fn(image_handle: k4a_image_t),
pub k4a_image_release: unsafe extern "C" fn(image_handle: k4a_image_t),
pub k4a_device_start_cameras: unsafe extern "C" fn(
device_handle: k4a_device_t,
config: *const k4a_device_configuration_t,
) -> k4a_result_t,
pub k4a_device_stop_cameras: unsafe extern "C" fn(device_handle: k4a_device_t),
pub k4a_device_start_imu: unsafe extern "C" fn(device_handle: k4a_device_t) -> k4a_result_t,
pub k4a_device_stop_imu: unsafe extern "C" fn(device_handle: k4a_device_t),
pub k4a_device_get_serialnum: unsafe extern "C" fn(
device_handle: k4a_device_t,
serial_number: *mut ::std::os::raw::c_char,
serial_number_size: *mut usize,
) -> k4a_buffer_result_t,
pub k4a_device_get_version: unsafe extern "C" fn(
device_handle: k4a_device_t,
version: *mut k4a_hardware_version_t,
) -> k4a_result_t,
pub k4a_device_get_color_control_capabilities: unsafe extern "C" fn(
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,
pub k4a_device_get_color_control: unsafe extern "C" fn(
device_handle: k4a_device_t,
command: k4a_color_control_command_t,
mode: *mut k4a_color_control_mode_t,
value: *mut i32,
) -> k4a_result_t,
pub k4a_device_set_color_control: unsafe extern "C" fn(
device_handle: k4a_device_t,
command: k4a_color_control_command_t,
mode: k4a_color_control_mode_t,
value: i32,
) -> k4a_result_t,
pub k4a_device_get_raw_calibration: unsafe extern "C" fn(
device_handle: k4a_device_t,
data: *mut u8,
data_size: *mut usize,
) -> k4a_buffer_result_t,
pub k4a_device_get_calibration: unsafe extern "C" fn(
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,
pub k4a_device_get_sync_jack: unsafe extern "C" fn(
device_handle: k4a_device_t,
sync_in_jack_connected: *mut bool,
sync_out_jack_connected: *mut bool,
) -> k4a_result_t,
pub k4a_calibration_get_from_raw: unsafe extern "C" fn(
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,
pub k4a_calibration_3d_to_3d: unsafe extern "C" fn(
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,
pub k4a_calibration_2d_to_3d: unsafe extern "C" fn(
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,
pub k4a_calibration_3d_to_2d: unsafe extern "C" fn(
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,
pub k4a_calibration_2d_to_2d: unsafe extern "C" fn(
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,
pub k4a_calibration_color_2d_to_depth_2d: unsafe extern "C" fn(
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,
pub k4a_transformation_create:
unsafe extern "C" fn(calibration: *const k4a_calibration_t) -> k4a_transformation_t,
pub k4a_transformation_destroy:
unsafe extern "C" fn(transformation_handle: k4a_transformation_t),
pub k4a_transformation_depth_image_to_color_camera: unsafe extern "C" fn(
transformation_handle: k4a_transformation_t,
depth_image: k4a_image_t,
transformed_depth_image: k4a_image_t,
) -> k4a_result_t,
pub k4a_transformation_depth_image_to_color_camera_custom: unsafe extern "C" fn(
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,
pub k4a_transformation_color_image_to_depth_camera: unsafe extern "C" fn(
transformation_handle: k4a_transformation_t,
depth_image: k4a_image_t,
color_image: k4a_image_t,
transformed_color_image: k4a_image_t,
) -> k4a_result_t,
pub k4a_transformation_depth_image_to_point_cloud: unsafe extern "C" fn(
transformation_handle: k4a_transformation_t,
depth_image: k4a_image_t,
camera: k4a_calibration_type_t,
xyz_image: k4a_image_t,
) -> k4a_result_t,
}