pub mod ptcloud {
use crate::mod_prelude::*;
use crate::{core, sys, types};
pub mod prelude {
pub use super::{KeyFrameTrait, KeyFrameTraitConst, MapPointTrait, MapPointTraitConst, MapTrait, MapTraitConst, OctreeTrait, OctreeTraitConst, OdometryFrameTrait, OdometryFrameTraitConst, OdometrySettingsTrait, OdometrySettingsTraitConst, OdometryTrait, OdometryTraitConst, RgbdNormalsTrait, RgbdNormalsTraitConst, VisualOdometryTrait, VisualOdometryTraitConst, VolumeSettingsTrait, VolumeSettingsTraitConst, VolumeTrait, VolumeTraitConst};
}
pub const GAUSSIAN_SPLAT_ALPHA: i32 = 12;
pub const GAUSSIAN_SPLAT_COV: i32 = 3;
pub const GAUSSIAN_SPLAT_POS: i32 = 0;
pub const GAUSSIAN_SPLAT_RGB: i32 = 9;
pub const GAUSSIAN_SPLAT_STRIDE: i32 = 13;
pub const INITIALIZING: i32 = 1;
pub const NOT_INITIALIZED: i32 = 0;
pub const N_PYRAMIDS: i32 = 9;
pub const OdometryAlgoType_COMMON: i32 = 0;
pub const OdometryAlgoType_FAST: i32 = 1;
pub const OdometryType_DEPTH: i32 = 0;
pub const OdometryType_RGB: i32 = 1;
pub const OdometryType_RGB_DEPTH: i32 = 2;
pub const PYR_CLOUD: i32 = 3;
pub const PYR_DEPTH: i32 = 1;
pub const PYR_DIX: i32 = 4;
pub const PYR_DIY: i32 = 5;
pub const PYR_IMAGE: i32 = 0;
pub const PYR_MASK: i32 = 2;
pub const PYR_NORM: i32 = 7;
pub const PYR_NORMMASK: i32 = 8;
pub const PYR_TEXMASK: i32 = 6;
pub const RASTERIZE_COMPAT_DISABLED: i32 = 0;
pub const RASTERIZE_COMPAT_INVDEPTH: i32 = 1;
pub const RASTERIZE_CULLING_CCW: i32 = 2;
pub const RASTERIZE_CULLING_CW: i32 = 1;
pub const RASTERIZE_CULLING_NONE: i32 = 0;
pub const RASTERIZE_SHADING_FLAT: i32 = 1;
pub const RASTERIZE_SHADING_SHADED: i32 = 2;
pub const RASTERIZE_SHADING_WHITE: i32 = 0;
pub const RENDER_SHADING: i32 = 1;
pub const RENDER_SIMPLE: i32 = 0;
pub const RENDER_WIREFRAME: i32 = 2;
pub const RGBD_PLANE_METHOD_DEFAULT: i32 = 0;
pub const RgbdNormals_RGBD_NORMALS_METHOD_CROSS_PRODUCT: i32 = 3;
pub const RgbdNormals_RGBD_NORMALS_METHOD_FALS: i32 = 0;
pub const RgbdNormals_RGBD_NORMALS_METHOD_LINEMOD: i32 = 1;
pub const RgbdNormals_RGBD_NORMALS_METHOD_SRI: i32 = 2;
pub const TRACKING: i32 = 2;
pub const VolumeType_ColorHashTSDF: i32 = 3;
pub const VolumeType_ColorTSDF: i32 = 2;
pub const VolumeType_HashTSDF: i32 = 1;
pub const VolumeType_TSDF: i32 = 0;
pub const Volume_VOLUME_UNIT: i32 = 0;
pub const Volume_VOXEL: i32 = 1;
#[repr(i32)]
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum GaussianSplatLayout {
GAUSSIAN_SPLAT_STRIDE = 13,
GAUSSIAN_SPLAT_POS = 0,
GAUSSIAN_SPLAT_COV = 3,
GAUSSIAN_SPLAT_RGB = 9,
GAUSSIAN_SPLAT_ALPHA = 12,
}
opencv_type_enum! { crate::ptcloud::GaussianSplatLayout { GAUSSIAN_SPLAT_STRIDE, GAUSSIAN_SPLAT_POS, GAUSSIAN_SPLAT_COV, GAUSSIAN_SPLAT_RGB, GAUSSIAN_SPLAT_ALPHA } }
#[repr(i32)]
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum OdometryAlgoType {
COMMON = 0,
FAST = 1,
}
opencv_type_enum! { crate::ptcloud::OdometryAlgoType { COMMON, FAST } }
#[repr(i32)]
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum OdometryFramePyramidType {
PYR_IMAGE = 0,
PYR_DEPTH = 1,
PYR_MASK = 2,
PYR_CLOUD = 3,
PYR_DIX = 4,
PYR_DIY = 5,
PYR_TEXMASK = 6,
PYR_NORM = 7,
PYR_NORMMASK = 8,
N_PYRAMIDS = 9,
}
opencv_type_enum! { crate::ptcloud::OdometryFramePyramidType { PYR_IMAGE, PYR_DEPTH, PYR_MASK, PYR_CLOUD, PYR_DIX, PYR_DIY, PYR_TEXMASK, PYR_NORM, PYR_NORMMASK, N_PYRAMIDS } }
#[repr(i32)]
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum OdometryState {
NOT_INITIALIZED = 0,
INITIALIZING = 1,
TRACKING = 2,
}
opencv_type_enum! { crate::ptcloud::OdometryState { NOT_INITIALIZED, INITIALIZING, TRACKING } }
#[repr(i32)]
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum OdometryType {
DEPTH = 0,
RGB = 1,
RGB_DEPTH = 2,
}
opencv_type_enum! { crate::ptcloud::OdometryType { DEPTH, RGB, RGB_DEPTH } }
#[repr(i32)]
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum RenderMode {
RENDER_SIMPLE = 0,
RENDER_SHADING = 1,
RENDER_WIREFRAME = 2,
}
opencv_type_enum! { crate::ptcloud::RenderMode { RENDER_SIMPLE, RENDER_SHADING, RENDER_WIREFRAME } }
#[repr(i32)]
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum RgbdNormals_RgbdNormalsMethod {
RGBD_NORMALS_METHOD_FALS = 0,
RGBD_NORMALS_METHOD_LINEMOD = 1,
RGBD_NORMALS_METHOD_SRI = 2,
RGBD_NORMALS_METHOD_CROSS_PRODUCT = 3,
}
opencv_type_enum! { crate::ptcloud::RgbdNormals_RgbdNormalsMethod { RGBD_NORMALS_METHOD_FALS, RGBD_NORMALS_METHOD_LINEMOD, RGBD_NORMALS_METHOD_SRI, RGBD_NORMALS_METHOD_CROSS_PRODUCT } }
#[repr(i32)]
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum RgbdPlaneMethod {
RGBD_PLANE_METHOD_DEFAULT = 0,
}
opencv_type_enum! { crate::ptcloud::RgbdPlaneMethod { RGBD_PLANE_METHOD_DEFAULT } }
#[repr(i32)]
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum TriangleCullingMode {
RASTERIZE_CULLING_NONE = 0,
RASTERIZE_CULLING_CW = 1,
RASTERIZE_CULLING_CCW = 2,
}
opencv_type_enum! { crate::ptcloud::TriangleCullingMode { RASTERIZE_CULLING_NONE, RASTERIZE_CULLING_CW, RASTERIZE_CULLING_CCW } }
#[repr(i32)]
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum TriangleGlCompatibleMode {
RASTERIZE_COMPAT_DISABLED = 0,
RASTERIZE_COMPAT_INVDEPTH = 1,
}
opencv_type_enum! { crate::ptcloud::TriangleGlCompatibleMode { RASTERIZE_COMPAT_DISABLED, RASTERIZE_COMPAT_INVDEPTH } }
#[repr(i32)]
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum TriangleShadingType {
RASTERIZE_SHADING_WHITE = 0,
RASTERIZE_SHADING_FLAT = 1,
RASTERIZE_SHADING_SHADED = 2,
}
opencv_type_enum! { crate::ptcloud::TriangleShadingType { RASTERIZE_SHADING_WHITE, RASTERIZE_SHADING_FLAT, RASTERIZE_SHADING_SHADED } }
#[repr(i32)]
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum VolumeType {
TSDF = 0,
HashTSDF = 1,
ColorTSDF = 2,
ColorHashTSDF = 3,
}
opencv_type_enum! { crate::ptcloud::VolumeType { TSDF, HashTSDF, ColorTSDF, ColorHashTSDF } }
#[repr(i32)]
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum Volume_BoundingBoxPrecision {
VOLUME_UNIT = 0,
VOXEL = 1,
}
opencv_type_enum! { crate::ptcloud::Volume_BoundingBoxPrecision { VOLUME_UNIT, VOXEL } }
#[inline]
pub fn approx_enclosing_sphere_3d(input_cloud: &impl ToInputArray, center: &mut impl ToOutputArray) -> Result<f64> {
input_array_arg!(input_cloud);
output_array_arg!(center);
return_send!(via ocvrs_return);
unsafe { sys::cv_approxEnclosingSphere3D_const__InputArrayR_const__OutputArrayR(input_cloud.as_raw__InputArray(), center.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn bounding_box_3d(input_cloud: &impl ToInputArray, min_bound: &mut impl ToOutputArray, max_bound: &mut impl ToOutputArray) -> Result<()> {
input_array_arg!(input_cloud);
output_array_arg!(min_bound);
output_array_arg!(max_bound);
return_send!(via ocvrs_return);
unsafe { sys::cv_boundingBox3D_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(input_cloud.as_raw__InputArray(), min_bound.as_raw__OutputArray(), max_bound.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn create_mesh_bpa_def(input_cloud: &impl ToInputArray, normals: &impl ToInputArray, vertices: &mut impl ToOutputArray, triangles: &mut impl ToOutputArray) -> Result<()> {
input_array_arg!(input_cloud);
input_array_arg!(normals);
output_array_arg!(vertices);
output_array_arg!(triangles);
return_send!(via ocvrs_return);
unsafe { sys::cv_createMeshBPA_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(input_cloud.as_raw__InputArray(), normals.as_raw__InputArray(), vertices.as_raw__OutputArray(), triangles.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn create_mesh_bpa(input_cloud: &impl ToInputArray, normals: &impl ToInputArray, vertices: &mut impl ToOutputArray, triangles: &mut impl ToOutputArray, radii: &impl ToInputArray) -> Result<()> {
input_array_arg!(input_cloud);
input_array_arg!(normals);
output_array_arg!(vertices);
output_array_arg!(triangles);
input_array_arg!(radii);
return_send!(via ocvrs_return);
unsafe { sys::cv_createMeshBPA_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__InputArrayR(input_cloud.as_raw__InputArray(), normals.as_raw__InputArray(), vertices.as_raw__OutputArray(), triangles.as_raw__OutputArray(), radii.as_raw__InputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn decode_gaussian_splats_packed(buf: &impl ToInputArray, splats: &mut impl ToOutputArray) -> Result<()> {
input_array_arg!(buf);
output_array_arg!(splats);
return_send!(via ocvrs_return);
unsafe { sys::cv_decodeGaussianSplatsPacked_const__InputArrayR_const__OutputArrayR(buf.as_raw__InputArray(), splats.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn decode_gaussian_splats(attributes: &impl ToInputArray, splats: &mut impl ToOutputArray) -> Result<()> {
input_array_arg!(attributes);
output_array_arg!(splats);
return_send!(via ocvrs_return);
unsafe { sys::cv_decodeGaussianSplats_const__InputArrayR_const__OutputArrayR(attributes.as_raw__InputArray(), splats.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn depth_to3d_sparse(depth: &impl ToInputArray, in_k: &impl ToInputArray, in_points: &impl ToInputArray, points3d: &mut impl ToOutputArray) -> Result<()> {
input_array_arg!(depth);
input_array_arg!(in_k);
input_array_arg!(in_points);
output_array_arg!(points3d);
return_send!(via ocvrs_return);
unsafe { sys::cv_depthTo3dSparse_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR(depth.as_raw__InputArray(), in_k.as_raw__InputArray(), in_points.as_raw__InputArray(), points3d.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn depth_to3d_def(depth: &impl ToInputArray, k: &impl ToInputArray, points3d: &mut impl ToOutputArray) -> Result<()> {
input_array_arg!(depth);
input_array_arg!(k);
output_array_arg!(points3d);
return_send!(via ocvrs_return);
unsafe { sys::cv_depthTo3d_const__InputArrayR_const__InputArrayR_const__OutputArrayR(depth.as_raw__InputArray(), k.as_raw__InputArray(), points3d.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn depth_to3d(depth: &impl ToInputArray, k: &impl ToInputArray, points3d: &mut impl ToOutputArray, mask: &impl ToInputArray) -> Result<()> {
input_array_arg!(depth);
input_array_arg!(k);
output_array_arg!(points3d);
input_array_arg!(mask);
return_send!(via ocvrs_return);
unsafe { sys::cv_depthTo3d_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__InputArrayR(depth.as_raw__InputArray(), k.as_raw__InputArray(), points3d.as_raw__OutputArray(), mask.as_raw__InputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn estimate_median_spacing(input_cloud: &impl ToInputArray) -> Result<f32> {
input_array_arg!(input_cloud);
return_send!(via ocvrs_return);
unsafe { sys::cv_estimateMedianSpacing_const__InputArrayR(input_cloud.as_raw__InputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn find_planes_def(points3d: &impl ToInputArray, normals: &impl ToInputArray, mask: &mut impl ToOutputArray, plane_coefficients: &mut impl ToOutputArray) -> Result<()> {
input_array_arg!(points3d);
input_array_arg!(normals);
output_array_arg!(mask);
output_array_arg!(plane_coefficients);
return_send!(via ocvrs_return);
unsafe { sys::cv_findPlanes_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(points3d.as_raw__InputArray(), normals.as_raw__InputArray(), mask.as_raw__OutputArray(), plane_coefficients.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn find_planes(points3d: &impl ToInputArray, normals: &impl ToInputArray, mask: &mut impl ToOutputArray, plane_coefficients: &mut impl ToOutputArray, block_size: i32, min_size: i32, threshold: f64, sensor_error_a: f64, sensor_error_b: f64, sensor_error_c: f64, method: crate::ptcloud::RgbdPlaneMethod) -> Result<()> {
input_array_arg!(points3d);
input_array_arg!(normals);
output_array_arg!(mask);
output_array_arg!(plane_coefficients);
return_send!(via ocvrs_return);
unsafe { sys::cv_findPlanes_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_int_int_double_double_double_double_RgbdPlaneMethod(points3d.as_raw__InputArray(), normals.as_raw__InputArray(), mask.as_raw__OutputArray(), plane_coefficients.as_raw__OutputArray(), block_size, min_size, threshold, sensor_error_a, sensor_error_b, sensor_error_c, method, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn get_gaussian_splat_ply_prop_names() -> Result<core::Vector<String>> {
return_send!(via ocvrs_return);
unsafe { sys::cv_getGaussianSplatPlyPropNames(ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
let ret = unsafe { core::Vector::<String>::opencv_from_extern(ret) };
Ok(ret)
}
#[inline]
pub fn load_gaussian_splats_def(filename: impl AsRef<OsStr>, splats: &mut impl ToOutputArray) -> Result<()> {
path_arg!(filename);
output_array_arg!(splats);
return_send!(via ocvrs_return);
unsafe { sys::cv_loadGaussianSplats_const_StringR_const__OutputArrayR(filename.opencv_as_extern(), splats.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn load_gaussian_splats(filename: impl AsRef<OsStr>, splats: &mut impl ToOutputArray, ply_properties: &core::Vector<String>) -> Result<()> {
path_arg!(filename);
output_array_arg!(splats);
return_send!(via ocvrs_return);
unsafe { sys::cv_loadGaussianSplats_const_StringR_const__OutputArrayR_const_vectorLStringGR(filename.opencv_as_extern(), splats.as_raw__OutputArray(), ply_properties.as_raw_VectorOfString(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn load_mesh_def(filename: impl AsRef<OsStr>, vertices: &mut impl ToOutputArray, indices: &mut impl ToOutputArray) -> Result<()> {
path_arg!(filename);
output_array_arg!(vertices);
output_array_arg!(indices);
return_send!(via ocvrs_return);
unsafe { sys::cv_loadMesh_const_StringR_const__OutputArrayR_const__OutputArrayR(filename.opencv_as_extern(), vertices.as_raw__OutputArray(), indices.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn load_mesh(filename: impl AsRef<OsStr>, vertices: &mut impl ToOutputArray, indices: &mut impl ToOutputArray, normals: &mut impl ToOutputArray, colors: &mut impl ToOutputArray, tex_coords: &mut impl ToOutputArray) -> Result<()> {
path_arg!(filename);
output_array_arg!(vertices);
output_array_arg!(indices);
output_array_arg!(normals);
output_array_arg!(colors);
output_array_arg!(tex_coords);
return_send!(via ocvrs_return);
unsafe { sys::cv_loadMesh_const_StringR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(filename.opencv_as_extern(), vertices.as_raw__OutputArray(), indices.as_raw__OutputArray(), normals.as_raw__OutputArray(), colors.as_raw__OutputArray(), tex_coords.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn load_point_cloud_def(filename: impl AsRef<OsStr>, vertices: &mut impl ToOutputArray) -> Result<()> {
path_arg!(filename);
output_array_arg!(vertices);
return_send!(via ocvrs_return);
unsafe { sys::cv_loadPointCloud_const_StringR_const__OutputArrayR(filename.opencv_as_extern(), vertices.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn load_point_cloud(filename: impl AsRef<OsStr>, vertices: &mut impl ToOutputArray, normals: &mut impl ToOutputArray, rgb: &mut impl ToOutputArray) -> Result<()> {
path_arg!(filename);
output_array_arg!(vertices);
output_array_arg!(normals);
output_array_arg!(rgb);
return_send!(via ocvrs_return);
unsafe { sys::cv_loadPointCloud_const_StringR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(filename.opencv_as_extern(), vertices.as_raw__OutputArray(), normals.as_raw__OutputArray(), rgb.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn orient_normals_consistent_def(input_cloud: &impl ToInputArray, normals: &mut impl ToInputOutputArray) -> Result<()> {
input_array_arg!(input_cloud);
input_output_array_arg!(normals);
return_send!(via ocvrs_return);
unsafe { sys::cv_orientNormalsConsistent_const__InputArrayR_const__InputOutputArrayR(input_cloud.as_raw__InputArray(), normals.as_raw__InputOutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn orient_normals_consistent(input_cloud: &impl ToInputArray, normals: &mut impl ToInputOutputArray, k: i32) -> Result<()> {
input_array_arg!(input_cloud);
input_output_array_arg!(normals);
return_send!(via ocvrs_return);
unsafe { sys::cv_orientNormalsConsistent_const__InputArrayR_const__InputOutputArrayR_int(input_cloud.as_raw__InputArray(), normals.as_raw__InputOutputArray(), k, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn orient_normals(input_cloud: &impl ToInputArray, normals: &mut impl ToInputOutputArray, viewpoint: core::Point3f) -> Result<()> {
input_array_arg!(input_cloud);
input_output_array_arg!(normals);
return_send!(via ocvrs_return);
unsafe { sys::cv_orientNormals_const__InputArrayR_const__InputOutputArrayR_const_Point3fR(input_cloud.as_raw__InputArray(), normals.as_raw__InputOutputArray(), &viewpoint, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn oriented_bounding_box_3d(input_cloud: &impl ToInputArray, center: &mut impl ToOutputArray, axes: &mut impl ToOutputArray, half_extents: &mut impl ToOutputArray) -> Result<()> {
input_array_arg!(input_cloud);
output_array_arg!(center);
output_array_arg!(axes);
output_array_arg!(half_extents);
return_send!(via ocvrs_return);
unsafe { sys::cv_orientedBoundingBox3D_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(input_cloud.as_raw__InputArray(), center.as_raw__OutputArray(), axes.as_raw__OutputArray(), half_extents.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn register_depth_def(unregistered_camera_matrix: &impl ToInputArray, registered_camera_matrix: &impl ToInputArray, registered_dist_coeffs: &impl ToInputArray, rt: &impl ToInputArray, unregistered_depth: &impl ToInputArray, output_image_plane_size: core::Size, registered_depth: &mut impl ToOutputArray) -> Result<()> {
input_array_arg!(unregistered_camera_matrix);
input_array_arg!(registered_camera_matrix);
input_array_arg!(registered_dist_coeffs);
input_array_arg!(rt);
input_array_arg!(unregistered_depth);
output_array_arg!(registered_depth);
return_send!(via ocvrs_return);
unsafe { sys::cv_registerDepth_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const_SizeR_const__OutputArrayR(unregistered_camera_matrix.as_raw__InputArray(), registered_camera_matrix.as_raw__InputArray(), registered_dist_coeffs.as_raw__InputArray(), rt.as_raw__InputArray(), unregistered_depth.as_raw__InputArray(), &output_image_plane_size, registered_depth.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn register_depth(unregistered_camera_matrix: &impl ToInputArray, registered_camera_matrix: &impl ToInputArray, registered_dist_coeffs: &impl ToInputArray, rt: &impl ToInputArray, unregistered_depth: &impl ToInputArray, output_image_plane_size: core::Size, registered_depth: &mut impl ToOutputArray, depth_dilation: bool) -> Result<()> {
input_array_arg!(unregistered_camera_matrix);
input_array_arg!(registered_camera_matrix);
input_array_arg!(registered_dist_coeffs);
input_array_arg!(rt);
input_array_arg!(unregistered_depth);
output_array_arg!(registered_depth);
return_send!(via ocvrs_return);
unsafe { sys::cv_registerDepth_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const_SizeR_const__OutputArrayR_bool(unregistered_camera_matrix.as_raw__InputArray(), registered_camera_matrix.as_raw__InputArray(), registered_dist_coeffs.as_raw__InputArray(), rt.as_raw__InputArray(), unregistered_depth.as_raw__InputArray(), &output_image_plane_size, registered_depth.as_raw__OutputArray(), depth_dilation, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn remove_radius_outliers_def(input_cloud: &impl ToInputArray, output_cloud: &mut impl ToOutputArray, radius: f64) -> Result<()> {
input_array_arg!(input_cloud);
output_array_arg!(output_cloud);
return_send!(via ocvrs_return);
unsafe { sys::cv_removeRadiusOutliers_const__InputArrayR_const__OutputArrayR_double(input_cloud.as_raw__InputArray(), output_cloud.as_raw__OutputArray(), radius, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn remove_radius_outliers(input_cloud: &impl ToInputArray, output_cloud: &mut impl ToOutputArray, radius: f64, min_neighbors: i32, kept_indices: &mut impl ToOutputArray) -> Result<()> {
input_array_arg!(input_cloud);
output_array_arg!(output_cloud);
output_array_arg!(kept_indices);
return_send!(via ocvrs_return);
unsafe { sys::cv_removeRadiusOutliers_const__InputArrayR_const__OutputArrayR_double_int_const__OutputArrayR(input_cloud.as_raw__InputArray(), output_cloud.as_raw__OutputArray(), radius, min_neighbors, kept_indices.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn remove_statistical_outliers_def(input_cloud: &impl ToInputArray, output_cloud: &mut impl ToOutputArray) -> Result<()> {
input_array_arg!(input_cloud);
output_array_arg!(output_cloud);
return_send!(via ocvrs_return);
unsafe { sys::cv_removeStatisticalOutliers_const__InputArrayR_const__OutputArrayR(input_cloud.as_raw__InputArray(), output_cloud.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn remove_statistical_outliers(input_cloud: &impl ToInputArray, output_cloud: &mut impl ToOutputArray, mean_k: i32, stddev_mul_thresh: f64, kept_indices: &mut impl ToOutputArray) -> Result<()> {
input_array_arg!(input_cloud);
output_array_arg!(output_cloud);
output_array_arg!(kept_indices);
return_send!(via ocvrs_return);
unsafe { sys::cv_removeStatisticalOutliers_const__InputArrayR_const__OutputArrayR_int_double_const__OutputArrayR(input_cloud.as_raw__InputArray(), output_cloud.as_raw__OutputArray(), mean_k, stddev_mul_thresh, kept_indices.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn rescale_depth_def(in_: &impl ToInputArray, typ: i32, out: &mut impl ToOutputArray) -> Result<()> {
input_array_arg!(in_);
output_array_arg!(out);
return_send!(via ocvrs_return);
unsafe { sys::cv_rescaleDepth_const__InputArrayR_int_const__OutputArrayR(in_.as_raw__InputArray(), typ, out.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn rescale_depth(in_: &impl ToInputArray, typ: i32, out: &mut impl ToOutputArray, depth_factor: f64) -> Result<()> {
input_array_arg!(in_);
output_array_arg!(out);
return_send!(via ocvrs_return);
unsafe { sys::cv_rescaleDepth_const__InputArrayR_int_const__OutputArrayR_double(in_.as_raw__InputArray(), typ, out.as_raw__OutputArray(), depth_factor, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn save_mesh_def(filename: impl AsRef<OsStr>, vertices: &impl ToInputArray, indices: &impl ToInputArray) -> Result<()> {
path_arg!(filename);
input_array_arg!(vertices);
input_array_arg!(indices);
return_send!(via ocvrs_return);
unsafe { sys::cv_saveMesh_const_StringR_const__InputArrayR_const__InputArrayR(filename.opencv_as_extern(), vertices.as_raw__InputArray(), indices.as_raw__InputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn save_mesh(filename: impl AsRef<OsStr>, vertices: &impl ToInputArray, indices: &impl ToInputArray, normals: &impl ToInputArray, colors: &impl ToInputArray, tex_coords: &impl ToInputArray) -> Result<()> {
path_arg!(filename);
input_array_arg!(vertices);
input_array_arg!(indices);
input_array_arg!(normals);
input_array_arg!(colors);
input_array_arg!(tex_coords);
return_send!(via ocvrs_return);
unsafe { sys::cv_saveMesh_const_StringR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR(filename.opencv_as_extern(), vertices.as_raw__InputArray(), indices.as_raw__InputArray(), normals.as_raw__InputArray(), colors.as_raw__InputArray(), tex_coords.as_raw__InputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn save_point_cloud_def(filename: impl AsRef<OsStr>, vertices: &impl ToInputArray) -> Result<()> {
path_arg!(filename);
input_array_arg!(vertices);
return_send!(via ocvrs_return);
unsafe { sys::cv_savePointCloud_const_StringR_const__InputArrayR(filename.opencv_as_extern(), vertices.as_raw__InputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn save_point_cloud(filename: impl AsRef<OsStr>, vertices: &impl ToInputArray, normals: &impl ToInputArray, rgb: &impl ToInputArray) -> Result<()> {
path_arg!(filename);
input_array_arg!(vertices);
input_array_arg!(normals);
input_array_arg!(rgb);
return_send!(via ocvrs_return);
unsafe { sys::cv_savePointCloud_const_StringR_const__InputArrayR_const__InputArrayR_const__InputArrayR(filename.opencv_as_extern(), vertices.as_raw__InputArray(), normals.as_raw__InputArray(), rgb.as_raw__InputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn triangle_rasterize_color_def(vertices: &impl ToInputArray, indices: &impl ToInputArray, colors: &impl ToInputArray, color_buf: &mut impl ToInputOutputArray, world2cam: &impl ToInputArray, fov_y: f64, z_near: f64, z_far: f64) -> Result<()> {
input_array_arg!(vertices);
input_array_arg!(indices);
input_array_arg!(colors);
input_output_array_arg!(color_buf);
input_array_arg!(world2cam);
return_send!(via ocvrs_return);
unsafe { sys::cv_triangleRasterizeColor_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__InputArrayR_double_double_double(vertices.as_raw__InputArray(), indices.as_raw__InputArray(), colors.as_raw__InputArray(), color_buf.as_raw__InputOutputArray(), world2cam.as_raw__InputArray(), fov_y, z_near, z_far, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn triangle_rasterize_color(vertices: &impl ToInputArray, indices: &impl ToInputArray, colors: &impl ToInputArray, color_buf: &mut impl ToInputOutputArray, world2cam: &impl ToInputArray, fov_y: f64, z_near: f64, z_far: f64, settings: crate::ptcloud::TriangleRasterizeSettings) -> Result<()> {
input_array_arg!(vertices);
input_array_arg!(indices);
input_array_arg!(colors);
input_output_array_arg!(color_buf);
input_array_arg!(world2cam);
return_send!(via ocvrs_return);
unsafe { sys::cv_triangleRasterizeColor_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__InputArrayR_double_double_double_const_TriangleRasterizeSettingsR(vertices.as_raw__InputArray(), indices.as_raw__InputArray(), colors.as_raw__InputArray(), color_buf.as_raw__InputOutputArray(), world2cam.as_raw__InputArray(), fov_y, z_near, z_far, &settings, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn triangle_rasterize_depth_def(vertices: &impl ToInputArray, indices: &impl ToInputArray, depth_buf: &mut impl ToInputOutputArray, world2cam: &impl ToInputArray, fov_y: f64, z_near: f64, z_far: f64) -> Result<()> {
input_array_arg!(vertices);
input_array_arg!(indices);
input_output_array_arg!(depth_buf);
input_array_arg!(world2cam);
return_send!(via ocvrs_return);
unsafe { sys::cv_triangleRasterizeDepth_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__InputArrayR_double_double_double(vertices.as_raw__InputArray(), indices.as_raw__InputArray(), depth_buf.as_raw__InputOutputArray(), world2cam.as_raw__InputArray(), fov_y, z_near, z_far, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn triangle_rasterize_depth(vertices: &impl ToInputArray, indices: &impl ToInputArray, depth_buf: &mut impl ToInputOutputArray, world2cam: &impl ToInputArray, fov_y: f64, z_near: f64, z_far: f64, settings: crate::ptcloud::TriangleRasterizeSettings) -> Result<()> {
input_array_arg!(vertices);
input_array_arg!(indices);
input_output_array_arg!(depth_buf);
input_array_arg!(world2cam);
return_send!(via ocvrs_return);
unsafe { sys::cv_triangleRasterizeDepth_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__InputArrayR_double_double_double_const_TriangleRasterizeSettingsR(vertices.as_raw__InputArray(), indices.as_raw__InputArray(), depth_buf.as_raw__InputOutputArray(), world2cam.as_raw__InputArray(), fov_y, z_near, z_far, &settings, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn triangle_rasterize_def(vertices: &impl ToInputArray, indices: &impl ToInputArray, colors: &impl ToInputArray, color_buf: &mut impl ToInputOutputArray, depth_buf: &mut impl ToInputOutputArray, world2cam: &impl ToInputArray, fov_y: f64, z_near: f64, z_far: f64) -> Result<()> {
input_array_arg!(vertices);
input_array_arg!(indices);
input_array_arg!(colors);
input_output_array_arg!(color_buf);
input_output_array_arg!(depth_buf);
input_array_arg!(world2cam);
return_send!(via ocvrs_return);
unsafe { sys::cv_triangleRasterize_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__InputOutputArrayR_const__InputArrayR_double_double_double(vertices.as_raw__InputArray(), indices.as_raw__InputArray(), colors.as_raw__InputArray(), color_buf.as_raw__InputOutputArray(), depth_buf.as_raw__InputOutputArray(), world2cam.as_raw__InputArray(), fov_y, z_near, z_far, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn triangle_rasterize(vertices: &impl ToInputArray, indices: &impl ToInputArray, colors: &impl ToInputArray, color_buf: &mut impl ToInputOutputArray, depth_buf: &mut impl ToInputOutputArray, world2cam: &impl ToInputArray, fov_y: f64, z_near: f64, z_far: f64, settings: crate::ptcloud::TriangleRasterizeSettings) -> Result<()> {
input_array_arg!(vertices);
input_array_arg!(indices);
input_array_arg!(colors);
input_output_array_arg!(color_buf);
input_output_array_arg!(depth_buf);
input_array_arg!(world2cam);
return_send!(via ocvrs_return);
unsafe { sys::cv_triangleRasterize_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__InputOutputArrayR_const__InputArrayR_double_double_double_const_TriangleRasterizeSettingsR(vertices.as_raw__InputArray(), indices.as_raw__InputArray(), colors.as_raw__InputArray(), color_buf.as_raw__InputOutputArray(), depth_buf.as_raw__InputOutputArray(), world2cam.as_raw__InputArray(), fov_y, z_near, z_far, &settings, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn destroy_object(win_name: &str, obj_name: &str) -> Result<()> {
extern_container_arg!(win_name);
extern_container_arg!(obj_name);
return_send!(via ocvrs_return);
unsafe { sys::cv_viz3d_destroyObject_const_StringR_const_StringR(win_name.opencv_as_extern(), obj_name.opencv_as_extern(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn set_grid_visible(win_name: &str, visible: bool) -> Result<()> {
extern_container_arg!(win_name);
return_send!(via ocvrs_return);
unsafe { sys::cv_viz3d_setGridVisible_const_StringR_bool(win_name.opencv_as_extern(), visible, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn set_object_position(win_name: &str, obj_name: &str, position: core::Vec3f) -> Result<()> {
extern_container_arg!(win_name);
extern_container_arg!(obj_name);
return_send!(via ocvrs_return);
unsafe { sys::cv_viz3d_setObjectPosition_const_StringR_const_StringR_const_Vec3fR(win_name.opencv_as_extern(), obj_name.opencv_as_extern(), &position, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn set_object_rotation(win_name: &str, obj_name: &str, rotation: core::Vec3f) -> Result<()> {
extern_container_arg!(win_name);
extern_container_arg!(obj_name);
return_send!(via ocvrs_return);
unsafe { sys::cv_viz3d_setObjectRotation_const_StringR_const_StringR_const_Vec3fR(win_name.opencv_as_extern(), obj_name.opencv_as_extern(), &rotation, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn set_perspective(win_name: &str, fov: f32, z_near: f32, z_far: f32) -> Result<()> {
extern_container_arg!(win_name);
return_send!(via ocvrs_return);
unsafe { sys::cv_viz3d_setPerspective_const_StringR_float_float_float(win_name.opencv_as_extern(), fov, z_near, z_far, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn set_sky(win_name: &str, color: core::Vec3f) -> Result<()> {
extern_container_arg!(win_name);
return_send!(via ocvrs_return);
unsafe { sys::cv_viz3d_setSky_const_StringR_const_Vec3fR(win_name.opencv_as_extern(), &color, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn set_sun(win_name: &str, direction: core::Vec3f, ambient: core::Vec3f, diffuse: core::Vec3f) -> Result<()> {
extern_container_arg!(win_name);
return_send!(via ocvrs_return);
unsafe { sys::cv_viz3d_setSun_const_StringR_const_Vec3fR_const_Vec3fR_const_Vec3fR(win_name.opencv_as_extern(), &direction, &ambient, &diffuse, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn show_box_def(win_name: &str, obj_name: &str, size: core::Vec3f, color: core::Vec3f) -> Result<()> {
extern_container_arg!(win_name);
extern_container_arg!(obj_name);
return_send!(via ocvrs_return);
unsafe { sys::cv_viz3d_showBox_const_StringR_const_StringR_const_Vec3fR_const_Vec3fR(win_name.opencv_as_extern(), obj_name.opencv_as_extern(), &size, &color, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn show_box(win_name: &str, obj_name: &str, size: core::Vec3f, color: core::Vec3f, mode: crate::ptcloud::RenderMode) -> Result<()> {
extern_container_arg!(win_name);
extern_container_arg!(obj_name);
return_send!(via ocvrs_return);
unsafe { sys::cv_viz3d_showBox_const_StringR_const_StringR_const_Vec3fR_const_Vec3fR_RenderMode(win_name.opencv_as_extern(), obj_name.opencv_as_extern(), &size, &color, mode, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn show_camera_trajectory_def(win_name: &str, obj_name: &str, trajectory: &impl ToInputArray, aspect: f32, scale: f32) -> Result<()> {
extern_container_arg!(win_name);
extern_container_arg!(obj_name);
input_array_arg!(trajectory);
return_send!(via ocvrs_return);
unsafe { sys::cv_viz3d_showCameraTrajectory_const_StringR_const_StringR_const__InputArrayR_float_float(win_name.opencv_as_extern(), obj_name.opencv_as_extern(), trajectory.as_raw__InputArray(), aspect, scale, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn show_camera_trajectory(win_name: &str, obj_name: &str, trajectory: &impl ToInputArray, aspect: f32, scale: f32, frustum_color: core::Vec3f, line_color: core::Vec3f) -> Result<()> {
extern_container_arg!(win_name);
extern_container_arg!(obj_name);
input_array_arg!(trajectory);
return_send!(via ocvrs_return);
unsafe { sys::cv_viz3d_showCameraTrajectory_const_StringR_const_StringR_const__InputArrayR_float_float_Vec3f_Vec3f(win_name.opencv_as_extern(), obj_name.opencv_as_extern(), trajectory.as_raw__InputArray(), aspect, scale, &frustum_color, &line_color, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn show_gaussian_splats(win_name: &str, obj_name: &str, splats: &impl ToInputArray) -> Result<()> {
extern_container_arg!(win_name);
extern_container_arg!(obj_name);
input_array_arg!(splats);
return_send!(via ocvrs_return);
unsafe { sys::cv_viz3d_showGaussianSplats_const_StringR_const_StringR_const__InputArrayR(win_name.opencv_as_extern(), obj_name.opencv_as_extern(), splats.as_raw__InputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn show_lines(win_name: &str, obj_name: &str, points: &impl ToInputArray) -> Result<()> {
extern_container_arg!(win_name);
extern_container_arg!(obj_name);
input_array_arg!(points);
return_send!(via ocvrs_return);
unsafe { sys::cv_viz3d_showLines_const_StringR_const_StringR_const__InputArrayR(win_name.opencv_as_extern(), obj_name.opencv_as_extern(), points.as_raw__InputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn show_mesh2(win_name: &str, obj_name: &str, verts: &impl ToInputArray) -> Result<()> {
extern_container_arg!(win_name);
extern_container_arg!(obj_name);
input_array_arg!(verts);
return_send!(via ocvrs_return);
unsafe { sys::cv_viz3d_showMesh_const_StringR_const_StringR_const__InputArrayR(win_name.opencv_as_extern(), obj_name.opencv_as_extern(), verts.as_raw__InputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn show_mesh(win_name: &str, obj_name: &str, verts: &impl ToInputArray, indices: &impl ToInputArray) -> Result<()> {
extern_container_arg!(win_name);
extern_container_arg!(obj_name);
input_array_arg!(verts);
input_array_arg!(indices);
return_send!(via ocvrs_return);
unsafe { sys::cv_viz3d_showMesh_const_StringR_const_StringR_const__InputArrayR_const__InputArrayR(win_name.opencv_as_extern(), obj_name.opencv_as_extern(), verts.as_raw__InputArray(), indices.as_raw__InputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn show_plane_def(win_name: &str, obj_name: &str, size: core::Vec2f, color: core::Vec3f) -> Result<()> {
extern_container_arg!(win_name);
extern_container_arg!(obj_name);
return_send!(via ocvrs_return);
unsafe { sys::cv_viz3d_showPlane_const_StringR_const_StringR_const_Vec2fR_const_Vec3fR(win_name.opencv_as_extern(), obj_name.opencv_as_extern(), &size, &color, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn show_plane(win_name: &str, obj_name: &str, size: core::Vec2f, color: core::Vec3f, mode: crate::ptcloud::RenderMode) -> Result<()> {
extern_container_arg!(win_name);
extern_container_arg!(obj_name);
return_send!(via ocvrs_return);
unsafe { sys::cv_viz3d_showPlane_const_StringR_const_StringR_const_Vec2fR_const_Vec3fR_RenderMode(win_name.opencv_as_extern(), obj_name.opencv_as_extern(), &size, &color, mode, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn show_points(win_name: &str, obj_name: &str, points: &impl ToInputArray) -> Result<()> {
extern_container_arg!(win_name);
extern_container_arg!(obj_name);
input_array_arg!(points);
return_send!(via ocvrs_return);
unsafe { sys::cv_viz3d_showPoints_const_StringR_const_StringR_const__InputArrayR(win_name.opencv_as_extern(), obj_name.opencv_as_extern(), points.as_raw__InputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn show_rgbd_def(win_name: &str, obj_name: &str, img: &impl ToInputArray, intrinsics: core::Matx33f) -> Result<()> {
extern_container_arg!(win_name);
extern_container_arg!(obj_name);
input_array_arg!(img);
return_send!(via ocvrs_return);
unsafe { sys::cv_viz3d_showRGBD_const_StringR_const_StringR_const__InputArrayR_const_Matx33fR(win_name.opencv_as_extern(), obj_name.opencv_as_extern(), img.as_raw__InputArray(), &intrinsics, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn show_rgbd(win_name: &str, obj_name: &str, img: &impl ToInputArray, intrinsics: core::Matx33f, scale: f32) -> Result<()> {
extern_container_arg!(win_name);
extern_container_arg!(obj_name);
input_array_arg!(img);
return_send!(via ocvrs_return);
unsafe { sys::cv_viz3d_showRGBD_const_StringR_const_StringR_const__InputArrayR_const_Matx33fR_float(win_name.opencv_as_extern(), obj_name.opencv_as_extern(), img.as_raw__InputArray(), &intrinsics, scale, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn show_sphere_def(win_name: &str, obj_name: &str, radius: f32, color: core::Vec3f) -> Result<()> {
extern_container_arg!(win_name);
extern_container_arg!(obj_name);
return_send!(via ocvrs_return);
unsafe { sys::cv_viz3d_showSphere_const_StringR_const_StringR_float_const_Vec3fR(win_name.opencv_as_extern(), obj_name.opencv_as_extern(), radius, &color, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn show_sphere(win_name: &str, obj_name: &str, radius: f32, color: core::Vec3f, mode: crate::ptcloud::RenderMode, divs: i32) -> Result<()> {
extern_container_arg!(win_name);
extern_container_arg!(obj_name);
return_send!(via ocvrs_return);
unsafe { sys::cv_viz3d_showSphere_const_StringR_const_StringR_float_const_Vec3fR_RenderMode_int(win_name.opencv_as_extern(), obj_name.opencv_as_extern(), radius, &color, mode, divs, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn warp_frame_def(depth: &impl ToInputArray, image: &impl ToInputArray, mask: &impl ToInputArray, rt: &impl ToInputArray, camera_matrix: &impl ToInputArray) -> Result<()> {
input_array_arg!(depth);
input_array_arg!(image);
input_array_arg!(mask);
input_array_arg!(rt);
input_array_arg!(camera_matrix);
return_send!(via ocvrs_return);
unsafe { sys::cv_warpFrame_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR(depth.as_raw__InputArray(), image.as_raw__InputArray(), mask.as_raw__InputArray(), rt.as_raw__InputArray(), camera_matrix.as_raw__InputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn warp_frame(depth: &impl ToInputArray, image: &impl ToInputArray, mask: &impl ToInputArray, rt: &impl ToInputArray, camera_matrix: &impl ToInputArray, warped_depth: &mut impl ToOutputArray, warped_image: &mut impl ToOutputArray, warped_mask: &mut impl ToOutputArray) -> Result<()> {
input_array_arg!(depth);
input_array_arg!(image);
input_array_arg!(mask);
input_array_arg!(rt);
input_array_arg!(camera_matrix);
output_array_arg!(warped_depth);
output_array_arg!(warped_image);
output_array_arg!(warped_mask);
return_send!(via ocvrs_return);
unsafe { sys::cv_warpFrame_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(depth.as_raw__InputArray(), image.as_raw__InputArray(), mask.as_raw__InputArray(), rt.as_raw__InputArray(), camera_matrix.as_raw__InputArray(), warped_depth.as_raw__OutputArray(), warped_image.as_raw__OutputArray(), warped_mask.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
pub struct Octree {
ptr: *mut c_void,
}
opencv_type_boxed! { Octree }
impl Drop for Octree {
#[inline]
fn drop(&mut self) {
unsafe { sys::cv_Octree_delete(self.as_raw_mut_Octree()) };
}
}
unsafe impl Send for Octree {}
impl Octree {
#[inline]
pub fn default() -> Result<crate::ptcloud::Octree> {
return_send!(via ocvrs_return);
unsafe { sys::cv_Octree_Octree(ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
let ret = unsafe { crate::ptcloud::Octree::opencv_from_extern(ret) };
Ok(ret)
}
#[inline]
pub fn create_with_depth(max_depth: i32, size: f64, origin: core::Point3f, with_colors: bool) -> Result<core::Ptr<crate::ptcloud::Octree>> {
return_send!(via ocvrs_return);
unsafe { sys::cv_Octree_createWithDepth_int_double_const_Point3fR_bool(max_depth, size, &origin, with_colors, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
let ret = unsafe { core::Ptr::<crate::ptcloud::Octree>::opencv_from_extern(ret) };
Ok(ret)
}
#[inline]
pub fn create_with_depth_def(max_depth: i32, size: f64) -> Result<core::Ptr<crate::ptcloud::Octree>> {
return_send!(via ocvrs_return);
unsafe { sys::cv_Octree_createWithDepth_int_double(max_depth, size, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
let ret = unsafe { core::Ptr::<crate::ptcloud::Octree>::opencv_from_extern(ret) };
Ok(ret)
}
#[inline]
pub fn create_with_depth_1(max_depth: i32, point_cloud: &impl ToInputArray, colors: &impl ToInputArray) -> Result<core::Ptr<crate::ptcloud::Octree>> {
input_array_arg!(point_cloud);
input_array_arg!(colors);
return_send!(via ocvrs_return);
unsafe { sys::cv_Octree_createWithDepth_int_const__InputArrayR_const__InputArrayR(max_depth, point_cloud.as_raw__InputArray(), colors.as_raw__InputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
let ret = unsafe { core::Ptr::<crate::ptcloud::Octree>::opencv_from_extern(ret) };
Ok(ret)
}
#[inline]
pub fn create_with_depth_def_1(max_depth: i32, point_cloud: &impl ToInputArray) -> Result<core::Ptr<crate::ptcloud::Octree>> {
input_array_arg!(point_cloud);
return_send!(via ocvrs_return);
unsafe { sys::cv_Octree_createWithDepth_int_const__InputArrayR(max_depth, point_cloud.as_raw__InputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
let ret = unsafe { core::Ptr::<crate::ptcloud::Octree>::opencv_from_extern(ret) };
Ok(ret)
}
#[inline]
pub fn create_with_resolution(resolution: f64, size: f64, origin: core::Point3f, with_colors: bool) -> Result<core::Ptr<crate::ptcloud::Octree>> {
return_send!(via ocvrs_return);
unsafe { sys::cv_Octree_createWithResolution_double_double_const_Point3fR_bool(resolution, size, &origin, with_colors, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
let ret = unsafe { core::Ptr::<crate::ptcloud::Octree>::opencv_from_extern(ret) };
Ok(ret)
}
#[inline]
pub fn create_with_resolution_def(resolution: f64, size: f64) -> Result<core::Ptr<crate::ptcloud::Octree>> {
return_send!(via ocvrs_return);
unsafe { sys::cv_Octree_createWithResolution_double_double(resolution, size, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
let ret = unsafe { core::Ptr::<crate::ptcloud::Octree>::opencv_from_extern(ret) };
Ok(ret)
}
#[inline]
pub fn create_with_resolution_1(resolution: f64, point_cloud: &impl ToInputArray, colors: &impl ToInputArray) -> Result<core::Ptr<crate::ptcloud::Octree>> {
input_array_arg!(point_cloud);
input_array_arg!(colors);
return_send!(via ocvrs_return);
unsafe { sys::cv_Octree_createWithResolution_double_const__InputArrayR_const__InputArrayR(resolution, point_cloud.as_raw__InputArray(), colors.as_raw__InputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
let ret = unsafe { core::Ptr::<crate::ptcloud::Octree>::opencv_from_extern(ret) };
Ok(ret)
}
#[inline]
pub fn create_with_resolution_def_1(resolution: f64, point_cloud: &impl ToInputArray) -> Result<core::Ptr<crate::ptcloud::Octree>> {
input_array_arg!(point_cloud);
return_send!(via ocvrs_return);
unsafe { sys::cv_Octree_createWithResolution_double_const__InputArrayR(resolution, point_cloud.as_raw__InputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
let ret = unsafe { core::Ptr::<crate::ptcloud::Octree>::opencv_from_extern(ret) };
Ok(ret)
}
}
pub trait OctreeTraitConst {
fn as_raw_Octree(&self) -> *const c_void;
#[inline]
fn is_point_in_bound(&self, point: core::Point3f) -> Result<bool> {
return_send!(via ocvrs_return);
unsafe { sys::cv_Octree_isPointInBound_const_const_Point3fR(self.as_raw_Octree(), &point, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn empty(&self) -> Result<bool> {
return_send!(via ocvrs_return);
unsafe { sys::cv_Octree_empty_const(self.as_raw_Octree(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn radius_nn_search(&self, query: core::Point3f, radius: f32, points: &mut impl ToOutputArray, square_dists: &mut impl ToOutputArray) -> Result<i32> {
output_array_arg!(points);
output_array_arg!(square_dists);
return_send!(via ocvrs_return);
unsafe { sys::cv_Octree_radiusNNSearch_const_const_Point3fR_float_const__OutputArrayR_const__OutputArrayR(self.as_raw_Octree(), &query, radius, points.as_raw__OutputArray(), square_dists.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn radius_nn_search_def(&self, query: core::Point3f, radius: f32, points: &mut impl ToOutputArray) -> Result<i32> {
output_array_arg!(points);
return_send!(via ocvrs_return);
unsafe { sys::cv_Octree_radiusNNSearch_const_const_Point3fR_float_const__OutputArrayR(self.as_raw_Octree(), &query, radius, points.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn radius_nn_search_1(&self, query: core::Point3f, radius: f32, points: &mut impl ToOutputArray, colors: &mut impl ToOutputArray, square_dists: &mut impl ToOutputArray) -> Result<i32> {
output_array_arg!(points);
output_array_arg!(colors);
output_array_arg!(square_dists);
return_send!(via ocvrs_return);
unsafe { sys::cv_Octree_radiusNNSearch_const_const_Point3fR_float_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(self.as_raw_Octree(), &query, radius, points.as_raw__OutputArray(), colors.as_raw__OutputArray(), square_dists.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn knn_search(&self, query: core::Point3f, k: i32, points: &mut impl ToOutputArray, square_dists: &mut impl ToOutputArray) -> Result<()> {
output_array_arg!(points);
output_array_arg!(square_dists);
return_send!(via ocvrs_return);
unsafe { sys::cv_Octree_KNNSearch_const_const_Point3fR_const_int_const__OutputArrayR_const__OutputArrayR(self.as_raw_Octree(), &query, k, points.as_raw__OutputArray(), square_dists.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn knn_search_def(&self, query: core::Point3f, k: i32, points: &mut impl ToOutputArray) -> Result<()> {
output_array_arg!(points);
return_send!(via ocvrs_return);
unsafe { sys::cv_Octree_KNNSearch_const_const_Point3fR_const_int_const__OutputArrayR(self.as_raw_Octree(), &query, k, points.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn knn_search_1(&self, query: core::Point3f, k: i32, points: &mut impl ToOutputArray, colors: &mut impl ToOutputArray, square_dists: &mut impl ToOutputArray) -> Result<()> {
output_array_arg!(points);
output_array_arg!(colors);
output_array_arg!(square_dists);
return_send!(via ocvrs_return);
unsafe { sys::cv_Octree_KNNSearch_const_const_Point3fR_const_int_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(self.as_raw_Octree(), &query, k, points.as_raw__OutputArray(), colors.as_raw__OutputArray(), square_dists.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
}
pub trait OctreeTrait: crate::ptcloud::OctreeTraitConst {
fn as_raw_mut_Octree(&mut self) -> *mut c_void;
#[inline]
fn insert_point(&mut self, point: core::Point3f, color: core::Point3f) -> Result<bool> {
return_send!(via ocvrs_return);
unsafe { sys::cv_Octree_insertPoint_const_Point3fR_const_Point3fR(self.as_raw_mut_Octree(), &point, &color, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn insert_point_def(&mut self, point: core::Point3f) -> Result<bool> {
return_send!(via ocvrs_return);
unsafe { sys::cv_Octree_insertPoint_const_Point3fR(self.as_raw_mut_Octree(), &point, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn clear(&mut self) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_Octree_clear(self.as_raw_mut_Octree(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn delete_point(&mut self, point: core::Point3f) -> Result<bool> {
return_send!(via ocvrs_return);
unsafe { sys::cv_Octree_deletePoint_const_Point3fR(self.as_raw_mut_Octree(), &point, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_point_cloud_by_octree(&mut self, restored_point_cloud: &mut impl ToOutputArray, restored_color: &mut impl ToOutputArray) -> Result<()> {
output_array_arg!(restored_point_cloud);
output_array_arg!(restored_color);
return_send!(via ocvrs_return);
unsafe { sys::cv_Octree_getPointCloudByOctree_const__OutputArrayR_const__OutputArrayR(self.as_raw_mut_Octree(), restored_point_cloud.as_raw__OutputArray(), restored_color.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_point_cloud_by_octree_def(&mut self, restored_point_cloud: &mut impl ToOutputArray) -> Result<()> {
output_array_arg!(restored_point_cloud);
return_send!(via ocvrs_return);
unsafe { sys::cv_Octree_getPointCloudByOctree_const__OutputArrayR(self.as_raw_mut_Octree(), restored_point_cloud.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
}
impl fmt::Debug for Octree {
#[inline]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_struct("Octree")
.finish()
}
}
impl crate::ptcloud::OctreeTraitConst for Octree {
#[inline] fn as_raw_Octree(&self) -> *const c_void { self.as_raw() }
}
impl crate::ptcloud::OctreeTrait for Octree {
#[inline] fn as_raw_mut_Octree(&mut self) -> *mut c_void { self.as_raw_mut() }
}
boxed_ref! { Octree, crate::ptcloud::OctreeTraitConst, as_raw_Octree, crate::ptcloud::OctreeTrait, as_raw_mut_Octree }
pub struct Odometry {
ptr: *mut c_void,
}
opencv_type_boxed! { Odometry }
impl Drop for Odometry {
#[inline]
fn drop(&mut self) {
unsafe { sys::cv_Odometry_delete(self.as_raw_mut_Odometry()) };
}
}
unsafe impl Send for Odometry {}
impl Odometry {
#[inline]
pub fn default() -> Result<crate::ptcloud::Odometry> {
return_send!(via ocvrs_return);
unsafe { sys::cv_Odometry_Odometry(ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
let ret = unsafe { crate::ptcloud::Odometry::opencv_from_extern(ret) };
Ok(ret)
}
#[inline]
pub fn new(otype: crate::ptcloud::OdometryType) -> Result<crate::ptcloud::Odometry> {
return_send!(via ocvrs_return);
unsafe { sys::cv_Odometry_Odometry_OdometryType(otype, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
let ret = unsafe { crate::ptcloud::Odometry::opencv_from_extern(ret) };
Ok(ret)
}
#[inline]
pub fn new_1(otype: crate::ptcloud::OdometryType, settings: &impl crate::ptcloud::OdometrySettingsTraitConst, algtype: crate::ptcloud::OdometryAlgoType) -> Result<crate::ptcloud::Odometry> {
return_send!(via ocvrs_return);
unsafe { sys::cv_Odometry_Odometry_OdometryType_const_OdometrySettingsR_OdometryAlgoType(otype, settings.as_raw_OdometrySettings(), algtype, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
let ret = unsafe { crate::ptcloud::Odometry::opencv_from_extern(ret) };
Ok(ret)
}
}
pub trait OdometryTraitConst {
fn as_raw_Odometry(&self) -> *const c_void;
#[inline]
fn prepare_frame(&self, frame: &mut impl crate::ptcloud::OdometryFrameTrait) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_Odometry_prepareFrame_const_OdometryFrameR(self.as_raw_Odometry(), frame.as_raw_mut_OdometryFrame(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn prepare_frames(&self, src_frame: &mut impl crate::ptcloud::OdometryFrameTrait, dst_frame: &mut impl crate::ptcloud::OdometryFrameTrait) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_Odometry_prepareFrames_const_OdometryFrameR_OdometryFrameR(self.as_raw_Odometry(), src_frame.as_raw_mut_OdometryFrame(), dst_frame.as_raw_mut_OdometryFrame(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn compute(&self, src_frame: &impl crate::ptcloud::OdometryFrameTraitConst, dst_frame: &impl crate::ptcloud::OdometryFrameTraitConst, rt: &mut impl ToOutputArray) -> Result<bool> {
output_array_arg!(rt);
return_send!(via ocvrs_return);
unsafe { sys::cv_Odometry_compute_const_const_OdometryFrameR_const_OdometryFrameR_const__OutputArrayR(self.as_raw_Odometry(), src_frame.as_raw_OdometryFrame(), dst_frame.as_raw_OdometryFrame(), rt.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn compute_1(&self, src_depth: &impl ToInputArray, dst_depth: &impl ToInputArray, rt: &mut impl ToOutputArray) -> Result<bool> {
input_array_arg!(src_depth);
input_array_arg!(dst_depth);
output_array_arg!(rt);
return_send!(via ocvrs_return);
unsafe { sys::cv_Odometry_compute_const_const__InputArrayR_const__InputArrayR_const__OutputArrayR(self.as_raw_Odometry(), src_depth.as_raw__InputArray(), dst_depth.as_raw__InputArray(), rt.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn compute_2(&self, src_depth: &impl ToInputArray, src_rgb: &impl ToInputArray, dst_depth: &impl ToInputArray, dst_rgb: &impl ToInputArray, rt: &mut impl ToOutputArray) -> Result<bool> {
input_array_arg!(src_depth);
input_array_arg!(src_rgb);
input_array_arg!(dst_depth);
input_array_arg!(dst_rgb);
output_array_arg!(rt);
return_send!(via ocvrs_return);
unsafe { sys::cv_Odometry_compute_const_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR(self.as_raw_Odometry(), src_depth.as_raw__InputArray(), src_rgb.as_raw__InputArray(), dst_depth.as_raw__InputArray(), dst_rgb.as_raw__InputArray(), rt.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_normals_computer(&self) -> Result<core::Ptr<crate::ptcloud::RgbdNormals>> {
return_send!(via ocvrs_return);
unsafe { sys::cv_Odometry_getNormalsComputer_const(self.as_raw_Odometry(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
let ret = unsafe { core::Ptr::<crate::ptcloud::RgbdNormals>::opencv_from_extern(ret) };
Ok(ret)
}
}
pub trait OdometryTrait: crate::ptcloud::OdometryTraitConst {
fn as_raw_mut_Odometry(&mut self) -> *mut c_void;
}
impl fmt::Debug for Odometry {
#[inline]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_struct("Odometry")
.finish()
}
}
impl crate::ptcloud::OdometryTraitConst for Odometry {
#[inline] fn as_raw_Odometry(&self) -> *const c_void { self.as_raw() }
}
impl crate::ptcloud::OdometryTrait for Odometry {
#[inline] fn as_raw_mut_Odometry(&mut self) -> *mut c_void { self.as_raw_mut() }
}
boxed_ref! { Odometry, crate::ptcloud::OdometryTraitConst, as_raw_Odometry, crate::ptcloud::OdometryTrait, as_raw_mut_Odometry }
pub struct OdometryFrame {
ptr: *mut c_void,
}
opencv_type_boxed! { OdometryFrame }
impl Drop for OdometryFrame {
#[inline]
fn drop(&mut self) {
unsafe { sys::cv_OdometryFrame_delete(self.as_raw_mut_OdometryFrame()) };
}
}
unsafe impl Send for OdometryFrame {}
impl OdometryFrame {
#[inline]
pub fn new(depth: &impl ToInputArray, image: &impl ToInputArray, mask: &impl ToInputArray, normals: &impl ToInputArray) -> Result<crate::ptcloud::OdometryFrame> {
input_array_arg!(depth);
input_array_arg!(image);
input_array_arg!(mask);
input_array_arg!(normals);
return_send!(via ocvrs_return);
unsafe { sys::cv_OdometryFrame_OdometryFrame_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR(depth.as_raw__InputArray(), image.as_raw__InputArray(), mask.as_raw__InputArray(), normals.as_raw__InputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
let ret = unsafe { crate::ptcloud::OdometryFrame::opencv_from_extern(ret) };
Ok(ret)
}
#[inline]
pub fn new_def() -> Result<crate::ptcloud::OdometryFrame> {
return_send!(via ocvrs_return);
unsafe { sys::cv_OdometryFrame_OdometryFrame(ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
let ret = unsafe { crate::ptcloud::OdometryFrame::opencv_from_extern(ret) };
Ok(ret)
}
}
pub trait OdometryFrameTraitConst {
fn as_raw_OdometryFrame(&self) -> *const c_void;
#[inline]
fn get_image(&self, image: &mut impl ToOutputArray) -> Result<()> {
output_array_arg!(image);
return_send!(via ocvrs_return);
unsafe { sys::cv_OdometryFrame_getImage_const_const__OutputArrayR(self.as_raw_OdometryFrame(), image.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_gray_image(&self, image: &mut impl ToOutputArray) -> Result<()> {
output_array_arg!(image);
return_send!(via ocvrs_return);
unsafe { sys::cv_OdometryFrame_getGrayImage_const_const__OutputArrayR(self.as_raw_OdometryFrame(), image.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_depth(&self, depth: &mut impl ToOutputArray) -> Result<()> {
output_array_arg!(depth);
return_send!(via ocvrs_return);
unsafe { sys::cv_OdometryFrame_getDepth_const_const__OutputArrayR(self.as_raw_OdometryFrame(), depth.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_processed_depth(&self, depth: &mut impl ToOutputArray) -> Result<()> {
output_array_arg!(depth);
return_send!(via ocvrs_return);
unsafe { sys::cv_OdometryFrame_getProcessedDepth_const_const__OutputArrayR(self.as_raw_OdometryFrame(), depth.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_mask(&self, mask: &mut impl ToOutputArray) -> Result<()> {
output_array_arg!(mask);
return_send!(via ocvrs_return);
unsafe { sys::cv_OdometryFrame_getMask_const_const__OutputArrayR(self.as_raw_OdometryFrame(), mask.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_normals(&self, normals: &mut impl ToOutputArray) -> Result<()> {
output_array_arg!(normals);
return_send!(via ocvrs_return);
unsafe { sys::cv_OdometryFrame_getNormals_const_const__OutputArrayR(self.as_raw_OdometryFrame(), normals.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_pyramid_levels(&self) -> Result<i32> {
return_send!(via ocvrs_return);
unsafe { sys::cv_OdometryFrame_getPyramidLevels_const(self.as_raw_OdometryFrame(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_pyramid_at(&self, img: &mut impl ToOutputArray, pyr_type: crate::ptcloud::OdometryFramePyramidType, level: size_t) -> Result<()> {
output_array_arg!(img);
return_send!(via ocvrs_return);
unsafe { sys::cv_OdometryFrame_getPyramidAt_const_const__OutputArrayR_OdometryFramePyramidType_size_t(self.as_raw_OdometryFrame(), img.as_raw__OutputArray(), pyr_type, level, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
}
pub trait OdometryFrameTrait: crate::ptcloud::OdometryFrameTraitConst {
fn as_raw_mut_OdometryFrame(&mut self) -> *mut c_void;
}
impl Clone for OdometryFrame {
#[inline]
fn clone(&self) -> Self {
unsafe { Self::from_raw(sys::cv_OdometryFrame_implicitClone_const(self.as_raw_OdometryFrame())) }
}
}
impl fmt::Debug for OdometryFrame {
#[inline]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_struct("OdometryFrame")
.finish()
}
}
impl crate::ptcloud::OdometryFrameTraitConst for OdometryFrame {
#[inline] fn as_raw_OdometryFrame(&self) -> *const c_void { self.as_raw() }
}
impl crate::ptcloud::OdometryFrameTrait for OdometryFrame {
#[inline] fn as_raw_mut_OdometryFrame(&mut self) -> *mut c_void { self.as_raw_mut() }
}
boxed_ref! { OdometryFrame, crate::ptcloud::OdometryFrameTraitConst, as_raw_OdometryFrame, crate::ptcloud::OdometryFrameTrait, as_raw_mut_OdometryFrame }
pub struct OdometrySettings {
ptr: *mut c_void,
}
opencv_type_boxed! { OdometrySettings }
impl Drop for OdometrySettings {
#[inline]
fn drop(&mut self) {
unsafe { sys::cv_OdometrySettings_delete(self.as_raw_mut_OdometrySettings()) };
}
}
unsafe impl Send for OdometrySettings {}
impl OdometrySettings {
#[inline]
pub fn default() -> Result<crate::ptcloud::OdometrySettings> {
return_send!(via ocvrs_return);
unsafe { sys::cv_OdometrySettings_OdometrySettings(ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
let ret = unsafe { crate::ptcloud::OdometrySettings::opencv_from_extern(ret) };
Ok(ret)
}
#[inline]
pub fn copy(unnamed: &impl crate::ptcloud::OdometrySettingsTraitConst) -> Result<crate::ptcloud::OdometrySettings> {
return_send!(via ocvrs_return);
unsafe { sys::cv_OdometrySettings_OdometrySettings_const_OdometrySettingsR(unnamed.as_raw_OdometrySettings(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
let ret = unsafe { crate::ptcloud::OdometrySettings::opencv_from_extern(ret) };
Ok(ret)
}
}
pub trait OdometrySettingsTraitConst {
fn as_raw_OdometrySettings(&self) -> *const c_void;
#[inline]
fn get_camera_matrix(&self, val: &mut impl ToOutputArray) -> Result<()> {
output_array_arg!(val);
return_send!(via ocvrs_return);
unsafe { sys::cv_OdometrySettings_getCameraMatrix_const_const__OutputArrayR(self.as_raw_OdometrySettings(), val.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_iter_counts(&self, val: &mut impl ToOutputArray) -> Result<()> {
output_array_arg!(val);
return_send!(via ocvrs_return);
unsafe { sys::cv_OdometrySettings_getIterCounts_const_const__OutputArrayR(self.as_raw_OdometrySettings(), val.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_min_depth(&self) -> Result<f32> {
return_send!(via ocvrs_return);
unsafe { sys::cv_OdometrySettings_getMinDepth_const(self.as_raw_OdometrySettings(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_max_depth(&self) -> Result<f32> {
return_send!(via ocvrs_return);
unsafe { sys::cv_OdometrySettings_getMaxDepth_const(self.as_raw_OdometrySettings(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_max_depth_diff(&self) -> Result<f32> {
return_send!(via ocvrs_return);
unsafe { sys::cv_OdometrySettings_getMaxDepthDiff_const(self.as_raw_OdometrySettings(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_max_points_part(&self) -> Result<f32> {
return_send!(via ocvrs_return);
unsafe { sys::cv_OdometrySettings_getMaxPointsPart_const(self.as_raw_OdometrySettings(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_sobel_size(&self) -> Result<i32> {
return_send!(via ocvrs_return);
unsafe { sys::cv_OdometrySettings_getSobelSize_const(self.as_raw_OdometrySettings(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_sobel_scale(&self) -> Result<f64> {
return_send!(via ocvrs_return);
unsafe { sys::cv_OdometrySettings_getSobelScale_const(self.as_raw_OdometrySettings(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_normal_win_size(&self) -> Result<i32> {
return_send!(via ocvrs_return);
unsafe { sys::cv_OdometrySettings_getNormalWinSize_const(self.as_raw_OdometrySettings(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_normal_diff_threshold(&self) -> Result<f32> {
return_send!(via ocvrs_return);
unsafe { sys::cv_OdometrySettings_getNormalDiffThreshold_const(self.as_raw_OdometrySettings(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_normal_method(&self) -> Result<crate::ptcloud::RgbdNormals_RgbdNormalsMethod> {
return_send!(via ocvrs_return);
unsafe { sys::cv_OdometrySettings_getNormalMethod_const(self.as_raw_OdometrySettings(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_angle_threshold(&self) -> Result<f32> {
return_send!(via ocvrs_return);
unsafe { sys::cv_OdometrySettings_getAngleThreshold_const(self.as_raw_OdometrySettings(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_max_translation(&self) -> Result<f32> {
return_send!(via ocvrs_return);
unsafe { sys::cv_OdometrySettings_getMaxTranslation_const(self.as_raw_OdometrySettings(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_max_rotation(&self) -> Result<f32> {
return_send!(via ocvrs_return);
unsafe { sys::cv_OdometrySettings_getMaxRotation_const(self.as_raw_OdometrySettings(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_min_gradient_magnitude(&self) -> Result<f32> {
return_send!(via ocvrs_return);
unsafe { sys::cv_OdometrySettings_getMinGradientMagnitude_const(self.as_raw_OdometrySettings(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_min_gradient_magnitudes(&self, val: &mut impl ToOutputArray) -> Result<()> {
output_array_arg!(val);
return_send!(via ocvrs_return);
unsafe { sys::cv_OdometrySettings_getMinGradientMagnitudes_const_const__OutputArrayR(self.as_raw_OdometrySettings(), val.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
}
pub trait OdometrySettingsTrait: crate::ptcloud::OdometrySettingsTraitConst {
fn as_raw_mut_OdometrySettings(&mut self) -> *mut c_void;
#[inline]
fn set(&mut self, unnamed: &impl crate::ptcloud::OdometrySettingsTraitConst) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_OdometrySettings_operatorST_const_OdometrySettingsR(self.as_raw_mut_OdometrySettings(), unnamed.as_raw_OdometrySettings(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn set_camera_matrix(&mut self, val: &impl ToInputArray) -> Result<()> {
input_array_arg!(val);
return_send!(via ocvrs_return);
unsafe { sys::cv_OdometrySettings_setCameraMatrix_const__InputArrayR(self.as_raw_mut_OdometrySettings(), val.as_raw__InputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn set_iter_counts(&mut self, val: &impl ToInputArray) -> Result<()> {
input_array_arg!(val);
return_send!(via ocvrs_return);
unsafe { sys::cv_OdometrySettings_setIterCounts_const__InputArrayR(self.as_raw_mut_OdometrySettings(), val.as_raw__InputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn set_min_depth(&mut self, val: f32) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_OdometrySettings_setMinDepth_float(self.as_raw_mut_OdometrySettings(), val, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn set_max_depth(&mut self, val: f32) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_OdometrySettings_setMaxDepth_float(self.as_raw_mut_OdometrySettings(), val, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn set_max_depth_diff(&mut self, val: f32) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_OdometrySettings_setMaxDepthDiff_float(self.as_raw_mut_OdometrySettings(), val, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn set_max_points_part(&mut self, val: f32) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_OdometrySettings_setMaxPointsPart_float(self.as_raw_mut_OdometrySettings(), val, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn set_sobel_size(&mut self, val: i32) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_OdometrySettings_setSobelSize_int(self.as_raw_mut_OdometrySettings(), val, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn set_sobel_scale(&mut self, val: f64) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_OdometrySettings_setSobelScale_double(self.as_raw_mut_OdometrySettings(), val, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn set_normal_win_size(&mut self, val: i32) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_OdometrySettings_setNormalWinSize_int(self.as_raw_mut_OdometrySettings(), val, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn set_normal_diff_threshold(&mut self, val: f32) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_OdometrySettings_setNormalDiffThreshold_float(self.as_raw_mut_OdometrySettings(), val, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn set_normal_method(&mut self, nm: crate::ptcloud::RgbdNormals_RgbdNormalsMethod) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_OdometrySettings_setNormalMethod_RgbdNormalsMethod(self.as_raw_mut_OdometrySettings(), nm, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn set_angle_threshold(&mut self, val: f32) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_OdometrySettings_setAngleThreshold_float(self.as_raw_mut_OdometrySettings(), val, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn set_max_translation(&mut self, val: f32) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_OdometrySettings_setMaxTranslation_float(self.as_raw_mut_OdometrySettings(), val, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn set_max_rotation(&mut self, val: f32) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_OdometrySettings_setMaxRotation_float(self.as_raw_mut_OdometrySettings(), val, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn set_min_gradient_magnitude(&mut self, val: f32) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_OdometrySettings_setMinGradientMagnitude_float(self.as_raw_mut_OdometrySettings(), val, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn set_min_gradient_magnitudes(&mut self, val: &impl ToInputArray) -> Result<()> {
input_array_arg!(val);
return_send!(via ocvrs_return);
unsafe { sys::cv_OdometrySettings_setMinGradientMagnitudes_const__InputArrayR(self.as_raw_mut_OdometrySettings(), val.as_raw__InputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
}
impl Clone for OdometrySettings {
#[inline]
fn clone(&self) -> Self {
unsafe { Self::from_raw(sys::cv_OdometrySettings_implicitClone_const(self.as_raw_OdometrySettings())) }
}
}
impl fmt::Debug for OdometrySettings {
#[inline]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_struct("OdometrySettings")
.finish()
}
}
impl crate::ptcloud::OdometrySettingsTraitConst for OdometrySettings {
#[inline] fn as_raw_OdometrySettings(&self) -> *const c_void { self.as_raw() }
}
impl crate::ptcloud::OdometrySettingsTrait for OdometrySettings {
#[inline] fn as_raw_mut_OdometrySettings(&mut self) -> *mut c_void { self.as_raw_mut() }
}
boxed_ref! { OdometrySettings, crate::ptcloud::OdometrySettingsTraitConst, as_raw_OdometrySettings, crate::ptcloud::OdometrySettingsTrait, as_raw_mut_OdometrySettings }
pub struct RgbdNormals {
ptr: *mut c_void,
}
opencv_type_boxed! { RgbdNormals }
impl Drop for RgbdNormals {
#[inline]
fn drop(&mut self) {
unsafe { sys::cv_RgbdNormals_delete(self.as_raw_mut_RgbdNormals()) };
}
}
unsafe impl Send for RgbdNormals {}
impl RgbdNormals {
#[inline]
pub fn create(rows: i32, cols: i32, depth: i32, k: &impl ToInputArray, window_size: i32, diff_threshold: f32, method: crate::ptcloud::RgbdNormals_RgbdNormalsMethod) -> Result<core::Ptr<crate::ptcloud::RgbdNormals>> {
input_array_arg!(k);
return_send!(via ocvrs_return);
unsafe { sys::cv_RgbdNormals_create_int_int_int_const__InputArrayR_int_float_RgbdNormalsMethod(rows, cols, depth, k.as_raw__InputArray(), window_size, diff_threshold, method, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
let ret = unsafe { core::Ptr::<crate::ptcloud::RgbdNormals>::opencv_from_extern(ret) };
Ok(ret)
}
#[inline]
pub fn create_def() -> Result<core::Ptr<crate::ptcloud::RgbdNormals>> {
return_send!(via ocvrs_return);
unsafe { sys::cv_RgbdNormals_create(ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
let ret = unsafe { core::Ptr::<crate::ptcloud::RgbdNormals>::opencv_from_extern(ret) };
Ok(ret)
}
}
pub trait RgbdNormalsTraitConst {
fn as_raw_RgbdNormals(&self) -> *const c_void;
#[inline]
fn apply(&self, points: &impl ToInputArray, normals: &mut impl ToOutputArray) -> Result<()> {
input_array_arg!(points);
output_array_arg!(normals);
return_send!(via ocvrs_return);
unsafe { sys::cv_RgbdNormals_apply_const_const__InputArrayR_const__OutputArrayR(self.as_raw_RgbdNormals(), points.as_raw__InputArray(), normals.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn cache(&self) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_RgbdNormals_cache_const(self.as_raw_RgbdNormals(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_rows(&self) -> Result<i32> {
return_send!(via ocvrs_return);
unsafe { sys::cv_RgbdNormals_getRows_const(self.as_raw_RgbdNormals(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_cols(&self) -> Result<i32> {
return_send!(via ocvrs_return);
unsafe { sys::cv_RgbdNormals_getCols_const(self.as_raw_RgbdNormals(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_window_size(&self) -> Result<i32> {
return_send!(via ocvrs_return);
unsafe { sys::cv_RgbdNormals_getWindowSize_const(self.as_raw_RgbdNormals(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_depth(&self) -> Result<i32> {
return_send!(via ocvrs_return);
unsafe { sys::cv_RgbdNormals_getDepth_const(self.as_raw_RgbdNormals(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_k(&self, val: &mut impl ToOutputArray) -> Result<()> {
output_array_arg!(val);
return_send!(via ocvrs_return);
unsafe { sys::cv_RgbdNormals_getK_const_const__OutputArrayR(self.as_raw_RgbdNormals(), val.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_method(&self) -> Result<crate::ptcloud::RgbdNormals_RgbdNormalsMethod> {
return_send!(via ocvrs_return);
unsafe { sys::cv_RgbdNormals_getMethod_const(self.as_raw_RgbdNormals(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
}
pub trait RgbdNormalsTrait: crate::ptcloud::RgbdNormalsTraitConst {
fn as_raw_mut_RgbdNormals(&mut self) -> *mut c_void;
#[inline]
fn set_rows(&mut self, val: i32) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_RgbdNormals_setRows_int(self.as_raw_mut_RgbdNormals(), val, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn set_cols(&mut self, val: i32) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_RgbdNormals_setCols_int(self.as_raw_mut_RgbdNormals(), val, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn set_window_size(&mut self, val: i32) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_RgbdNormals_setWindowSize_int(self.as_raw_mut_RgbdNormals(), val, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn set_k(&mut self, val: &impl ToInputArray) -> Result<()> {
input_array_arg!(val);
return_send!(via ocvrs_return);
unsafe { sys::cv_RgbdNormals_setK_const__InputArrayR(self.as_raw_mut_RgbdNormals(), val.as_raw__InputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
}
impl fmt::Debug for RgbdNormals {
#[inline]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_struct("RgbdNormals")
.finish()
}
}
impl crate::ptcloud::RgbdNormalsTraitConst for RgbdNormals {
#[inline] fn as_raw_RgbdNormals(&self) -> *const c_void { self.as_raw() }
}
impl crate::ptcloud::RgbdNormalsTrait for RgbdNormals {
#[inline] fn as_raw_mut_RgbdNormals(&mut self) -> *mut c_void { self.as_raw_mut() }
}
boxed_ref! { RgbdNormals, crate::ptcloud::RgbdNormalsTraitConst, as_raw_RgbdNormals, crate::ptcloud::RgbdNormalsTrait, as_raw_mut_RgbdNormals }
#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct TriangleRasterizeSettings {
pub shading_type: crate::ptcloud::TriangleShadingType,
pub culling_mode: crate::ptcloud::TriangleCullingMode,
pub gl_compatible_mode: crate::ptcloud::TriangleGlCompatibleMode,
}
opencv_type_simple! { crate::ptcloud::TriangleRasterizeSettings }
impl TriangleRasterizeSettings {
#[inline]
pub fn default() -> Result<crate::ptcloud::TriangleRasterizeSettings> {
return_send!(via ocvrs_return);
unsafe { sys::cv_TriangleRasterizeSettings_TriangleRasterizeSettings(ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn set_shading_type(self, st: crate::ptcloud::TriangleShadingType) -> Result<crate::ptcloud::TriangleRasterizeSettings> {
return_send!(via ocvrs_return);
unsafe { sys::cv_TriangleRasterizeSettings_setShadingType_TriangleShadingType(&self, st, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn set_culling_mode(self, cm: crate::ptcloud::TriangleCullingMode) -> Result<crate::ptcloud::TriangleRasterizeSettings> {
return_send!(via ocvrs_return);
unsafe { sys::cv_TriangleRasterizeSettings_setCullingMode_TriangleCullingMode(&self, cm, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
pub fn set_gl_compatible_mode(self, gm: crate::ptcloud::TriangleGlCompatibleMode) -> Result<crate::ptcloud::TriangleRasterizeSettings> {
return_send!(via ocvrs_return);
unsafe { sys::cv_TriangleRasterizeSettings_setGlCompatibleMode_TriangleGlCompatibleMode(&self, gm, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
}
pub struct Volume {
ptr: *mut c_void,
}
opencv_type_boxed! { Volume }
impl Drop for Volume {
#[inline]
fn drop(&mut self) {
unsafe { sys::cv_Volume_delete(self.as_raw_mut_Volume()) };
}
}
unsafe impl Send for Volume {}
impl Volume {
#[inline]
pub fn new(vtype: crate::ptcloud::VolumeType, settings: &impl crate::ptcloud::VolumeSettingsTraitConst) -> Result<crate::ptcloud::Volume> {
return_send!(via ocvrs_return);
unsafe { sys::cv_Volume_Volume_VolumeType_const_VolumeSettingsR(vtype, settings.as_raw_VolumeSettings(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
let ret = unsafe { crate::ptcloud::Volume::opencv_from_extern(ret) };
Ok(ret)
}
#[inline]
pub fn new_def() -> Result<crate::ptcloud::Volume> {
return_send!(via ocvrs_return);
unsafe { sys::cv_Volume_Volume(ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
let ret = unsafe { crate::ptcloud::Volume::opencv_from_extern(ret) };
Ok(ret)
}
}
pub trait VolumeTraitConst {
fn as_raw_Volume(&self) -> *const c_void;
#[inline]
fn raycast(&self, camera_pose: &impl ToInputArray, points: &mut impl ToOutputArray, normals: &mut impl ToOutputArray) -> Result<()> {
input_array_arg!(camera_pose);
output_array_arg!(points);
output_array_arg!(normals);
return_send!(via ocvrs_return);
unsafe { sys::cv_Volume_raycast_const_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(self.as_raw_Volume(), camera_pose.as_raw__InputArray(), points.as_raw__OutputArray(), normals.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn raycast_color(&self, camera_pose: &impl ToInputArray, points: &mut impl ToOutputArray, normals: &mut impl ToOutputArray, colors: &mut impl ToOutputArray) -> Result<()> {
input_array_arg!(camera_pose);
output_array_arg!(points);
output_array_arg!(normals);
output_array_arg!(colors);
return_send!(via ocvrs_return);
unsafe { sys::cv_Volume_raycast_const_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(self.as_raw_Volume(), camera_pose.as_raw__InputArray(), points.as_raw__OutputArray(), normals.as_raw__OutputArray(), colors.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn raycast_ex(&self, camera_pose: &impl ToInputArray, height: i32, width: i32, k: &impl ToInputArray, points: &mut impl ToOutputArray, normals: &mut impl ToOutputArray) -> Result<()> {
input_array_arg!(camera_pose);
input_array_arg!(k);
output_array_arg!(points);
output_array_arg!(normals);
return_send!(via ocvrs_return);
unsafe { sys::cv_Volume_raycast_const_const__InputArrayR_int_int_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(self.as_raw_Volume(), camera_pose.as_raw__InputArray(), height, width, k.as_raw__InputArray(), points.as_raw__OutputArray(), normals.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn raycast_ex_color(&self, camera_pose: &impl ToInputArray, height: i32, width: i32, k: &impl ToInputArray, points: &mut impl ToOutputArray, normals: &mut impl ToOutputArray, colors: &mut impl ToOutputArray) -> Result<()> {
input_array_arg!(camera_pose);
input_array_arg!(k);
output_array_arg!(points);
output_array_arg!(normals);
output_array_arg!(colors);
return_send!(via ocvrs_return);
unsafe { sys::cv_Volume_raycast_const_const__InputArrayR_int_int_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(self.as_raw_Volume(), camera_pose.as_raw__InputArray(), height, width, k.as_raw__InputArray(), points.as_raw__OutputArray(), normals.as_raw__OutputArray(), colors.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn fetch_normals(&self, points: &impl ToInputArray, normals: &mut impl ToOutputArray) -> Result<()> {
input_array_arg!(points);
output_array_arg!(normals);
return_send!(via ocvrs_return);
unsafe { sys::cv_Volume_fetchNormals_const_const__InputArrayR_const__OutputArrayR(self.as_raw_Volume(), points.as_raw__InputArray(), normals.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn fetch_points_normals(&self, points: &mut impl ToOutputArray, normals: &mut impl ToOutputArray) -> Result<()> {
output_array_arg!(points);
output_array_arg!(normals);
return_send!(via ocvrs_return);
unsafe { sys::cv_Volume_fetchPointsNormals_const_const__OutputArrayR_const__OutputArrayR(self.as_raw_Volume(), points.as_raw__OutputArray(), normals.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn fetch_points_normals_colors(&self, points: &mut impl ToOutputArray, normals: &mut impl ToOutputArray, colors: &mut impl ToOutputArray) -> Result<()> {
output_array_arg!(points);
output_array_arg!(normals);
output_array_arg!(colors);
return_send!(via ocvrs_return);
unsafe { sys::cv_Volume_fetchPointsNormalsColors_const_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(self.as_raw_Volume(), points.as_raw__OutputArray(), normals.as_raw__OutputArray(), colors.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_visible_blocks(&self) -> Result<i32> {
return_send!(via ocvrs_return);
unsafe { sys::cv_Volume_getVisibleBlocks_const(self.as_raw_Volume(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_total_volume_units(&self) -> Result<size_t> {
return_send!(via ocvrs_return);
unsafe { sys::cv_Volume_getTotalVolumeUnits_const(self.as_raw_Volume(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_bounding_box(&self, bb: &mut impl ToOutputArray, precision: i32) -> Result<()> {
output_array_arg!(bb);
return_send!(via ocvrs_return);
unsafe { sys::cv_Volume_getBoundingBox_const_const__OutputArrayR_int(self.as_raw_Volume(), bb.as_raw__OutputArray(), precision, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_enable_growth(&self) -> Result<bool> {
return_send!(via ocvrs_return);
unsafe { sys::cv_Volume_getEnableGrowth_const(self.as_raw_Volume(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
}
pub trait VolumeTrait: crate::ptcloud::VolumeTraitConst {
fn as_raw_mut_Volume(&mut self) -> *mut c_void;
#[inline]
fn integrate_frame(&mut self, frame: &impl crate::ptcloud::OdometryFrameTraitConst, pose: &impl ToInputArray) -> Result<()> {
input_array_arg!(pose);
return_send!(via ocvrs_return);
unsafe { sys::cv_Volume_integrate_const_OdometryFrameR_const__InputArrayR(self.as_raw_mut_Volume(), frame.as_raw_OdometryFrame(), pose.as_raw__InputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn integrate(&mut self, depth: &impl ToInputArray, pose: &impl ToInputArray) -> Result<()> {
input_array_arg!(depth);
input_array_arg!(pose);
return_send!(via ocvrs_return);
unsafe { sys::cv_Volume_integrate_const__InputArrayR_const__InputArrayR(self.as_raw_mut_Volume(), depth.as_raw__InputArray(), pose.as_raw__InputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn integrate_color(&mut self, depth: &impl ToInputArray, image: &impl ToInputArray, pose: &impl ToInputArray) -> Result<()> {
input_array_arg!(depth);
input_array_arg!(image);
input_array_arg!(pose);
return_send!(via ocvrs_return);
unsafe { sys::cv_Volume_integrate_const__InputArrayR_const__InputArrayR_const__InputArrayR(self.as_raw_mut_Volume(), depth.as_raw__InputArray(), image.as_raw__InputArray(), pose.as_raw__InputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn reset(&mut self) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_Volume_reset(self.as_raw_mut_Volume(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn set_enable_growth(&mut self, v: bool) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_Volume_setEnableGrowth_bool(self.as_raw_mut_Volume(), v, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
}
impl fmt::Debug for Volume {
#[inline]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_struct("Volume")
.finish()
}
}
impl crate::ptcloud::VolumeTraitConst for Volume {
#[inline] fn as_raw_Volume(&self) -> *const c_void { self.as_raw() }
}
impl crate::ptcloud::VolumeTrait for Volume {
#[inline] fn as_raw_mut_Volume(&mut self) -> *mut c_void { self.as_raw_mut() }
}
boxed_ref! { Volume, crate::ptcloud::VolumeTraitConst, as_raw_Volume, crate::ptcloud::VolumeTrait, as_raw_mut_Volume }
pub struct VolumeSettings {
ptr: *mut c_void,
}
opencv_type_boxed! { VolumeSettings }
impl Drop for VolumeSettings {
#[inline]
fn drop(&mut self) {
unsafe { sys::cv_VolumeSettings_delete(self.as_raw_mut_VolumeSettings()) };
}
}
unsafe impl Send for VolumeSettings {}
impl VolumeSettings {
#[inline]
pub fn new(volume_type: crate::ptcloud::VolumeType) -> Result<crate::ptcloud::VolumeSettings> {
return_send!(via ocvrs_return);
unsafe { sys::cv_VolumeSettings_VolumeSettings_VolumeType(volume_type, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
let ret = unsafe { crate::ptcloud::VolumeSettings::opencv_from_extern(ret) };
Ok(ret)
}
#[inline]
pub fn new_def() -> Result<crate::ptcloud::VolumeSettings> {
return_send!(via ocvrs_return);
unsafe { sys::cv_VolumeSettings_VolumeSettings(ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
let ret = unsafe { crate::ptcloud::VolumeSettings::opencv_from_extern(ret) };
Ok(ret)
}
#[inline]
pub fn copy(vs: &impl crate::ptcloud::VolumeSettingsTraitConst) -> Result<crate::ptcloud::VolumeSettings> {
return_send!(via ocvrs_return);
unsafe { sys::cv_VolumeSettings_VolumeSettings_const_VolumeSettingsR(vs.as_raw_VolumeSettings(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
let ret = unsafe { crate::ptcloud::VolumeSettings::opencv_from_extern(ret) };
Ok(ret)
}
}
pub trait VolumeSettingsTraitConst {
fn as_raw_VolumeSettings(&self) -> *const c_void;
#[inline]
fn get_integrate_width(&self) -> Result<i32> {
return_send!(via ocvrs_return);
unsafe { sys::cv_VolumeSettings_getIntegrateWidth_const(self.as_raw_VolumeSettings(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_integrate_height(&self) -> Result<i32> {
return_send!(via ocvrs_return);
unsafe { sys::cv_VolumeSettings_getIntegrateHeight_const(self.as_raw_VolumeSettings(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_raycast_width(&self) -> Result<i32> {
return_send!(via ocvrs_return);
unsafe { sys::cv_VolumeSettings_getRaycastWidth_const(self.as_raw_VolumeSettings(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_raycast_height(&self) -> Result<i32> {
return_send!(via ocvrs_return);
unsafe { sys::cv_VolumeSettings_getRaycastHeight_const(self.as_raw_VolumeSettings(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_depth_factor(&self) -> Result<f32> {
return_send!(via ocvrs_return);
unsafe { sys::cv_VolumeSettings_getDepthFactor_const(self.as_raw_VolumeSettings(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_voxel_size(&self) -> Result<f32> {
return_send!(via ocvrs_return);
unsafe { sys::cv_VolumeSettings_getVoxelSize_const(self.as_raw_VolumeSettings(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_tsdf_truncate_distance(&self) -> Result<f32> {
return_send!(via ocvrs_return);
unsafe { sys::cv_VolumeSettings_getTsdfTruncateDistance_const(self.as_raw_VolumeSettings(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_gradient_delta_factor(&self) -> Result<f32> {
return_send!(via ocvrs_return);
unsafe { sys::cv_VolumeSettings_getGradientDeltaFactor_const(self.as_raw_VolumeSettings(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_volume_unit_hide_threshold(&self) -> Result<i32> {
return_send!(via ocvrs_return);
unsafe { sys::cv_VolumeSettings_getVolumeUnitHideThreshold_const(self.as_raw_VolumeSettings(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_max_depth(&self) -> Result<f32> {
return_send!(via ocvrs_return);
unsafe { sys::cv_VolumeSettings_getMaxDepth_const(self.as_raw_VolumeSettings(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_max_weight(&self) -> Result<i32> {
return_send!(via ocvrs_return);
unsafe { sys::cv_VolumeSettings_getMaxWeight_const(self.as_raw_VolumeSettings(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_raycast_step_factor(&self) -> Result<f32> {
return_send!(via ocvrs_return);
unsafe { sys::cv_VolumeSettings_getRaycastStepFactor_const(self.as_raw_VolumeSettings(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_volume_pose(&self, val: &mut impl ToOutputArray) -> Result<()> {
output_array_arg!(val);
return_send!(via ocvrs_return);
unsafe { sys::cv_VolumeSettings_getVolumePose_const_const__OutputArrayR(self.as_raw_VolumeSettings(), val.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_volume_resolution(&self, val: &mut impl ToOutputArray) -> Result<()> {
output_array_arg!(val);
return_send!(via ocvrs_return);
unsafe { sys::cv_VolumeSettings_getVolumeResolution_const_const__OutputArrayR(self.as_raw_VolumeSettings(), val.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_volume_strides(&self, val: &mut impl ToOutputArray) -> Result<()> {
output_array_arg!(val);
return_send!(via ocvrs_return);
unsafe { sys::cv_VolumeSettings_getVolumeStrides_const_const__OutputArrayR(self.as_raw_VolumeSettings(), val.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_camera_integrate_intrinsics(&self, val: &mut impl ToOutputArray) -> Result<()> {
output_array_arg!(val);
return_send!(via ocvrs_return);
unsafe { sys::cv_VolumeSettings_getCameraIntegrateIntrinsics_const_const__OutputArrayR(self.as_raw_VolumeSettings(), val.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_camera_raycast_intrinsics(&self, val: &mut impl ToOutputArray) -> Result<()> {
output_array_arg!(val);
return_send!(via ocvrs_return);
unsafe { sys::cv_VolumeSettings_getCameraRaycastIntrinsics_const_const__OutputArrayR(self.as_raw_VolumeSettings(), val.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
}
pub trait VolumeSettingsTrait: crate::ptcloud::VolumeSettingsTraitConst {
fn as_raw_mut_VolumeSettings(&mut self) -> *mut c_void;
#[inline]
fn set(&mut self, unnamed: &impl crate::ptcloud::VolumeSettingsTraitConst) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_VolumeSettings_operatorST_const_VolumeSettingsR(self.as_raw_mut_VolumeSettings(), unnamed.as_raw_VolumeSettings(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn set_integrate_width(&mut self, val: i32) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_VolumeSettings_setIntegrateWidth_int(self.as_raw_mut_VolumeSettings(), val, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn set_integrate_height(&mut self, val: i32) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_VolumeSettings_setIntegrateHeight_int(self.as_raw_mut_VolumeSettings(), val, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn set_raycast_width(&mut self, val: i32) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_VolumeSettings_setRaycastWidth_int(self.as_raw_mut_VolumeSettings(), val, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn set_raycast_height(&mut self, val: i32) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_VolumeSettings_setRaycastHeight_int(self.as_raw_mut_VolumeSettings(), val, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn set_depth_factor(&mut self, val: f32) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_VolumeSettings_setDepthFactor_float(self.as_raw_mut_VolumeSettings(), val, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn set_voxel_size(&mut self, val: f32) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_VolumeSettings_setVoxelSize_float(self.as_raw_mut_VolumeSettings(), val, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn set_tsdf_truncate_distance(&mut self, val: f32) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_VolumeSettings_setTsdfTruncateDistance_float(self.as_raw_mut_VolumeSettings(), val, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn set_gradient_delta_factor(&mut self, val: f32) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_VolumeSettings_setGradientDeltaFactor_float(self.as_raw_mut_VolumeSettings(), val, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn set_volume_unit_hide_threshold(&mut self, val: i32) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_VolumeSettings_setVolumeUnitHideThreshold_int(self.as_raw_mut_VolumeSettings(), val, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn set_max_depth(&mut self, val: f32) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_VolumeSettings_setMaxDepth_float(self.as_raw_mut_VolumeSettings(), val, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn set_max_weight(&mut self, val: i32) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_VolumeSettings_setMaxWeight_int(self.as_raw_mut_VolumeSettings(), val, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn set_raycast_step_factor(&mut self, val: f32) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_VolumeSettings_setRaycastStepFactor_float(self.as_raw_mut_VolumeSettings(), val, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn set_volume_pose(&mut self, val: &impl ToInputArray) -> Result<()> {
input_array_arg!(val);
return_send!(via ocvrs_return);
unsafe { sys::cv_VolumeSettings_setVolumePose_const__InputArrayR(self.as_raw_mut_VolumeSettings(), val.as_raw__InputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn set_volume_resolution(&mut self, val: &impl ToInputArray) -> Result<()> {
input_array_arg!(val);
return_send!(via ocvrs_return);
unsafe { sys::cv_VolumeSettings_setVolumeResolution_const__InputArrayR(self.as_raw_mut_VolumeSettings(), val.as_raw__InputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn set_camera_integrate_intrinsics(&mut self, val: &impl ToInputArray) -> Result<()> {
input_array_arg!(val);
return_send!(via ocvrs_return);
unsafe { sys::cv_VolumeSettings_setCameraIntegrateIntrinsics_const__InputArrayR(self.as_raw_mut_VolumeSettings(), val.as_raw__InputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn set_camera_raycast_intrinsics(&mut self, val: &impl ToInputArray) -> Result<()> {
input_array_arg!(val);
return_send!(via ocvrs_return);
unsafe { sys::cv_VolumeSettings_setCameraRaycastIntrinsics_const__InputArrayR(self.as_raw_mut_VolumeSettings(), val.as_raw__InputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
}
impl Clone for VolumeSettings {
#[inline]
fn clone(&self) -> Self {
unsafe { Self::from_raw(sys::cv_VolumeSettings_implicitClone_const(self.as_raw_VolumeSettings())) }
}
}
impl fmt::Debug for VolumeSettings {
#[inline]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_struct("VolumeSettings")
.finish()
}
}
impl crate::ptcloud::VolumeSettingsTraitConst for VolumeSettings {
#[inline] fn as_raw_VolumeSettings(&self) -> *const c_void { self.as_raw() }
}
impl crate::ptcloud::VolumeSettingsTrait for VolumeSettings {
#[inline] fn as_raw_mut_VolumeSettings(&mut self) -> *mut c_void { self.as_raw_mut() }
}
boxed_ref! { VolumeSettings, crate::ptcloud::VolumeSettingsTraitConst, as_raw_VolumeSettings, crate::ptcloud::VolumeSettingsTrait, as_raw_mut_VolumeSettings }
pub struct KeyFrame {
ptr: *mut c_void,
}
opencv_type_boxed! { KeyFrame }
impl Drop for KeyFrame {
#[inline]
fn drop(&mut self) {
unsafe { sys::cv_slam_KeyFrame_delete(self.as_raw_mut_KeyFrame()) };
}
}
unsafe impl Send for KeyFrame {}
impl KeyFrame {
#[inline]
pub fn default() -> crate::ptcloud::KeyFrame {
let ret = unsafe { sys::cv_slam_KeyFrame_defaultNew_const() };
let ret = unsafe { crate::ptcloud::KeyFrame::opencv_from_extern(ret) };
ret
}
}
pub trait KeyFrameTraitConst {
fn as_raw_KeyFrame(&self) -> *const c_void;
#[inline]
fn id(&self) -> i32 {
let ret = unsafe { sys::cv_slam_KeyFrame_propId_const(self.as_raw_KeyFrame()) };
ret
}
#[inline]
fn pose_cw(&self) -> core::Matx44d {
return_send!(via ocvrs_return);
unsafe { sys::cv_slam_KeyFrame_propPoseCw_const(self.as_raw_KeyFrame(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
ret
}
#[inline]
fn keypoints(&self) -> core::Vector<core::KeyPoint> {
let ret = unsafe { sys::cv_slam_KeyFrame_propKeypoints_const(self.as_raw_KeyFrame()) };
let ret = unsafe { core::Vector::<core::KeyPoint>::opencv_from_extern(ret) };
ret
}
#[inline]
fn descriptors(&self) -> core::Mat {
let ret = unsafe { sys::cv_slam_KeyFrame_propDescriptors_const(self.as_raw_KeyFrame()) };
let ret = unsafe { core::Mat::opencv_from_extern(ret) };
ret
}
#[inline]
fn undist_kpts(&self) -> core::Vector<core::Point2f> {
let ret = unsafe { sys::cv_slam_KeyFrame_propUndistKpts_const(self.as_raw_KeyFrame()) };
let ret = unsafe { core::Vector::<core::Point2f>::opencv_from_extern(ret) };
ret
}
#[inline]
fn image_size(&self) -> core::Size {
return_send!(via ocvrs_return);
unsafe { sys::cv_slam_KeyFrame_propImageSize_const(self.as_raw_KeyFrame(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
ret
}
#[inline]
fn global_desc(&self) -> core::Mat {
let ret = unsafe { sys::cv_slam_KeyFrame_propGlobalDesc_const(self.as_raw_KeyFrame()) };
let ret = unsafe { core::Mat::opencv_from_extern(ret) };
ret
}
}
pub trait KeyFrameTrait: crate::ptcloud::KeyFrameTraitConst {
fn as_raw_mut_KeyFrame(&mut self) -> *mut c_void;
#[inline]
fn set_id(&mut self, val: i32) {
let ret = unsafe { sys::cv_slam_KeyFrame_propId_int(self.as_raw_mut_KeyFrame(), val) };
ret
}
#[inline]
fn set_pose_cw(&mut self, val: core::Matx44d) {
let ret = unsafe { sys::cv_slam_KeyFrame_propPoseCw_Matx44d(self.as_raw_mut_KeyFrame(), &val) };
ret
}
#[inline]
fn set_keypoints(&mut self, mut val: core::Vector<core::KeyPoint>) {
let ret = unsafe { sys::cv_slam_KeyFrame_propKeypoints_vectorLKeyPointG(self.as_raw_mut_KeyFrame(), val.as_raw_mut_VectorOfKeyPoint()) };
ret
}
#[inline]
fn set_descriptors(&mut self, mut val: core::Mat) {
let ret = unsafe { sys::cv_slam_KeyFrame_propDescriptors_Mat(self.as_raw_mut_KeyFrame(), val.as_raw_mut_Mat()) };
ret
}
#[inline]
fn set_undist_kpts(&mut self, mut val: core::Vector<core::Point2f>) {
let ret = unsafe { sys::cv_slam_KeyFrame_propUndistKpts_vectorLPoint2fG(self.as_raw_mut_KeyFrame(), val.as_raw_mut_VectorOfPoint2f()) };
ret
}
#[inline]
fn set_image_size(&mut self, val: core::Size) {
let ret = unsafe { sys::cv_slam_KeyFrame_propImageSize_Size(self.as_raw_mut_KeyFrame(), &val) };
ret
}
#[inline]
fn parent(&mut self) -> crate::ptcloud::KeyFrame {
let ret = unsafe { sys::cv_slam_KeyFrame_propParent(self.as_raw_mut_KeyFrame()) };
let ret = unsafe { crate::ptcloud::KeyFrame::opencv_from_extern(ret) };
ret
}
#[inline]
unsafe fn set_parent(&mut self, val: *mut crate::ptcloud::KeyFrame) {
let ret = unsafe { sys::cv_slam_KeyFrame_propParent_KeyFrameX(self.as_raw_mut_KeyFrame(), val.cast()) };
ret
}
#[inline]
fn set_global_desc(&mut self, mut val: core::Mat) {
let ret = unsafe { sys::cv_slam_KeyFrame_propGlobalDesc_Mat(self.as_raw_mut_KeyFrame(), val.as_raw_mut_Mat()) };
ret
}
}
impl Default for KeyFrame {
#[inline]
fn default() -> Self {
Self::default()
}
}
impl fmt::Debug for KeyFrame {
#[inline]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_struct("KeyFrame")
.field("id", &crate::ptcloud::KeyFrameTraitConst::id(self))
.field("pose_cw", &crate::ptcloud::KeyFrameTraitConst::pose_cw(self))
.field("keypoints", &crate::ptcloud::KeyFrameTraitConst::keypoints(self))
.field("descriptors", &crate::ptcloud::KeyFrameTraitConst::descriptors(self))
.field("undist_kpts", &crate::ptcloud::KeyFrameTraitConst::undist_kpts(self))
.field("image_size", &crate::ptcloud::KeyFrameTraitConst::image_size(self))
.field("global_desc", &crate::ptcloud::KeyFrameTraitConst::global_desc(self))
.finish()
}
}
impl crate::ptcloud::KeyFrameTraitConst for KeyFrame {
#[inline] fn as_raw_KeyFrame(&self) -> *const c_void { self.as_raw() }
}
impl crate::ptcloud::KeyFrameTrait for KeyFrame {
#[inline] fn as_raw_mut_KeyFrame(&mut self) -> *mut c_void { self.as_raw_mut() }
}
boxed_ref! { KeyFrame, crate::ptcloud::KeyFrameTraitConst, as_raw_KeyFrame, crate::ptcloud::KeyFrameTrait, as_raw_mut_KeyFrame }
pub struct Map {
ptr: *mut c_void,
}
opencv_type_boxed! { Map }
impl Drop for Map {
#[inline]
fn drop(&mut self) {
unsafe { sys::cv_slam_Map_delete(self.as_raw_mut_Map()) };
}
}
unsafe impl Send for Map {}
impl Map {
#[inline]
pub fn default() -> Result<crate::ptcloud::Map> {
return_send!(via ocvrs_return);
unsafe { sys::cv_slam_Map_Map(ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
let ret = unsafe { crate::ptcloud::Map::opencv_from_extern(ret) };
Ok(ret)
}
}
pub trait MapTraitConst {
fn as_raw_Map(&self) -> *const c_void;
#[inline]
fn get_keyframe(&self, id: i32) -> Result<crate::ptcloud::KeyFrame> {
return_send!(via ocvrs_return);
unsafe { sys::cv_slam_Map_getKeyframe_const_int(self.as_raw_Map(), id, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
let ret = unsafe { crate::ptcloud::KeyFrame::opencv_from_extern(ret) };
Ok(ret)
}
#[inline]
fn num_keyframes(&self) -> Result<i32> {
return_send!(via ocvrs_return);
unsafe { sys::cv_slam_Map_numKeyframes_const(self.as_raw_Map(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_map_point(&self, id: i32) -> Result<crate::ptcloud::MapPoint> {
return_send!(via ocvrs_return);
unsafe { sys::cv_slam_Map_getMapPoint_const_int(self.as_raw_Map(), id, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
let ret = unsafe { crate::ptcloud::MapPoint::opencv_from_extern(ret) };
Ok(ret)
}
#[inline]
fn num_map_points(&self) -> Result<i32> {
return_send!(via ocvrs_return);
unsafe { sys::cv_slam_Map_numMapPoints_const(self.as_raw_Map(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_ref_keyframe(&self) -> Result<crate::ptcloud::KeyFrame> {
return_send!(via ocvrs_return);
unsafe { sys::cv_slam_Map_getRefKeyframe_const(self.as_raw_Map(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
let ret = unsafe { crate::ptcloud::KeyFrame::opencv_from_extern(ret) };
Ok(ret)
}
#[inline]
fn get_current_keyframe(&self) -> Result<crate::ptcloud::KeyFrame> {
return_send!(via ocvrs_return);
unsafe { sys::cv_slam_Map_getCurrentKeyframe_const(self.as_raw_Map(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
let ret = unsafe { crate::ptcloud::KeyFrame::opencv_from_extern(ret) };
Ok(ret)
}
#[inline]
fn trajectory(&self) -> Result<core::Vector<core::Matx44d>> {
return_send!(via ocvrs_return);
unsafe { sys::cv_slam_Map_trajectory_const(self.as_raw_Map(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
let ret = unsafe { core::Vector::<core::Matx44d>::opencv_from_extern(ret) };
Ok(ret)
}
}
pub trait MapTrait: crate::ptcloud::MapTraitConst {
fn as_raw_mut_Map(&mut self) -> *mut c_void;
#[inline]
fn add_keyframe(&mut self, kf: &mut impl crate::ptcloud::KeyFrameTrait) -> Result<crate::ptcloud::KeyFrame> {
return_send!(via ocvrs_return);
unsafe { sys::cv_slam_Map_addKeyframe_KeyFrameX(self.as_raw_mut_Map(), kf.as_raw_mut_KeyFrame(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
let ret = unsafe { crate::ptcloud::KeyFrame::opencv_from_extern(ret) };
Ok(ret)
}
#[inline]
fn add_map_point(&mut self, mp: &mut impl crate::ptcloud::MapPointTrait) -> Result<crate::ptcloud::MapPoint> {
return_send!(via ocvrs_return);
unsafe { sys::cv_slam_Map_addMapPoint_MapPointX(self.as_raw_mut_Map(), mp.as_raw_mut_MapPoint(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
let ret = unsafe { crate::ptcloud::MapPoint::opencv_from_extern(ret) };
Ok(ret)
}
#[inline]
fn add_observation(&mut self, kf: &mut impl crate::ptcloud::KeyFrameTrait, kp_idx: size_t, mp: &mut impl crate::ptcloud::MapPointTrait) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_slam_Map_addObservation_KeyFrameX_size_t_MapPointX(self.as_raw_mut_Map(), kf.as_raw_mut_KeyFrame(), kp_idx, mp.as_raw_mut_MapPoint(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn remove_observation(&mut self, kf: &mut impl crate::ptcloud::KeyFrameTrait, mp: &mut impl crate::ptcloud::MapPointTrait) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_slam_Map_removeObservation_KeyFrameX_MapPointX(self.as_raw_mut_Map(), kf.as_raw_mut_KeyFrame(), mp.as_raw_mut_MapPoint(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn remove_map_point(&mut self, mp: &mut impl crate::ptcloud::MapPointTrait) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_slam_Map_removeMapPoint_MapPointX(self.as_raw_mut_Map(), mp.as_raw_mut_MapPoint(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn set_ref_keyframe(&mut self, kf: &mut impl crate::ptcloud::KeyFrameTrait) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_slam_Map_setRefKeyframe_KeyFrameX(self.as_raw_mut_Map(), kf.as_raw_mut_KeyFrame(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn set_current_keyframe(&mut self, kf: &mut impl crate::ptcloud::KeyFrameTrait) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_slam_Map_setCurrentKeyframe_KeyFrameX(self.as_raw_mut_Map(), kf.as_raw_mut_KeyFrame(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn append_pose(&mut self, t_cw: core::Matx44d) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_slam_Map_appendPose_const_Matx44dR(self.as_raw_mut_Map(), &t_cw, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn clear(&mut self) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_slam_Map_clear(self.as_raw_mut_Map(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
}
impl fmt::Debug for Map {
#[inline]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_struct("Map")
.finish()
}
}
impl crate::ptcloud::MapTraitConst for Map {
#[inline] fn as_raw_Map(&self) -> *const c_void { self.as_raw() }
}
impl crate::ptcloud::MapTrait for Map {
#[inline] fn as_raw_mut_Map(&mut self) -> *mut c_void { self.as_raw_mut() }
}
boxed_ref! { Map, crate::ptcloud::MapTraitConst, as_raw_Map, crate::ptcloud::MapTrait, as_raw_mut_Map }
pub struct MapPoint {
ptr: *mut c_void,
}
opencv_type_boxed! { MapPoint }
impl Drop for MapPoint {
#[inline]
fn drop(&mut self) {
unsafe { sys::cv_slam_MapPoint_delete(self.as_raw_mut_MapPoint()) };
}
}
unsafe impl Send for MapPoint {}
impl MapPoint {
#[inline]
pub fn default() -> crate::ptcloud::MapPoint {
let ret = unsafe { sys::cv_slam_MapPoint_defaultNew_const() };
let ret = unsafe { crate::ptcloud::MapPoint::opencv_from_extern(ret) };
ret
}
}
pub trait MapPointTraitConst {
fn as_raw_MapPoint(&self) -> *const c_void;
#[inline]
fn id(&self) -> i32 {
let ret = unsafe { sys::cv_slam_MapPoint_propId_const(self.as_raw_MapPoint()) };
ret
}
#[inline]
fn pos(&self) -> core::Point3d {
return_send!(via ocvrs_return);
unsafe { sys::cv_slam_MapPoint_propPos_const(self.as_raw_MapPoint(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
ret
}
#[inline]
fn ref_desc(&self) -> core::Mat {
let ret = unsafe { sys::cv_slam_MapPoint_propRefDesc_const(self.as_raw_MapPoint()) };
let ret = unsafe { core::Mat::opencv_from_extern(ret) };
ret
}
#[inline]
fn visible_count(&self) -> i32 {
let ret = unsafe { sys::cv_slam_MapPoint_propVisibleCount_const(self.as_raw_MapPoint()) };
ret
}
#[inline]
fn found_count(&self) -> i32 {
let ret = unsafe { sys::cv_slam_MapPoint_propFoundCount_const(self.as_raw_MapPoint()) };
ret
}
#[inline]
fn bad(&self) -> bool {
let ret = unsafe { sys::cv_slam_MapPoint_propBad_const(self.as_raw_MapPoint()) };
ret
}
}
pub trait MapPointTrait: crate::ptcloud::MapPointTraitConst {
fn as_raw_mut_MapPoint(&mut self) -> *mut c_void;
#[inline]
fn set_id(&mut self, val: i32) {
let ret = unsafe { sys::cv_slam_MapPoint_propId_int(self.as_raw_mut_MapPoint(), val) };
ret
}
#[inline]
fn set_pos(&mut self, val: core::Point3d) {
let ret = unsafe { sys::cv_slam_MapPoint_propPos_Point3d(self.as_raw_mut_MapPoint(), &val) };
ret
}
#[inline]
fn set_ref_desc(&mut self, mut val: core::Mat) {
let ret = unsafe { sys::cv_slam_MapPoint_propRefDesc_Mat(self.as_raw_mut_MapPoint(), val.as_raw_mut_Mat()) };
ret
}
#[inline]
fn set_visible_count(&mut self, val: i32) {
let ret = unsafe { sys::cv_slam_MapPoint_propVisibleCount_int(self.as_raw_mut_MapPoint(), val) };
ret
}
#[inline]
fn set_found_count(&mut self, val: i32) {
let ret = unsafe { sys::cv_slam_MapPoint_propFoundCount_int(self.as_raw_mut_MapPoint(), val) };
ret
}
#[inline]
fn set_bad(&mut self, val: bool) {
let ret = unsafe { sys::cv_slam_MapPoint_propBad_bool(self.as_raw_mut_MapPoint(), val) };
ret
}
}
impl Default for MapPoint {
#[inline]
fn default() -> Self {
Self::default()
}
}
impl fmt::Debug for MapPoint {
#[inline]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_struct("MapPoint")
.field("id", &crate::ptcloud::MapPointTraitConst::id(self))
.field("pos", &crate::ptcloud::MapPointTraitConst::pos(self))
.field("ref_desc", &crate::ptcloud::MapPointTraitConst::ref_desc(self))
.field("visible_count", &crate::ptcloud::MapPointTraitConst::visible_count(self))
.field("found_count", &crate::ptcloud::MapPointTraitConst::found_count(self))
.field("bad", &crate::ptcloud::MapPointTraitConst::bad(self))
.finish()
}
}
impl crate::ptcloud::MapPointTraitConst for MapPoint {
#[inline] fn as_raw_MapPoint(&self) -> *const c_void { self.as_raw() }
}
impl crate::ptcloud::MapPointTrait for MapPoint {
#[inline] fn as_raw_mut_MapPoint(&mut self) -> *mut c_void { self.as_raw_mut() }
}
boxed_ref! { MapPoint, crate::ptcloud::MapPointTraitConst, as_raw_MapPoint, crate::ptcloud::MapPointTrait, as_raw_mut_MapPoint }
#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct OdometryParams {
pub min_init_inliers: i32,
pub min_init_parallax_deg: f64,
pub min_init_points: i32,
pub hf_ratio_thresh: f64,
pub min_growth_parallax_deg: f64,
pub essential_ransac_thresh: f64,
pub essential_ransac_confidence: f64,
pub pnp_reproj_thresh: f64,
pub pnp_min_inliers: i32,
pub pnp_ransac_iters: i32,
pub pnp_confidence: f64,
pub motion_model_radius: f64,
pub motion_model_radius_wide: f64,
pub motion_model_min_matches: i32,
pub desc_proj_thresh: f64,
pub optical_flow_min_inliers: i32,
pub kf_min_frames: i32,
pub kf_max_frames: i32,
pub kf_inlier_ratio: f64,
pub kf_min_inliers: i32,
pub kf_rot_thresh_deg: f64,
pub kf_trans_thresh: f64,
pub local_map_top_k: i32,
pub local_map_neighbor_k: i32,
pub local_map_radius: f64,
}
opencv_type_simple! { crate::ptcloud::OdometryParams }
impl OdometryParams {
#[inline]
pub fn default() -> Result<crate::ptcloud::OdometryParams> {
return_send!(via ocvrs_return);
unsafe { sys::cv_slam_OdometryParams_OdometryParams(ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
}
pub struct VisualOdometry {
ptr: *mut c_void,
}
opencv_type_boxed! { VisualOdometry }
impl Drop for VisualOdometry {
#[inline]
fn drop(&mut self) {
unsafe { sys::cv_slam_VisualOdometry_delete(self.as_raw_mut_VisualOdometry()) };
}
}
unsafe impl Send for VisualOdometry {}
impl VisualOdometry {
#[inline]
pub fn create(detector: &core::Ptr<crate::features::Feature2D>, matcher: &core::Ptr<crate::features::DescriptorMatcher>, camera_matrix: &impl ToInputArray, dist_coeffs: &impl ToInputArray, params: crate::ptcloud::OdometryParams) -> Result<core::Ptr<crate::ptcloud::VisualOdometry>> {
input_array_arg!(camera_matrix);
input_array_arg!(dist_coeffs);
return_send!(via ocvrs_return);
unsafe { sys::cv_slam_VisualOdometry_create_const_PtrLFeature2DGR_const_PtrLDescriptorMatcherGR_const__InputArrayR_const__InputArrayR_const_OdometryParamsR(detector.as_raw_PtrOfFeature2D(), matcher.as_raw_PtrOfDescriptorMatcher(), camera_matrix.as_raw__InputArray(), dist_coeffs.as_raw__InputArray(), ¶ms, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
let ret = unsafe { core::Ptr::<crate::ptcloud::VisualOdometry>::opencv_from_extern(ret) };
Ok(ret)
}
#[inline]
pub fn create_def(detector: &core::Ptr<crate::features::Feature2D>, matcher: &core::Ptr<crate::features::DescriptorMatcher>, camera_matrix: &impl ToInputArray) -> Result<core::Ptr<crate::ptcloud::VisualOdometry>> {
input_array_arg!(camera_matrix);
return_send!(via ocvrs_return);
unsafe { sys::cv_slam_VisualOdometry_create_const_PtrLFeature2DGR_const_PtrLDescriptorMatcherGR_const__InputArrayR(detector.as_raw_PtrOfFeature2D(), matcher.as_raw_PtrOfDescriptorMatcher(), camera_matrix.as_raw__InputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
let ret = unsafe { core::Ptr::<crate::ptcloud::VisualOdometry>::opencv_from_extern(ret) };
Ok(ret)
}
}
pub trait VisualOdometryTraitConst {
fn as_raw_VisualOdometry(&self) -> *const c_void;
#[inline]
fn get_state(&self) -> Result<crate::ptcloud::OdometryState> {
return_send!(via ocvrs_return);
unsafe { sys::cv_slam_VisualOdometry_getState_const(self.as_raw_VisualOdometry(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_last_pose(&self) -> Result<core::Matx44d> {
return_send!(via ocvrs_return);
unsafe { sys::cv_slam_VisualOdometry_getLastPose_const(self.as_raw_VisualOdometry(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_num_keyframes(&self) -> Result<i32> {
return_send!(via ocvrs_return);
unsafe { sys::cv_slam_VisualOdometry_getNumKeyframes_const(self.as_raw_VisualOdometry(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_num_map_points(&self) -> Result<i32> {
return_send!(via ocvrs_return);
unsafe { sys::cv_slam_VisualOdometry_getNumMapPoints_const(self.as_raw_VisualOdometry(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_trajectory(&self) -> Result<core::Vector<core::Matx44d>> {
return_send!(via ocvrs_return);
unsafe { sys::cv_slam_VisualOdometry_getTrajectory_const(self.as_raw_VisualOdometry(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
let ret = unsafe { core::Vector::<core::Matx44d>::opencv_from_extern(ret) };
Ok(ret)
}
#[inline]
fn get_params(&self) -> Result<crate::ptcloud::OdometryParams> {
return_send!(via ocvrs_return);
unsafe { sys::cv_slam_VisualOdometry_getParams_const(self.as_raw_VisualOdometry(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
}
pub trait VisualOdometryTrait: crate::ptcloud::VisualOdometryTraitConst {
fn as_raw_mut_VisualOdometry(&mut self) -> *mut c_void;
#[inline]
fn process_frame(&mut self, image: &impl ToInputArray) -> Result<bool> {
input_array_arg!(image);
return_send!(via ocvrs_return);
unsafe { sys::cv_slam_VisualOdometry_processFrame_const__InputArrayR(self.as_raw_mut_VisualOdometry(), image.as_raw__InputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn reset(&mut self) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_slam_VisualOdometry_reset(self.as_raw_mut_VisualOdometry(), ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn set_params(&mut self, params: crate::ptcloud::OdometryParams) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_slam_VisualOdometry_setParams_const_OdometryParamsR(self.as_raw_mut_VisualOdometry(), ¶ms, ocvrs_return.as_mut_ptr()) };
return_receive!(ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
}
impl fmt::Debug for VisualOdometry {
#[inline]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_struct("VisualOdometry")
.finish()
}
}
impl crate::ptcloud::VisualOdometryTraitConst for VisualOdometry {
#[inline] fn as_raw_VisualOdometry(&self) -> *const c_void { self.as_raw() }
}
impl crate::ptcloud::VisualOdometryTrait for VisualOdometry {
#[inline] fn as_raw_mut_VisualOdometry(&mut self) -> *mut c_void { self.as_raw_mut() }
}
boxed_ref! { VisualOdometry, crate::ptcloud::VisualOdometryTraitConst, as_raw_VisualOdometry, crate::ptcloud::VisualOdometryTrait, as_raw_mut_VisualOdometry }
}