#[repr(C)]
#[derive(Default)]
pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
impl<T> __IncompleteArrayField<T> {
#[inline]
pub const fn new() -> Self {
__IncompleteArrayField(::std::marker::PhantomData, [])
}
#[inline]
pub fn as_ptr(&self) -> *const T {
self as *const _ as *const T
}
#[inline]
pub fn as_mut_ptr(&mut self) -> *mut T {
self as *mut _ as *mut T
}
#[inline]
pub unsafe fn as_slice(&self, len: usize) -> &[T] {
::std::slice::from_raw_parts(self.as_ptr(), len)
}
#[inline]
pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
}
}
impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
fmt.write_str("__IncompleteArrayField")
}
}
pub type size_t = ::std::os::raw::c_ulong;
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 __int64_t = ::std::os::raw::c_long;
pub type __uint64_t = ::std::os::raw::c_ulong;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __pthread_internal_list {
pub __prev: *mut __pthread_internal_list,
pub __next: *mut __pthread_internal_list,
}
#[test]
fn bindgen_test_layout___pthread_internal_list() {
assert_eq!(
::std::mem::size_of::<__pthread_internal_list>(),
16usize,
concat!("Size of: ", stringify!(__pthread_internal_list))
);
assert_eq!(
::std::mem::align_of::<__pthread_internal_list>(),
8usize,
concat!("Alignment of ", stringify!(__pthread_internal_list))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_internal_list>())).__prev as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_internal_list),
"::",
stringify!(__prev)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_internal_list>())).__next as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(__pthread_internal_list),
"::",
stringify!(__next)
)
);
}
pub type __pthread_list_t = __pthread_internal_list;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __pthread_mutex_s {
pub __lock: ::std::os::raw::c_int,
pub __count: ::std::os::raw::c_uint,
pub __owner: ::std::os::raw::c_int,
pub __nusers: ::std::os::raw::c_uint,
pub __kind: ::std::os::raw::c_int,
pub __spins: ::std::os::raw::c_short,
pub __elision: ::std::os::raw::c_short,
pub __list: __pthread_list_t,
}
#[test]
fn bindgen_test_layout___pthread_mutex_s() {
assert_eq!(
::std::mem::size_of::<__pthread_mutex_s>(),
40usize,
concat!("Size of: ", stringify!(__pthread_mutex_s))
);
assert_eq!(
::std::mem::align_of::<__pthread_mutex_s>(),
8usize,
concat!("Alignment of ", stringify!(__pthread_mutex_s))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_mutex_s>())).__lock as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__lock)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_mutex_s>())).__count as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_mutex_s>())).__owner as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__owner)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_mutex_s>())).__nusers as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__nusers)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_mutex_s>())).__kind as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__kind)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_mutex_s>())).__spins as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__spins)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_mutex_s>())).__elision as *const _ as usize },
22usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__elision)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_mutex_s>())).__list as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__list)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_mutex_t {
pub __data: __pthread_mutex_s,
pub __size: [::std::os::raw::c_char; 40usize],
pub __align: ::std::os::raw::c_long,
_bindgen_union_align: [u64; 5usize],
}
#[test]
fn bindgen_test_layout_pthread_mutex_t() {
assert_eq!(
::std::mem::size_of::<pthread_mutex_t>(),
40usize,
concat!("Size of: ", stringify!(pthread_mutex_t))
);
assert_eq!(
::std::mem::align_of::<pthread_mutex_t>(),
8usize,
concat!("Alignment of ", stringify!(pthread_mutex_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_mutex_t>())).__data as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_mutex_t),
"::",
stringify!(__data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_mutex_t>())).__size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_mutex_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_mutex_t>())).__align as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_mutex_t),
"::",
stringify!(__align)
)
);
}
#[repr(C)]
#[derive(Debug)]
pub struct matd_t {
pub nrows: ::std::os::raw::c_uint,
pub ncols: ::std::os::raw::c_uint,
pub data: __IncompleteArrayField<f64>,
}
#[test]
fn bindgen_test_layout_matd_t() {
assert_eq!(
::std::mem::size_of::<matd_t>(),
8usize,
concat!("Size of: ", stringify!(matd_t))
);
assert_eq!(
::std::mem::align_of::<matd_t>(),
8usize,
concat!("Alignment of ", stringify!(matd_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<matd_t>())).nrows as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(matd_t),
"::",
stringify!(nrows)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<matd_t>())).ncols as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(matd_t),
"::",
stringify!(ncols)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<matd_t>())).data as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(matd_t),
"::",
stringify!(data)
)
);
}
extern "C" {
pub fn matd_create(rows: ::std::os::raw::c_int, cols: ::std::os::raw::c_int) -> *mut matd_t;
}
extern "C" {
pub fn matd_create_data(
rows: ::std::os::raw::c_int,
cols: ::std::os::raw::c_int,
data: *const f64,
) -> *mut matd_t;
}
extern "C" {
pub fn matd_create_dataf(
rows: ::std::os::raw::c_int,
cols: ::std::os::raw::c_int,
data: *const f32,
) -> *mut matd_t;
}
extern "C" {
pub fn matd_identity(dim: ::std::os::raw::c_int) -> *mut matd_t;
}
extern "C" {
pub fn matd_create_scalar(v: f64) -> *mut matd_t;
}
extern "C" {
pub fn matd_get(
m: *const matd_t,
row: ::std::os::raw::c_int,
col: ::std::os::raw::c_int,
) -> f64;
}
extern "C" {
pub fn matd_put(
m: *mut matd_t,
row: ::std::os::raw::c_int,
col: ::std::os::raw::c_int,
value: f64,
);
}
extern "C" {
pub fn matd_get_scalar(m: *const matd_t) -> f64;
}
extern "C" {
pub fn matd_put_scalar(m: *mut matd_t, value: f64);
}
extern "C" {
pub fn matd_copy(m: *const matd_t) -> *mut matd_t;
}
extern "C" {
pub fn matd_select(
a: *const matd_t,
r0: ::std::os::raw::c_int,
r1: ::std::os::raw::c_int,
c0: ::std::os::raw::c_int,
c1: ::std::os::raw::c_int,
) -> *mut matd_t;
}
extern "C" {
pub fn matd_print(m: *const matd_t, fmt: *const ::std::os::raw::c_char);
}
extern "C" {
pub fn matd_print_transpose(m: *const matd_t, fmt: *const ::std::os::raw::c_char);
}
extern "C" {
pub fn matd_add(a: *const matd_t, b: *const matd_t) -> *mut matd_t;
}
extern "C" {
pub fn matd_add_inplace(a: *mut matd_t, b: *const matd_t);
}
extern "C" {
pub fn matd_subtract(a: *const matd_t, b: *const matd_t) -> *mut matd_t;
}
extern "C" {
pub fn matd_subtract_inplace(a: *mut matd_t, b: *const matd_t);
}
extern "C" {
pub fn matd_scale(a: *const matd_t, s: f64) -> *mut matd_t;
}
extern "C" {
pub fn matd_scale_inplace(a: *mut matd_t, s: f64);
}
extern "C" {
pub fn matd_multiply(a: *const matd_t, b: *const matd_t) -> *mut matd_t;
}
extern "C" {
pub fn matd_transpose(a: *const matd_t) -> *mut matd_t;
}
extern "C" {
pub fn matd_det(a: *const matd_t) -> f64;
}
extern "C" {
pub fn matd_inverse(a: *const matd_t) -> *mut matd_t;
}
extern "C" {
pub fn matd_vec_mag(a: *const matd_t) -> f64;
}
extern "C" {
pub fn matd_vec_dist(a: *const matd_t, b: *const matd_t) -> f64;
}
extern "C" {
pub fn matd_vec_dist_n(a: *const matd_t, b: *const matd_t, n: ::std::os::raw::c_int) -> f64;
}
extern "C" {
pub fn matd_vec_dot_product(a: *const matd_t, b: *const matd_t) -> f64;
}
extern "C" {
pub fn matd_vec_normalize(a: *const matd_t) -> *mut matd_t;
}
extern "C" {
pub fn matd_crossproduct(a: *const matd_t, b: *const matd_t) -> *mut matd_t;
}
extern "C" {
pub fn matd_err_inf(a: *const matd_t, b: *const matd_t) -> f64;
}
extern "C" {
pub fn matd_op(expr: *const ::std::os::raw::c_char, ...) -> *mut matd_t;
}
extern "C" {
pub fn matd_destroy(m: *mut matd_t);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct matd_svd_t {
pub U: *mut matd_t,
pub S: *mut matd_t,
pub V: *mut matd_t,
}
#[test]
fn bindgen_test_layout_matd_svd_t() {
assert_eq!(
::std::mem::size_of::<matd_svd_t>(),
24usize,
concat!("Size of: ", stringify!(matd_svd_t))
);
assert_eq!(
::std::mem::align_of::<matd_svd_t>(),
8usize,
concat!("Alignment of ", stringify!(matd_svd_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<matd_svd_t>())).U as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(matd_svd_t),
"::",
stringify!(U)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<matd_svd_t>())).S as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(matd_svd_t),
"::",
stringify!(S)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<matd_svd_t>())).V as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(matd_svd_t),
"::",
stringify!(V)
)
);
}
extern "C" {
pub fn matd_svd(A: *mut matd_t) -> matd_svd_t;
}
extern "C" {
pub fn matd_svd_flags(A: *mut matd_t, flags: ::std::os::raw::c_int) -> matd_svd_t;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct matd_plu_t {
pub singular: ::std::os::raw::c_int,
pub piv: *mut ::std::os::raw::c_uint,
pub pivsign: ::std::os::raw::c_int,
pub lu: *mut matd_t,
}
#[test]
fn bindgen_test_layout_matd_plu_t() {
assert_eq!(
::std::mem::size_of::<matd_plu_t>(),
32usize,
concat!("Size of: ", stringify!(matd_plu_t))
);
assert_eq!(
::std::mem::align_of::<matd_plu_t>(),
8usize,
concat!("Alignment of ", stringify!(matd_plu_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<matd_plu_t>())).singular as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(matd_plu_t),
"::",
stringify!(singular)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<matd_plu_t>())).piv as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(matd_plu_t),
"::",
stringify!(piv)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<matd_plu_t>())).pivsign as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(matd_plu_t),
"::",
stringify!(pivsign)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<matd_plu_t>())).lu as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(matd_plu_t),
"::",
stringify!(lu)
)
);
}
extern "C" {
pub fn matd_plu(a: *const matd_t) -> *mut matd_plu_t;
}
extern "C" {
pub fn matd_plu_destroy(mlu: *mut matd_plu_t);
}
extern "C" {
pub fn matd_plu_det(lu: *const matd_plu_t) -> f64;
}
extern "C" {
pub fn matd_plu_p(lu: *const matd_plu_t) -> *mut matd_t;
}
extern "C" {
pub fn matd_plu_l(lu: *const matd_plu_t) -> *mut matd_t;
}
extern "C" {
pub fn matd_plu_u(lu: *const matd_plu_t) -> *mut matd_t;
}
extern "C" {
pub fn matd_plu_solve(mlu: *const matd_plu_t, b: *const matd_t) -> *mut matd_t;
}
extern "C" {
pub fn matd_solve(A: *mut matd_t, b: *mut matd_t) -> *mut matd_t;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct matd_chol_t {
pub is_spd: ::std::os::raw::c_int,
pub u: *mut matd_t,
}
#[test]
fn bindgen_test_layout_matd_chol_t() {
assert_eq!(
::std::mem::size_of::<matd_chol_t>(),
16usize,
concat!("Size of: ", stringify!(matd_chol_t))
);
assert_eq!(
::std::mem::align_of::<matd_chol_t>(),
8usize,
concat!("Alignment of ", stringify!(matd_chol_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<matd_chol_t>())).is_spd as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(matd_chol_t),
"::",
stringify!(is_spd)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<matd_chol_t>())).u as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(matd_chol_t),
"::",
stringify!(u)
)
);
}
extern "C" {
pub fn matd_chol(A: *mut matd_t) -> *mut matd_chol_t;
}
extern "C" {
pub fn matd_chol_solve(chol: *const matd_chol_t, b: *const matd_t) -> *mut matd_t;
}
extern "C" {
pub fn matd_chol_destroy(chol: *mut matd_chol_t);
}
extern "C" {
pub fn matd_chol_inverse(a: *mut matd_t) -> *mut matd_t;
}
extern "C" {
pub fn matd_ltransposetriangle_solve(u: *mut matd_t, b: *const f64, x: *mut f64);
}
extern "C" {
pub fn matd_ltriangle_solve(u: *mut matd_t, b: *const f64, x: *mut f64);
}
extern "C" {
pub fn matd_utriangle_solve(u: *mut matd_t, b: *const f64, x: *mut f64);
}
extern "C" {
pub fn matd_max(m: *mut matd_t) -> f64;
}
pub type image_u8_t = image_u8;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct image_u8 {
pub width: i32,
pub height: i32,
pub stride: i32,
pub buf: *mut u8,
}
#[test]
fn bindgen_test_layout_image_u8() {
assert_eq!(
::std::mem::size_of::<image_u8>(),
24usize,
concat!("Size of: ", stringify!(image_u8))
);
assert_eq!(
::std::mem::align_of::<image_u8>(),
8usize,
concat!("Alignment of ", stringify!(image_u8))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<image_u8>())).width as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(image_u8),
"::",
stringify!(width)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<image_u8>())).height as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(image_u8),
"::",
stringify!(height)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<image_u8>())).stride as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(image_u8),
"::",
stringify!(stride)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<image_u8>())).buf as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(image_u8),
"::",
stringify!(buf)
)
);
}
pub type image_u8x3_t = image_u8x3;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct image_u8x3 {
pub width: i32,
pub height: i32,
pub stride: i32,
pub buf: *mut u8,
}
#[test]
fn bindgen_test_layout_image_u8x3() {
assert_eq!(
::std::mem::size_of::<image_u8x3>(),
24usize,
concat!("Size of: ", stringify!(image_u8x3))
);
assert_eq!(
::std::mem::align_of::<image_u8x3>(),
8usize,
concat!("Alignment of ", stringify!(image_u8x3))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<image_u8x3>())).width as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(image_u8x3),
"::",
stringify!(width)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<image_u8x3>())).height as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(image_u8x3),
"::",
stringify!(height)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<image_u8x3>())).stride as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(image_u8x3),
"::",
stringify!(stride)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<image_u8x3>())).buf as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(image_u8x3),
"::",
stringify!(buf)
)
);
}
pub type image_u8x4_t = image_u8x4;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct image_u8x4 {
pub width: i32,
pub height: i32,
pub stride: i32,
pub buf: *mut u8,
}
#[test]
fn bindgen_test_layout_image_u8x4() {
assert_eq!(
::std::mem::size_of::<image_u8x4>(),
24usize,
concat!("Size of: ", stringify!(image_u8x4))
);
assert_eq!(
::std::mem::align_of::<image_u8x4>(),
8usize,
concat!("Alignment of ", stringify!(image_u8x4))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<image_u8x4>())).width as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(image_u8x4),
"::",
stringify!(width)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<image_u8x4>())).height as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(image_u8x4),
"::",
stringify!(height)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<image_u8x4>())).stride as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(image_u8x4),
"::",
stringify!(stride)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<image_u8x4>())).buf as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(image_u8x4),
"::",
stringify!(buf)
)
);
}
pub type image_f32_t = image_f32;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct image_f32 {
pub width: i32,
pub height: i32,
pub stride: i32,
pub buf: *mut f32,
}
#[test]
fn bindgen_test_layout_image_f32() {
assert_eq!(
::std::mem::size_of::<image_f32>(),
24usize,
concat!("Size of: ", stringify!(image_f32))
);
assert_eq!(
::std::mem::align_of::<image_f32>(),
8usize,
concat!("Alignment of ", stringify!(image_f32))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<image_f32>())).width as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(image_f32),
"::",
stringify!(width)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<image_f32>())).height as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(image_f32),
"::",
stringify!(height)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<image_f32>())).stride as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(image_f32),
"::",
stringify!(stride)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<image_f32>())).buf as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(image_f32),
"::",
stringify!(buf)
)
);
}
pub type image_u8_lut_t = image_u8_lut;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct image_u8_lut {
pub scale: f32,
pub nvalues: ::std::os::raw::c_int,
pub values: *mut u8,
}
#[test]
fn bindgen_test_layout_image_u8_lut() {
assert_eq!(
::std::mem::size_of::<image_u8_lut>(),
16usize,
concat!("Size of: ", stringify!(image_u8_lut))
);
assert_eq!(
::std::mem::align_of::<image_u8_lut>(),
8usize,
concat!("Alignment of ", stringify!(image_u8_lut))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<image_u8_lut>())).scale as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(image_u8_lut),
"::",
stringify!(scale)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<image_u8_lut>())).nvalues as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(image_u8_lut),
"::",
stringify!(nvalues)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<image_u8_lut>())).values as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(image_u8_lut),
"::",
stringify!(values)
)
);
}
extern "C" {
pub fn image_u8_create_stride(
width: ::std::os::raw::c_uint,
height: ::std::os::raw::c_uint,
stride: ::std::os::raw::c_uint,
) -> *mut image_u8_t;
}
extern "C" {
pub fn image_u8_create(
width: ::std::os::raw::c_uint,
height: ::std::os::raw::c_uint,
) -> *mut image_u8_t;
}
extern "C" {
pub fn image_u8_create_alignment(
width: ::std::os::raw::c_uint,
height: ::std::os::raw::c_uint,
alignment: ::std::os::raw::c_uint,
) -> *mut image_u8_t;
}
extern "C" {
pub fn image_u8_create_from_f32(fim: *mut image_f32_t) -> *mut image_u8_t;
}
extern "C" {
pub fn image_u8_create_from_pnm(path: *const ::std::os::raw::c_char) -> *mut image_u8_t;
}
extern "C" {
pub fn image_u8_create_from_pnm_alignment(
path: *const ::std::os::raw::c_char,
alignment: ::std::os::raw::c_int,
) -> *mut image_u8_t;
}
extern "C" {
pub fn image_u8_copy(in_: *const image_u8_t) -> *mut image_u8_t;
}
extern "C" {
pub fn image_u8_draw_line(
im: *mut image_u8_t,
x0: f32,
y0: f32,
x1: f32,
y1: f32,
v: ::std::os::raw::c_int,
width: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn image_u8_draw_circle(
im: *mut image_u8_t,
x0: f32,
y0: f32,
r: f32,
v: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn image_u8_draw_annulus(
im: *mut image_u8_t,
x0: f32,
y0: f32,
r0: f32,
r1: f32,
v: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn image_u8_fill_line_max(
im: *mut image_u8_t,
lut: *const image_u8_lut_t,
xy0: *const f32,
xy1: *const f32,
);
}
extern "C" {
pub fn image_u8_clear(im: *mut image_u8_t);
}
extern "C" {
pub fn image_u8_darken(im: *mut image_u8_t);
}
extern "C" {
pub fn image_u8_convolve_2D(im: *mut image_u8_t, k: *const u8, ksz: ::std::os::raw::c_int);
}
extern "C" {
pub fn image_u8_gaussian_blur(im: *mut image_u8_t, sigma: f64, k: ::std::os::raw::c_int);
}
extern "C" {
pub fn image_u8_decimate(im: *mut image_u8_t, factor: f32) -> *mut image_u8_t;
}
extern "C" {
pub fn image_u8_destroy(im: *mut image_u8_t);
}
extern "C" {
pub fn image_u8_write_pnm(
im: *const image_u8_t,
path: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn image_u8_rotate(in_: *const image_u8_t, rad: f64, pad: u8) -> *mut image_u8_t;
}
pub type zarray_t = zarray;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct zarray {
pub el_sz: size_t,
pub size: ::std::os::raw::c_int,
pub alloc: ::std::os::raw::c_int,
pub data: *mut ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_zarray() {
assert_eq!(
::std::mem::size_of::<zarray>(),
24usize,
concat!("Size of: ", stringify!(zarray))
);
assert_eq!(
::std::mem::align_of::<zarray>(),
8usize,
concat!("Alignment of ", stringify!(zarray))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<zarray>())).el_sz as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(zarray),
"::",
stringify!(el_sz)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<zarray>())).size as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(zarray),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<zarray>())).alloc as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(zarray),
"::",
stringify!(alloc)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<zarray>())).data as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(zarray),
"::",
stringify!(data)
)
);
}
extern "C" {
pub fn zarray_vmap(za: *mut zarray_t, f: ::std::option::Option<unsafe extern "C" fn()>);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct workerpool {
_unused: [u8; 0],
}
pub type workerpool_t = workerpool;
pub type timeprofile_t = timeprofile;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct timeprofile {
pub utime: i64,
pub stamps: *mut zarray_t,
}
#[test]
fn bindgen_test_layout_timeprofile() {
assert_eq!(
::std::mem::size_of::<timeprofile>(),
16usize,
concat!("Size of: ", stringify!(timeprofile))
);
assert_eq!(
::std::mem::align_of::<timeprofile>(),
8usize,
concat!("Alignment of ", stringify!(timeprofile))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<timeprofile>())).utime as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(timeprofile),
"::",
stringify!(utime)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<timeprofile>())).stamps as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(timeprofile),
"::",
stringify!(stamps)
)
);
}
pub type apriltag_family_t = apriltag_family;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct apriltag_family {
pub ncodes: u32,
pub codes: *mut u64,
pub width_at_border: ::std::os::raw::c_int,
pub total_width: ::std::os::raw::c_int,
pub reversed_border: bool,
pub nbits: u32,
pub bit_x: *mut u32,
pub bit_y: *mut u32,
pub h: u32,
pub name: *mut ::std::os::raw::c_char,
pub impl_: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_apriltag_family() {
assert_eq!(
::std::mem::size_of::<apriltag_family>(),
72usize,
concat!("Size of: ", stringify!(apriltag_family))
);
assert_eq!(
::std::mem::align_of::<apriltag_family>(),
8usize,
concat!("Alignment of ", stringify!(apriltag_family))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<apriltag_family>())).ncodes as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(apriltag_family),
"::",
stringify!(ncodes)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<apriltag_family>())).codes as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(apriltag_family),
"::",
stringify!(codes)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<apriltag_family>())).width_at_border as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(apriltag_family),
"::",
stringify!(width_at_border)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<apriltag_family>())).total_width as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(apriltag_family),
"::",
stringify!(total_width)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<apriltag_family>())).reversed_border as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(apriltag_family),
"::",
stringify!(reversed_border)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<apriltag_family>())).nbits as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(apriltag_family),
"::",
stringify!(nbits)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<apriltag_family>())).bit_x as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(apriltag_family),
"::",
stringify!(bit_x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<apriltag_family>())).bit_y as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(apriltag_family),
"::",
stringify!(bit_y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<apriltag_family>())).h as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(apriltag_family),
"::",
stringify!(h)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<apriltag_family>())).name as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(apriltag_family),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<apriltag_family>())).impl_ as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(apriltag_family),
"::",
stringify!(impl_)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct apriltag_quad_thresh_params {
pub min_cluster_pixels: ::std::os::raw::c_int,
pub max_nmaxima: ::std::os::raw::c_int,
pub critical_rad: f32,
pub cos_critical_rad: f32,
pub max_line_fit_mse: f32,
pub min_white_black_diff: ::std::os::raw::c_int,
pub deglitch: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_apriltag_quad_thresh_params() {
assert_eq!(
::std::mem::size_of::<apriltag_quad_thresh_params>(),
28usize,
concat!("Size of: ", stringify!(apriltag_quad_thresh_params))
);
assert_eq!(
::std::mem::align_of::<apriltag_quad_thresh_params>(),
4usize,
concat!("Alignment of ", stringify!(apriltag_quad_thresh_params))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<apriltag_quad_thresh_params>())).min_cluster_pixels as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(apriltag_quad_thresh_params),
"::",
stringify!(min_cluster_pixels)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<apriltag_quad_thresh_params>())).max_nmaxima as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(apriltag_quad_thresh_params),
"::",
stringify!(max_nmaxima)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<apriltag_quad_thresh_params>())).critical_rad as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(apriltag_quad_thresh_params),
"::",
stringify!(critical_rad)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<apriltag_quad_thresh_params>())).cos_critical_rad as *const _
as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(apriltag_quad_thresh_params),
"::",
stringify!(cos_critical_rad)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<apriltag_quad_thresh_params>())).max_line_fit_mse as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(apriltag_quad_thresh_params),
"::",
stringify!(max_line_fit_mse)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<apriltag_quad_thresh_params>())).min_white_black_diff as *const _
as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(apriltag_quad_thresh_params),
"::",
stringify!(min_white_black_diff)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<apriltag_quad_thresh_params>())).deglitch as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(apriltag_quad_thresh_params),
"::",
stringify!(deglitch)
)
);
}
pub type apriltag_detector_t = apriltag_detector;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct apriltag_detector {
pub nthreads: ::std::os::raw::c_int,
pub quad_decimate: f32,
pub quad_sigma: f32,
pub refine_edges: ::std::os::raw::c_int,
pub decode_sharpening: f64,
pub debug: ::std::os::raw::c_int,
pub qtp: apriltag_quad_thresh_params,
pub tp: *mut timeprofile_t,
pub nedges: u32,
pub nsegments: u32,
pub nquads: u32,
pub tag_families: *mut zarray_t,
pub wp: *mut workerpool_t,
pub mutex: pthread_mutex_t,
}
#[test]
fn bindgen_test_layout_apriltag_detector() {
assert_eq!(
::std::mem::size_of::<apriltag_detector>(),
136usize,
concat!("Size of: ", stringify!(apriltag_detector))
);
assert_eq!(
::std::mem::align_of::<apriltag_detector>(),
8usize,
concat!("Alignment of ", stringify!(apriltag_detector))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<apriltag_detector>())).nthreads as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(apriltag_detector),
"::",
stringify!(nthreads)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<apriltag_detector>())).quad_decimate as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(apriltag_detector),
"::",
stringify!(quad_decimate)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<apriltag_detector>())).quad_sigma as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(apriltag_detector),
"::",
stringify!(quad_sigma)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<apriltag_detector>())).refine_edges as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(apriltag_detector),
"::",
stringify!(refine_edges)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<apriltag_detector>())).decode_sharpening as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(apriltag_detector),
"::",
stringify!(decode_sharpening)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<apriltag_detector>())).debug as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(apriltag_detector),
"::",
stringify!(debug)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<apriltag_detector>())).qtp as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(apriltag_detector),
"::",
stringify!(qtp)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<apriltag_detector>())).tp as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(apriltag_detector),
"::",
stringify!(tp)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<apriltag_detector>())).nedges as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(apriltag_detector),
"::",
stringify!(nedges)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<apriltag_detector>())).nsegments as *const _ as usize },
68usize,
concat!(
"Offset of field: ",
stringify!(apriltag_detector),
"::",
stringify!(nsegments)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<apriltag_detector>())).nquads as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(apriltag_detector),
"::",
stringify!(nquads)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<apriltag_detector>())).tag_families as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(apriltag_detector),
"::",
stringify!(tag_families)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<apriltag_detector>())).wp as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(apriltag_detector),
"::",
stringify!(wp)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<apriltag_detector>())).mutex as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(apriltag_detector),
"::",
stringify!(mutex)
)
);
}
pub type apriltag_detection_t = apriltag_detection;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct apriltag_detection {
pub family: *mut apriltag_family_t,
pub id: ::std::os::raw::c_int,
pub hamming: ::std::os::raw::c_int,
pub decision_margin: f32,
pub H: *mut matd_t,
pub c: [f64; 2usize],
pub p: [[f64; 2usize]; 4usize],
}
#[test]
fn bindgen_test_layout_apriltag_detection() {
assert_eq!(
::std::mem::size_of::<apriltag_detection>(),
112usize,
concat!("Size of: ", stringify!(apriltag_detection))
);
assert_eq!(
::std::mem::align_of::<apriltag_detection>(),
8usize,
concat!("Alignment of ", stringify!(apriltag_detection))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<apriltag_detection>())).family as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(apriltag_detection),
"::",
stringify!(family)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<apriltag_detection>())).id as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(apriltag_detection),
"::",
stringify!(id)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<apriltag_detection>())).hamming as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(apriltag_detection),
"::",
stringify!(hamming)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<apriltag_detection>())).decision_margin as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(apriltag_detection),
"::",
stringify!(decision_margin)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<apriltag_detection>())).H as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(apriltag_detection),
"::",
stringify!(H)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<apriltag_detection>())).c as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(apriltag_detection),
"::",
stringify!(c)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<apriltag_detection>())).p as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(apriltag_detection),
"::",
stringify!(p)
)
);
}
extern "C" {
pub fn apriltag_detector_create() -> *mut apriltag_detector_t;
}
extern "C" {
pub fn apriltag_detector_add_family_bits(
td: *mut apriltag_detector_t,
fam: *mut apriltag_family_t,
bits_corrected: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn apriltag_detector_remove_family(
td: *mut apriltag_detector_t,
fam: *mut apriltag_family_t,
);
}
extern "C" {
pub fn apriltag_detector_clear_families(td: *mut apriltag_detector_t);
}
extern "C" {
pub fn apriltag_detector_destroy(td: *mut apriltag_detector_t);
}
extern "C" {
pub fn apriltag_detector_detect(
td: *mut apriltag_detector_t,
im_orig: *mut image_u8_t,
) -> *mut zarray_t;
}
extern "C" {
pub fn apriltag_detection_destroy(det: *mut apriltag_detection_t);
}
extern "C" {
pub fn apriltag_detections_destroy(detections: *mut zarray_t);
}
extern "C" {
pub fn apriltag_to_image(
fam: *mut apriltag_family_t,
idx: ::std::os::raw::c_int,
) -> *mut image_u8_t;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct apriltag_detection_info_t {
pub det: *mut apriltag_detection_t,
pub tagsize: f64,
pub fx: f64,
pub fy: f64,
pub cx: f64,
pub cy: f64,
}
#[test]
fn bindgen_test_layout_apriltag_detection_info_t() {
assert_eq!(
::std::mem::size_of::<apriltag_detection_info_t>(),
48usize,
concat!("Size of: ", stringify!(apriltag_detection_info_t))
);
assert_eq!(
::std::mem::align_of::<apriltag_detection_info_t>(),
8usize,
concat!("Alignment of ", stringify!(apriltag_detection_info_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<apriltag_detection_info_t>())).det as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(apriltag_detection_info_t),
"::",
stringify!(det)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<apriltag_detection_info_t>())).tagsize as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(apriltag_detection_info_t),
"::",
stringify!(tagsize)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<apriltag_detection_info_t>())).fx as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(apriltag_detection_info_t),
"::",
stringify!(fx)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<apriltag_detection_info_t>())).fy as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(apriltag_detection_info_t),
"::",
stringify!(fy)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<apriltag_detection_info_t>())).cx as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(apriltag_detection_info_t),
"::",
stringify!(cx)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<apriltag_detection_info_t>())).cy as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(apriltag_detection_info_t),
"::",
stringify!(cy)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct apriltag_pose_t {
pub R: *mut matd_t,
pub t: *mut matd_t,
}
#[test]
fn bindgen_test_layout_apriltag_pose_t() {
assert_eq!(
::std::mem::size_of::<apriltag_pose_t>(),
16usize,
concat!("Size of: ", stringify!(apriltag_pose_t))
);
assert_eq!(
::std::mem::align_of::<apriltag_pose_t>(),
8usize,
concat!("Alignment of ", stringify!(apriltag_pose_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<apriltag_pose_t>())).R as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(apriltag_pose_t),
"::",
stringify!(R)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<apriltag_pose_t>())).t as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(apriltag_pose_t),
"::",
stringify!(t)
)
);
}
extern "C" {
pub fn tag16h5_create() -> *mut apriltag_family_t;
}
extern "C" {
pub fn tag16h5_destroy(tf: *mut apriltag_family_t);
}
extern "C" {
pub fn tag25h9_create() -> *mut apriltag_family_t;
}
extern "C" {
pub fn tag25h9_destroy(tf: *mut apriltag_family_t);
}
extern "C" {
pub fn tag36h11_create() -> *mut apriltag_family_t;
}
extern "C" {
pub fn tag36h11_destroy(tf: *mut apriltag_family_t);
}
extern "C" {
pub fn tagCircle21h7_create() -> *mut apriltag_family_t;
}
extern "C" {
pub fn tagCircle21h7_destroy(tf: *mut apriltag_family_t);
}
extern "C" {
pub fn tagCircle49h12_create() -> *mut apriltag_family_t;
}
extern "C" {
pub fn tagCircle49h12_destroy(tf: *mut apriltag_family_t);
}
extern "C" {
pub fn tagCustom48h12_create() -> *mut apriltag_family_t;
}
extern "C" {
pub fn tagCustom48h12_destroy(tf: *mut apriltag_family_t);
}
extern "C" {
pub fn tagStandard41h12_create() -> *mut apriltag_family_t;
}
extern "C" {
pub fn tagStandard41h12_destroy(tf: *mut apriltag_family_t);
}
extern "C" {
pub fn tagStandard52h13_create() -> *mut apriltag_family_t;
}
extern "C" {
pub fn tagStandard52h13_destroy(tf: *mut apriltag_family_t);
}