From cd6b8a17666d699fd2bd4756e875f4348c92cd0c Mon Sep 17 00:00:00 2001 From: Pro Date: Thu, 9 Jan 2025 22:00:28 +0100 Subject: [PATCH] Regenerate docs --- docs/core.rs | 273 +- docs/cudalegacy.rs | 1235 ++++++++ docs/dnn.rs | 12 + docs/face.rs | 3 - docs/highgui.rs | 15 - docs/hub.rs | 134 +- docs/objdetect.rs | 4 +- docs/sys.rs | 7100 ++++++++++++++++++++++---------------------- docs/types.rs | 2268 +------------- docs/viz.rs | 6 - 10 files changed, 5099 insertions(+), 5951 deletions(-) create mode 100644 docs/cudalegacy.rs diff --git a/docs/core.rs b/docs/core.rs index f4a1bba9..9a1aa30d 100644 --- a/docs/core.rs +++ b/docs/core.rs @@ -34,7 +34,7 @@ pub mod core { use crate::mod_prelude::*; use crate::{core, sys, types}; pub mod prelude { - pub use super::{AlgorithmTrait, AlgorithmTraitConst, ArraysTrait, ArraysTraitConst, AsyncArrayTrait, AsyncArrayTraitConst, AsyncPromiseTrait, AsyncPromiseTraitConst, BufferPoolTrait, BufferPoolTraitConst, BufferTrait, BufferTraitConst, CommandLineParserTrait, CommandLineParserTraitConst, ConjGradSolverTrait, ConjGradSolverTraitConst, ContextTrait, ContextTraitConst, Context_UserContextTrait, Context_UserContextTraitConst, Detail_CheckContextTrait, Detail_CheckContextTraitConst, DeviceInfoTrait, DeviceInfoTraitConst, DeviceTrait, DeviceTraitConst, DownhillSolverTrait, DownhillSolverTraitConst, EventTrait, EventTraitConst, ExceptionTrait, ExceptionTraitConst, FileNodeIteratorTrait, FileNodeIteratorTraitConst, FileNodeTrait, FileNodeTraitConst, FileStorageTrait, FileStorageTraitConst, FormattedTrait, FormattedTraitConst, FormatterTrait, FormatterTraitConst, FunctionParamsTrait, FunctionParamsTraitConst, GpuDataTrait, GpuDataTraitConst, GpuMatNDTrait, GpuMatNDTraitConst, GpuMatTrait, GpuMatTraitConst, GpuMat_AllocatorTrait, GpuMat_AllocatorTraitConst, HammingTrait, HammingTraitConst, HostMemTrait, HostMemTraitConst, Image2DTrait, Image2DTraitConst, KernelArgTrait, KernelArgTraitConst, KernelTrait, KernelTraitConst, KeyPointTrait, KeyPointTraitConst, LDATrait, LDATraitConst, LogTagTrait, LogTagTraitConst, MatConstIteratorTrait, MatConstIteratorTraitConst, MatExprTrait, MatExprTraitConst, MatOpTrait, MatOpTraitConst, MatSizeTrait, MatSizeTraitConst, MatStepTrait, MatStepTraitConst, MatTrait, MatTraitConst, Matx_AddOpTrait, Matx_AddOpTraitConst, Matx_DivOpTrait, Matx_DivOpTraitConst, Matx_MatMulOpTrait, Matx_MatMulOpTraitConst, Matx_MulOpTrait, Matx_MulOpTraitConst, Matx_ScaleOpTrait, Matx_ScaleOpTraitConst, Matx_SubOpTrait, Matx_SubOpTraitConst, Matx_TOpTrait, Matx_TOpTraitConst, MinProblemSolverTrait, MinProblemSolverTraitConst, MinProblemSolver_FunctionTrait, MinProblemSolver_FunctionTraitConst, NodeDataTrait, NodeDataTraitConst, OpenCLExecutionContextTrait, OpenCLExecutionContextTraitConst, OriginalClassNameTrait, OriginalClassNameTraitConst, PCATrait, PCATraitConst, ParallelLoopBodyTrait, ParallelLoopBodyTraitConst, PlatformInfoTrait, PlatformInfoTraitConst, PlatformTrait, PlatformTraitConst, ProgramSourceTrait, ProgramSourceTraitConst, ProgramTrait, ProgramTraitConst, QueueTrait, QueueTraitConst, RNGTrait, RNGTraitConst, RNG_MT19937Trait, RNG_MT19937TraitConst, RangeTrait, RangeTraitConst, SVDTrait, SVDTraitConst, SparseMatConstIteratorTrait, SparseMatConstIteratorTraitConst, SparseMatIteratorTrait, SparseMatIteratorTraitConst, SparseMatTrait, SparseMatTraitConst, SparseMat_HdrTrait, SparseMat_HdrTraitConst, SparseMat_NodeTrait, SparseMat_NodeTraitConst, StreamTrait, StreamTraitConst, TargetArchsTrait, TargetArchsTraitConst, Texture2DTrait, Texture2DTraitConst, TickMeterTrait, TickMeterTraitConst, TimerTrait, TimerTraitConst, UMatDataTrait, UMatDataTraitConst, UMatTrait, UMatTraitConst, WriteStructContextTrait, WriteStructContextTraitConst, _InputArrayTrait, _InputArrayTraitConst, _InputOutputArrayTrait, _InputOutputArrayTraitConst, _OutputArrayTrait, _OutputArrayTraitConst}; + pub use super::{AlgorithmTrait, AlgorithmTraitConst, ArraysTrait, ArraysTraitConst, AsyncArrayTrait, AsyncArrayTraitConst, AsyncPromiseTrait, AsyncPromiseTraitConst, BufferPoolTrait, BufferPoolTraitConst, BufferTrait, BufferTraitConst, CommandLineParserTrait, CommandLineParserTraitConst, ConjGradSolverTrait, ConjGradSolverTraitConst, ContextTrait, ContextTraitConst, Context_UserContextTrait, Context_UserContextTraitConst, Detail_CheckContextTrait, Detail_CheckContextTraitConst, DeviceInfoTrait, DeviceInfoTraitConst, DeviceTrait, DeviceTraitConst, DownhillSolverTrait, DownhillSolverTraitConst, EventTrait, EventTraitConst, ExceptionTrait, ExceptionTraitConst, FileNodeIteratorTrait, FileNodeIteratorTraitConst, FileNodeTrait, FileNodeTraitConst, FileStorageTrait, FileStorageTraitConst, FormattedTrait, FormattedTraitConst, FormatterTrait, FormatterTraitConst, GpuDataTrait, GpuDataTraitConst, GpuMatNDTrait, GpuMatNDTraitConst, GpuMatTrait, GpuMatTraitConst, GpuMat_AllocatorTrait, GpuMat_AllocatorTraitConst, HammingTrait, HammingTraitConst, HostMemTrait, HostMemTraitConst, Image2DTrait, Image2DTraitConst, KernelArgTrait, KernelArgTraitConst, KernelTrait, KernelTraitConst, KeyPointTrait, KeyPointTraitConst, LDATrait, LDATraitConst, LogTagTrait, LogTagTraitConst, MatConstIteratorTrait, MatConstIteratorTraitConst, MatExprTrait, MatExprTraitConst, MatOpTrait, MatOpTraitConst, MatSizeTrait, MatSizeTraitConst, MatStepTrait, MatStepTraitConst, MatTrait, MatTraitConst, Matx_AddOpTrait, Matx_AddOpTraitConst, Matx_DivOpTrait, Matx_DivOpTraitConst, Matx_MatMulOpTrait, Matx_MatMulOpTraitConst, Matx_MulOpTrait, Matx_MulOpTraitConst, Matx_ScaleOpTrait, Matx_ScaleOpTraitConst, Matx_SubOpTrait, Matx_SubOpTraitConst, Matx_TOpTrait, Matx_TOpTraitConst, MinProblemSolverTrait, MinProblemSolverTraitConst, MinProblemSolver_FunctionTrait, MinProblemSolver_FunctionTraitConst, NodeDataTrait, NodeDataTraitConst, OpenCLExecutionContextTrait, OpenCLExecutionContextTraitConst, OriginalClassNameTrait, OriginalClassNameTraitConst, PCATrait, PCATraitConst, ParallelLoopBodyTrait, ParallelLoopBodyTraitConst, PlatformInfoTrait, PlatformInfoTraitConst, PlatformTrait, PlatformTraitConst, ProgramSourceTrait, ProgramSourceTraitConst, ProgramTrait, ProgramTraitConst, QueueTrait, QueueTraitConst, RNGTrait, RNGTraitConst, RNG_MT19937Trait, RNG_MT19937TraitConst, RangeTrait, RangeTraitConst, SVDTrait, SVDTraitConst, SparseMatConstIteratorTrait, SparseMatConstIteratorTraitConst, SparseMatIteratorTrait, SparseMatIteratorTraitConst, SparseMatTrait, SparseMatTraitConst, SparseMat_HdrTrait, SparseMat_HdrTraitConst, SparseMat_NodeTrait, SparseMat_NodeTraitConst, StreamTrait, StreamTraitConst, TargetArchsTrait, TargetArchsTraitConst, Texture2DTrait, Texture2DTraitConst, TickMeterTrait, TickMeterTraitConst, TimerTrait, TimerTraitConst, UMatDataTrait, UMatDataTraitConst, UMatTrait, UMatTraitConst, WriteStructContextTrait, WriteStructContextTraitConst, _InputArrayTrait, _InputArrayTraitConst, _InputOutputArrayTrait, _InputOutputArrayTraitConst, _OutputArrayTrait, _OutputArrayTraitConst}; } pub const ACCESS_FAST: i32 = 67108864; @@ -11638,11 +11638,11 @@ pub mod core { /// ## C++ default parameters /// * params: FunctionParams() #[inline] - pub fn copy_mat_and_dump_named_arguments(src: &impl ToInputArray, dst: &mut impl ToOutputArray, params: &impl core::FunctionParamsTraitConst) -> Result { + pub fn copy_mat_and_dump_named_arguments(src: &impl ToInputArray, dst: &mut impl ToOutputArray, params: core::FunctionParams) -> Result { input_array_arg!(src); output_array_arg!(dst); return_send!(via ocvrs_return); - unsafe { sys::cv_utils_copyMatAndDumpNamedArguments_const__InputArrayR_const__OutputArrayR_const_FunctionParamsR(src.as_raw__InputArray(), dst.as_raw__OutputArray(), params.as_raw_FunctionParams(), ocvrs_return.as_mut_ptr()) }; + unsafe { sys::cv_utils_copyMatAndDumpNamedArguments_const__InputArrayR_const__OutputArrayR_const_FunctionParamsR(src.as_raw__InputArray(), dst.as_raw__OutputArray(), ¶ms, ocvrs_return.as_mut_ptr()) }; return_receive!(unsafe ocvrs_return => ret); let ret = ret.into_result()?; let ret = unsafe { String::opencv_from_extern(ret) }; @@ -13066,6 +13066,10 @@ pub mod core { /// parser.get("@image"); /// ``` /// + /// + /// ## Note + /// This alternative version of [CommandLineParserTraitConst::get_bool] function uses the following default values for its arguments: + /// * space_delete: true #[inline] fn get_bool_def(&self, name: &str) -> Result { extern_container_arg!(name); @@ -13161,6 +13165,10 @@ pub mod core { /// parser.get("@image"); /// ``` /// + /// + /// ## Note + /// This alternative version of [CommandLineParserTraitConst::get_i32] function uses the following default values for its arguments: + /// * space_delete: true #[inline] fn get_i32_def(&self, name: &str) -> Result { extern_container_arg!(name); @@ -13256,6 +13264,10 @@ pub mod core { /// parser.get("@image"); /// ``` /// + /// + /// ## Note + /// This alternative version of [CommandLineParserTraitConst::get_f64] function uses the following default values for its arguments: + /// * space_delete: true #[inline] fn get_f64_def(&self, name: &str) -> Result { extern_container_arg!(name); @@ -13352,6 +13364,10 @@ pub mod core { /// parser.get("@image"); /// ``` /// + /// + /// ## Note + /// This alternative version of [CommandLineParserTraitConst::get_str] function uses the following default values for its arguments: + /// * space_delete: true #[inline] fn get_str_def(&self, name: &str) -> Result { extern_container_arg!(name); @@ -13448,6 +13464,10 @@ pub mod core { /// parser.get("@image"); /// ``` /// + /// + /// ## Note + /// This alternative version of [CommandLineParserTraitConst::get_u64] function uses the following default values for its arguments: + /// * space_delete: true #[inline] fn get_u64_def(&self, name: &str) -> Result { extern_container_arg!(name); @@ -13524,6 +13544,10 @@ pub mod core { /// * index: index of the argument /// * space_delete: remove spaces from the left and right of the string /// @tparam T the argument will be converted to this type if possible + /// + /// ## Note + /// This alternative version of [CommandLineParserTraitConst::get_bool_idx] function uses the following default values for its arguments: + /// * space_delete: true #[inline] fn get_bool_idx_def(&self, index: i32) -> Result { return_send!(via ocvrs_return); @@ -13599,6 +13623,10 @@ pub mod core { /// * index: index of the argument /// * space_delete: remove spaces from the left and right of the string /// @tparam T the argument will be converted to this type if possible + /// + /// ## Note + /// This alternative version of [CommandLineParserTraitConst::get_i32_idx] function uses the following default values for its arguments: + /// * space_delete: true #[inline] fn get_i32_idx_def(&self, index: i32) -> Result { return_send!(via ocvrs_return); @@ -13674,6 +13702,10 @@ pub mod core { /// * index: index of the argument /// * space_delete: remove spaces from the left and right of the string /// @tparam T the argument will be converted to this type if possible + /// + /// ## Note + /// This alternative version of [CommandLineParserTraitConst::get_f64_idx] function uses the following default values for its arguments: + /// * space_delete: true #[inline] fn get_f64_idx_def(&self, index: i32) -> Result { return_send!(via ocvrs_return); @@ -13750,6 +13782,10 @@ pub mod core { /// * index: index of the argument /// * space_delete: remove spaces from the left and right of the string /// @tparam T the argument will be converted to this type if possible + /// + /// ## Note + /// This alternative version of [CommandLineParserTraitConst::get_str_idx] function uses the following default values for its arguments: + /// * space_delete: true #[inline] fn get_str_idx_def(&self, index: i32) -> Result { return_send!(via ocvrs_return); @@ -13826,6 +13862,10 @@ pub mod core { /// * index: index of the argument /// * space_delete: remove spaces from the left and right of the string /// @tparam T the argument will be converted to this type if possible + /// + /// ## Note + /// This alternative version of [CommandLineParserTraitConst::get_u64_idx] function uses the following default values for its arguments: + /// * space_delete: true #[inline] fn get_u64_idx_def(&self, index: i32) -> Result { return_send!(via ocvrs_return); @@ -15072,9 +15112,6 @@ pub mod core { /// Internal method used when reading FileStorage. /// Sets the type (int, real or string) and value of the previously created node. - /// - /// ## C++ default parameters - /// * len: -1 #[inline] fn set_value(&mut self, typ: i32, value: &mut [u8]) -> Result<()> { return_send!(via ocvrs_return); @@ -15311,9 +15348,6 @@ pub mod core { /// * vec: Pointer to the destination array. /// * len: Number of bytes to read (buffer size limit). If it is greater than number of /// remaining elements then all of them will be read. - /// - /// ## C++ default parameters - /// * len: (size_t)INT_MAX #[inline] fn read_raw(&mut self, fmt: &str, vec: &mut [u8]) -> Result { extern_container_arg!(fmt); @@ -18330,6 +18364,50 @@ pub mod core { core::mat_forward::at(self, i0) } + /// Returns a reference to the specified array element. + /// + /// The template methods return a reference to the specified array element. For the sake of higher + /// performance, the index range checks are only performed in the Debug configuration. + /// + /// Note that the variants with a single index (i) can be used to access elements of single-row or + /// single-column 2-dimensional arrays. That is, if, for example, A is a 1 x N floating-point matrix and + /// B is an M x 1 integer matrix, you can simply write `A.at(k+4)` and `B.at(2*i+1)` + /// instead of `A.at(0,k+4)` and `B.at(2*i+1,0)`, respectively. + /// + /// The example below initializes a Hilbert matrix: + /// ```C++ + /// Mat H(100, 100, CV_64F); + /// for(int i = 0; i < H.rows; i++) + /// for(int j = 0; j < H.cols; j++) + /// H.at(i,j)=1./(i+j+1); + /// ``` + /// + /// + /// Keep in mind that the size identifier used in the at operator cannot be chosen at random. It depends + /// on the image from which you are trying to retrieve the data. The table below gives a better insight in this: + /// - If matrix is of type `CV_8U` then use `Mat.at(y,x)`. + /// - If matrix is of type `CV_8S` then use `Mat.at(y,x)`. + /// - If matrix is of type `CV_16U` then use `Mat.at(y,x)`. + /// - If matrix is of type `CV_16S` then use `Mat.at(y,x)`. + /// - If matrix is of type `CV_32S` then use `Mat.at(y,x)`. + /// - If matrix is of type `CV_32F` then use `Mat.at(y,x)`. + /// - If matrix is of type `CV_64F` then use `Mat.at(y,x)`. + /// + /// ## Parameters + /// * i0: Index along the dimension 0 + /// + /// ## Overloaded parameters + /// + /// * i0: Index along the dimension 0 + /// + /// ## Note + /// This alternative version of [MatTraitConst::at] function uses the following default values for its arguments: + /// * i0: 0 + #[inline] + fn at_def(&self) -> Result<&T> { + core::mat_forward::at_def(self, ) + } + /// Returns a reference to the specified array element. /// /// The template methods return a reference to the specified array element. For the sake of higher @@ -18582,7 +18660,7 @@ pub mod core { } #[inline] - fn set_size(&mut self, val: core::MatSize) { + fn set_mat_size(&mut self, val: core::MatSize) { let ret = unsafe { sys::cv_Mat_propSize_const_MatSize(self.as_raw_mut_Mat(), val.as_raw_MatSize()) }; ret } @@ -19608,6 +19686,46 @@ pub mod core { core::mat_forward::at_mut(self, i0) } + /// Returns a reference to the specified array element. + /// + /// The template methods return a reference to the specified array element. For the sake of higher + /// performance, the index range checks are only performed in the Debug configuration. + /// + /// Note that the variants with a single index (i) can be used to access elements of single-row or + /// single-column 2-dimensional arrays. That is, if, for example, A is a 1 x N floating-point matrix and + /// B is an M x 1 integer matrix, you can simply write `A.at(k+4)` and `B.at(2*i+1)` + /// instead of `A.at(0,k+4)` and `B.at(2*i+1,0)`, respectively. + /// + /// The example below initializes a Hilbert matrix: + /// ```C++ + /// Mat H(100, 100, CV_64F); + /// for(int i = 0; i < H.rows; i++) + /// for(int j = 0; j < H.cols; j++) + /// H.at(i,j)=1./(i+j+1); + /// ``` + /// + /// + /// Keep in mind that the size identifier used in the at operator cannot be chosen at random. It depends + /// on the image from which you are trying to retrieve the data. The table below gives a better insight in this: + /// - If matrix is of type `CV_8U` then use `Mat.at(y,x)`. + /// - If matrix is of type `CV_8S` then use `Mat.at(y,x)`. + /// - If matrix is of type `CV_16U` then use `Mat.at(y,x)`. + /// - If matrix is of type `CV_16S` then use `Mat.at(y,x)`. + /// - If matrix is of type `CV_32S` then use `Mat.at(y,x)`. + /// - If matrix is of type `CV_32F` then use `Mat.at(y,x)`. + /// - If matrix is of type `CV_64F` then use `Mat.at(y,x)`. + /// + /// ## Parameters + /// * i0: Index along the dimension 0 + /// + /// ## Note + /// This alternative version of [MatTrait::at_mut] function uses the following default values for its arguments: + /// * i0: 0 + #[inline] + fn at_mut_def(&mut self) -> Result<&mut T> { + core::mat_forward::at_mut_def(self, ) + } + /// Returns a reference to the specified array element. /// /// The template methods return a reference to the specified array element. For the sake of higher @@ -20683,23 +20801,12 @@ pub mod core { /// download data from GpuMat #[inline] - pub fn from_gpumat(m: &impl core::GpuMatTraitConst) -> Result> { + pub fn from_gpumat(m: &impl core::GpuMatTraitConst) -> Result { return_send!(via ocvrs_return); unsafe { sys::cv_Mat_Mat_const_GpuMatR(m.as_raw_GpuMat(), ocvrs_return.as_mut_ptr()) }; return_receive!(unsafe ocvrs_return => ret); let ret = ret.into_result()?; - let ret = unsafe { BoxedRef::::opencv_from_extern(ret) }; - Ok(ret) - } - - /// download data from GpuMat - #[inline] - pub fn from_gpumat_mut(m: &mut impl core::GpuMatTrait) -> Result> { - return_send!(via ocvrs_return); - unsafe { sys::cv_Mat_Mat_GpuMatR(m.as_raw_mut_GpuMat(), ocvrs_return.as_mut_ptr()) }; - return_receive!(unsafe ocvrs_return => ret); - let ret = ret.into_result()?; - let ret = unsafe { BoxedRefMut::::opencv_from_extern(ret) }; + let ret = unsafe { core::Mat::opencv_from_extern(ret) }; Ok(ret) } @@ -27397,7 +27504,7 @@ pub mod core { /// dimensional size of the matrix; accessible in various formats #[inline] - fn set_size(&mut self, val: core::MatSize) { + fn set_mat_size(&mut self, val: core::MatSize) { let ret = unsafe { sys::cv_UMat_propSize_const_MatSize(self.as_raw_mut_UMat(), val.as_raw_MatSize()) }; ret } @@ -32066,8 +32173,8 @@ pub mod core { /// allocator #[inline] - unsafe fn set_allocator(&mut self, val: &impl core::GpuMat_AllocatorTraitConst) { - let ret = { sys::cv_cuda_GpuMat_propAllocator_AllocatorX(self.as_raw_mut_GpuMat(), val.as_raw_GpuMat_Allocator()) }; + fn set_allocator(&mut self, val: &'static impl core::GpuMat_AllocatorTraitConst) { + let ret = unsafe { sys::cv_cuda_GpuMat_propAllocator_AllocatorX(self.as_raw_mut_GpuMat(), val.as_raw_GpuMat_Allocator()) }; ret } @@ -32433,10 +32540,10 @@ pub mod core { } #[inline] - pub unsafe fn set_default_allocator(allocator: &mut impl core::GpuMat_AllocatorTrait) -> Result<()> { + pub fn set_default_allocator(allocator: &'static mut impl core::GpuMat_AllocatorTrait) -> Result<()> { return_send!(via ocvrs_return); - { sys::cv_cuda_GpuMat_setDefaultAllocator_AllocatorX(allocator.as_raw_mut_GpuMat_Allocator(), ocvrs_return.as_mut_ptr()) }; - return_receive!(ocvrs_return => ret); + unsafe { sys::cv_cuda_GpuMat_setDefaultAllocator_AllocatorX(allocator.as_raw_mut_GpuMat_Allocator(), ocvrs_return.as_mut_ptr()) }; + return_receive!(unsafe ocvrs_return => ret); let ret = ret.into_result()?; Ok(ret) } @@ -39845,110 +39952,32 @@ pub mod core { } - /// Constant methods for [core::FunctionParams] - pub trait FunctionParamsTraitConst { - fn as_raw_FunctionParams(&self) -> *const c_void; - - #[inline] - fn lambda(&self) -> i32 { - let ret = unsafe { sys::cv_utils_FunctionParams_propLambda_const(self.as_raw_FunctionParams()) }; - ret - } - - #[inline] - fn sigma(&self) -> f32 { - let ret = unsafe { sys::cv_utils_FunctionParams_propSigma_const(self.as_raw_FunctionParams()) }; - ret - } - - } - - /// Mutable methods for [core::FunctionParams] - pub trait FunctionParamsTrait: core::FunctionParamsTraitConst { - fn as_raw_mut_FunctionParams(&mut self) -> *mut c_void; - - /// ## C++ default parameters - /// * val: -1 - #[inline] - fn set_lambda(&mut self, val: i32) { - let ret = unsafe { sys::cv_utils_FunctionParams_propLambda_const_int(self.as_raw_mut_FunctionParams(), val) }; - ret - } - - /// ## C++ default parameters - /// * val: 0.0f - #[inline] - fn set_sigma(&mut self, val: f32) { - let ret = unsafe { sys::cv_utils_FunctionParams_propSigma_const_float(self.as_raw_mut_FunctionParams(), val) }; - ret - } - - #[inline] - fn set_lambda_1(&mut self, value: i32) -> core::FunctionParams { - let ret = unsafe { sys::cv_utils_FunctionParams_setLambda_int(self.as_raw_mut_FunctionParams(), value) }; - let ret = unsafe { core::FunctionParams::opencv_from_extern(ret) }; - ret - } - - #[inline] - fn set_sigma_1(&mut self, value: f32) -> core::FunctionParams { - let ret = unsafe { sys::cv_utils_FunctionParams_setSigma_float(self.as_raw_mut_FunctionParams(), value) }; - let ret = unsafe { core::FunctionParams::opencv_from_extern(ret) }; - ret - } - - } - + #[repr(C)] + #[derive(Copy, Clone, Debug, PartialEq)] pub struct FunctionParams { - ptr: *mut c_void, - } - - opencv_type_boxed! { FunctionParams } - - impl Drop for FunctionParams { - #[inline] - fn drop(&mut self) { - unsafe { sys::cv_utils_FunctionParams_delete(self.as_raw_mut_FunctionParams()) }; - } - } - - unsafe impl Send for FunctionParams {} - - impl core::FunctionParamsTraitConst for FunctionParams { - #[inline] fn as_raw_FunctionParams(&self) -> *const c_void { self.as_raw() } - } - - impl core::FunctionParamsTrait for FunctionParams { - #[inline] fn as_raw_mut_FunctionParams(&mut self) -> *mut c_void { self.as_raw_mut() } + pub lambda: i32, + pub sigma: f32, } - boxed_ref! { FunctionParams, core::FunctionParamsTraitConst, as_raw_FunctionParams, core::FunctionParamsTrait, as_raw_mut_FunctionParams } + opencv_type_simple! { core::FunctionParams } impl FunctionParams { - /// Creates a default instance of the class by calling the default constructor #[inline] - fn default() -> Self { - unsafe { Self::from_raw(sys::cv_utils_FunctionParams_defaultNew_const()) } + pub fn set_lambda(self, value: i32) -> core::FunctionParams { + return_send!(via ocvrs_return); + unsafe { sys::cv_utils_FunctionParams_setLambda_int(&self, value, ocvrs_return.as_mut_ptr()) }; + return_receive!(unsafe ocvrs_return => ret); + ret } - } - - impl std::fmt::Debug for FunctionParams { #[inline] - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - f.debug_struct("FunctionParams") - .field("lambda", &core::FunctionParamsTraitConst::lambda(self)) - .field("sigma", &core::FunctionParamsTraitConst::sigma(self)) - .finish() + pub fn set_sigma(self, value: f32) -> core::FunctionParams { + return_send!(via ocvrs_return); + unsafe { sys::cv_utils_FunctionParams_setSigma_float(&self, value, ocvrs_return.as_mut_ptr()) }; + return_receive!(unsafe ocvrs_return => ret); + ret } - } - impl Default for FunctionParams { - #[inline] - /// Forwards to infallible Self::default() - fn default() -> Self { - Self::default() - } } /// Constant methods for [core::LogTag] diff --git a/docs/cudalegacy.rs b/docs/cudalegacy.rs new file mode 100644 index 00000000..ff7822e3 --- /dev/null +++ b/docs/cudalegacy.rs @@ -0,0 +1,1235 @@ +pub mod cudalegacy { + //! # Legacy support + use crate::mod_prelude::*; + use crate::{core, sys, types}; + pub mod prelude { + pub use super::{CUDA_BackgroundSubtractorFGDTrait, CUDA_BackgroundSubtractorFGDTraitConst, CUDA_BackgroundSubtractorGMGTrait, CUDA_BackgroundSubtractorGMGTraitConst, CUDA_FGDParamsTrait, CUDA_FGDParamsTraitConst, CUDA_FastOpticalFlowBMTrait, CUDA_FastOpticalFlowBMTraitConst, CUDA_ImagePyramidTrait, CUDA_ImagePyramidTraitConst}; + } + + /// Calculates optical flow for 2 images using block matching algorithm + /// + /// ## Note + /// This alternative version of [calc_optical_flow_bm] function uses the following default values for its arguments: + /// * stream: Stream::Null() + #[inline] + pub fn calc_optical_flow_bm_def(prev: &impl core::GpuMatTraitConst, curr: &impl core::GpuMatTraitConst, block_size: core::Size, shift_size: core::Size, max_range: core::Size, use_previous: bool, velx: &mut impl core::GpuMatTrait, vely: &mut impl core::GpuMatTrait, buf: &mut impl core::GpuMatTrait) -> Result<()> { + return_send!(via ocvrs_return); + unsafe { sys::cv_cuda_calcOpticalFlowBM_const_GpuMatR_const_GpuMatR_Size_Size_Size_bool_GpuMatR_GpuMatR_GpuMatR(prev.as_raw_GpuMat(), curr.as_raw_GpuMat(), &block_size, &shift_size, &max_range, use_previous, velx.as_raw_mut_GpuMat(), vely.as_raw_mut_GpuMat(), buf.as_raw_mut_GpuMat(), ocvrs_return.as_mut_ptr()) }; + return_receive!(unsafe ocvrs_return => ret); + let ret = ret.into_result()?; + Ok(ret) + } + + /// Calculates optical flow for 2 images using block matching algorithm + /// + /// ## C++ default parameters + /// * stream: Stream::Null() + #[inline] + pub fn calc_optical_flow_bm(prev: &impl core::GpuMatTraitConst, curr: &impl core::GpuMatTraitConst, block_size: core::Size, shift_size: core::Size, max_range: core::Size, use_previous: bool, velx: &mut impl core::GpuMatTrait, vely: &mut impl core::GpuMatTrait, buf: &mut impl core::GpuMatTrait, stream: &mut impl core::StreamTrait) -> Result<()> { + return_send!(via ocvrs_return); + unsafe { sys::cv_cuda_calcOpticalFlowBM_const_GpuMatR_const_GpuMatR_Size_Size_Size_bool_GpuMatR_GpuMatR_GpuMatR_StreamR(prev.as_raw_GpuMat(), curr.as_raw_GpuMat(), &block_size, &shift_size, &max_range, use_previous, velx.as_raw_mut_GpuMat(), vely.as_raw_mut_GpuMat(), buf.as_raw_mut_GpuMat(), stream.as_raw_mut_Stream(), ocvrs_return.as_mut_ptr()) }; + return_receive!(unsafe ocvrs_return => ret); + let ret = ret.into_result()?; + Ok(ret) + } + + /// compute mask for Generalized Flood fill componetns labeling. + /// + /// ## Note + /// This alternative version of [connectivity_mask] function uses the following default values for its arguments: + /// * stream: Stream::Null() + #[inline] + pub fn connectivity_mask_def(image: &impl core::GpuMatTraitConst, mask: &mut impl core::GpuMatTrait, lo: core::Scalar, hi: core::Scalar) -> Result<()> { + return_send!(via ocvrs_return); + unsafe { sys::cv_cuda_connectivityMask_const_GpuMatR_GpuMatR_const_ScalarR_const_ScalarR(image.as_raw_GpuMat(), mask.as_raw_mut_GpuMat(), &lo, &hi, ocvrs_return.as_mut_ptr()) }; + return_receive!(unsafe ocvrs_return => ret); + let ret = ret.into_result()?; + Ok(ret) + } + + /// compute mask for Generalized Flood fill componetns labeling. + /// + /// ## C++ default parameters + /// * stream: Stream::Null() + #[inline] + pub fn connectivity_mask(image: &impl core::GpuMatTraitConst, mask: &mut impl core::GpuMatTrait, lo: core::Scalar, hi: core::Scalar, stream: &mut impl core::StreamTrait) -> Result<()> { + return_send!(via ocvrs_return); + unsafe { sys::cv_cuda_connectivityMask_const_GpuMatR_GpuMatR_const_ScalarR_const_ScalarR_StreamR(image.as_raw_GpuMat(), mask.as_raw_mut_GpuMat(), &lo, &hi, stream.as_raw_mut_Stream(), ocvrs_return.as_mut_ptr()) }; + return_receive!(unsafe ocvrs_return => ret); + let ret = ret.into_result()?; + Ok(ret) + } + + /// Creates FGD Background Subtractor + /// + /// ## Parameters + /// * params: Algorithm's parameters. See [FGD2003](https://docs.opencv.org/4.11.0/d0/de3/citelist.html#CITEREF_FGD2003) for explanation. + /// + /// ## Note + /// This alternative version of [create_background_subtractor_fgd] function uses the following default values for its arguments: + /// * params: FGDParams() + #[inline] + pub fn create_background_subtractor_fgd_def() -> Result> { + return_send!(via ocvrs_return); + unsafe { sys::cv_cuda_createBackgroundSubtractorFGD(ocvrs_return.as_mut_ptr()) }; + return_receive!(unsafe ocvrs_return => ret); + let ret = ret.into_result()?; + let ret = unsafe { core::Ptr::::opencv_from_extern(ret) }; + Ok(ret) + } + + /// Creates FGD Background Subtractor + /// + /// ## Parameters + /// * params: Algorithm's parameters. See [FGD2003](https://docs.opencv.org/4.11.0/d0/de3/citelist.html#CITEREF_FGD2003) for explanation. + /// + /// ## C++ default parameters + /// * params: FGDParams() + #[inline] + pub fn create_background_subtractor_fgd(params: &impl crate::cudalegacy::CUDA_FGDParamsTraitConst) -> Result> { + return_send!(via ocvrs_return); + unsafe { sys::cv_cuda_createBackgroundSubtractorFGD_const_FGDParamsR(params.as_raw_CUDA_FGDParams(), ocvrs_return.as_mut_ptr()) }; + return_receive!(unsafe ocvrs_return => ret); + let ret = ret.into_result()?; + let ret = unsafe { core::Ptr::::opencv_from_extern(ret) }; + Ok(ret) + } + + /// Creates GMG Background Subtractor + /// + /// ## Parameters + /// * initializationFrames: Number of frames of video to use to initialize histograms. + /// * decisionThreshold: Value above which pixel is determined to be FG. + /// + /// ## Note + /// This alternative version of [create_background_subtractor_gmg] function uses the following default values for its arguments: + /// * initialization_frames: 120 + /// * decision_threshold: 0.8 + #[inline] + pub fn create_background_subtractor_gmg_def() -> Result> { + return_send!(via ocvrs_return); + unsafe { sys::cv_cuda_createBackgroundSubtractorGMG(ocvrs_return.as_mut_ptr()) }; + return_receive!(unsafe ocvrs_return => ret); + let ret = ret.into_result()?; + let ret = unsafe { core::Ptr::::opencv_from_extern(ret) }; + Ok(ret) + } + + /// Creates GMG Background Subtractor + /// + /// ## Parameters + /// * initializationFrames: Number of frames of video to use to initialize histograms. + /// * decisionThreshold: Value above which pixel is determined to be FG. + /// + /// ## C++ default parameters + /// * initialization_frames: 120 + /// * decision_threshold: 0.8 + #[inline] + pub fn create_background_subtractor_gmg(initialization_frames: i32, decision_threshold: f64) -> Result> { + return_send!(via ocvrs_return); + unsafe { sys::cv_cuda_createBackgroundSubtractorGMG_int_double(initialization_frames, decision_threshold, ocvrs_return.as_mut_ptr()) }; + return_receive!(unsafe ocvrs_return => ret); + let ret = ret.into_result()?; + let ret = unsafe { core::Ptr::::opencv_from_extern(ret) }; + Ok(ret) + } + + /// ## Note + /// This alternative version of [create_image_pyramid] function uses the following default values for its arguments: + /// * n_layers: -1 + /// * stream: Stream::Null() + #[inline] + pub fn create_image_pyramid_def(img: &impl ToInputArray) -> Result> { + input_array_arg!(img); + return_send!(via ocvrs_return); + unsafe { sys::cv_cuda_createImagePyramid_const__InputArrayR(img.as_raw__InputArray(), ocvrs_return.as_mut_ptr()) }; + return_receive!(unsafe ocvrs_return => ret); + let ret = ret.into_result()?; + let ret = unsafe { core::Ptr::::opencv_from_extern(ret) }; + Ok(ret) + } + + /// ## C++ default parameters + /// * n_layers: -1 + /// * stream: Stream::Null() + #[inline] + pub fn create_image_pyramid(img: &impl ToInputArray, n_layers: i32, stream: &mut impl core::StreamTrait) -> Result> { + input_array_arg!(img); + return_send!(via ocvrs_return); + unsafe { sys::cv_cuda_createImagePyramid_const__InputArrayR_int_StreamR(img.as_raw__InputArray(), n_layers, stream.as_raw_mut_Stream(), ocvrs_return.as_mut_ptr()) }; + return_receive!(unsafe ocvrs_return => ret); + let ret = ret.into_result()?; + let ret = unsafe { core::Ptr::::opencv_from_extern(ret) }; + Ok(ret) + } + + #[inline] + pub fn create_optical_flow_needle_map(u: &impl core::GpuMatTraitConst, v: &impl core::GpuMatTraitConst, vertex: &mut impl core::GpuMatTrait, colors: &mut impl core::GpuMatTrait) -> Result<()> { + return_send!(via ocvrs_return); + unsafe { sys::cv_cuda_createOpticalFlowNeedleMap_const_GpuMatR_const_GpuMatR_GpuMatR_GpuMatR(u.as_raw_GpuMat(), v.as_raw_GpuMat(), vertex.as_raw_mut_GpuMat(), colors.as_raw_mut_GpuMat(), ocvrs_return.as_mut_ptr()) }; + return_receive!(unsafe ocvrs_return => ret); + let ret = ret.into_result()?; + Ok(ret) + } + + /// performs labeling via graph cuts of a 2D regular 4-connected graph. + /// + /// ## Note + /// This alternative version of [graphcut] function uses the following default values for its arguments: + /// * stream: Stream::Null() + #[inline] + pub fn graphcut_def(terminals: &mut impl core::GpuMatTrait, left_transp: &mut impl core::GpuMatTrait, right_transp: &mut impl core::GpuMatTrait, top: &mut impl core::GpuMatTrait, bottom: &mut impl core::GpuMatTrait, labels: &mut impl core::GpuMatTrait, buf: &mut impl core::GpuMatTrait) -> Result<()> { + return_send!(via ocvrs_return); + unsafe { sys::cv_cuda_graphcut_GpuMatR_GpuMatR_GpuMatR_GpuMatR_GpuMatR_GpuMatR_GpuMatR(terminals.as_raw_mut_GpuMat(), left_transp.as_raw_mut_GpuMat(), right_transp.as_raw_mut_GpuMat(), top.as_raw_mut_GpuMat(), bottom.as_raw_mut_GpuMat(), labels.as_raw_mut_GpuMat(), buf.as_raw_mut_GpuMat(), ocvrs_return.as_mut_ptr()) }; + return_receive!(unsafe ocvrs_return => ret); + let ret = ret.into_result()?; + Ok(ret) + } + + /// performs labeling via graph cuts of a 2D regular 8-connected graph. + /// + /// ## Note + /// This alternative version of [graphcut_1] function uses the following default values for its arguments: + /// * stream: Stream::Null() + #[inline] + pub fn graphcut_1_def(terminals: &mut impl core::GpuMatTrait, left_transp: &mut impl core::GpuMatTrait, right_transp: &mut impl core::GpuMatTrait, top: &mut impl core::GpuMatTrait, top_left: &mut impl core::GpuMatTrait, top_right: &mut impl core::GpuMatTrait, bottom: &mut impl core::GpuMatTrait, bottom_left: &mut impl core::GpuMatTrait, bottom_right: &mut impl core::GpuMatTrait, labels: &mut impl core::GpuMatTrait, buf: &mut impl core::GpuMatTrait) -> Result<()> { + return_send!(via ocvrs_return); + unsafe { sys::cv_cuda_graphcut_GpuMatR_GpuMatR_GpuMatR_GpuMatR_GpuMatR_GpuMatR_GpuMatR_GpuMatR_GpuMatR_GpuMatR_GpuMatR(terminals.as_raw_mut_GpuMat(), left_transp.as_raw_mut_GpuMat(), right_transp.as_raw_mut_GpuMat(), top.as_raw_mut_GpuMat(), top_left.as_raw_mut_GpuMat(), top_right.as_raw_mut_GpuMat(), bottom.as_raw_mut_GpuMat(), bottom_left.as_raw_mut_GpuMat(), bottom_right.as_raw_mut_GpuMat(), labels.as_raw_mut_GpuMat(), buf.as_raw_mut_GpuMat(), ocvrs_return.as_mut_ptr()) }; + return_receive!(unsafe ocvrs_return => ret); + let ret = ret.into_result()?; + Ok(ret) + } + + /// performs labeling via graph cuts of a 2D regular 8-connected graph. + /// + /// ## C++ default parameters + /// * stream: Stream::Null() + #[inline] + pub fn graphcut_1(terminals: &mut impl core::GpuMatTrait, left_transp: &mut impl core::GpuMatTrait, right_transp: &mut impl core::GpuMatTrait, top: &mut impl core::GpuMatTrait, top_left: &mut impl core::GpuMatTrait, top_right: &mut impl core::GpuMatTrait, bottom: &mut impl core::GpuMatTrait, bottom_left: &mut impl core::GpuMatTrait, bottom_right: &mut impl core::GpuMatTrait, labels: &mut impl core::GpuMatTrait, buf: &mut impl core::GpuMatTrait, stream: &mut impl core::StreamTrait) -> Result<()> { + return_send!(via ocvrs_return); + unsafe { sys::cv_cuda_graphcut_GpuMatR_GpuMatR_GpuMatR_GpuMatR_GpuMatR_GpuMatR_GpuMatR_GpuMatR_GpuMatR_GpuMatR_GpuMatR_StreamR(terminals.as_raw_mut_GpuMat(), left_transp.as_raw_mut_GpuMat(), right_transp.as_raw_mut_GpuMat(), top.as_raw_mut_GpuMat(), top_left.as_raw_mut_GpuMat(), top_right.as_raw_mut_GpuMat(), bottom.as_raw_mut_GpuMat(), bottom_left.as_raw_mut_GpuMat(), bottom_right.as_raw_mut_GpuMat(), labels.as_raw_mut_GpuMat(), buf.as_raw_mut_GpuMat(), stream.as_raw_mut_Stream(), ocvrs_return.as_mut_ptr()) }; + return_receive!(unsafe ocvrs_return => ret); + let ret = ret.into_result()?; + Ok(ret) + } + + /// performs labeling via graph cuts of a 2D regular 4-connected graph. + /// + /// ## C++ default parameters + /// * stream: Stream::Null() + #[inline] + pub fn graphcut(terminals: &mut impl core::GpuMatTrait, left_transp: &mut impl core::GpuMatTrait, right_transp: &mut impl core::GpuMatTrait, top: &mut impl core::GpuMatTrait, bottom: &mut impl core::GpuMatTrait, labels: &mut impl core::GpuMatTrait, buf: &mut impl core::GpuMatTrait, stream: &mut impl core::StreamTrait) -> Result<()> { + return_send!(via ocvrs_return); + unsafe { sys::cv_cuda_graphcut_GpuMatR_GpuMatR_GpuMatR_GpuMatR_GpuMatR_GpuMatR_GpuMatR_StreamR(terminals.as_raw_mut_GpuMat(), left_transp.as_raw_mut_GpuMat(), right_transp.as_raw_mut_GpuMat(), top.as_raw_mut_GpuMat(), bottom.as_raw_mut_GpuMat(), labels.as_raw_mut_GpuMat(), buf.as_raw_mut_GpuMat(), stream.as_raw_mut_Stream(), ocvrs_return.as_mut_ptr()) }; + return_receive!(unsafe ocvrs_return => ret); + let ret = ret.into_result()?; + Ok(ret) + } + + /// Interpolates frames (images) using provided optical flow (displacement field). + /// + /// ## Parameters + /// * frame0: First frame (32-bit floating point images, single channel). + /// * frame1: Second frame. Must have the same type and size as frame0 . + /// * fu: Forward horizontal displacement. + /// * fv: Forward vertical displacement. + /// * bu: Backward horizontal displacement. + /// * bv: Backward vertical displacement. + /// * pos: New frame position. + /// * newFrame: Output image. + /// * buf: Temporary buffer, will have width x 6\*height size, CV_32FC1 type and contain 6 + /// GpuMat: occlusion masks for first frame, occlusion masks for second, interpolated forward + /// horizontal flow, interpolated forward vertical flow, interpolated backward horizontal flow, + /// interpolated backward vertical flow. + /// * stream: Stream for the asynchronous version. + /// + /// ## Note + /// This alternative version of [interpolate_frames] function uses the following default values for its arguments: + /// * stream: Stream::Null() + #[inline] + pub fn interpolate_frames_def(frame0: &impl core::GpuMatTraitConst, frame1: &impl core::GpuMatTraitConst, fu: &impl core::GpuMatTraitConst, fv: &impl core::GpuMatTraitConst, bu: &impl core::GpuMatTraitConst, bv: &impl core::GpuMatTraitConst, pos: f32, new_frame: &mut impl core::GpuMatTrait, buf: &mut impl core::GpuMatTrait) -> Result<()> { + return_send!(via ocvrs_return); + unsafe { sys::cv_cuda_interpolateFrames_const_GpuMatR_const_GpuMatR_const_GpuMatR_const_GpuMatR_const_GpuMatR_const_GpuMatR_float_GpuMatR_GpuMatR(frame0.as_raw_GpuMat(), frame1.as_raw_GpuMat(), fu.as_raw_GpuMat(), fv.as_raw_GpuMat(), bu.as_raw_GpuMat(), bv.as_raw_GpuMat(), pos, new_frame.as_raw_mut_GpuMat(), buf.as_raw_mut_GpuMat(), ocvrs_return.as_mut_ptr()) }; + return_receive!(unsafe ocvrs_return => ret); + let ret = ret.into_result()?; + Ok(ret) + } + + /// Interpolates frames (images) using provided optical flow (displacement field). + /// + /// ## Parameters + /// * frame0: First frame (32-bit floating point images, single channel). + /// * frame1: Second frame. Must have the same type and size as frame0 . + /// * fu: Forward horizontal displacement. + /// * fv: Forward vertical displacement. + /// * bu: Backward horizontal displacement. + /// * bv: Backward vertical displacement. + /// * pos: New frame position. + /// * newFrame: Output image. + /// * buf: Temporary buffer, will have width x 6\*height size, CV_32FC1 type and contain 6 + /// GpuMat: occlusion masks for first frame, occlusion masks for second, interpolated forward + /// horizontal flow, interpolated forward vertical flow, interpolated backward horizontal flow, + /// interpolated backward vertical flow. + /// * stream: Stream for the asynchronous version. + /// + /// ## C++ default parameters + /// * stream: Stream::Null() + #[inline] + pub fn interpolate_frames(frame0: &impl core::GpuMatTraitConst, frame1: &impl core::GpuMatTraitConst, fu: &impl core::GpuMatTraitConst, fv: &impl core::GpuMatTraitConst, bu: &impl core::GpuMatTraitConst, bv: &impl core::GpuMatTraitConst, pos: f32, new_frame: &mut impl core::GpuMatTrait, buf: &mut impl core::GpuMatTrait, stream: &mut impl core::StreamTrait) -> Result<()> { + return_send!(via ocvrs_return); + unsafe { sys::cv_cuda_interpolateFrames_const_GpuMatR_const_GpuMatR_const_GpuMatR_const_GpuMatR_const_GpuMatR_const_GpuMatR_float_GpuMatR_GpuMatR_StreamR(frame0.as_raw_GpuMat(), frame1.as_raw_GpuMat(), fu.as_raw_GpuMat(), fv.as_raw_GpuMat(), bu.as_raw_GpuMat(), bv.as_raw_GpuMat(), pos, new_frame.as_raw_mut_GpuMat(), buf.as_raw_mut_GpuMat(), stream.as_raw_mut_Stream(), ocvrs_return.as_mut_ptr()) }; + return_receive!(unsafe ocvrs_return => ret); + let ret = ret.into_result()?; + Ok(ret) + } + + /// performs connected componnents labeling. + /// + /// ## Note + /// This alternative version of [label_components] function uses the following default values for its arguments: + /// * flags: 0 + /// * stream: Stream::Null() + #[inline] + pub fn label_components_def(mask: &impl core::GpuMatTraitConst, components: &mut impl core::GpuMatTrait) -> Result<()> { + return_send!(via ocvrs_return); + unsafe { sys::cv_cuda_labelComponents_const_GpuMatR_GpuMatR(mask.as_raw_GpuMat(), components.as_raw_mut_GpuMat(), ocvrs_return.as_mut_ptr()) }; + return_receive!(unsafe ocvrs_return => ret); + let ret = ret.into_result()?; + Ok(ret) + } + + /// performs connected componnents labeling. + /// + /// ## C++ default parameters + /// * flags: 0 + /// * stream: Stream::Null() + #[inline] + pub fn label_components(mask: &impl core::GpuMatTraitConst, components: &mut impl core::GpuMatTrait, flags: i32, stream: &mut impl core::StreamTrait) -> Result<()> { + return_send!(via ocvrs_return); + unsafe { sys::cv_cuda_labelComponents_const_GpuMatR_GpuMatR_int_StreamR(mask.as_raw_GpuMat(), components.as_raw_mut_GpuMat(), flags, stream.as_raw_mut_Stream(), ocvrs_return.as_mut_ptr()) }; + return_receive!(unsafe ocvrs_return => ret); + let ret = ret.into_result()?; + Ok(ret) + } + + /// ## Note + /// This alternative version of [project_points] function uses the following default values for its arguments: + /// * stream: Stream::Null() + #[inline] + pub fn project_points_def(src: &impl core::GpuMatTraitConst, rvec: &impl core::MatTraitConst, tvec: &impl core::MatTraitConst, camera_mat: &impl core::MatTraitConst, dist_coef: &impl core::MatTraitConst, dst: &mut impl core::GpuMatTrait) -> Result<()> { + return_send!(via ocvrs_return); + unsafe { sys::cv_cuda_projectPoints_const_GpuMatR_const_MatR_const_MatR_const_MatR_const_MatR_GpuMatR(src.as_raw_GpuMat(), rvec.as_raw_Mat(), tvec.as_raw_Mat(), camera_mat.as_raw_Mat(), dist_coef.as_raw_Mat(), dst.as_raw_mut_GpuMat(), ocvrs_return.as_mut_ptr()) }; + return_receive!(unsafe ocvrs_return => ret); + let ret = ret.into_result()?; + Ok(ret) + } + + /// ## C++ default parameters + /// * stream: Stream::Null() + #[inline] + pub fn project_points(src: &impl core::GpuMatTraitConst, rvec: &impl core::MatTraitConst, tvec: &impl core::MatTraitConst, camera_mat: &impl core::MatTraitConst, dist_coef: &impl core::MatTraitConst, dst: &mut impl core::GpuMatTrait, stream: &mut impl core::StreamTrait) -> Result<()> { + return_send!(via ocvrs_return); + unsafe { sys::cv_cuda_projectPoints_const_GpuMatR_const_MatR_const_MatR_const_MatR_const_MatR_GpuMatR_StreamR(src.as_raw_GpuMat(), rvec.as_raw_Mat(), tvec.as_raw_Mat(), camera_mat.as_raw_Mat(), dist_coef.as_raw_Mat(), dst.as_raw_mut_GpuMat(), stream.as_raw_mut_Stream(), ocvrs_return.as_mut_ptr()) }; + return_receive!(unsafe ocvrs_return => ret); + let ret = ret.into_result()?; + Ok(ret) + } + + /// Finds the object pose from 3D-2D point correspondences. + /// + /// ## Parameters + /// * object: Single-row matrix of object points. + /// * image: Single-row matrix of image points. + /// * camera_mat: 3x3 matrix of intrinsic camera parameters. + /// * dist_coef: Distortion coefficients. See undistortPoints for details. + /// * rvec: Output 3D rotation vector. + /// * tvec: Output 3D translation vector. + /// * use_extrinsic_guess: Flag to indicate that the function must use rvec and tvec as an + /// initial transformation guess. It is not supported for now. + /// * num_iters: Maximum number of RANSAC iterations. + /// * max_dist: Euclidean distance threshold to detect whether point is inlier or not. + /// * min_inlier_count: Flag to indicate that the function must stop if greater or equal number + /// of inliers is achieved. It is not supported for now. + /// * inliers: Output vector of inlier indices. + /// + /// ## Note + /// This alternative version of [solve_pnp_ransac] function uses the following default values for its arguments: + /// * use_extrinsic_guess: false + /// * num_iters: 100 + /// * max_dist: 8.0 + /// * min_inlier_count: 100 + /// * inliers: NULL + #[inline] + pub fn solve_pnp_ransac_def(object: &impl core::MatTraitConst, image: &impl core::MatTraitConst, camera_mat: &impl core::MatTraitConst, dist_coef: &impl core::MatTraitConst, rvec: &mut impl core::MatTrait, tvec: &mut impl core::MatTrait) -> Result<()> { + return_send!(via ocvrs_return); + unsafe { sys::cv_cuda_solvePnPRansac_const_MatR_const_MatR_const_MatR_const_MatR_MatR_MatR(object.as_raw_Mat(), image.as_raw_Mat(), camera_mat.as_raw_Mat(), dist_coef.as_raw_Mat(), rvec.as_raw_mut_Mat(), tvec.as_raw_mut_Mat(), ocvrs_return.as_mut_ptr()) }; + return_receive!(unsafe ocvrs_return => ret); + let ret = ret.into_result()?; + Ok(ret) + } + + /// Finds the object pose from 3D-2D point correspondences. + /// + /// ## Parameters + /// * object: Single-row matrix of object points. + /// * image: Single-row matrix of image points. + /// * camera_mat: 3x3 matrix of intrinsic camera parameters. + /// * dist_coef: Distortion coefficients. See undistortPoints for details. + /// * rvec: Output 3D rotation vector. + /// * tvec: Output 3D translation vector. + /// * use_extrinsic_guess: Flag to indicate that the function must use rvec and tvec as an + /// initial transformation guess. It is not supported for now. + /// * num_iters: Maximum number of RANSAC iterations. + /// * max_dist: Euclidean distance threshold to detect whether point is inlier or not. + /// * min_inlier_count: Flag to indicate that the function must stop if greater or equal number + /// of inliers is achieved. It is not supported for now. + /// * inliers: Output vector of inlier indices. + /// + /// ## C++ default parameters + /// * use_extrinsic_guess: false + /// * num_iters: 100 + /// * max_dist: 8.0 + /// * min_inlier_count: 100 + /// * inliers: NULL + #[inline] + pub fn solve_pnp_ransac(object: &impl core::MatTraitConst, image: &impl core::MatTraitConst, camera_mat: &impl core::MatTraitConst, dist_coef: &impl core::MatTraitConst, rvec: &mut impl core::MatTrait, tvec: &mut impl core::MatTrait, use_extrinsic_guess: bool, num_iters: i32, max_dist: f32, min_inlier_count: i32, inliers: &mut core::Vector) -> Result<()> { + return_send!(via ocvrs_return); + unsafe { sys::cv_cuda_solvePnPRansac_const_MatR_const_MatR_const_MatR_const_MatR_MatR_MatR_bool_int_float_int_vectorLintGX(object.as_raw_Mat(), image.as_raw_Mat(), camera_mat.as_raw_Mat(), dist_coef.as_raw_Mat(), rvec.as_raw_mut_Mat(), tvec.as_raw_mut_Mat(), use_extrinsic_guess, num_iters, max_dist, min_inlier_count, inliers.as_raw_mut_VectorOfi32(), ocvrs_return.as_mut_ptr()) }; + return_receive!(unsafe ocvrs_return => ret); + let ret = ret.into_result()?; + Ok(ret) + } + + /// ## Note + /// This alternative version of [transform_points] function uses the following default values for its arguments: + /// * stream: Stream::Null() + #[inline] + pub fn transform_points_def(src: &impl core::GpuMatTraitConst, rvec: &impl core::MatTraitConst, tvec: &impl core::MatTraitConst, dst: &mut impl core::GpuMatTrait) -> Result<()> { + return_send!(via ocvrs_return); + unsafe { sys::cv_cuda_transformPoints_const_GpuMatR_const_MatR_const_MatR_GpuMatR(src.as_raw_GpuMat(), rvec.as_raw_Mat(), tvec.as_raw_Mat(), dst.as_raw_mut_GpuMat(), ocvrs_return.as_mut_ptr()) }; + return_receive!(unsafe ocvrs_return => ret); + let ret = ret.into_result()?; + Ok(ret) + } + + /// ## C++ default parameters + /// * stream: Stream::Null() + #[inline] + pub fn transform_points(src: &impl core::GpuMatTraitConst, rvec: &impl core::MatTraitConst, tvec: &impl core::MatTraitConst, dst: &mut impl core::GpuMatTrait, stream: &mut impl core::StreamTrait) -> Result<()> { + return_send!(via ocvrs_return); + unsafe { sys::cv_cuda_transformPoints_const_GpuMatR_const_MatR_const_MatR_GpuMatR_StreamR(src.as_raw_GpuMat(), rvec.as_raw_Mat(), tvec.as_raw_Mat(), dst.as_raw_mut_GpuMat(), stream.as_raw_mut_Stream(), ocvrs_return.as_mut_ptr()) }; + return_receive!(unsafe ocvrs_return => ret); + let ret = ret.into_result()?; + Ok(ret) + } + + /// Constant methods for [crate::cudalegacy::CUDA_BackgroundSubtractorFGD] + pub trait CUDA_BackgroundSubtractorFGDTraitConst: crate::video::BackgroundSubtractorTraitConst { + fn as_raw_CUDA_BackgroundSubtractorFGD(&self) -> *const c_void; + + } + + /// Mutable methods for [crate::cudalegacy::CUDA_BackgroundSubtractorFGD] + pub trait CUDA_BackgroundSubtractorFGDTrait: crate::cudalegacy::CUDA_BackgroundSubtractorFGDTraitConst + crate::video::BackgroundSubtractorTrait { + fn as_raw_mut_CUDA_BackgroundSubtractorFGD(&mut self) -> *mut c_void; + + /// Returns the output foreground regions calculated by findContours. + /// + /// ## Parameters + /// * foreground_regions: Output array (CPU memory). + #[inline] + fn get_foreground_regions(&mut self, foreground_regions: &mut impl ToOutputArray) -> Result<()> { + output_array_arg!(foreground_regions); + return_send!(via ocvrs_return); + unsafe { sys::cv_cuda_BackgroundSubtractorFGD_getForegroundRegions_const__OutputArrayR(self.as_raw_mut_CUDA_BackgroundSubtractorFGD(), foreground_regions.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) }; + return_receive!(unsafe ocvrs_return => ret); + let ret = ret.into_result()?; + Ok(ret) + } + + } + + /// The class discriminates between foreground and background pixels by building and maintaining a model + /// of the background. + /// + /// Any pixel which does not fit this model is then deemed to be foreground. The class implements + /// algorithm described in [FGD2003](https://docs.opencv.org/4.11.0/d0/de3/citelist.html#CITEREF_FGD2003) . + /// ## See also + /// BackgroundSubtractor + pub struct CUDA_BackgroundSubtractorFGD { + ptr: *mut c_void, + } + + opencv_type_boxed! { CUDA_BackgroundSubtractorFGD } + + impl Drop for CUDA_BackgroundSubtractorFGD { + #[inline] + fn drop(&mut self) { + unsafe { sys::cv_cuda_BackgroundSubtractorFGD_delete(self.as_raw_mut_CUDA_BackgroundSubtractorFGD()) }; + } + } + + unsafe impl Send for CUDA_BackgroundSubtractorFGD {} + + impl core::AlgorithmTraitConst for CUDA_BackgroundSubtractorFGD { + #[inline] fn as_raw_Algorithm(&self) -> *const c_void { self.as_raw() } + } + + impl core::AlgorithmTrait for CUDA_BackgroundSubtractorFGD { + #[inline] fn as_raw_mut_Algorithm(&mut self) -> *mut c_void { self.as_raw_mut() } + } + + boxed_ref! { CUDA_BackgroundSubtractorFGD, core::AlgorithmTraitConst, as_raw_Algorithm, core::AlgorithmTrait, as_raw_mut_Algorithm } + + impl crate::video::BackgroundSubtractorTraitConst for CUDA_BackgroundSubtractorFGD { + #[inline] fn as_raw_BackgroundSubtractor(&self) -> *const c_void { self.as_raw() } + } + + impl crate::video::BackgroundSubtractorTrait for CUDA_BackgroundSubtractorFGD { + #[inline] fn as_raw_mut_BackgroundSubtractor(&mut self) -> *mut c_void { self.as_raw_mut() } + } + + boxed_ref! { CUDA_BackgroundSubtractorFGD, crate::video::BackgroundSubtractorTraitConst, as_raw_BackgroundSubtractor, crate::video::BackgroundSubtractorTrait, as_raw_mut_BackgroundSubtractor } + + impl crate::cudalegacy::CUDA_BackgroundSubtractorFGDTraitConst for CUDA_BackgroundSubtractorFGD { + #[inline] fn as_raw_CUDA_BackgroundSubtractorFGD(&self) -> *const c_void { self.as_raw() } + } + + impl crate::cudalegacy::CUDA_BackgroundSubtractorFGDTrait for CUDA_BackgroundSubtractorFGD { + #[inline] fn as_raw_mut_CUDA_BackgroundSubtractorFGD(&mut self) -> *mut c_void { self.as_raw_mut() } + } + + boxed_ref! { CUDA_BackgroundSubtractorFGD, crate::cudalegacy::CUDA_BackgroundSubtractorFGDTraitConst, as_raw_CUDA_BackgroundSubtractorFGD, crate::cudalegacy::CUDA_BackgroundSubtractorFGDTrait, as_raw_mut_CUDA_BackgroundSubtractorFGD } + + impl CUDA_BackgroundSubtractorFGD { + } + + boxed_cast_base! { CUDA_BackgroundSubtractorFGD, core::Algorithm, cv_cuda_BackgroundSubtractorFGD_to_Algorithm } + + boxed_cast_base! { CUDA_BackgroundSubtractorFGD, crate::video::BackgroundSubtractor, cv_cuda_BackgroundSubtractorFGD_to_BackgroundSubtractor } + + impl std::fmt::Debug for CUDA_BackgroundSubtractorFGD { + #[inline] + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + f.debug_struct("CUDA_BackgroundSubtractorFGD") + .finish() + } + } + + /// Constant methods for [crate::cudalegacy::CUDA_BackgroundSubtractorGMG] + pub trait CUDA_BackgroundSubtractorGMGTraitConst: crate::video::BackgroundSubtractorTraitConst { + fn as_raw_CUDA_BackgroundSubtractorGMG(&self) -> *const c_void; + + #[inline] + fn get_max_features(&self) -> Result { + return_send!(via ocvrs_return); + unsafe { sys::cv_cuda_BackgroundSubtractorGMG_getMaxFeatures_const(self.as_raw_CUDA_BackgroundSubtractorGMG(), ocvrs_return.as_mut_ptr()) }; + return_receive!(unsafe ocvrs_return => ret); + let ret = ret.into_result()?; + Ok(ret) + } + + #[inline] + fn get_default_learning_rate(&self) -> Result { + return_send!(via ocvrs_return); + unsafe { sys::cv_cuda_BackgroundSubtractorGMG_getDefaultLearningRate_const(self.as_raw_CUDA_BackgroundSubtractorGMG(), ocvrs_return.as_mut_ptr()) }; + return_receive!(unsafe ocvrs_return => ret); + let ret = ret.into_result()?; + Ok(ret) + } + + #[inline] + fn get_num_frames(&self) -> Result { + return_send!(via ocvrs_return); + unsafe { sys::cv_cuda_BackgroundSubtractorGMG_getNumFrames_const(self.as_raw_CUDA_BackgroundSubtractorGMG(), ocvrs_return.as_mut_ptr()) }; + return_receive!(unsafe ocvrs_return => ret); + let ret = ret.into_result()?; + Ok(ret) + } + + #[inline] + fn get_quantization_levels(&self) -> Result { + return_send!(via ocvrs_return); + unsafe { sys::cv_cuda_BackgroundSubtractorGMG_getQuantizationLevels_const(self.as_raw_CUDA_BackgroundSubtractorGMG(), ocvrs_return.as_mut_ptr()) }; + return_receive!(unsafe ocvrs_return => ret); + let ret = ret.into_result()?; + Ok(ret) + } + + #[inline] + fn get_background_prior(&self) -> Result { + return_send!(via ocvrs_return); + unsafe { sys::cv_cuda_BackgroundSubtractorGMG_getBackgroundPrior_const(self.as_raw_CUDA_BackgroundSubtractorGMG(), ocvrs_return.as_mut_ptr()) }; + return_receive!(unsafe ocvrs_return => ret); + let ret = ret.into_result()?; + Ok(ret) + } + + #[inline] + fn get_smoothing_radius(&self) -> Result { + return_send!(via ocvrs_return); + unsafe { sys::cv_cuda_BackgroundSubtractorGMG_getSmoothingRadius_const(self.as_raw_CUDA_BackgroundSubtractorGMG(), ocvrs_return.as_mut_ptr()) }; + return_receive!(unsafe ocvrs_return => ret); + let ret = ret.into_result()?; + Ok(ret) + } + + #[inline] + fn get_decision_threshold(&self) -> Result { + return_send!(via ocvrs_return); + unsafe { sys::cv_cuda_BackgroundSubtractorGMG_getDecisionThreshold_const(self.as_raw_CUDA_BackgroundSubtractorGMG(), ocvrs_return.as_mut_ptr()) }; + return_receive!(unsafe ocvrs_return => ret); + let ret = ret.into_result()?; + Ok(ret) + } + + #[inline] + fn get_update_background_model(&self) -> Result { + return_send!(via ocvrs_return); + unsafe { sys::cv_cuda_BackgroundSubtractorGMG_getUpdateBackgroundModel_const(self.as_raw_CUDA_BackgroundSubtractorGMG(), ocvrs_return.as_mut_ptr()) }; + return_receive!(unsafe ocvrs_return => ret); + let ret = ret.into_result()?; + Ok(ret) + } + + #[inline] + fn get_min_val(&self) -> Result { + return_send!(via ocvrs_return); + unsafe { sys::cv_cuda_BackgroundSubtractorGMG_getMinVal_const(self.as_raw_CUDA_BackgroundSubtractorGMG(), ocvrs_return.as_mut_ptr()) }; + return_receive!(unsafe ocvrs_return => ret); + let ret = ret.into_result()?; + Ok(ret) + } + + #[inline] + fn get_max_val(&self) -> Result { + return_send!(via ocvrs_return); + unsafe { sys::cv_cuda_BackgroundSubtractorGMG_getMaxVal_const(self.as_raw_CUDA_BackgroundSubtractorGMG(), ocvrs_return.as_mut_ptr()) }; + return_receive!(unsafe ocvrs_return => ret); + let ret = ret.into_result()?; + Ok(ret) + } + + } + + /// Mutable methods for [crate::cudalegacy::CUDA_BackgroundSubtractorGMG] + pub trait CUDA_BackgroundSubtractorGMGTrait: crate::cudalegacy::CUDA_BackgroundSubtractorGMGTraitConst + crate::video::BackgroundSubtractorTrait { + fn as_raw_mut_CUDA_BackgroundSubtractorGMG(&mut self) -> *mut c_void; + + #[inline] + fn apply(&mut self, image: &impl ToInputArray, fgmask: &mut impl ToOutputArray, learning_rate: f64, stream: &mut impl core::StreamTrait) -> Result<()> { + input_array_arg!(image); + output_array_arg!(fgmask); + return_send!(via ocvrs_return); + unsafe { sys::cv_cuda_BackgroundSubtractorGMG_apply_const__InputArrayR_const__OutputArrayR_double_StreamR(self.as_raw_mut_CUDA_BackgroundSubtractorGMG(), image.as_raw__InputArray(), fgmask.as_raw__OutputArray(), learning_rate, stream.as_raw_mut_Stream(), ocvrs_return.as_mut_ptr()) }; + return_receive!(unsafe ocvrs_return => ret); + let ret = ret.into_result()?; + Ok(ret) + } + + #[inline] + fn set_max_features(&mut self, max_features: i32) -> Result<()> { + return_send!(via ocvrs_return); + unsafe { sys::cv_cuda_BackgroundSubtractorGMG_setMaxFeatures_int(self.as_raw_mut_CUDA_BackgroundSubtractorGMG(), max_features, ocvrs_return.as_mut_ptr()) }; + return_receive!(unsafe ocvrs_return => ret); + let ret = ret.into_result()?; + Ok(ret) + } + + #[inline] + fn set_default_learning_rate(&mut self, lr: f64) -> Result<()> { + return_send!(via ocvrs_return); + unsafe { sys::cv_cuda_BackgroundSubtractorGMG_setDefaultLearningRate_double(self.as_raw_mut_CUDA_BackgroundSubtractorGMG(), lr, ocvrs_return.as_mut_ptr()) }; + return_receive!(unsafe ocvrs_return => ret); + let ret = ret.into_result()?; + Ok(ret) + } + + #[inline] + fn set_num_frames(&mut self, nframes: i32) -> Result<()> { + return_send!(via ocvrs_return); + unsafe { sys::cv_cuda_BackgroundSubtractorGMG_setNumFrames_int(self.as_raw_mut_CUDA_BackgroundSubtractorGMG(), nframes, ocvrs_return.as_mut_ptr()) }; + return_receive!(unsafe ocvrs_return => ret); + let ret = ret.into_result()?; + Ok(ret) + } + + #[inline] + fn set_quantization_levels(&mut self, nlevels: i32) -> Result<()> { + return_send!(via ocvrs_return); + unsafe { sys::cv_cuda_BackgroundSubtractorGMG_setQuantizationLevels_int(self.as_raw_mut_CUDA_BackgroundSubtractorGMG(), nlevels, ocvrs_return.as_mut_ptr()) }; + return_receive!(unsafe ocvrs_return => ret); + let ret = ret.into_result()?; + Ok(ret) + } + + #[inline] + fn set_background_prior(&mut self, bgprior: f64) -> Result<()> { + return_send!(via ocvrs_return); + unsafe { sys::cv_cuda_BackgroundSubtractorGMG_setBackgroundPrior_double(self.as_raw_mut_CUDA_BackgroundSubtractorGMG(), bgprior, ocvrs_return.as_mut_ptr()) }; + return_receive!(unsafe ocvrs_return => ret); + let ret = ret.into_result()?; + Ok(ret) + } + + #[inline] + fn set_smoothing_radius(&mut self, radius: i32) -> Result<()> { + return_send!(via ocvrs_return); + unsafe { sys::cv_cuda_BackgroundSubtractorGMG_setSmoothingRadius_int(self.as_raw_mut_CUDA_BackgroundSubtractorGMG(), radius, ocvrs_return.as_mut_ptr()) }; + return_receive!(unsafe ocvrs_return => ret); + let ret = ret.into_result()?; + Ok(ret) + } + + #[inline] + fn set_decision_threshold(&mut self, thresh: f64) -> Result<()> { + return_send!(via ocvrs_return); + unsafe { sys::cv_cuda_BackgroundSubtractorGMG_setDecisionThreshold_double(self.as_raw_mut_CUDA_BackgroundSubtractorGMG(), thresh, ocvrs_return.as_mut_ptr()) }; + return_receive!(unsafe ocvrs_return => ret); + let ret = ret.into_result()?; + Ok(ret) + } + + #[inline] + fn set_update_background_model(&mut self, update: bool) -> Result<()> { + return_send!(via ocvrs_return); + unsafe { sys::cv_cuda_BackgroundSubtractorGMG_setUpdateBackgroundModel_bool(self.as_raw_mut_CUDA_BackgroundSubtractorGMG(), update, ocvrs_return.as_mut_ptr()) }; + return_receive!(unsafe ocvrs_return => ret); + let ret = ret.into_result()?; + Ok(ret) + } + + #[inline] + fn set_min_val(&mut self, val: f64) -> Result<()> { + return_send!(via ocvrs_return); + unsafe { sys::cv_cuda_BackgroundSubtractorGMG_setMinVal_double(self.as_raw_mut_CUDA_BackgroundSubtractorGMG(), val, ocvrs_return.as_mut_ptr()) }; + return_receive!(unsafe ocvrs_return => ret); + let ret = ret.into_result()?; + Ok(ret) + } + + #[inline] + fn set_max_val(&mut self, val: f64) -> Result<()> { + return_send!(via ocvrs_return); + unsafe { sys::cv_cuda_BackgroundSubtractorGMG_setMaxVal_double(self.as_raw_mut_CUDA_BackgroundSubtractorGMG(), val, ocvrs_return.as_mut_ptr()) }; + return_receive!(unsafe ocvrs_return => ret); + let ret = ret.into_result()?; + Ok(ret) + } + + } + + /// Background/Foreground Segmentation Algorithm. + /// + /// The class discriminates between foreground and background pixels by building and maintaining a model + /// of the background. Any pixel which does not fit this model is then deemed to be foreground. The + /// class implements algorithm described in [Gold2012](https://docs.opencv.org/4.11.0/d0/de3/citelist.html#CITEREF_Gold2012) . + pub struct CUDA_BackgroundSubtractorGMG { + ptr: *mut c_void, + } + + opencv_type_boxed! { CUDA_BackgroundSubtractorGMG } + + impl Drop for CUDA_BackgroundSubtractorGMG { + #[inline] + fn drop(&mut self) { + unsafe { sys::cv_cuda_BackgroundSubtractorGMG_delete(self.as_raw_mut_CUDA_BackgroundSubtractorGMG()) }; + } + } + + unsafe impl Send for CUDA_BackgroundSubtractorGMG {} + + impl core::AlgorithmTraitConst for CUDA_BackgroundSubtractorGMG { + #[inline] fn as_raw_Algorithm(&self) -> *const c_void { self.as_raw() } + } + + impl core::AlgorithmTrait for CUDA_BackgroundSubtractorGMG { + #[inline] fn as_raw_mut_Algorithm(&mut self) -> *mut c_void { self.as_raw_mut() } + } + + boxed_ref! { CUDA_BackgroundSubtractorGMG, core::AlgorithmTraitConst, as_raw_Algorithm, core::AlgorithmTrait, as_raw_mut_Algorithm } + + impl crate::video::BackgroundSubtractorTraitConst for CUDA_BackgroundSubtractorGMG { + #[inline] fn as_raw_BackgroundSubtractor(&self) -> *const c_void { self.as_raw() } + } + + impl crate::video::BackgroundSubtractorTrait for CUDA_BackgroundSubtractorGMG { + #[inline] fn as_raw_mut_BackgroundSubtractor(&mut self) -> *mut c_void { self.as_raw_mut() } + } + + boxed_ref! { CUDA_BackgroundSubtractorGMG, crate::video::BackgroundSubtractorTraitConst, as_raw_BackgroundSubtractor, crate::video::BackgroundSubtractorTrait, as_raw_mut_BackgroundSubtractor } + + impl crate::cudalegacy::CUDA_BackgroundSubtractorGMGTraitConst for CUDA_BackgroundSubtractorGMG { + #[inline] fn as_raw_CUDA_BackgroundSubtractorGMG(&self) -> *const c_void { self.as_raw() } + } + + impl crate::cudalegacy::CUDA_BackgroundSubtractorGMGTrait for CUDA_BackgroundSubtractorGMG { + #[inline] fn as_raw_mut_CUDA_BackgroundSubtractorGMG(&mut self) -> *mut c_void { self.as_raw_mut() } + } + + boxed_ref! { CUDA_BackgroundSubtractorGMG, crate::cudalegacy::CUDA_BackgroundSubtractorGMGTraitConst, as_raw_CUDA_BackgroundSubtractorGMG, crate::cudalegacy::CUDA_BackgroundSubtractorGMGTrait, as_raw_mut_CUDA_BackgroundSubtractorGMG } + + impl CUDA_BackgroundSubtractorGMG { + } + + boxed_cast_base! { CUDA_BackgroundSubtractorGMG, core::Algorithm, cv_cuda_BackgroundSubtractorGMG_to_Algorithm } + + boxed_cast_base! { CUDA_BackgroundSubtractorGMG, crate::video::BackgroundSubtractor, cv_cuda_BackgroundSubtractorGMG_to_BackgroundSubtractor } + + impl std::fmt::Debug for CUDA_BackgroundSubtractorGMG { + #[inline] + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + f.debug_struct("CUDA_BackgroundSubtractorGMG") + .finish() + } + } + + /// Constant methods for [crate::cudalegacy::CUDA_FGDParams] + pub trait CUDA_FGDParamsTraitConst { + fn as_raw_CUDA_FGDParams(&self) -> *const c_void; + + /// Quantized levels per 'color' component. Power of two, typically 32, 64 or 128. + #[inline] + fn lc(&self) -> i32 { + let ret = unsafe { sys::cv_cuda_FGDParams_propLc_const(self.as_raw_CUDA_FGDParams()) }; + ret + } + + /// Number of color vectors used to model normal background color variation at a given pixel. + #[inline] + fn n1c(&self) -> i32 { + let ret = unsafe { sys::cv_cuda_FGDParams_propN1c_const(self.as_raw_CUDA_FGDParams()) }; + ret + } + + /// Number of color vectors retained at given pixel. Must be > N1c, typically ~ 5/3 of N1c. + /// Used to allow the first N1c vectors to adapt over time to changing background. + #[inline] + fn n2c(&self) -> i32 { + let ret = unsafe { sys::cv_cuda_FGDParams_propN2c_const(self.as_raw_CUDA_FGDParams()) }; + ret + } + + /// Quantized levels per 'color co-occurrence' component. Power of two, typically 16, 32 or 64. + #[inline] + fn lcc(&self) -> i32 { + let ret = unsafe { sys::cv_cuda_FGDParams_propLcc_const(self.as_raw_CUDA_FGDParams()) }; + ret + } + + /// Number of color co-occurrence vectors used to model normal background color variation at a given pixel. + #[inline] + fn n1cc(&self) -> i32 { + let ret = unsafe { sys::cv_cuda_FGDParams_propN1cc_const(self.as_raw_CUDA_FGDParams()) }; + ret + } + + /// Number of color co-occurrence vectors retained at given pixel. Must be > N1cc, typically ~ 5/3 of N1cc. + /// Used to allow the first N1cc vectors to adapt over time to changing background. + #[inline] + fn n2cc(&self) -> i32 { + let ret = unsafe { sys::cv_cuda_FGDParams_propN2cc_const(self.as_raw_CUDA_FGDParams()) }; + ret + } + + /// If TRUE we ignore holes within foreground blobs. Defaults to TRUE. + #[inline] + fn is_obj_without_holes(&self) -> bool { + let ret = unsafe { sys::cv_cuda_FGDParams_propIs_obj_without_holes_const(self.as_raw_CUDA_FGDParams()) }; + ret + } + + /// Number of erode-dilate-erode foreground-blob cleanup iterations. + /// These erase one-pixel junk blobs and merge almost-touching blobs. Default value is 1. + #[inline] + fn perform_morphing(&self) -> i32 { + let ret = unsafe { sys::cv_cuda_FGDParams_propPerform_morphing_const(self.as_raw_CUDA_FGDParams()) }; + ret + } + + /// How quickly we forget old background pixel values seen. Typically set to 0.1. + #[inline] + fn alpha1(&self) -> f32 { + let ret = unsafe { sys::cv_cuda_FGDParams_propAlpha1_const(self.as_raw_CUDA_FGDParams()) }; + ret + } + + /// "Controls speed of feature learning". Depends on T. Typical value circa 0.005. + #[inline] + fn alpha2(&self) -> f32 { + let ret = unsafe { sys::cv_cuda_FGDParams_propAlpha2_const(self.as_raw_CUDA_FGDParams()) }; + ret + } + + /// Alternate to alpha2, used (e.g.) for quicker initial convergence. Typical value 0.1. + #[inline] + fn alpha3(&self) -> f32 { + let ret = unsafe { sys::cv_cuda_FGDParams_propAlpha3_const(self.as_raw_CUDA_FGDParams()) }; + ret + } + + /// Affects color and color co-occurrence quantization, typically set to 2. + #[inline] + fn delta(&self) -> f32 { + let ret = unsafe { sys::cv_cuda_FGDParams_propDelta_const(self.as_raw_CUDA_FGDParams()) }; + ret + } + + /// A percentage value which determines when new features can be recognized as new background. (Typically 0.9). + #[inline] + fn t(&self) -> f32 { + let ret = unsafe { sys::cv_cuda_FGDParams_propT_const(self.as_raw_CUDA_FGDParams()) }; + ret + } + + /// Discard foreground blobs whose bounding box is smaller than this threshold. + #[inline] + fn min_area(&self) -> f32 { + let ret = unsafe { sys::cv_cuda_FGDParams_propMinArea_const(self.as_raw_CUDA_FGDParams()) }; + ret + } + + } + + /// Mutable methods for [crate::cudalegacy::CUDA_FGDParams] + pub trait CUDA_FGDParamsTrait: crate::cudalegacy::CUDA_FGDParamsTraitConst { + fn as_raw_mut_CUDA_FGDParams(&mut self) -> *mut c_void; + + /// Quantized levels per 'color' component. Power of two, typically 32, 64 or 128. + #[inline] + fn set_lc(&mut self, val: i32) { + let ret = unsafe { sys::cv_cuda_FGDParams_propLc_const_int(self.as_raw_mut_CUDA_FGDParams(), val) }; + ret + } + + /// Number of color vectors used to model normal background color variation at a given pixel. + #[inline] + fn set_n1c(&mut self, val: i32) { + let ret = unsafe { sys::cv_cuda_FGDParams_propN1c_const_int(self.as_raw_mut_CUDA_FGDParams(), val) }; + ret + } + + /// Number of color vectors retained at given pixel. Must be > N1c, typically ~ 5/3 of N1c. + /// Used to allow the first N1c vectors to adapt over time to changing background. + #[inline] + fn set_n2c(&mut self, val: i32) { + let ret = unsafe { sys::cv_cuda_FGDParams_propN2c_const_int(self.as_raw_mut_CUDA_FGDParams(), val) }; + ret + } + + /// Quantized levels per 'color co-occurrence' component. Power of two, typically 16, 32 or 64. + #[inline] + fn set_lcc(&mut self, val: i32) { + let ret = unsafe { sys::cv_cuda_FGDParams_propLcc_const_int(self.as_raw_mut_CUDA_FGDParams(), val) }; + ret + } + + /// Number of color co-occurrence vectors used to model normal background color variation at a given pixel. + #[inline] + fn set_n1cc(&mut self, val: i32) { + let ret = unsafe { sys::cv_cuda_FGDParams_propN1cc_const_int(self.as_raw_mut_CUDA_FGDParams(), val) }; + ret + } + + /// Number of color co-occurrence vectors retained at given pixel. Must be > N1cc, typically ~ 5/3 of N1cc. + /// Used to allow the first N1cc vectors to adapt over time to changing background. + #[inline] + fn set_n2cc(&mut self, val: i32) { + let ret = unsafe { sys::cv_cuda_FGDParams_propN2cc_const_int(self.as_raw_mut_CUDA_FGDParams(), val) }; + ret + } + + /// If TRUE we ignore holes within foreground blobs. Defaults to TRUE. + #[inline] + fn set_is_obj_without_holes(&mut self, val: bool) { + let ret = unsafe { sys::cv_cuda_FGDParams_propIs_obj_without_holes_const_bool(self.as_raw_mut_CUDA_FGDParams(), val) }; + ret + } + + /// Number of erode-dilate-erode foreground-blob cleanup iterations. + /// These erase one-pixel junk blobs and merge almost-touching blobs. Default value is 1. + #[inline] + fn set_perform_morphing(&mut self, val: i32) { + let ret = unsafe { sys::cv_cuda_FGDParams_propPerform_morphing_const_int(self.as_raw_mut_CUDA_FGDParams(), val) }; + ret + } + + /// How quickly we forget old background pixel values seen. Typically set to 0.1. + #[inline] + fn set_alpha1(&mut self, val: f32) { + let ret = unsafe { sys::cv_cuda_FGDParams_propAlpha1_const_float(self.as_raw_mut_CUDA_FGDParams(), val) }; + ret + } + + /// "Controls speed of feature learning". Depends on T. Typical value circa 0.005. + #[inline] + fn set_alpha2(&mut self, val: f32) { + let ret = unsafe { sys::cv_cuda_FGDParams_propAlpha2_const_float(self.as_raw_mut_CUDA_FGDParams(), val) }; + ret + } + + /// Alternate to alpha2, used (e.g.) for quicker initial convergence. Typical value 0.1. + #[inline] + fn set_alpha3(&mut self, val: f32) { + let ret = unsafe { sys::cv_cuda_FGDParams_propAlpha3_const_float(self.as_raw_mut_CUDA_FGDParams(), val) }; + ret + } + + /// Affects color and color co-occurrence quantization, typically set to 2. + #[inline] + fn set_delta(&mut self, val: f32) { + let ret = unsafe { sys::cv_cuda_FGDParams_propDelta_const_float(self.as_raw_mut_CUDA_FGDParams(), val) }; + ret + } + + /// A percentage value which determines when new features can be recognized as new background. (Typically 0.9). + #[inline] + fn set_t(&mut self, val: f32) { + let ret = unsafe { sys::cv_cuda_FGDParams_propT_const_float(self.as_raw_mut_CUDA_FGDParams(), val) }; + ret + } + + /// Discard foreground blobs whose bounding box is smaller than this threshold. + #[inline] + fn set_min_area(&mut self, val: f32) { + let ret = unsafe { sys::cv_cuda_FGDParams_propMinArea_const_float(self.as_raw_mut_CUDA_FGDParams(), val) }; + ret + } + + } + + pub struct CUDA_FGDParams { + ptr: *mut c_void, + } + + opencv_type_boxed! { CUDA_FGDParams } + + impl Drop for CUDA_FGDParams { + #[inline] + fn drop(&mut self) { + unsafe { sys::cv_cuda_FGDParams_delete(self.as_raw_mut_CUDA_FGDParams()) }; + } + } + + unsafe impl Send for CUDA_FGDParams {} + + impl crate::cudalegacy::CUDA_FGDParamsTraitConst for CUDA_FGDParams { + #[inline] fn as_raw_CUDA_FGDParams(&self) -> *const c_void { self.as_raw() } + } + + impl crate::cudalegacy::CUDA_FGDParamsTrait for CUDA_FGDParams { + #[inline] fn as_raw_mut_CUDA_FGDParams(&mut self) -> *mut c_void { self.as_raw_mut() } + } + + boxed_ref! { CUDA_FGDParams, crate::cudalegacy::CUDA_FGDParamsTraitConst, as_raw_CUDA_FGDParams, crate::cudalegacy::CUDA_FGDParamsTrait, as_raw_mut_CUDA_FGDParams } + + impl CUDA_FGDParams { + /// default Params + #[inline] + pub fn default() -> Result { + return_send!(via ocvrs_return); + unsafe { sys::cv_cuda_FGDParams_FGDParams(ocvrs_return.as_mut_ptr()) }; + return_receive!(unsafe ocvrs_return => ret); + let ret = ret.into_result()?; + let ret = unsafe { crate::cudalegacy::CUDA_FGDParams::opencv_from_extern(ret) }; + Ok(ret) + } + + } + + impl std::fmt::Debug for CUDA_FGDParams { + #[inline] + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + f.debug_struct("CUDA_FGDParams") + .field("lc", &crate::cudalegacy::CUDA_FGDParamsTraitConst::lc(self)) + .field("n1c", &crate::cudalegacy::CUDA_FGDParamsTraitConst::n1c(self)) + .field("n2c", &crate::cudalegacy::CUDA_FGDParamsTraitConst::n2c(self)) + .field("lcc", &crate::cudalegacy::CUDA_FGDParamsTraitConst::lcc(self)) + .field("n1cc", &crate::cudalegacy::CUDA_FGDParamsTraitConst::n1cc(self)) + .field("n2cc", &crate::cudalegacy::CUDA_FGDParamsTraitConst::n2cc(self)) + .field("is_obj_without_holes", &crate::cudalegacy::CUDA_FGDParamsTraitConst::is_obj_without_holes(self)) + .field("perform_morphing", &crate::cudalegacy::CUDA_FGDParamsTraitConst::perform_morphing(self)) + .field("alpha1", &crate::cudalegacy::CUDA_FGDParamsTraitConst::alpha1(self)) + .field("alpha2", &crate::cudalegacy::CUDA_FGDParamsTraitConst::alpha2(self)) + .field("alpha3", &crate::cudalegacy::CUDA_FGDParamsTraitConst::alpha3(self)) + .field("delta", &crate::cudalegacy::CUDA_FGDParamsTraitConst::delta(self)) + .field("t", &crate::cudalegacy::CUDA_FGDParamsTraitConst::t(self)) + .field("min_area", &crate::cudalegacy::CUDA_FGDParamsTraitConst::min_area(self)) + .finish() + } + } + + /// Constant methods for [crate::cudalegacy::CUDA_FastOpticalFlowBM] + pub trait CUDA_FastOpticalFlowBMTraitConst { + fn as_raw_CUDA_FastOpticalFlowBM(&self) -> *const c_void; + + } + + /// Mutable methods for [crate::cudalegacy::CUDA_FastOpticalFlowBM] + pub trait CUDA_FastOpticalFlowBMTrait: crate::cudalegacy::CUDA_FastOpticalFlowBMTraitConst { + fn as_raw_mut_CUDA_FastOpticalFlowBM(&mut self) -> *mut c_void; + + /// ## C++ default parameters + /// * search_window: 21 + /// * block_window: 7 + /// * s: Stream::Null() + #[inline] + fn apply(&mut self, i0: &impl core::GpuMatTraitConst, i1: &impl core::GpuMatTraitConst, flowx: &mut impl core::GpuMatTrait, flowy: &mut impl core::GpuMatTrait, search_window: i32, block_window: i32, s: &mut impl core::StreamTrait) -> Result<()> { + return_send!(via ocvrs_return); + unsafe { sys::cv_cuda_FastOpticalFlowBM_operator___const_GpuMatR_const_GpuMatR_GpuMatR_GpuMatR_int_int_StreamR(self.as_raw_mut_CUDA_FastOpticalFlowBM(), i0.as_raw_GpuMat(), i1.as_raw_GpuMat(), flowx.as_raw_mut_GpuMat(), flowy.as_raw_mut_GpuMat(), search_window, block_window, s.as_raw_mut_Stream(), ocvrs_return.as_mut_ptr()) }; + return_receive!(unsafe ocvrs_return => ret); + let ret = ret.into_result()?; + Ok(ret) + } + + /// ## Note + /// This alternative version of [CUDA_FastOpticalFlowBMTrait::apply] function uses the following default values for its arguments: + /// * search_window: 21 + /// * block_window: 7 + /// * s: Stream::Null() + #[inline] + fn apply_def(&mut self, i0: &impl core::GpuMatTraitConst, i1: &impl core::GpuMatTraitConst, flowx: &mut impl core::GpuMatTrait, flowy: &mut impl core::GpuMatTrait) -> Result<()> { + return_send!(via ocvrs_return); + unsafe { sys::cv_cuda_FastOpticalFlowBM_operator___const_GpuMatR_const_GpuMatR_GpuMatR_GpuMatR(self.as_raw_mut_CUDA_FastOpticalFlowBM(), i0.as_raw_GpuMat(), i1.as_raw_GpuMat(), flowx.as_raw_mut_GpuMat(), flowy.as_raw_mut_GpuMat(), ocvrs_return.as_mut_ptr()) }; + return_receive!(unsafe ocvrs_return => ret); + let ret = ret.into_result()?; + Ok(ret) + } + + } + + pub struct CUDA_FastOpticalFlowBM { + ptr: *mut c_void, + } + + opencv_type_boxed! { CUDA_FastOpticalFlowBM } + + impl Drop for CUDA_FastOpticalFlowBM { + #[inline] + fn drop(&mut self) { + unsafe { sys::cv_cuda_FastOpticalFlowBM_delete(self.as_raw_mut_CUDA_FastOpticalFlowBM()) }; + } + } + + unsafe impl Send for CUDA_FastOpticalFlowBM {} + + impl crate::cudalegacy::CUDA_FastOpticalFlowBMTraitConst for CUDA_FastOpticalFlowBM { + #[inline] fn as_raw_CUDA_FastOpticalFlowBM(&self) -> *const c_void { self.as_raw() } + } + + impl crate::cudalegacy::CUDA_FastOpticalFlowBMTrait for CUDA_FastOpticalFlowBM { + #[inline] fn as_raw_mut_CUDA_FastOpticalFlowBM(&mut self) -> *mut c_void { self.as_raw_mut() } + } + + boxed_ref! { CUDA_FastOpticalFlowBM, crate::cudalegacy::CUDA_FastOpticalFlowBMTraitConst, as_raw_CUDA_FastOpticalFlowBM, crate::cudalegacy::CUDA_FastOpticalFlowBMTrait, as_raw_mut_CUDA_FastOpticalFlowBM } + + impl CUDA_FastOpticalFlowBM { + /// Creates a default instance of the class by calling the default constructor + #[inline] + fn default() -> Self { + unsafe { Self::from_raw(sys::cv_cuda_FastOpticalFlowBM_defaultNew_const()) } + } + + } + + impl std::fmt::Debug for CUDA_FastOpticalFlowBM { + #[inline] + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + f.debug_struct("CUDA_FastOpticalFlowBM") + .finish() + } + } + + impl Default for CUDA_FastOpticalFlowBM { + #[inline] + /// Forwards to infallible Self::default() + fn default() -> Self { + Self::default() + } + } + + /// Constant methods for [crate::cudalegacy::CUDA_ImagePyramid] + pub trait CUDA_ImagePyramidTraitConst: core::AlgorithmTraitConst { + fn as_raw_CUDA_ImagePyramid(&self) -> *const c_void; + + /// ## C++ default parameters + /// * stream: Stream::Null() + #[inline] + fn get_layer(&self, out_img: &mut impl ToOutputArray, out_roi: core::Size, stream: &mut impl core::StreamTrait) -> Result<()> { + output_array_arg!(out_img); + return_send!(via ocvrs_return); + unsafe { sys::cv_cuda_ImagePyramid_getLayer_const_const__OutputArrayR_Size_StreamR(self.as_raw_CUDA_ImagePyramid(), out_img.as_raw__OutputArray(), &out_roi, stream.as_raw_mut_Stream(), ocvrs_return.as_mut_ptr()) }; + return_receive!(unsafe ocvrs_return => ret); + let ret = ret.into_result()?; + Ok(ret) + } + + /// ## Note + /// This alternative version of [CUDA_ImagePyramidTraitConst::get_layer] function uses the following default values for its arguments: + /// * stream: Stream::Null() + #[inline] + fn get_layer_def(&self, out_img: &mut impl ToOutputArray, out_roi: core::Size) -> Result<()> { + output_array_arg!(out_img); + return_send!(via ocvrs_return); + unsafe { sys::cv_cuda_ImagePyramid_getLayer_const_const__OutputArrayR_Size(self.as_raw_CUDA_ImagePyramid(), out_img.as_raw__OutputArray(), &out_roi, ocvrs_return.as_mut_ptr()) }; + return_receive!(unsafe ocvrs_return => ret); + let ret = ret.into_result()?; + Ok(ret) + } + + } + + /// Mutable methods for [crate::cudalegacy::CUDA_ImagePyramid] + pub trait CUDA_ImagePyramidTrait: core::AlgorithmTrait + crate::cudalegacy::CUDA_ImagePyramidTraitConst { + fn as_raw_mut_CUDA_ImagePyramid(&mut self) -> *mut c_void; + + } + + pub struct CUDA_ImagePyramid { + ptr: *mut c_void, + } + + opencv_type_boxed! { CUDA_ImagePyramid } + + impl Drop for CUDA_ImagePyramid { + #[inline] + fn drop(&mut self) { + unsafe { sys::cv_cuda_ImagePyramid_delete(self.as_raw_mut_CUDA_ImagePyramid()) }; + } + } + + unsafe impl Send for CUDA_ImagePyramid {} + + impl core::AlgorithmTraitConst for CUDA_ImagePyramid { + #[inline] fn as_raw_Algorithm(&self) -> *const c_void { self.as_raw() } + } + + impl core::AlgorithmTrait for CUDA_ImagePyramid { + #[inline] fn as_raw_mut_Algorithm(&mut self) -> *mut c_void { self.as_raw_mut() } + } + + boxed_ref! { CUDA_ImagePyramid, core::AlgorithmTraitConst, as_raw_Algorithm, core::AlgorithmTrait, as_raw_mut_Algorithm } + + impl crate::cudalegacy::CUDA_ImagePyramidTraitConst for CUDA_ImagePyramid { + #[inline] fn as_raw_CUDA_ImagePyramid(&self) -> *const c_void { self.as_raw() } + } + + impl crate::cudalegacy::CUDA_ImagePyramidTrait for CUDA_ImagePyramid { + #[inline] fn as_raw_mut_CUDA_ImagePyramid(&mut self) -> *mut c_void { self.as_raw_mut() } + } + + boxed_ref! { CUDA_ImagePyramid, crate::cudalegacy::CUDA_ImagePyramidTraitConst, as_raw_CUDA_ImagePyramid, crate::cudalegacy::CUDA_ImagePyramidTrait, as_raw_mut_CUDA_ImagePyramid } + + impl CUDA_ImagePyramid { + } + + boxed_cast_base! { CUDA_ImagePyramid, core::Algorithm, cv_cuda_ImagePyramid_to_Algorithm } + + impl std::fmt::Debug for CUDA_ImagePyramid { + #[inline] + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + f.debug_struct("CUDA_ImagePyramid") + .finish() + } + } +} diff --git a/docs/dnn.rs b/docs/dnn.rs index f8dab452..fd46a1d7 100644 --- a/docs/dnn.rs +++ b/docs/dnn.rs @@ -7420,6 +7420,9 @@ pub mod dnn { Ok(ret) } + /// ## Note + /// This alternative version of [DictValueTraitConst::get_str] function uses the following default values for its arguments: + /// * idx: -1 #[inline] fn get_str_def(&self) -> Result { return_send!(via ocvrs_return); @@ -7441,6 +7444,9 @@ pub mod dnn { Ok(ret) } + /// ## Note + /// This alternative version of [DictValueTraitConst::get_f64] function uses the following default values for its arguments: + /// * idx: -1 #[inline] fn get_f64_def(&self) -> Result { return_send!(via ocvrs_return); @@ -7461,6 +7467,9 @@ pub mod dnn { Ok(ret) } + /// ## Note + /// This alternative version of [DictValueTraitConst::get_i32] function uses the following default values for its arguments: + /// * idx: -1 #[inline] fn get_i32_def(&self) -> Result { return_send!(via ocvrs_return); @@ -7481,6 +7490,9 @@ pub mod dnn { Ok(ret) } + /// ## Note + /// This alternative version of [DictValueTraitConst::get_i64] function uses the following default values for its arguments: + /// * idx: -1 #[inline] fn get_i64_def(&self) -> Result { return_send!(via ocvrs_return); diff --git a/docs/face.rs b/docs/face.rs index 25a83be3..4617ec3c 100644 --- a/docs/face.rs +++ b/docs/face.rs @@ -3664,9 +3664,6 @@ pub mod face { /// /// /// TODO Lifetime of detector parameters is uncontrolled. Rework interface design to "Ptr". - /// - /// ## C++ default parameters - /// * user_data: 0 #[inline] fn set_face_detector(&mut self, detector: crate::face::FN_FaceDetector) -> Result { callback_arg!(detector_trampoline(unnamed: *const c_void, unnamed_1: *const c_void, user_data: *mut c_void) -> bool => user_data in detector(unnamed: *const c_void, unnamed_1: *const c_void) -> bool); diff --git a/docs/highgui.rs b/docs/highgui.rs index 9d41a6ec..bc94aeda 100644 --- a/docs/highgui.rs +++ b/docs/highgui.rs @@ -571,12 +571,8 @@ pub mod highgui { /// /// ## Note /// This alternative version of [create_button] function uses the following default values for its arguments: - /// * userdata: 0 /// * typ: QT_PUSH_BUTTON /// * initial_button_state: false - /// - /// ## C++ default parameters - /// * userdata: 0 #[inline] pub fn create_button_def(bar_name: &str, on_change: crate::highgui::ButtonCallback) -> Result { extern_container_arg!(bar_name); @@ -618,7 +614,6 @@ pub mod highgui { /// value could be 0 or 1. (__Optional__) /// /// ## C++ default parameters - /// * userdata: 0 /// * typ: QT_PUSH_BUTTON /// * initial_button_state: false #[inline] @@ -664,10 +659,6 @@ pub mod highgui { /// Call the callback function manually with the desired initial value to avoid runtime warnings. /// ## See also /// \ref tutorial_trackbar - /// - /// ## C++ default parameters - /// * on_change: 0 - /// * userdata: 0 #[inline] pub fn create_trackbar(trackbarname: &str, winname: &str, value: Option<&mut i32>, count: i32, on_change: crate::highgui::TrackbarCallback) -> Result { extern_container_arg!(trackbarname); @@ -1447,9 +1438,6 @@ pub mod highgui { /// * winname: Name of the window. /// * onMouse: Callback function for mouse events. See OpenCV samples on how to specify and use the callback. /// * userdata: The optional parameter passed to the callback. - /// - /// ## C++ default parameters - /// * userdata: 0 #[inline] pub fn set_mouse_callback(winname: &str, on_mouse: crate::highgui::MouseCallback) -> Result<()> { extern_container_arg!(winname); @@ -1517,9 +1505,6 @@ pub mod highgui { /// * onOpenGlDraw: Pointer to the function to be called every frame. This function should be /// prototyped as void Foo(void\*) . /// * userdata: Pointer passed to the callback function.(__Optional__) - /// - /// ## C++ default parameters - /// * userdata: 0 #[inline] pub fn set_opengl_draw_callback(winname: &str, on_opengl_draw: crate::highgui::OpenGlDrawCallback) -> Result<()> { extern_container_arg!(winname); diff --git a/docs/hub.rs b/docs/hub.rs index c9bdecce..038dc934 100644 --- a/docs/hub.rs +++ b/docs/hub.rs @@ -1,134 +1,69 @@ -#[cfg(ocvrs_has_module_alphamat)] include!(concat!(env!("OUT_DIR"), "/opencv/alphamat.rs")); -#[cfg(ocvrs_has_module_aruco)] include!(concat!(env!("OUT_DIR"), "/opencv/aruco.rs")); -#[cfg(ocvrs_has_module_bgsegm)] include!(concat!(env!("OUT_DIR"), "/opencv/bgsegm.rs")); -#[cfg(ocvrs_has_module_bioinspired)] include!(concat!(env!("OUT_DIR"), "/opencv/bioinspired.rs")); -#[cfg(ocvrs_has_module_calib3d)] include!(concat!(env!("OUT_DIR"), "/opencv/calib3d.rs")); -#[cfg(ocvrs_has_module_ccalib)] include!(concat!(env!("OUT_DIR"), "/opencv/ccalib.rs")); -#[cfg(ocvrs_has_module_core)] include!(concat!(env!("OUT_DIR"), "/opencv/core.rs")); -#[cfg(ocvrs_has_module_cudaarithm)] include!(concat!(env!("OUT_DIR"), "/opencv/cudaarithm.rs")); -#[cfg(ocvrs_has_module_cudabgsegm)] include!(concat!(env!("OUT_DIR"), "/opencv/cudabgsegm.rs")); -#[cfg(ocvrs_has_module_cudacodec)] include!(concat!(env!("OUT_DIR"), "/opencv/cudacodec.rs")); -#[cfg(ocvrs_has_module_cudafeatures2d)] include!(concat!(env!("OUT_DIR"), "/opencv/cudafeatures2d.rs")); -#[cfg(ocvrs_has_module_cudafilters)] include!(concat!(env!("OUT_DIR"), "/opencv/cudafilters.rs")); -#[cfg(ocvrs_has_module_cudaimgproc)] include!(concat!(env!("OUT_DIR"), "/opencv/cudaimgproc.rs")); -#[cfg(ocvrs_has_module_cudaobjdetect)] +include!(concat!(env!("OUT_DIR"), "/opencv/cudalegacy.rs")); include!(concat!(env!("OUT_DIR"), "/opencv/cudaobjdetect.rs")); -#[cfg(ocvrs_has_module_cudaoptflow)] include!(concat!(env!("OUT_DIR"), "/opencv/cudaoptflow.rs")); -#[cfg(ocvrs_has_module_cudastereo)] include!(concat!(env!("OUT_DIR"), "/opencv/cudastereo.rs")); -#[cfg(ocvrs_has_module_cudawarping)] include!(concat!(env!("OUT_DIR"), "/opencv/cudawarping.rs")); -#[cfg(ocvrs_has_module_cvv)] include!(concat!(env!("OUT_DIR"), "/opencv/cvv.rs")); -#[cfg(ocvrs_has_module_dnn)] include!(concat!(env!("OUT_DIR"), "/opencv/dnn.rs")); -#[cfg(ocvrs_has_module_dnn_superres)] include!(concat!(env!("OUT_DIR"), "/opencv/dnn_superres.rs")); -#[cfg(ocvrs_has_module_dpm)] include!(concat!(env!("OUT_DIR"), "/opencv/dpm.rs")); -#[cfg(ocvrs_has_module_face)] include!(concat!(env!("OUT_DIR"), "/opencv/face.rs")); -#[cfg(ocvrs_has_module_features2d)] include!(concat!(env!("OUT_DIR"), "/opencv/features2d.rs")); -#[cfg(ocvrs_has_module_flann)] include!(concat!(env!("OUT_DIR"), "/opencv/flann.rs")); -#[cfg(ocvrs_has_module_freetype)] include!(concat!(env!("OUT_DIR"), "/opencv/freetype.rs")); -#[cfg(ocvrs_has_module_fuzzy)] include!(concat!(env!("OUT_DIR"), "/opencv/fuzzy.rs")); -#[cfg(ocvrs_has_module_gapi)] include!(concat!(env!("OUT_DIR"), "/opencv/gapi.rs")); -#[cfg(ocvrs_has_module_hdf)] include!(concat!(env!("OUT_DIR"), "/opencv/hdf.rs")); -#[cfg(ocvrs_has_module_hfs)] include!(concat!(env!("OUT_DIR"), "/opencv/hfs.rs")); -#[cfg(ocvrs_has_module_highgui)] include!(concat!(env!("OUT_DIR"), "/opencv/highgui.rs")); -#[cfg(ocvrs_has_module_img_hash)] include!(concat!(env!("OUT_DIR"), "/opencv/img_hash.rs")); -#[cfg(ocvrs_has_module_imgcodecs)] include!(concat!(env!("OUT_DIR"), "/opencv/imgcodecs.rs")); -#[cfg(ocvrs_has_module_imgproc)] include!(concat!(env!("OUT_DIR"), "/opencv/imgproc.rs")); -#[cfg(ocvrs_has_module_intensity_transform)] include!(concat!(env!("OUT_DIR"), "/opencv/intensity_transform.rs")); -#[cfg(ocvrs_has_module_line_descriptor)] include!(concat!(env!("OUT_DIR"), "/opencv/line_descriptor.rs")); -#[cfg(ocvrs_has_module_mcc)] include!(concat!(env!("OUT_DIR"), "/opencv/mcc.rs")); -#[cfg(ocvrs_has_module_ml)] include!(concat!(env!("OUT_DIR"), "/opencv/ml.rs")); -#[cfg(ocvrs_has_module_objdetect)] include!(concat!(env!("OUT_DIR"), "/opencv/objdetect.rs")); -#[cfg(ocvrs_has_module_optflow)] include!(concat!(env!("OUT_DIR"), "/opencv/optflow.rs")); -#[cfg(ocvrs_has_module_ovis)] include!(concat!(env!("OUT_DIR"), "/opencv/ovis.rs")); -#[cfg(ocvrs_has_module_phase_unwrapping)] include!(concat!(env!("OUT_DIR"), "/opencv/phase_unwrapping.rs")); -#[cfg(ocvrs_has_module_photo)] include!(concat!(env!("OUT_DIR"), "/opencv/photo.rs")); -#[cfg(ocvrs_has_module_plot)] include!(concat!(env!("OUT_DIR"), "/opencv/plot.rs")); -#[cfg(ocvrs_has_module_quality)] include!(concat!(env!("OUT_DIR"), "/opencv/quality.rs")); -#[cfg(ocvrs_has_module_rapid)] include!(concat!(env!("OUT_DIR"), "/opencv/rapid.rs")); -#[cfg(ocvrs_has_module_rgbd)] include!(concat!(env!("OUT_DIR"), "/opencv/rgbd.rs")); -#[cfg(ocvrs_has_module_saliency)] include!(concat!(env!("OUT_DIR"), "/opencv/saliency.rs")); -#[cfg(ocvrs_has_module_sfm)] include!(concat!(env!("OUT_DIR"), "/opencv/sfm.rs")); -#[cfg(ocvrs_has_module_shape)] include!(concat!(env!("OUT_DIR"), "/opencv/shape.rs")); -#[cfg(ocvrs_has_module_signal)] include!(concat!(env!("OUT_DIR"), "/opencv/signal.rs")); -#[cfg(ocvrs_has_module_stereo)] include!(concat!(env!("OUT_DIR"), "/opencv/stereo.rs")); -#[cfg(ocvrs_has_module_stitching)] include!(concat!(env!("OUT_DIR"), "/opencv/stitching.rs")); -#[cfg(ocvrs_has_module_structured_light)] include!(concat!(env!("OUT_DIR"), "/opencv/structured_light.rs")); -#[cfg(ocvrs_has_module_superres)] include!(concat!(env!("OUT_DIR"), "/opencv/superres.rs")); -#[cfg(ocvrs_has_module_surface_matching)] include!(concat!(env!("OUT_DIR"), "/opencv/surface_matching.rs")); -#[cfg(ocvrs_has_module_text)] include!(concat!(env!("OUT_DIR"), "/opencv/text.rs")); -#[cfg(ocvrs_has_module_tracking)] include!(concat!(env!("OUT_DIR"), "/opencv/tracking.rs")); -#[cfg(ocvrs_has_module_video)] include!(concat!(env!("OUT_DIR"), "/opencv/video.rs")); -#[cfg(ocvrs_has_module_videoio)] include!(concat!(env!("OUT_DIR"), "/opencv/videoio.rs")); -#[cfg(ocvrs_has_module_videostab)] include!(concat!(env!("OUT_DIR"), "/opencv/videostab.rs")); -#[cfg(ocvrs_has_module_viz)] include!(concat!(env!("OUT_DIR"), "/opencv/viz.rs")); -#[cfg(ocvrs_has_module_wechat_qrcode)] include!(concat!(env!("OUT_DIR"), "/opencv/wechat_qrcode.rs")); -#[cfg(ocvrs_has_module_xfeatures2d)] include!(concat!(env!("OUT_DIR"), "/opencv/xfeatures2d.rs")); -#[cfg(ocvrs_has_module_ximgproc)] include!(concat!(env!("OUT_DIR"), "/opencv/ximgproc.rs")); -#[cfg(ocvrs_has_module_xobjdetect)] include!(concat!(env!("OUT_DIR"), "/opencv/xobjdetect.rs")); -#[cfg(ocvrs_has_module_xphoto)] include!(concat!(env!("OUT_DIR"), "/opencv/xphoto.rs")); pub mod types { include!(concat!(env!("OUT_DIR"), "/opencv/types.rs")); @@ -138,137 +73,72 @@ pub mod sys { include!(concat!(env!("OUT_DIR"), "/opencv/sys.rs")); } pub mod hub_prelude { - #[cfg(ocvrs_has_module_alphamat)] pub use super::alphamat::prelude::*; - #[cfg(ocvrs_has_module_aruco)] pub use super::aruco::prelude::*; - #[cfg(ocvrs_has_module_bgsegm)] pub use super::bgsegm::prelude::*; - #[cfg(ocvrs_has_module_bioinspired)] pub use super::bioinspired::prelude::*; - #[cfg(ocvrs_has_module_calib3d)] pub use super::calib3d::prelude::*; - #[cfg(ocvrs_has_module_ccalib)] pub use super::ccalib::prelude::*; - #[cfg(ocvrs_has_module_core)] pub use super::core::prelude::*; - #[cfg(ocvrs_has_module_cudaarithm)] pub use super::cudaarithm::prelude::*; - #[cfg(ocvrs_has_module_cudabgsegm)] pub use super::cudabgsegm::prelude::*; - #[cfg(ocvrs_has_module_cudacodec)] pub use super::cudacodec::prelude::*; - #[cfg(ocvrs_has_module_cudafeatures2d)] pub use super::cudafeatures2d::prelude::*; - #[cfg(ocvrs_has_module_cudafilters)] pub use super::cudafilters::prelude::*; - #[cfg(ocvrs_has_module_cudaimgproc)] pub use super::cudaimgproc::prelude::*; - #[cfg(ocvrs_has_module_cudaobjdetect)] + pub use super::cudalegacy::prelude::*; pub use super::cudaobjdetect::prelude::*; - #[cfg(ocvrs_has_module_cudaoptflow)] pub use super::cudaoptflow::prelude::*; - #[cfg(ocvrs_has_module_cudastereo)] pub use super::cudastereo::prelude::*; - #[cfg(ocvrs_has_module_cudawarping)] pub use super::cudawarping::prelude::*; - #[cfg(ocvrs_has_module_cvv)] pub use super::cvv::prelude::*; - #[cfg(ocvrs_has_module_dnn)] pub use super::dnn::prelude::*; - #[cfg(ocvrs_has_module_dnn_superres)] pub use super::dnn_superres::prelude::*; - #[cfg(ocvrs_has_module_dpm)] pub use super::dpm::prelude::*; - #[cfg(ocvrs_has_module_face)] pub use super::face::prelude::*; - #[cfg(ocvrs_has_module_features2d)] pub use super::features2d::prelude::*; - #[cfg(ocvrs_has_module_flann)] pub use super::flann::prelude::*; - #[cfg(ocvrs_has_module_freetype)] pub use super::freetype::prelude::*; - #[cfg(ocvrs_has_module_fuzzy)] pub use super::fuzzy::prelude::*; - #[cfg(ocvrs_has_module_gapi)] pub use super::gapi::prelude::*; - #[cfg(ocvrs_has_module_hdf)] pub use super::hdf::prelude::*; - #[cfg(ocvrs_has_module_hfs)] pub use super::hfs::prelude::*; - #[cfg(ocvrs_has_module_highgui)] pub use super::highgui::prelude::*; - #[cfg(ocvrs_has_module_img_hash)] pub use super::img_hash::prelude::*; - #[cfg(ocvrs_has_module_imgcodecs)] pub use super::imgcodecs::prelude::*; - #[cfg(ocvrs_has_module_imgproc)] pub use super::imgproc::prelude::*; - #[cfg(ocvrs_has_module_intensity_transform)] pub use super::intensity_transform::prelude::*; - #[cfg(ocvrs_has_module_line_descriptor)] pub use super::line_descriptor::prelude::*; - #[cfg(ocvrs_has_module_mcc)] pub use super::mcc::prelude::*; - #[cfg(ocvrs_has_module_ml)] pub use super::ml::prelude::*; - #[cfg(ocvrs_has_module_objdetect)] pub use super::objdetect::prelude::*; - #[cfg(ocvrs_has_module_optflow)] pub use super::optflow::prelude::*; - #[cfg(ocvrs_has_module_ovis)] pub use super::ovis::prelude::*; - #[cfg(ocvrs_has_module_phase_unwrapping)] pub use super::phase_unwrapping::prelude::*; - #[cfg(ocvrs_has_module_photo)] pub use super::photo::prelude::*; - #[cfg(ocvrs_has_module_plot)] pub use super::plot::prelude::*; - #[cfg(ocvrs_has_module_quality)] pub use super::quality::prelude::*; - #[cfg(ocvrs_has_module_rapid)] pub use super::rapid::prelude::*; - #[cfg(ocvrs_has_module_rgbd)] pub use super::rgbd::prelude::*; - #[cfg(ocvrs_has_module_saliency)] pub use super::saliency::prelude::*; - #[cfg(ocvrs_has_module_sfm)] pub use super::sfm::prelude::*; - #[cfg(ocvrs_has_module_shape)] pub use super::shape::prelude::*; - #[cfg(ocvrs_has_module_signal)] pub use super::signal::prelude::*; - #[cfg(ocvrs_has_module_stereo)] pub use super::stereo::prelude::*; - #[cfg(ocvrs_has_module_stitching)] pub use super::stitching::prelude::*; - #[cfg(ocvrs_has_module_structured_light)] pub use super::structured_light::prelude::*; - #[cfg(ocvrs_has_module_superres)] pub use super::superres::prelude::*; - #[cfg(ocvrs_has_module_surface_matching)] pub use super::surface_matching::prelude::*; - #[cfg(ocvrs_has_module_text)] pub use super::text::prelude::*; - #[cfg(ocvrs_has_module_tracking)] pub use super::tracking::prelude::*; - #[cfg(ocvrs_has_module_video)] pub use super::video::prelude::*; - #[cfg(ocvrs_has_module_videoio)] pub use super::videoio::prelude::*; - #[cfg(ocvrs_has_module_videostab)] pub use super::videostab::prelude::*; - #[cfg(ocvrs_has_module_viz)] pub use super::viz::prelude::*; - #[cfg(ocvrs_has_module_wechat_qrcode)] pub use super::wechat_qrcode::prelude::*; - #[cfg(ocvrs_has_module_xfeatures2d)] pub use super::xfeatures2d::prelude::*; - #[cfg(ocvrs_has_module_ximgproc)] pub use super::ximgproc::prelude::*; - #[cfg(ocvrs_has_module_xobjdetect)] pub use super::xobjdetect::prelude::*; - #[cfg(ocvrs_has_module_xphoto)] pub use super::xphoto::prelude::*; } diff --git a/docs/objdetect.rs b/docs/objdetect.rs index d20fe043..4938d1c6 100644 --- a/docs/objdetect.rs +++ b/docs/objdetect.rs @@ -3750,7 +3750,7 @@ pub mod objdetect { /// coefficients for the linear SVM classifier. #[inline] - fn set_svm_detector_vec(&mut self, val: core::Vector) { + fn set_svm_detector(&mut self, val: core::Vector) { let ret = unsafe { sys::cv_HOGDescriptor_propSvmDetector_const_vectorLfloatG(self.as_raw_mut_HOGDescriptor(), val.as_raw_VectorOff32()) }; ret } @@ -3789,7 +3789,7 @@ pub mod objdetect { /// ## Parameters /// * svmdetector: coefficients for the linear SVM classifier. #[inline] - fn set_svm_detector(&mut self, svmdetector: &impl ToInputArray) -> Result<()> { + fn set_svm_detector_input_array(&mut self, svmdetector: &impl ToInputArray) -> Result<()> { input_array_arg!(svmdetector); return_send!(via ocvrs_return); unsafe { sys::cv_HOGDescriptor_setSVMDetector_const__InputArrayR(self.as_raw_mut_HOGDescriptor(), svmdetector.as_raw__InputArray(), ocvrs_return.as_mut_ptr()) }; diff --git a/docs/sys.rs b/docs/sys.rs index 5e39d877..0bc9a35c 100644 --- a/docs/sys.rs +++ b/docs/sys.rs @@ -1,17 +1,14 @@ use crate::{mod_prelude_sys::*, core}; -#[cfg(ocvrs_has_module_alphamat)] mod alphamat_sys { use super::*; extern "C" { - pub fn cv_alphamat_infoFlow_const__InputArrayR_const__InputArrayR_const__OutputArrayR(image: *const c_void, tmap: *const c_void, result: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_alphamat_infoFlow_const__InputArrayR_const__InputArrayR_const__OutputArrayR(image: *const c_void, tmap: *const c_void, result: *const c_void, ocvrs_return: *mut Result<()>); } } -#[cfg(ocvrs_has_module_alphamat)] pub use alphamat_sys::*; -#[cfg(ocvrs_has_module_aruco)] mod aruco_sys { use super::*; @@ -24,24 +21,24 @@ mod aruco_sys { pub fn cv_aruco_calibrateCameraCharuco_const__InputArrayR_const__InputArrayR_const_PtrLCharucoBoardGR_Size_const__InputOutputArrayR_const__InputOutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(charuco_corners: *const c_void, charuco_ids: *const c_void, board: *const c_void, image_size: *const core::Size, camera_matrix: *const c_void, dist_coeffs: *const c_void, rvecs: *const c_void, tvecs: *const c_void, std_deviations_intrinsics: *const c_void, std_deviations_extrinsics: *const c_void, per_view_errors: *const c_void, ocvrs_return: *mut Result); pub fn cv_aruco_calibrateCameraCharuco_const__InputArrayR_const__InputArrayR_const_PtrLCharucoBoardGR_Size_const__InputOutputArrayR_const__InputOutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_int_const_TermCriteriaR(charuco_corners: *const c_void, charuco_ids: *const c_void, board: *const c_void, image_size: *const core::Size, camera_matrix: *const c_void, dist_coeffs: *const c_void, rvecs: *const c_void, tvecs: *const c_void, std_deviations_intrinsics: *const c_void, std_deviations_extrinsics: *const c_void, per_view_errors: *const c_void, flags: i32, criteria: *const core::TermCriteria, ocvrs_return: *mut Result); pub fn cv_aruco_calibrateCameraCharuco_const__InputArrayR_const__InputArrayR_const_PtrLCharucoBoardGR_Size_const__InputOutputArrayR_const__InputOutputArrayR_const__OutputArrayR_const__OutputArrayR_int_const_TermCriteriaR(charuco_corners: *const c_void, charuco_ids: *const c_void, board: *const c_void, image_size: *const core::Size, camera_matrix: *const c_void, dist_coeffs: *const c_void, rvecs: *const c_void, tvecs: *const c_void, flags: i32, criteria: *const core::TermCriteria, ocvrs_return: *mut Result); - pub fn cv_aruco_detectCharucoDiamond_const__InputArrayR_const__InputArrayR_const__InputArrayR_float_const__OutputArrayR_const__OutputArrayR(image: *const c_void, marker_corners: *const c_void, marker_ids: *const c_void, square_marker_length_rate: f32, diamond_corners: *const c_void, diamond_ids: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_aruco_detectCharucoDiamond_const__InputArrayR_const__InputArrayR_const__InputArrayR_float_const__OutputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR_PtrLDictionaryG(image: *const c_void, marker_corners: *const c_void, marker_ids: *const c_void, square_marker_length_rate: f32, diamond_corners: *const c_void, diamond_ids: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, dictionary: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_aruco_detectMarkers_const__InputArrayR_const_PtrLDictionaryGR_const__OutputArrayR_const__OutputArrayR(image: *const c_void, dictionary: *const c_void, corners: *const c_void, ids: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_aruco_detectMarkers_const__InputArrayR_const_PtrLDictionaryGR_const__OutputArrayR_const__OutputArrayR_const_PtrLDetectorParametersGR_const__OutputArrayR(image: *const c_void, dictionary: *const c_void, corners: *const c_void, ids: *const c_void, parameters: *const c_void, rejected_img_points: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_aruco_drawCharucoDiamond_const_PtrLDictionaryGR_Vec4i_int_int_const__OutputArrayR(dictionary: *const c_void, ids: *const core::Vec4i, square_length: i32, marker_length: i32, img: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_aruco_drawCharucoDiamond_const_PtrLDictionaryGR_Vec4i_int_int_const__OutputArrayR_int_int(dictionary: *const c_void, ids: *const core::Vec4i, square_length: i32, marker_length: i32, img: *const c_void, margin_size: i32, border_bits: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_aruco_drawPlanarBoard_const_PtrLBoardGR_Size_const__OutputArrayR_int_int(board: *const c_void, out_size: *const core::Size, img: *const c_void, margin_size: i32, border_bits: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_aruco_detectCharucoDiamond_const__InputArrayR_const__InputArrayR_const__InputArrayR_float_const__OutputArrayR_const__OutputArrayR(image: *const c_void, marker_corners: *const c_void, marker_ids: *const c_void, square_marker_length_rate: f32, diamond_corners: *const c_void, diamond_ids: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_aruco_detectCharucoDiamond_const__InputArrayR_const__InputArrayR_const__InputArrayR_float_const__OutputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR_PtrLDictionaryG(image: *const c_void, marker_corners: *const c_void, marker_ids: *const c_void, square_marker_length_rate: f32, diamond_corners: *const c_void, diamond_ids: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, dictionary: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_aruco_detectMarkers_const__InputArrayR_const_PtrLDictionaryGR_const__OutputArrayR_const__OutputArrayR(image: *const c_void, dictionary: *const c_void, corners: *const c_void, ids: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_aruco_detectMarkers_const__InputArrayR_const_PtrLDictionaryGR_const__OutputArrayR_const__OutputArrayR_const_PtrLDetectorParametersGR_const__OutputArrayR(image: *const c_void, dictionary: *const c_void, corners: *const c_void, ids: *const c_void, parameters: *const c_void, rejected_img_points: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_aruco_drawCharucoDiamond_const_PtrLDictionaryGR_Vec4i_int_int_const__OutputArrayR(dictionary: *const c_void, ids: *const core::Vec4i, square_length: i32, marker_length: i32, img: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_aruco_drawCharucoDiamond_const_PtrLDictionaryGR_Vec4i_int_int_const__OutputArrayR_int_int(dictionary: *const c_void, ids: *const core::Vec4i, square_length: i32, marker_length: i32, img: *const c_void, margin_size: i32, border_bits: i32, ocvrs_return: *mut Result<()>); + pub fn cv_aruco_drawPlanarBoard_const_PtrLBoardGR_Size_const__OutputArrayR_int_int(board: *const c_void, out_size: *const core::Size, img: *const c_void, margin_size: i32, border_bits: i32, ocvrs_return: *mut Result<()>); pub fn cv_aruco_estimatePoseBoard_const__InputArrayR_const__InputArrayR_const_PtrLBoardGR_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__InputOutputArrayR(corners: *const c_void, ids: *const c_void, board: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, rvec: *const c_void, tvec: *const c_void, ocvrs_return: *mut Result); pub fn cv_aruco_estimatePoseBoard_const__InputArrayR_const__InputArrayR_const_PtrLBoardGR_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__InputOutputArrayR_bool(corners: *const c_void, ids: *const c_void, board: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, rvec: *const c_void, tvec: *const c_void, use_extrinsic_guess: bool, ocvrs_return: *mut Result); pub fn cv_aruco_estimatePoseCharucoBoard_const__InputArrayR_const__InputArrayR_const_PtrLCharucoBoardGR_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__InputOutputArrayR(charuco_corners: *const c_void, charuco_ids: *const c_void, board: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, rvec: *const c_void, tvec: *const c_void, ocvrs_return: *mut Result); pub fn cv_aruco_estimatePoseCharucoBoard_const__InputArrayR_const__InputArrayR_const_PtrLCharucoBoardGR_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__InputOutputArrayR_bool(charuco_corners: *const c_void, charuco_ids: *const c_void, board: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, rvec: *const c_void, tvec: *const c_void, use_extrinsic_guess: bool, ocvrs_return: *mut Result); - pub fn cv_aruco_estimatePoseSingleMarkers_const__InputArrayR_float_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(corners: *const c_void, marker_length: f32, camera_matrix: *const c_void, dist_coeffs: *const c_void, rvecs: *const c_void, tvecs: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_aruco_estimatePoseSingleMarkers_const__InputArrayR_float_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const_PtrLEstimateParametersGR(corners: *const c_void, marker_length: f32, camera_matrix: *const c_void, dist_coeffs: *const c_void, rvecs: *const c_void, tvecs: *const c_void, obj_points: *const c_void, estimate_parameters: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_aruco_getBoardObjectAndImagePoints_const_PtrLBoardGR_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(board: *const c_void, detected_corners: *const c_void, detected_ids: *const c_void, obj_points: *const c_void, img_points: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_aruco_estimatePoseSingleMarkers_const__InputArrayR_float_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(corners: *const c_void, marker_length: f32, camera_matrix: *const c_void, dist_coeffs: *const c_void, rvecs: *const c_void, tvecs: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_aruco_estimatePoseSingleMarkers_const__InputArrayR_float_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const_PtrLEstimateParametersGR(corners: *const c_void, marker_length: f32, camera_matrix: *const c_void, dist_coeffs: *const c_void, rvecs: *const c_void, tvecs: *const c_void, obj_points: *const c_void, estimate_parameters: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_aruco_getBoardObjectAndImagePoints_const_PtrLBoardGR_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(board: *const c_void, detected_corners: *const c_void, detected_ids: *const c_void, obj_points: *const c_void, img_points: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_aruco_interpolateCornersCharuco_const__InputArrayR_const__InputArrayR_const__InputArrayR_const_PtrLCharucoBoardGR_const__OutputArrayR_const__OutputArrayR(marker_corners: *const c_void, marker_ids: *const c_void, image: *const c_void, board: *const c_void, charuco_corners: *const c_void, charuco_ids: *const c_void, ocvrs_return: *mut Result); pub fn cv_aruco_interpolateCornersCharuco_const__InputArrayR_const__InputArrayR_const__InputArrayR_const_PtrLCharucoBoardGR_const__OutputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR_int(marker_corners: *const c_void, marker_ids: *const c_void, image: *const c_void, board: *const c_void, charuco_corners: *const c_void, charuco_ids: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, min_markers: i32, ocvrs_return: *mut Result); - pub fn cv_aruco_refineDetectedMarkers_const__InputArrayR_const_PtrLBoardGR_const__InputOutputArrayR_const__InputOutputArrayR_const__InputOutputArrayR(image: *const c_void, board: *const c_void, detected_corners: *const c_void, detected_ids: *const c_void, rejected_corners: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_aruco_refineDetectedMarkers_const__InputArrayR_const_PtrLBoardGR_const__InputOutputArrayR_const__InputOutputArrayR_const__InputOutputArrayR_const__InputArrayR_const__InputArrayR_float_float_bool_const__OutputArrayR_const_PtrLDetectorParametersGR(image: *const c_void, board: *const c_void, detected_corners: *const c_void, detected_ids: *const c_void, rejected_corners: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, min_rep_distance: f32, error_correction_rate: f32, check_all_orders: bool, recovered_idxs: *const c_void, parameters: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_aruco_refineDetectedMarkers_const__InputArrayR_const_PtrLBoardGR_const__InputOutputArrayR_const__InputOutputArrayR_const__InputOutputArrayR(image: *const c_void, board: *const c_void, detected_corners: *const c_void, detected_ids: *const c_void, rejected_corners: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_aruco_refineDetectedMarkers_const__InputArrayR_const_PtrLBoardGR_const__InputOutputArrayR_const__InputOutputArrayR_const__InputOutputArrayR_const__InputArrayR_const__InputArrayR_float_float_bool_const__OutputArrayR_const_PtrLDetectorParametersGR(image: *const c_void, board: *const c_void, detected_corners: *const c_void, detected_ids: *const c_void, rejected_corners: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, min_rep_distance: f32, error_correction_rate: f32, check_all_orders: bool, recovered_idxs: *const c_void, parameters: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_aruco_testCharucoCornersCollinear_const_PtrLCharucoBoardGR_const__InputArrayR(board: *const c_void, charuco_ids: *const c_void, ocvrs_return: *mut Result); pub fn cv_aruco_EstimateParameters_EstimateParameters(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_aruco_EstimateParameters_implicitClone_const(instance: *const c_void) -> *mut c_void; @@ -59,10 +56,8 @@ mod aruco_sys { pub fn cv_PtrLcv_aruco_EstimateParametersG_new_const_EstimateParameters(val: *mut c_void) -> *mut c_void; } } -#[cfg(ocvrs_has_module_aruco)] pub use aruco_sys::*; -#[cfg(ocvrs_has_module_bgsegm)] mod bgsegm_sys { use super::*; @@ -79,76 +74,76 @@ mod bgsegm_sys { pub fn cv_bgsegm_createBackgroundSubtractorMOG_int_int_double_double(history: i32, nmixtures: i32, background_ratio: f64, noise_sigma: f64, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_bgsegm_createSyntheticSequenceGenerator_const__InputArrayR_const__InputArrayR(background: *const c_void, object: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_bgsegm_createSyntheticSequenceGenerator_const__InputArrayR_const__InputArrayR_double_double_double_double(background: *const c_void, object: *const c_void, amplitude: f64, wavelength: f64, wavespeed: f64, objspeed: f64, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_bgsegm_BackgroundSubtractorCNT_apply_const__InputArrayR_const__OutputArrayR_double(instance: *mut c_void, image: *const c_void, fgmask: *const c_void, learning_rate: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_bgsegm_BackgroundSubtractorCNT_apply_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, fgmask: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_bgsegm_BackgroundSubtractorCNT_getBackgroundImage_const_const__OutputArrayR(instance: *const c_void, background_image: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_bgsegm_BackgroundSubtractorCNT_apply_const__InputArrayR_const__OutputArrayR_double(instance: *mut c_void, image: *const c_void, fgmask: *const c_void, learning_rate: f64, ocvrs_return: *mut Result<()>); + pub fn cv_bgsegm_BackgroundSubtractorCNT_apply_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, fgmask: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_bgsegm_BackgroundSubtractorCNT_getBackgroundImage_const_const__OutputArrayR(instance: *const c_void, background_image: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_bgsegm_BackgroundSubtractorCNT_getMinPixelStability_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_bgsegm_BackgroundSubtractorCNT_setMinPixelStability_int(instance: *mut c_void, value: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_bgsegm_BackgroundSubtractorCNT_setMinPixelStability_int(instance: *mut c_void, value: i32, ocvrs_return: *mut Result<()>); pub fn cv_bgsegm_BackgroundSubtractorCNT_getMaxPixelStability_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_bgsegm_BackgroundSubtractorCNT_setMaxPixelStability_int(instance: *mut c_void, value: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_bgsegm_BackgroundSubtractorCNT_setMaxPixelStability_int(instance: *mut c_void, value: i32, ocvrs_return: *mut Result<()>); pub fn cv_bgsegm_BackgroundSubtractorCNT_getUseHistory_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_bgsegm_BackgroundSubtractorCNT_setUseHistory_bool(instance: *mut c_void, value: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_bgsegm_BackgroundSubtractorCNT_setUseHistory_bool(instance: *mut c_void, value: bool, ocvrs_return: *mut Result<()>); pub fn cv_bgsegm_BackgroundSubtractorCNT_getIsParallel_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_bgsegm_BackgroundSubtractorCNT_setIsParallel_bool(instance: *mut c_void, value: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_bgsegm_BackgroundSubtractorCNT_setIsParallel_bool(instance: *mut c_void, value: bool, ocvrs_return: *mut Result<()>); pub fn cv_bgsegm_BackgroundSubtractorCNT_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_bgsegm_BackgroundSubtractorCNT_to_BackgroundSubtractor(instance: *mut c_void) -> *mut c_void; pub fn cv_bgsegm_BackgroundSubtractorCNT_delete(instance: *mut c_void); - pub fn cv_bgsegm_BackgroundSubtractorGMG_apply_const__InputArrayR_const__OutputArrayR_double(instance: *mut c_void, image: *const c_void, fgmask: *const c_void, learning_rate: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_bgsegm_BackgroundSubtractorGMG_apply_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, fgmask: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_bgsegm_BackgroundSubtractorGMG_getBackgroundImage_const_const__OutputArrayR(instance: *const c_void, background_image: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_bgsegm_BackgroundSubtractorGMG_apply_const__InputArrayR_const__OutputArrayR_double(instance: *mut c_void, image: *const c_void, fgmask: *const c_void, learning_rate: f64, ocvrs_return: *mut Result<()>); + pub fn cv_bgsegm_BackgroundSubtractorGMG_apply_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, fgmask: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_bgsegm_BackgroundSubtractorGMG_getBackgroundImage_const_const__OutputArrayR(instance: *const c_void, background_image: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_bgsegm_BackgroundSubtractorGMG_getMaxFeatures_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_bgsegm_BackgroundSubtractorGMG_setMaxFeatures_int(instance: *mut c_void, max_features: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_bgsegm_BackgroundSubtractorGMG_setMaxFeatures_int(instance: *mut c_void, max_features: i32, ocvrs_return: *mut Result<()>); pub fn cv_bgsegm_BackgroundSubtractorGMG_getDefaultLearningRate_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_bgsegm_BackgroundSubtractorGMG_setDefaultLearningRate_double(instance: *mut c_void, lr: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_bgsegm_BackgroundSubtractorGMG_setDefaultLearningRate_double(instance: *mut c_void, lr: f64, ocvrs_return: *mut Result<()>); pub fn cv_bgsegm_BackgroundSubtractorGMG_getNumFrames_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_bgsegm_BackgroundSubtractorGMG_setNumFrames_int(instance: *mut c_void, nframes: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_bgsegm_BackgroundSubtractorGMG_setNumFrames_int(instance: *mut c_void, nframes: i32, ocvrs_return: *mut Result<()>); pub fn cv_bgsegm_BackgroundSubtractorGMG_getQuantizationLevels_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_bgsegm_BackgroundSubtractorGMG_setQuantizationLevels_int(instance: *mut c_void, nlevels: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_bgsegm_BackgroundSubtractorGMG_setQuantizationLevels_int(instance: *mut c_void, nlevels: i32, ocvrs_return: *mut Result<()>); pub fn cv_bgsegm_BackgroundSubtractorGMG_getBackgroundPrior_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_bgsegm_BackgroundSubtractorGMG_setBackgroundPrior_double(instance: *mut c_void, bgprior: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_bgsegm_BackgroundSubtractorGMG_setBackgroundPrior_double(instance: *mut c_void, bgprior: f64, ocvrs_return: *mut Result<()>); pub fn cv_bgsegm_BackgroundSubtractorGMG_getSmoothingRadius_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_bgsegm_BackgroundSubtractorGMG_setSmoothingRadius_int(instance: *mut c_void, radius: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_bgsegm_BackgroundSubtractorGMG_setSmoothingRadius_int(instance: *mut c_void, radius: i32, ocvrs_return: *mut Result<()>); pub fn cv_bgsegm_BackgroundSubtractorGMG_getDecisionThreshold_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_bgsegm_BackgroundSubtractorGMG_setDecisionThreshold_double(instance: *mut c_void, thresh: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_bgsegm_BackgroundSubtractorGMG_setDecisionThreshold_double(instance: *mut c_void, thresh: f64, ocvrs_return: *mut Result<()>); pub fn cv_bgsegm_BackgroundSubtractorGMG_getUpdateBackgroundModel_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_bgsegm_BackgroundSubtractorGMG_setUpdateBackgroundModel_bool(instance: *mut c_void, update: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_bgsegm_BackgroundSubtractorGMG_setUpdateBackgroundModel_bool(instance: *mut c_void, update: bool, ocvrs_return: *mut Result<()>); pub fn cv_bgsegm_BackgroundSubtractorGMG_getMinVal_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_bgsegm_BackgroundSubtractorGMG_setMinVal_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_bgsegm_BackgroundSubtractorGMG_setMinVal_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_bgsegm_BackgroundSubtractorGMG_getMaxVal_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_bgsegm_BackgroundSubtractorGMG_setMaxVal_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_bgsegm_BackgroundSubtractorGMG_setMaxVal_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_bgsegm_BackgroundSubtractorGMG_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_bgsegm_BackgroundSubtractorGMG_to_BackgroundSubtractor(instance: *mut c_void) -> *mut c_void; pub fn cv_bgsegm_BackgroundSubtractorGMG_delete(instance: *mut c_void); - pub fn cv_bgsegm_BackgroundSubtractorGSOC_apply_const__InputArrayR_const__OutputArrayR_double(instance: *mut c_void, image: *const c_void, fgmask: *const c_void, learning_rate: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_bgsegm_BackgroundSubtractorGSOC_apply_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, fgmask: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_bgsegm_BackgroundSubtractorGSOC_getBackgroundImage_const_const__OutputArrayR(instance: *const c_void, background_image: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_bgsegm_BackgroundSubtractorGSOC_apply_const__InputArrayR_const__OutputArrayR_double(instance: *mut c_void, image: *const c_void, fgmask: *const c_void, learning_rate: f64, ocvrs_return: *mut Result<()>); + pub fn cv_bgsegm_BackgroundSubtractorGSOC_apply_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, fgmask: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_bgsegm_BackgroundSubtractorGSOC_getBackgroundImage_const_const__OutputArrayR(instance: *const c_void, background_image: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_bgsegm_BackgroundSubtractorGSOC_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_bgsegm_BackgroundSubtractorGSOC_to_BackgroundSubtractor(instance: *mut c_void) -> *mut c_void; pub fn cv_bgsegm_BackgroundSubtractorGSOC_delete(instance: *mut c_void); - pub fn cv_bgsegm_BackgroundSubtractorLSBP_apply_const__InputArrayR_const__OutputArrayR_double(instance: *mut c_void, image: *const c_void, fgmask: *const c_void, learning_rate: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_bgsegm_BackgroundSubtractorLSBP_apply_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, fgmask: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_bgsegm_BackgroundSubtractorLSBP_getBackgroundImage_const_const__OutputArrayR(instance: *const c_void, background_image: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_bgsegm_BackgroundSubtractorLSBP_apply_const__InputArrayR_const__OutputArrayR_double(instance: *mut c_void, image: *const c_void, fgmask: *const c_void, learning_rate: f64, ocvrs_return: *mut Result<()>); + pub fn cv_bgsegm_BackgroundSubtractorLSBP_apply_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, fgmask: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_bgsegm_BackgroundSubtractorLSBP_getBackgroundImage_const_const__OutputArrayR(instance: *const c_void, background_image: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_bgsegm_BackgroundSubtractorLSBP_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_bgsegm_BackgroundSubtractorLSBP_to_BackgroundSubtractor(instance: *mut c_void) -> *mut c_void; pub fn cv_bgsegm_BackgroundSubtractorLSBP_delete(instance: *mut c_void); - pub fn cv_bgsegm_BackgroundSubtractorLSBPDesc_calcLocalSVDValues_const__OutputArrayR_const_MatR(local_svd_values: *const c_void, frame: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_bgsegm_BackgroundSubtractorLSBPDesc_computeFromLocalSVDValues_const__OutputArrayR_const_MatR_const_Point2iX(desc: *const c_void, local_svd_values: *const c_void, lsbp_sample_points: *const core::Point2i, ocvrs_return: *mut ResultVoid); - pub fn cv_bgsegm_BackgroundSubtractorLSBPDesc_compute_const__OutputArrayR_const_MatR_const_Point2iX(desc: *const c_void, frame: *const c_void, lsbp_sample_points: *const core::Point2i, ocvrs_return: *mut ResultVoid); + pub fn cv_bgsegm_BackgroundSubtractorLSBPDesc_calcLocalSVDValues_const__OutputArrayR_const_MatR(local_svd_values: *const c_void, frame: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_bgsegm_BackgroundSubtractorLSBPDesc_computeFromLocalSVDValues_const__OutputArrayR_const_MatR_const_Point2iX(desc: *const c_void, local_svd_values: *const c_void, lsbp_sample_points: *const core::Point2i, ocvrs_return: *mut Result<()>); + pub fn cv_bgsegm_BackgroundSubtractorLSBPDesc_compute_const__OutputArrayR_const_MatR_const_Point2iX(desc: *const c_void, frame: *const c_void, lsbp_sample_points: *const core::Point2i, ocvrs_return: *mut Result<()>); pub fn cv_bgsegm_BackgroundSubtractorLSBPDesc_defaultNew_const() -> *mut c_void; pub fn cv_bgsegm_BackgroundSubtractorLSBPDesc_delete(instance: *mut c_void); pub fn cv_bgsegm_BackgroundSubtractorMOG_getHistory_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_bgsegm_BackgroundSubtractorMOG_setHistory_int(instance: *mut c_void, nframes: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_bgsegm_BackgroundSubtractorMOG_setHistory_int(instance: *mut c_void, nframes: i32, ocvrs_return: *mut Result<()>); pub fn cv_bgsegm_BackgroundSubtractorMOG_getNMixtures_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_bgsegm_BackgroundSubtractorMOG_setNMixtures_int(instance: *mut c_void, nmix: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_bgsegm_BackgroundSubtractorMOG_setNMixtures_int(instance: *mut c_void, nmix: i32, ocvrs_return: *mut Result<()>); pub fn cv_bgsegm_BackgroundSubtractorMOG_getBackgroundRatio_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_bgsegm_BackgroundSubtractorMOG_setBackgroundRatio_double(instance: *mut c_void, background_ratio: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_bgsegm_BackgroundSubtractorMOG_setBackgroundRatio_double(instance: *mut c_void, background_ratio: f64, ocvrs_return: *mut Result<()>); pub fn cv_bgsegm_BackgroundSubtractorMOG_getNoiseSigma_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_bgsegm_BackgroundSubtractorMOG_setNoiseSigma_double(instance: *mut c_void, noise_sigma: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_bgsegm_BackgroundSubtractorMOG_setNoiseSigma_double(instance: *mut c_void, noise_sigma: f64, ocvrs_return: *mut Result<()>); pub fn cv_bgsegm_BackgroundSubtractorMOG_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_bgsegm_BackgroundSubtractorMOG_to_BackgroundSubtractor(instance: *mut c_void) -> *mut c_void; pub fn cv_bgsegm_BackgroundSubtractorMOG_delete(instance: *mut c_void); pub fn cv_bgsegm_SyntheticSequenceGenerator_SyntheticSequenceGenerator_const__InputArrayR_const__InputArrayR_double_double_double_double(background: *const c_void, object: *const c_void, amplitude: f64, wavelength: f64, wavespeed: f64, objspeed: f64, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_bgsegm_SyntheticSequenceGenerator_getNextFrame_const__OutputArrayR_const__OutputArrayR(instance: *mut c_void, frame: *const c_void, gt_mask: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_bgsegm_SyntheticSequenceGenerator_getNextFrame_const__OutputArrayR_const__OutputArrayR(instance: *mut c_void, frame: *const c_void, gt_mask: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_bgsegm_SyntheticSequenceGenerator_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_bgsegm_SyntheticSequenceGenerator_delete(instance: *mut c_void); pub fn cv_PtrLcv_bgsegm_BackgroundSubtractorCNTG_getInnerPtr_const(instance: *const c_void) -> *mut c_void; @@ -189,50 +184,48 @@ mod bgsegm_sys { pub fn cv_PtrLcv_bgsegm_SyntheticSequenceGeneratorG_new_const_SyntheticSequenceGenerator(val: *mut c_void) -> *mut c_void; } } -#[cfg(ocvrs_has_module_bgsegm)] pub use bgsegm_sys::*; -#[cfg(ocvrs_has_module_bioinspired)] mod bioinspired_sys { use super::*; extern "C" { pub fn cv_bioinspired_Retina_getInputSize(instance: *mut c_void, ocvrs_return: *mut Result); pub fn cv_bioinspired_Retina_getOutputSize(instance: *mut c_void, ocvrs_return: *mut Result); - pub fn cv_bioinspired_Retina_setup_String_const_bool(instance: *mut c_void, retina_parameter_file: *const c_char, apply_default_setup_on_failure: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_bioinspired_Retina_setup(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_bioinspired_Retina_setup_FileStorageR_const_bool(instance: *mut c_void, fs: *mut c_void, apply_default_setup_on_failure: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_bioinspired_Retina_setup_FileStorageR(instance: *mut c_void, fs: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_bioinspired_Retina_setup_RetinaParameters(instance: *mut c_void, new_parameters: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_bioinspired_Retina_setup_String_const_bool(instance: *mut c_void, retina_parameter_file: *const c_char, apply_default_setup_on_failure: bool, ocvrs_return: *mut Result<()>); + pub fn cv_bioinspired_Retina_setup(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_bioinspired_Retina_setup_FileStorageR_const_bool(instance: *mut c_void, fs: *mut c_void, apply_default_setup_on_failure: bool, ocvrs_return: *mut Result<()>); + pub fn cv_bioinspired_Retina_setup_FileStorageR(instance: *mut c_void, fs: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_bioinspired_Retina_setup_RetinaParameters(instance: *mut c_void, new_parameters: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_bioinspired_Retina_getParameters(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_bioinspired_Retina_printSetup(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_bioinspired_Retina_write_const_String(instance: *const c_void, fs: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_bioinspired_Retina_write_const_FileStorageR(instance: *const c_void, fs: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_bioinspired_Retina_setupOPLandIPLParvoChannel_const_bool_const_bool_const_float_const_float_const_float_const_float_const_float_const_float_const_float(instance: *mut c_void, color_mode: bool, normalise_output: bool, photoreceptors_local_adaptation_sensitivity: f32, photoreceptors_temporal_constant: f32, photoreceptors_spatial_constant: f32, horizontal_cells_gain: f32, hcells_temporal_constant: f32, hcells_spatial_constant: f32, ganglion_cells_sensitivity: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_bioinspired_Retina_setupOPLandIPLParvoChannel(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_bioinspired_Retina_setupIPLMagnoChannel_const_bool_const_float_const_float_const_float_const_float_const_float_const_float_const_float(instance: *mut c_void, normalise_output: bool, parasol_cells_beta: f32, parasol_cells_tau: f32, parasol_cells_k: f32, amacrin_cells_temporal_cut_frequency: f32, v0_compression_parameter: f32, local_adaptintegration_tau: f32, local_adaptintegration_k: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_bioinspired_Retina_setupIPLMagnoChannel(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_bioinspired_Retina_run_const__InputArrayR(instance: *mut c_void, input_image: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_bioinspired_Retina_applyFastToneMapping_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, input_image: *const c_void, output_tone_mapped_image: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_bioinspired_Retina_getParvo_const__OutputArrayR(instance: *mut c_void, retina_output_parvo: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_bioinspired_Retina_getParvoRAW_const__OutputArrayR(instance: *mut c_void, retina_output_parvo: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_bioinspired_Retina_getMagno_const__OutputArrayR(instance: *mut c_void, retina_output_magno: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_bioinspired_Retina_getMagnoRAW_const__OutputArrayR(instance: *mut c_void, retina_output_magno: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_bioinspired_Retina_write_const_String(instance: *const c_void, fs: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_bioinspired_Retina_write_const_FileStorageR(instance: *const c_void, fs: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_bioinspired_Retina_setupOPLandIPLParvoChannel_const_bool_const_bool_const_float_const_float_const_float_const_float_const_float_const_float_const_float(instance: *mut c_void, color_mode: bool, normalise_output: bool, photoreceptors_local_adaptation_sensitivity: f32, photoreceptors_temporal_constant: f32, photoreceptors_spatial_constant: f32, horizontal_cells_gain: f32, hcells_temporal_constant: f32, hcells_spatial_constant: f32, ganglion_cells_sensitivity: f32, ocvrs_return: *mut Result<()>); + pub fn cv_bioinspired_Retina_setupOPLandIPLParvoChannel(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_bioinspired_Retina_setupIPLMagnoChannel_const_bool_const_float_const_float_const_float_const_float_const_float_const_float_const_float(instance: *mut c_void, normalise_output: bool, parasol_cells_beta: f32, parasol_cells_tau: f32, parasol_cells_k: f32, amacrin_cells_temporal_cut_frequency: f32, v0_compression_parameter: f32, local_adaptintegration_tau: f32, local_adaptintegration_k: f32, ocvrs_return: *mut Result<()>); + pub fn cv_bioinspired_Retina_setupIPLMagnoChannel(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_bioinspired_Retina_run_const__InputArrayR(instance: *mut c_void, input_image: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_bioinspired_Retina_applyFastToneMapping_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, input_image: *const c_void, output_tone_mapped_image: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_bioinspired_Retina_getParvo_const__OutputArrayR(instance: *mut c_void, retina_output_parvo: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_bioinspired_Retina_getParvoRAW_const__OutputArrayR(instance: *mut c_void, retina_output_parvo: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_bioinspired_Retina_getMagno_const__OutputArrayR(instance: *mut c_void, retina_output_magno: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_bioinspired_Retina_getMagnoRAW_const__OutputArrayR(instance: *mut c_void, retina_output_magno: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_bioinspired_Retina_getMagnoRAW_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_bioinspired_Retina_getParvoRAW_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_bioinspired_Retina_setColorSaturation_const_bool_const_float(instance: *mut c_void, saturate_colors: bool, color_saturation_value: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_bioinspired_Retina_setColorSaturation(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_bioinspired_Retina_clearBuffers(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_bioinspired_Retina_activateMovingContoursProcessing_const_bool(instance: *mut c_void, activate: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_bioinspired_Retina_activateContoursProcessing_const_bool(instance: *mut c_void, activate: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_bioinspired_Retina_setColorSaturation_const_bool_const_float(instance: *mut c_void, saturate_colors: bool, color_saturation_value: f32, ocvrs_return: *mut Result<()>); + pub fn cv_bioinspired_Retina_setColorSaturation(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_bioinspired_Retina_clearBuffers(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_bioinspired_Retina_activateMovingContoursProcessing_const_bool(instance: *mut c_void, activate: bool, ocvrs_return: *mut Result<()>); + pub fn cv_bioinspired_Retina_activateContoursProcessing_const_bool(instance: *mut c_void, activate: bool, ocvrs_return: *mut Result<()>); pub fn cv_bioinspired_Retina_create_Size(input_size: *const core::Size, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_bioinspired_Retina_create_Size_const_bool_int_const_bool_const_float_const_float(input_size: *const core::Size, color_mode: bool, color_sampling_method: i32, use_retina_log_sampling: bool, reduction_factor: f32, sampling_strength: f32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_bioinspired_Retina_create_Size_const_bool(input_size: *const core::Size, color_mode: bool, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_bioinspired_Retina_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_bioinspired_Retina_delete(instance: *mut c_void); - pub fn cv_bioinspired_RetinaFastToneMapping_applyFastToneMapping_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, input_image: *const c_void, output_tone_mapped_image: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_bioinspired_RetinaFastToneMapping_setup_const_float_const_float_const_float(instance: *mut c_void, photoreceptors_neighborhood_radius: f32, ganglioncells_neighborhood_radius: f32, mean_luminance_modulator_k: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_bioinspired_RetinaFastToneMapping_setup(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_bioinspired_RetinaFastToneMapping_applyFastToneMapping_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, input_image: *const c_void, output_tone_mapped_image: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_bioinspired_RetinaFastToneMapping_setup_const_float_const_float_const_float(instance: *mut c_void, photoreceptors_neighborhood_radius: f32, ganglioncells_neighborhood_radius: f32, mean_luminance_modulator_k: f32, ocvrs_return: *mut Result<()>); + pub fn cv_bioinspired_RetinaFastToneMapping_setup(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_bioinspired_RetinaFastToneMapping_create_Size(input_size: *const core::Size, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_bioinspired_RetinaFastToneMapping_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_bioinspired_RetinaFastToneMapping_delete(instance: *mut c_void); @@ -247,19 +240,19 @@ mod bioinspired_sys { pub fn cv_bioinspired_RetinaParameters_OPLandIplParvoParameters_OPLandIplParvoParameters(ocvrs_return: *mut Result); pub fn cv_bioinspired_SegmentationParameters_SegmentationParameters(ocvrs_return: *mut Result); pub fn cv_bioinspired_TransientAreasSegmentationModule_getSize(instance: *mut c_void, ocvrs_return: *mut Result); - pub fn cv_bioinspired_TransientAreasSegmentationModule_setup_String_const_bool(instance: *mut c_void, segmentation_parameter_file: *const c_char, apply_default_setup_on_failure: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_bioinspired_TransientAreasSegmentationModule_setup(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_bioinspired_TransientAreasSegmentationModule_setup_FileStorageR_const_bool(instance: *mut c_void, fs: *mut c_void, apply_default_setup_on_failure: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_bioinspired_TransientAreasSegmentationModule_setup_FileStorageR(instance: *mut c_void, fs: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_bioinspired_TransientAreasSegmentationModule_setup_SegmentationParameters(instance: *mut c_void, new_parameters: *const crate::bioinspired::SegmentationParameters, ocvrs_return: *mut ResultVoid); + pub fn cv_bioinspired_TransientAreasSegmentationModule_setup_String_const_bool(instance: *mut c_void, segmentation_parameter_file: *const c_char, apply_default_setup_on_failure: bool, ocvrs_return: *mut Result<()>); + pub fn cv_bioinspired_TransientAreasSegmentationModule_setup(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_bioinspired_TransientAreasSegmentationModule_setup_FileStorageR_const_bool(instance: *mut c_void, fs: *mut c_void, apply_default_setup_on_failure: bool, ocvrs_return: *mut Result<()>); + pub fn cv_bioinspired_TransientAreasSegmentationModule_setup_FileStorageR(instance: *mut c_void, fs: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_bioinspired_TransientAreasSegmentationModule_setup_SegmentationParameters(instance: *mut c_void, new_parameters: *const crate::bioinspired::SegmentationParameters, ocvrs_return: *mut Result<()>); pub fn cv_bioinspired_TransientAreasSegmentationModule_getParameters(instance: *mut c_void, ocvrs_return: *mut Result); pub fn cv_bioinspired_TransientAreasSegmentationModule_printSetup(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_bioinspired_TransientAreasSegmentationModule_write_const_String(instance: *const c_void, fs: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_bioinspired_TransientAreasSegmentationModule_write_const_FileStorageR(instance: *const c_void, fs: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_bioinspired_TransientAreasSegmentationModule_run_const__InputArrayR_const_int(instance: *mut c_void, input_to_segment: *const c_void, channel_index: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_bioinspired_TransientAreasSegmentationModule_run_const__InputArrayR(instance: *mut c_void, input_to_segment: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_bioinspired_TransientAreasSegmentationModule_getSegmentationPicture_const__OutputArrayR(instance: *mut c_void, transient_areas: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_bioinspired_TransientAreasSegmentationModule_clearAllBuffers(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_bioinspired_TransientAreasSegmentationModule_write_const_String(instance: *const c_void, fs: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_bioinspired_TransientAreasSegmentationModule_write_const_FileStorageR(instance: *const c_void, fs: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_bioinspired_TransientAreasSegmentationModule_run_const__InputArrayR_const_int(instance: *mut c_void, input_to_segment: *const c_void, channel_index: i32, ocvrs_return: *mut Result<()>); + pub fn cv_bioinspired_TransientAreasSegmentationModule_run_const__InputArrayR(instance: *mut c_void, input_to_segment: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_bioinspired_TransientAreasSegmentationModule_getSegmentationPicture_const__OutputArrayR(instance: *mut c_void, transient_areas: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_bioinspired_TransientAreasSegmentationModule_clearAllBuffers(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_bioinspired_TransientAreasSegmentationModule_create_Size(input_size: *const core::Size, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_bioinspired_TransientAreasSegmentationModule_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_bioinspired_TransientAreasSegmentationModule_delete(instance: *mut c_void); @@ -280,18 +273,16 @@ mod bioinspired_sys { pub fn cv_PtrLcv_bioinspired_TransientAreasSegmentationModuleG_to_PtrOfAlgorithm(instance: *mut c_void) -> *mut c_void; } } -#[cfg(ocvrs_has_module_bioinspired)] pub use bioinspired_sys::*; -#[cfg(ocvrs_has_module_calib3d)] mod calib3d_sys { use super::*; extern "C" { pub fn cv_RQDecomp3x3_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(src: *const c_void, mtx_r: *const c_void, mtx_q: *const c_void, ocvrs_return: *mut Result); pub fn cv_RQDecomp3x3_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(src: *const c_void, mtx_r: *const c_void, mtx_q: *const c_void, qx: *const c_void, qy: *const c_void, qz: *const c_void, ocvrs_return: *mut Result); - pub fn cv_Rodrigues_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_Rodrigues_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, jacobian: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_Rodrigues_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_Rodrigues_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, jacobian: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_calibrateCameraRO_const__InputArrayR_const__InputArrayR_Size_int_const__InputOutputArrayR_const__InputOutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(object_points: *const c_void, image_points: *const c_void, image_size: *const core::Size, i_fixed_point: i32, camera_matrix: *const c_void, dist_coeffs: *const c_void, rvecs: *const c_void, tvecs: *const c_void, new_obj_points: *const c_void, ocvrs_return: *mut Result); pub fn cv_calibrateCameraRO_const__InputArrayR_const__InputArrayR_Size_int_const__InputOutputArrayR_const__InputOutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(object_points: *const c_void, image_points: *const c_void, image_size: *const core::Size, i_fixed_point: i32, camera_matrix: *const c_void, dist_coeffs: *const c_void, rvecs: *const c_void, tvecs: *const c_void, new_obj_points: *const c_void, std_deviations_intrinsics: *const c_void, std_deviations_extrinsics: *const c_void, std_deviations_obj_points: *const c_void, per_view_errors: *const c_void, ocvrs_return: *mut Result); pub fn cv_calibrateCameraRO_const__InputArrayR_const__InputArrayR_Size_int_const__InputOutputArrayR_const__InputOutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_int_TermCriteria(object_points: *const c_void, image_points: *const c_void, image_size: *const core::Size, i_fixed_point: i32, camera_matrix: *const c_void, dist_coeffs: *const c_void, rvecs: *const c_void, tvecs: *const c_void, new_obj_points: *const c_void, std_deviations_intrinsics: *const c_void, std_deviations_extrinsics: *const c_void, std_deviations_obj_points: *const c_void, per_view_errors: *const c_void, flags: i32, criteria: *const core::TermCriteria, ocvrs_return: *mut Result); @@ -300,26 +291,26 @@ mod calib3d_sys { pub fn cv_calibrateCamera_const__InputArrayR_const__InputArrayR_Size_const__InputOutputArrayR_const__InputOutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(object_points: *const c_void, image_points: *const c_void, image_size: *const core::Size, camera_matrix: *const c_void, dist_coeffs: *const c_void, rvecs: *const c_void, tvecs: *const c_void, std_deviations_intrinsics: *const c_void, std_deviations_extrinsics: *const c_void, per_view_errors: *const c_void, ocvrs_return: *mut Result); pub fn cv_calibrateCamera_const__InputArrayR_const__InputArrayR_Size_const__InputOutputArrayR_const__InputOutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_int_TermCriteria(object_points: *const c_void, image_points: *const c_void, image_size: *const core::Size, camera_matrix: *const c_void, dist_coeffs: *const c_void, rvecs: *const c_void, tvecs: *const c_void, std_deviations_intrinsics: *const c_void, std_deviations_extrinsics: *const c_void, per_view_errors: *const c_void, flags: i32, criteria: *const core::TermCriteria, ocvrs_return: *mut Result); pub fn cv_calibrateCamera_const__InputArrayR_const__InputArrayR_Size_const__InputOutputArrayR_const__InputOutputArrayR_const__OutputArrayR_const__OutputArrayR_int_TermCriteria(object_points: *const c_void, image_points: *const c_void, image_size: *const core::Size, camera_matrix: *const c_void, dist_coeffs: *const c_void, rvecs: *const c_void, tvecs: *const c_void, flags: i32, criteria: *const core::TermCriteria, ocvrs_return: *mut Result); - pub fn cv_calibrateHandEye_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(r_gripper2base: *const c_void, t_gripper2base: *const c_void, r_target2cam: *const c_void, t_target2cam: *const c_void, r_cam2gripper: *const c_void, t_cam2gripper: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_calibrateHandEye_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_HandEyeCalibrationMethod(r_gripper2base: *const c_void, t_gripper2base: *const c_void, r_target2cam: *const c_void, t_target2cam: *const c_void, r_cam2gripper: *const c_void, t_cam2gripper: *const c_void, method: crate::calib3d::HandEyeCalibrationMethod, ocvrs_return: *mut ResultVoid); - pub fn cv_calibrateRobotWorldHandEye_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(r_world2cam: *const c_void, t_world2cam: *const c_void, r_base2gripper: *const c_void, t_base2gripper: *const c_void, r_base2world: *const c_void, t_base2world: *const c_void, r_gripper2cam: *const c_void, t_gripper2cam: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_calibrateRobotWorldHandEye_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_RobotWorldHandEyeCalibrationMethod(r_world2cam: *const c_void, t_world2cam: *const c_void, r_base2gripper: *const c_void, t_base2gripper: *const c_void, r_base2world: *const c_void, t_base2world: *const c_void, r_gripper2cam: *const c_void, t_gripper2cam: *const c_void, method: crate::calib3d::RobotWorldHandEyeCalibrationMethod, ocvrs_return: *mut ResultVoid); - pub fn cv_calibrationMatrixValues_const__InputArrayR_Size_double_double_doubleR_doubleR_doubleR_Point2dR_doubleR(camera_matrix: *const c_void, image_size: *const core::Size, aperture_width: f64, aperture_height: f64, fovx: *mut f64, fovy: *mut f64, focal_length: *mut f64, principal_point: *mut core::Point2d, aspect_ratio: *mut f64, ocvrs_return: *mut ResultVoid); + pub fn cv_calibrateHandEye_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(r_gripper2base: *const c_void, t_gripper2base: *const c_void, r_target2cam: *const c_void, t_target2cam: *const c_void, r_cam2gripper: *const c_void, t_cam2gripper: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_calibrateHandEye_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_HandEyeCalibrationMethod(r_gripper2base: *const c_void, t_gripper2base: *const c_void, r_target2cam: *const c_void, t_target2cam: *const c_void, r_cam2gripper: *const c_void, t_cam2gripper: *const c_void, method: crate::calib3d::HandEyeCalibrationMethod, ocvrs_return: *mut Result<()>); + pub fn cv_calibrateRobotWorldHandEye_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(r_world2cam: *const c_void, t_world2cam: *const c_void, r_base2gripper: *const c_void, t_base2gripper: *const c_void, r_base2world: *const c_void, t_base2world: *const c_void, r_gripper2cam: *const c_void, t_gripper2cam: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_calibrateRobotWorldHandEye_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_RobotWorldHandEyeCalibrationMethod(r_world2cam: *const c_void, t_world2cam: *const c_void, r_base2gripper: *const c_void, t_base2gripper: *const c_void, r_base2world: *const c_void, t_base2world: *const c_void, r_gripper2cam: *const c_void, t_gripper2cam: *const c_void, method: crate::calib3d::RobotWorldHandEyeCalibrationMethod, ocvrs_return: *mut Result<()>); + pub fn cv_calibrationMatrixValues_const__InputArrayR_Size_double_double_doubleR_doubleR_doubleR_Point2dR_doubleR(camera_matrix: *const c_void, image_size: *const core::Size, aperture_width: f64, aperture_height: f64, fovx: *mut f64, fovy: *mut f64, focal_length: *mut f64, principal_point: *mut core::Point2d, aspect_ratio: *mut f64, ocvrs_return: *mut Result<()>); pub fn cv_checkChessboard_const__InputArrayR_Size(img: *const c_void, size: *const core::Size, ocvrs_return: *mut Result); - pub fn cv_composeRT_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(rvec1: *const c_void, tvec1: *const c_void, rvec2: *const c_void, tvec2: *const c_void, rvec3: *const c_void, tvec3: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_composeRT_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(rvec1: *const c_void, tvec1: *const c_void, rvec2: *const c_void, tvec2: *const c_void, rvec3: *const c_void, tvec3: *const c_void, dr3dr1: *const c_void, dr3dt1: *const c_void, dr3dr2: *const c_void, dr3dt2: *const c_void, dt3dr1: *const c_void, dt3dt1: *const c_void, dt3dr2: *const c_void, dt3dt2: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_computeCorrespondEpilines_const__InputArrayR_int_const__InputArrayR_const__OutputArrayR(points: *const c_void, which_image: i32, f: *const c_void, lines: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_convertPointsFromHomogeneous_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_convertPointsHomogeneous_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_convertPointsToHomogeneous_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_correctMatches_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(f: *const c_void, points1: *const c_void, points2: *const c_void, new_points1: *const c_void, new_points2: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_decomposeEssentialMat_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(e: *const c_void, r1: *const c_void, r2: *const c_void, t: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_composeRT_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(rvec1: *const c_void, tvec1: *const c_void, rvec2: *const c_void, tvec2: *const c_void, rvec3: *const c_void, tvec3: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_composeRT_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(rvec1: *const c_void, tvec1: *const c_void, rvec2: *const c_void, tvec2: *const c_void, rvec3: *const c_void, tvec3: *const c_void, dr3dr1: *const c_void, dr3dt1: *const c_void, dr3dr2: *const c_void, dr3dt2: *const c_void, dt3dr1: *const c_void, dt3dt1: *const c_void, dt3dr2: *const c_void, dt3dt2: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_computeCorrespondEpilines_const__InputArrayR_int_const__InputArrayR_const__OutputArrayR(points: *const c_void, which_image: i32, f: *const c_void, lines: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_convertPointsFromHomogeneous_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_convertPointsHomogeneous_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_convertPointsToHomogeneous_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_correctMatches_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(f: *const c_void, points1: *const c_void, points2: *const c_void, new_points1: *const c_void, new_points2: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_decomposeEssentialMat_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(e: *const c_void, r1: *const c_void, r2: *const c_void, t: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_decomposeHomographyMat_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(h: *const c_void, k: *const c_void, rotations: *const c_void, translations: *const c_void, normals: *const c_void, ocvrs_return: *mut Result); - pub fn cv_decomposeProjectionMatrix_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(proj_matrix: *const c_void, camera_matrix: *const c_void, rot_matrix: *const c_void, trans_vect: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_decomposeProjectionMatrix_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(proj_matrix: *const c_void, camera_matrix: *const c_void, rot_matrix: *const c_void, trans_vect: *const c_void, rot_matrix_x: *const c_void, rot_matrix_y: *const c_void, rot_matrix_z: *const c_void, euler_angles: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_drawChessboardCorners_const__InputOutputArrayR_Size_const__InputArrayR_bool(image: *const c_void, pattern_size: *const core::Size, corners: *const c_void, pattern_was_found: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_drawFrameAxes_const__InputOutputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_float(image: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, rvec: *const c_void, tvec: *const c_void, length: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_drawFrameAxes_const__InputOutputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_float_int(image: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, rvec: *const c_void, tvec: *const c_void, length: f32, thickness: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_decomposeProjectionMatrix_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(proj_matrix: *const c_void, camera_matrix: *const c_void, rot_matrix: *const c_void, trans_vect: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_decomposeProjectionMatrix_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(proj_matrix: *const c_void, camera_matrix: *const c_void, rot_matrix: *const c_void, trans_vect: *const c_void, rot_matrix_x: *const c_void, rot_matrix_y: *const c_void, rot_matrix_z: *const c_void, euler_angles: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_drawChessboardCorners_const__InputOutputArrayR_Size_const__InputArrayR_bool(image: *const c_void, pattern_size: *const core::Size, corners: *const c_void, pattern_was_found: bool, ocvrs_return: *mut Result<()>); + pub fn cv_drawFrameAxes_const__InputOutputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_float(image: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, rvec: *const c_void, tvec: *const c_void, length: f32, ocvrs_return: *mut Result<()>); + pub fn cv_drawFrameAxes_const__InputOutputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_float_int(image: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, rvec: *const c_void, tvec: *const c_void, length: f32, thickness: i32, ocvrs_return: *mut Result<()>); pub fn cv_estimateAffine2D_const__InputArrayR_const__InputArrayR(from: *const c_void, to: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_estimateAffine2D_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const_UsacParamsR(pts1: *const c_void, pts2: *const c_void, inliers: *const c_void, params: *const crate::calib3d::UsacParams, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_estimateAffine2D_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int_double_size_t_double_size_t(from: *const c_void, to: *const c_void, inliers: *const c_void, method: i32, ransac_reproj_threshold: f64, max_iters: size_t, confidence: f64, refine_iters: size_t, ocvrs_return: *mut Result<*mut c_void>); @@ -333,10 +324,10 @@ mod calib3d_sys { pub fn cv_estimateChessboardSharpness_const__InputArrayR_Size_const__InputArrayR_float_bool_const__OutputArrayR(image: *const c_void, pattern_size: *const core::Size, corners: *const c_void, rise_distance: f32, vertical: bool, sharpness: *const c_void, ocvrs_return: *mut Result); pub fn cv_estimateTranslation3D_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, out: *const c_void, inliers: *const c_void, ocvrs_return: *mut Result); pub fn cv_estimateTranslation3D_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_double_double(src: *const c_void, dst: *const c_void, out: *const c_void, inliers: *const c_void, ransac_threshold: f64, confidence: f64, ocvrs_return: *mut Result); - pub fn cv_filterHomographyDecompByVisibleRefpoints_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR(rotations: *const c_void, normals: *const c_void, before_points: *const c_void, after_points: *const c_void, possible_solutions: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_filterHomographyDecompByVisibleRefpoints_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__InputArrayR(rotations: *const c_void, normals: *const c_void, before_points: *const c_void, after_points: *const c_void, possible_solutions: *const c_void, points_mask: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_filterSpeckles_const__InputOutputArrayR_double_int_double(img: *const c_void, new_val: f64, max_speckle_size: i32, max_diff: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_filterSpeckles_const__InputOutputArrayR_double_int_double_const__InputOutputArrayR(img: *const c_void, new_val: f64, max_speckle_size: i32, max_diff: f64, buf: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_filterHomographyDecompByVisibleRefpoints_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR(rotations: *const c_void, normals: *const c_void, before_points: *const c_void, after_points: *const c_void, possible_solutions: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_filterHomographyDecompByVisibleRefpoints_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__InputArrayR(rotations: *const c_void, normals: *const c_void, before_points: *const c_void, after_points: *const c_void, possible_solutions: *const c_void, points_mask: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_filterSpeckles_const__InputOutputArrayR_double_int_double(img: *const c_void, new_val: f64, max_speckle_size: i32, max_diff: f64, ocvrs_return: *mut Result<()>); + pub fn cv_filterSpeckles_const__InputOutputArrayR_double_int_double_const__InputOutputArrayR(img: *const c_void, new_val: f64, max_speckle_size: i32, max_diff: f64, buf: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_find4QuadCornerSubpix_const__InputArrayR_const__InputOutputArrayR_Size(img: *const c_void, corners: *const c_void, region_size: *const core::Size, ocvrs_return: *mut Result); pub fn cv_findChessboardCornersSB_const__InputArrayR_Size_const__OutputArrayR(image: *const c_void, pattern_size: *const core::Size, corners: *const c_void, ocvrs_return: *mut Result); pub fn cv_findChessboardCornersSB_const__InputArrayR_Size_const__OutputArrayR_int(image: *const c_void, pattern_size: *const core::Size, corners: *const c_void, flags: i32, ocvrs_return: *mut Result); @@ -369,29 +360,29 @@ mod calib3d_sys { pub fn cv_findHomography_const__InputArrayR_const__InputArrayR_int_double_const__OutputArrayR_const_int_const_double(src_points: *const c_void, dst_points: *const c_void, method: i32, ransac_reproj_threshold: f64, mask: *const c_void, max_iters: i32, confidence: f64, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_fisheye_calibrate_const__InputArrayR_const__InputArrayR_const_SizeR_const__InputOutputArrayR_const__InputOutputArrayR_const__OutputArrayR_const__OutputArrayR(object_points: *const c_void, image_points: *const c_void, image_size: *const core::Size, k: *const c_void, d: *const c_void, rvecs: *const c_void, tvecs: *const c_void, ocvrs_return: *mut Result); pub fn cv_fisheye_calibrate_const__InputArrayR_const__InputArrayR_const_SizeR_const__InputOutputArrayR_const__InputOutputArrayR_const__OutputArrayR_const__OutputArrayR_int_TermCriteria(object_points: *const c_void, image_points: *const c_void, image_size: *const core::Size, k: *const c_void, d: *const c_void, rvecs: *const c_void, tvecs: *const c_void, flags: i32, criteria: *const core::TermCriteria, ocvrs_return: *mut Result); - pub fn cv_fisheye_distortPoints_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR(undistorted: *const c_void, distorted: *const c_void, k: *const c_void, d: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_fisheye_distortPoints_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR(undistorted: *const c_void, distorted: *const c_void, kundistorted: *const c_void, k: *const c_void, d: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_fisheye_distortPoints_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_double(undistorted: *const c_void, distorted: *const c_void, kundistorted: *const c_void, k: *const c_void, d: *const c_void, alpha: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_fisheye_distortPoints_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR_double(undistorted: *const c_void, distorted: *const c_void, k: *const c_void, d: *const c_void, alpha: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_fisheye_estimateNewCameraMatrixForUndistortRectify_const__InputArrayR_const__InputArrayR_const_SizeR_const__InputArrayR_const__OutputArrayR(k: *const c_void, d: *const c_void, image_size: *const core::Size, r: *const c_void, p: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_fisheye_estimateNewCameraMatrixForUndistortRectify_const__InputArrayR_const__InputArrayR_const_SizeR_const__InputArrayR_const__OutputArrayR_double_const_SizeR_double(k: *const c_void, d: *const c_void, image_size: *const core::Size, r: *const c_void, p: *const c_void, balance: f64, new_size: *const core::Size, fov_scale: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_fisheye_initUndistortRectifyMap_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const_SizeR_int_const__OutputArrayR_const__OutputArrayR(k: *const c_void, d: *const c_void, r: *const c_void, p: *const c_void, size: *const core::Size, m1type: i32, map1: *const c_void, map2: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_fisheye_projectPoints_const__InputArrayR_const__OutputArrayR_const_Affine3dR_const__InputArrayR_const__InputArrayR(object_points: *const c_void, image_points: *const c_void, affine: *const core::Affine3d, k: *const c_void, d: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_fisheye_projectPoints_const__InputArrayR_const__OutputArrayR_const_Affine3dR_const__InputArrayR_const__InputArrayR_double_const__OutputArrayR(object_points: *const c_void, image_points: *const c_void, affine: *const core::Affine3d, k: *const c_void, d: *const c_void, alpha: f64, jacobian: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_fisheye_projectPoints_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR(object_points: *const c_void, image_points: *const c_void, rvec: *const c_void, tvec: *const c_void, k: *const c_void, d: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_fisheye_projectPoints_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_double_const__OutputArrayR(object_points: *const c_void, image_points: *const c_void, rvec: *const c_void, tvec: *const c_void, k: *const c_void, d: *const c_void, alpha: f64, jacobian: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_fisheye_distortPoints_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR(undistorted: *const c_void, distorted: *const c_void, k: *const c_void, d: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_fisheye_distortPoints_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR(undistorted: *const c_void, distorted: *const c_void, kundistorted: *const c_void, k: *const c_void, d: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_fisheye_distortPoints_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_double(undistorted: *const c_void, distorted: *const c_void, kundistorted: *const c_void, k: *const c_void, d: *const c_void, alpha: f64, ocvrs_return: *mut Result<()>); + pub fn cv_fisheye_distortPoints_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR_double(undistorted: *const c_void, distorted: *const c_void, k: *const c_void, d: *const c_void, alpha: f64, ocvrs_return: *mut Result<()>); + pub fn cv_fisheye_estimateNewCameraMatrixForUndistortRectify_const__InputArrayR_const__InputArrayR_const_SizeR_const__InputArrayR_const__OutputArrayR(k: *const c_void, d: *const c_void, image_size: *const core::Size, r: *const c_void, p: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_fisheye_estimateNewCameraMatrixForUndistortRectify_const__InputArrayR_const__InputArrayR_const_SizeR_const__InputArrayR_const__OutputArrayR_double_const_SizeR_double(k: *const c_void, d: *const c_void, image_size: *const core::Size, r: *const c_void, p: *const c_void, balance: f64, new_size: *const core::Size, fov_scale: f64, ocvrs_return: *mut Result<()>); + pub fn cv_fisheye_initUndistortRectifyMap_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const_SizeR_int_const__OutputArrayR_const__OutputArrayR(k: *const c_void, d: *const c_void, r: *const c_void, p: *const c_void, size: *const core::Size, m1type: i32, map1: *const c_void, map2: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_fisheye_projectPoints_const__InputArrayR_const__OutputArrayR_const_Affine3dR_const__InputArrayR_const__InputArrayR(object_points: *const c_void, image_points: *const c_void, affine: *const core::Affine3d, k: *const c_void, d: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_fisheye_projectPoints_const__InputArrayR_const__OutputArrayR_const_Affine3dR_const__InputArrayR_const__InputArrayR_double_const__OutputArrayR(object_points: *const c_void, image_points: *const c_void, affine: *const core::Affine3d, k: *const c_void, d: *const c_void, alpha: f64, jacobian: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_fisheye_projectPoints_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR(object_points: *const c_void, image_points: *const c_void, rvec: *const c_void, tvec: *const c_void, k: *const c_void, d: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_fisheye_projectPoints_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_double_const__OutputArrayR(object_points: *const c_void, image_points: *const c_void, rvec: *const c_void, tvec: *const c_void, k: *const c_void, d: *const c_void, alpha: f64, jacobian: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_fisheye_solvePnP_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(object_points: *const c_void, image_points: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, rvec: *const c_void, tvec: *const c_void, ocvrs_return: *mut Result); pub fn cv_fisheye_solvePnP_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_bool_int_TermCriteria(object_points: *const c_void, image_points: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, rvec: *const c_void, tvec: *const c_void, use_extrinsic_guess: bool, flags: i32, criteria: *const core::TermCriteria, ocvrs_return: *mut Result); pub fn cv_fisheye_stereoCalibrate_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__InputOutputArrayR_const__InputOutputArrayR_const__InputOutputArrayR_Size_const__OutputArrayR_const__OutputArrayR(object_points: *const c_void, image_points1: *const c_void, image_points2: *const c_void, k1: *const c_void, d1: *const c_void, k2: *const c_void, d2: *const c_void, image_size: *const core::Size, r: *const c_void, t: *const c_void, ocvrs_return: *mut Result); pub fn cv_fisheye_stereoCalibrate_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__InputOutputArrayR_const__InputOutputArrayR_const__InputOutputArrayR_Size_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(object_points: *const c_void, image_points1: *const c_void, image_points2: *const c_void, k1: *const c_void, d1: *const c_void, k2: *const c_void, d2: *const c_void, image_size: *const core::Size, r: *const c_void, t: *const c_void, rvecs: *const c_void, tvecs: *const c_void, ocvrs_return: *mut Result); pub fn cv_fisheye_stereoCalibrate_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__InputOutputArrayR_const__InputOutputArrayR_const__InputOutputArrayR_Size_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_int_TermCriteria(object_points: *const c_void, image_points1: *const c_void, image_points2: *const c_void, k1: *const c_void, d1: *const c_void, k2: *const c_void, d2: *const c_void, image_size: *const core::Size, r: *const c_void, t: *const c_void, rvecs: *const c_void, tvecs: *const c_void, flags: i32, criteria: *const core::TermCriteria, ocvrs_return: *mut Result); pub fn cv_fisheye_stereoCalibrate_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__InputOutputArrayR_const__InputOutputArrayR_const__InputOutputArrayR_Size_const__OutputArrayR_const__OutputArrayR_int_TermCriteria(object_points: *const c_void, image_points1: *const c_void, image_points2: *const c_void, k1: *const c_void, d1: *const c_void, k2: *const c_void, d2: *const c_void, image_size: *const core::Size, r: *const c_void, t: *const c_void, flags: i32, criteria: *const core::TermCriteria, ocvrs_return: *mut Result); - pub fn cv_fisheye_stereoRectify_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const_SizeR_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_int(k1: *const c_void, d1: *const c_void, k2: *const c_void, d2: *const c_void, image_size: *const core::Size, r: *const c_void, tvec: *const c_void, r1: *const c_void, r2: *const c_void, p1: *const c_void, p2: *const c_void, q: *const c_void, flags: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_fisheye_stereoRectify_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const_SizeR_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_int_const_SizeR_double_double(k1: *const c_void, d1: *const c_void, k2: *const c_void, d2: *const c_void, image_size: *const core::Size, r: *const c_void, tvec: *const c_void, r1: *const c_void, r2: *const c_void, p1: *const c_void, p2: *const c_void, q: *const c_void, flags: i32, new_image_size: *const core::Size, balance: f64, fov_scale: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_fisheye_undistortImage_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR(distorted: *const c_void, undistorted: *const c_void, k: *const c_void, d: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_fisheye_undistortImage_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const_SizeR(distorted: *const c_void, undistorted: *const c_void, k: *const c_void, d: *const c_void, knew: *const c_void, new_size: *const core::Size, ocvrs_return: *mut ResultVoid); - pub fn cv_fisheye_undistortPoints_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR(distorted: *const c_void, undistorted: *const c_void, k: *const c_void, d: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_fisheye_undistortPoints_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_TermCriteria(distorted: *const c_void, undistorted: *const c_void, k: *const c_void, d: *const c_void, r: *const c_void, p: *const c_void, criteria: *const core::TermCriteria, ocvrs_return: *mut ResultVoid); + pub fn cv_fisheye_stereoRectify_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const_SizeR_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_int(k1: *const c_void, d1: *const c_void, k2: *const c_void, d2: *const c_void, image_size: *const core::Size, r: *const c_void, tvec: *const c_void, r1: *const c_void, r2: *const c_void, p1: *const c_void, p2: *const c_void, q: *const c_void, flags: i32, ocvrs_return: *mut Result<()>); + pub fn cv_fisheye_stereoRectify_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const_SizeR_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_int_const_SizeR_double_double(k1: *const c_void, d1: *const c_void, k2: *const c_void, d2: *const c_void, image_size: *const core::Size, r: *const c_void, tvec: *const c_void, r1: *const c_void, r2: *const c_void, p1: *const c_void, p2: *const c_void, q: *const c_void, flags: i32, new_image_size: *const core::Size, balance: f64, fov_scale: f64, ocvrs_return: *mut Result<()>); + pub fn cv_fisheye_undistortImage_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR(distorted: *const c_void, undistorted: *const c_void, k: *const c_void, d: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_fisheye_undistortImage_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const_SizeR(distorted: *const c_void, undistorted: *const c_void, k: *const c_void, d: *const c_void, knew: *const c_void, new_size: *const core::Size, ocvrs_return: *mut Result<()>); + pub fn cv_fisheye_undistortPoints_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR(distorted: *const c_void, undistorted: *const c_void, k: *const c_void, d: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_fisheye_undistortPoints_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_TermCriteria(distorted: *const c_void, undistorted: *const c_void, k: *const c_void, d: *const c_void, r: *const c_void, p: *const c_void, criteria: *const core::TermCriteria, ocvrs_return: *mut Result<()>); pub fn cv_getDefaultNewCameraMatrix_const__InputArrayR(camera_matrix: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_getDefaultNewCameraMatrix_const__InputArrayR_Size_bool(camera_matrix: *const c_void, imgsize: *const core::Size, center_principal_point: bool, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_getOptimalNewCameraMatrix_const__InputArrayR_const__InputArrayR_Size_double(camera_matrix: *const c_void, dist_coeffs: *const c_void, image_size: *const core::Size, alpha: f64, ocvrs_return: *mut Result<*mut c_void>); @@ -399,13 +390,13 @@ mod calib3d_sys { pub fn cv_getValidDisparityROI_Rect_Rect_int_int_int(roi1: *const core::Rect, roi2: *const core::Rect, min_disparity: i32, number_of_disparities: i32, block_size: i32, ocvrs_return: *mut Result); pub fn cv_initCameraMatrix2D_const__InputArrayR_const__InputArrayR_Size(object_points: *const c_void, image_points: *const c_void, image_size: *const core::Size, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_initCameraMatrix2D_const__InputArrayR_const__InputArrayR_Size_double(object_points: *const c_void, image_points: *const c_void, image_size: *const core::Size, aspect_ratio: f64, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_initInverseRectificationMap_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const_SizeR_int_const__OutputArrayR_const__OutputArrayR(camera_matrix: *const c_void, dist_coeffs: *const c_void, r: *const c_void, new_camera_matrix: *const c_void, size: *const core::Size, m1type: i32, map1: *const c_void, map2: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_initUndistortRectifyMap_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_Size_int_const__OutputArrayR_const__OutputArrayR(camera_matrix: *const c_void, dist_coeffs: *const c_void, r: *const c_void, new_camera_matrix: *const c_void, size: *const core::Size, m1type: i32, map1: *const c_void, map2: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_initInverseRectificationMap_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const_SizeR_int_const__OutputArrayR_const__OutputArrayR(camera_matrix: *const c_void, dist_coeffs: *const c_void, r: *const c_void, new_camera_matrix: *const c_void, size: *const core::Size, m1type: i32, map1: *const c_void, map2: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_initUndistortRectifyMap_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_Size_int_const__OutputArrayR_const__OutputArrayR(camera_matrix: *const c_void, dist_coeffs: *const c_void, r: *const c_void, new_camera_matrix: *const c_void, size: *const core::Size, m1type: i32, map1: *const c_void, map2: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_initWideAngleProjMap_const__InputArrayR_const__InputArrayR_Size_int_int_const__OutputArrayR_const__OutputArrayR(camera_matrix: *const c_void, dist_coeffs: *const c_void, image_size: *const core::Size, dest_image_width: i32, m1type: i32, map1: *const c_void, map2: *const c_void, ocvrs_return: *mut Result); pub fn cv_initWideAngleProjMap_const__InputArrayR_const__InputArrayR_Size_int_int_const__OutputArrayR_const__OutputArrayR_UndistortTypes_double(camera_matrix: *const c_void, dist_coeffs: *const c_void, image_size: *const core::Size, dest_image_width: i32, m1type: i32, map1: *const c_void, map2: *const c_void, proj_type: crate::calib3d::UndistortTypes, alpha: f64, ocvrs_return: *mut Result); - pub fn cv_matMulDeriv_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(a: *const c_void, b: *const c_void, d_a_bd_a: *const c_void, d_a_bd_b: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_projectPoints_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR(object_points: *const c_void, rvec: *const c_void, tvec: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, image_points: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_projectPoints_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_double(object_points: *const c_void, rvec: *const c_void, tvec: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, image_points: *const c_void, jacobian: *const c_void, aspect_ratio: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_matMulDeriv_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(a: *const c_void, b: *const c_void, d_a_bd_a: *const c_void, d_a_bd_b: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_projectPoints_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR(object_points: *const c_void, rvec: *const c_void, tvec: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, image_points: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_projectPoints_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_double(object_points: *const c_void, rvec: *const c_void, tvec: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, image_points: *const c_void, jacobian: *const c_void, aspect_ratio: f64, ocvrs_return: *mut Result<()>); pub fn cv_recoverPose_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(points1: *const c_void, points2: *const c_void, camera_matrix1: *const c_void, dist_coeffs1: *const c_void, camera_matrix2: *const c_void, dist_coeffs2: *const c_void, e: *const c_void, r: *const c_void, t: *const c_void, ocvrs_return: *mut Result); pub fn cv_recoverPose_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_int_double_double_const__InputOutputArrayR(points1: *const c_void, points2: *const c_void, camera_matrix1: *const c_void, dist_coeffs1: *const c_void, camera_matrix2: *const c_void, dist_coeffs2: *const c_void, e: *const c_void, r: *const c_void, t: *const c_void, method: i32, prob: f64, threshold: f64, mask: *const c_void, ocvrs_return: *mut Result); pub fn cv_recoverPose_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(e: *const c_void, points1: *const c_void, points2: *const c_void, camera_matrix: *const c_void, r: *const c_void, t: *const c_void, ocvrs_return: *mut Result); @@ -415,8 +406,8 @@ mod calib3d_sys { pub fn cv_recoverPose_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(e: *const c_void, points1: *const c_void, points2: *const c_void, r: *const c_void, t: *const c_void, ocvrs_return: *mut Result); pub fn cv_recoverPose_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_double_Point2d_const__InputOutputArrayR(e: *const c_void, points1: *const c_void, points2: *const c_void, r: *const c_void, t: *const c_void, focal: f64, pp: *const core::Point2d, mask: *const c_void, ocvrs_return: *mut Result); pub fn cv_rectify3Collinear_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_Size_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_double_Size_RectX_RectX_int(camera_matrix1: *const c_void, dist_coeffs1: *const c_void, camera_matrix2: *const c_void, dist_coeffs2: *const c_void, camera_matrix3: *const c_void, dist_coeffs3: *const c_void, imgpt1: *const c_void, imgpt3: *const c_void, image_size: *const core::Size, r12: *const c_void, t12: *const c_void, r13: *const c_void, t13: *const c_void, r1: *const c_void, r2: *const c_void, r3: *const c_void, p1: *const c_void, p2: *const c_void, p3: *const c_void, q: *const c_void, alpha: f64, new_img_size: *const core::Size, roi1: *mut core::Rect, roi2: *mut core::Rect, flags: i32, ocvrs_return: *mut Result); - pub fn cv_reprojectImageTo3D_const__InputArrayR_const__OutputArrayR_const__InputArrayR(disparity: *const c_void, _3d_image: *const c_void, q: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_reprojectImageTo3D_const__InputArrayR_const__OutputArrayR_const__InputArrayR_bool_int(disparity: *const c_void, _3d_image: *const c_void, q: *const c_void, handle_missing_values: bool, ddepth: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_reprojectImageTo3D_const__InputArrayR_const__OutputArrayR_const__InputArrayR(disparity: *const c_void, _3d_image: *const c_void, q: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_reprojectImageTo3D_const__InputArrayR_const__OutputArrayR_const__InputArrayR_bool_int(disparity: *const c_void, _3d_image: *const c_void, q: *const c_void, handle_missing_values: bool, ddepth: i32, ocvrs_return: *mut Result<()>); pub fn cv_sampsonDistance_const__InputArrayR_const__InputArrayR_const__InputArrayR(pt1: *const c_void, pt2: *const c_void, f: *const c_void, ocvrs_return: *mut Result); pub fn cv_solveP3P_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_int(object_points: *const c_void, image_points: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, rvecs: *const c_void, tvecs: *const c_void, flags: i32, ocvrs_return: *mut Result); pub fn cv_solvePnPGeneric_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(object_points: *const c_void, image_points: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, rvecs: *const c_void, tvecs: *const c_void, ocvrs_return: *mut Result); @@ -425,10 +416,10 @@ mod calib3d_sys { pub fn cv_solvePnPRansac_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_bool_int_float_double_const__OutputArrayR_int(object_points: *const c_void, image_points: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, rvec: *const c_void, tvec: *const c_void, use_extrinsic_guess: bool, iterations_count: i32, reprojection_error: f32, confidence: f64, inliers: *const c_void, flags: i32, ocvrs_return: *mut Result); pub fn cv_solvePnPRansac_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(object_points: *const c_void, image_points: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, rvec: *const c_void, tvec: *const c_void, inliers: *const c_void, ocvrs_return: *mut Result); pub fn cv_solvePnPRansac_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const_UsacParamsR(object_points: *const c_void, image_points: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, rvec: *const c_void, tvec: *const c_void, inliers: *const c_void, params: *const crate::calib3d::UsacParams, ocvrs_return: *mut Result); - pub fn cv_solvePnPRefineLM_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__InputOutputArrayR(object_points: *const c_void, image_points: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, rvec: *const c_void, tvec: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_solvePnPRefineLM_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__InputOutputArrayR_TermCriteria(object_points: *const c_void, image_points: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, rvec: *const c_void, tvec: *const c_void, criteria: *const core::TermCriteria, ocvrs_return: *mut ResultVoid); - pub fn cv_solvePnPRefineVVS_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__InputOutputArrayR(object_points: *const c_void, image_points: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, rvec: *const c_void, tvec: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_solvePnPRefineVVS_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__InputOutputArrayR_TermCriteria_double(object_points: *const c_void, image_points: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, rvec: *const c_void, tvec: *const c_void, criteria: *const core::TermCriteria, vv_slambda: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_solvePnPRefineLM_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__InputOutputArrayR(object_points: *const c_void, image_points: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, rvec: *const c_void, tvec: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_solvePnPRefineLM_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__InputOutputArrayR_TermCriteria(object_points: *const c_void, image_points: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, rvec: *const c_void, tvec: *const c_void, criteria: *const core::TermCriteria, ocvrs_return: *mut Result<()>); + pub fn cv_solvePnPRefineVVS_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__InputOutputArrayR(object_points: *const c_void, image_points: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, rvec: *const c_void, tvec: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_solvePnPRefineVVS_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__InputOutputArrayR_TermCriteria_double(object_points: *const c_void, image_points: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, rvec: *const c_void, tvec: *const c_void, criteria: *const core::TermCriteria, vv_slambda: f64, ocvrs_return: *mut Result<()>); pub fn cv_solvePnP_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(object_points: *const c_void, image_points: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, rvec: *const c_void, tvec: *const c_void, ocvrs_return: *mut Result); pub fn cv_solvePnP_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_bool_int(object_points: *const c_void, image_points: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, rvec: *const c_void, tvec: *const c_void, use_extrinsic_guess: bool, flags: i32, ocvrs_return: *mut Result); pub fn cv_stereoCalibrate_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__InputOutputArrayR_const__InputOutputArrayR_const__InputOutputArrayR_Size_const__InputOutputArrayR_const__InputOutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(object_points: *const c_void, image_points1: *const c_void, image_points2: *const c_void, camera_matrix1: *const c_void, dist_coeffs1: *const c_void, camera_matrix2: *const c_void, dist_coeffs2: *const c_void, image_size: *const core::Size, r: *const c_void, t: *const c_void, e: *const c_void, f: *const c_void, per_view_errors: *const c_void, ocvrs_return: *mut Result); @@ -439,21 +430,21 @@ mod calib3d_sys { pub fn cv_stereoCalibrate_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__InputOutputArrayR_const__InputOutputArrayR_const__InputOutputArrayR_Size_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_int_TermCriteria(object_points: *const c_void, image_points1: *const c_void, image_points2: *const c_void, camera_matrix1: *const c_void, dist_coeffs1: *const c_void, camera_matrix2: *const c_void, dist_coeffs2: *const c_void, image_size: *const core::Size, r: *const c_void, t: *const c_void, e: *const c_void, f: *const c_void, flags: i32, criteria: *const core::TermCriteria, ocvrs_return: *mut Result); pub fn cv_stereoRectifyUncalibrated_const__InputArrayR_const__InputArrayR_const__InputArrayR_Size_const__OutputArrayR_const__OutputArrayR(points1: *const c_void, points2: *const c_void, f: *const c_void, img_size: *const core::Size, h1: *const c_void, h2: *const c_void, ocvrs_return: *mut Result); pub fn cv_stereoRectifyUncalibrated_const__InputArrayR_const__InputArrayR_const__InputArrayR_Size_const__OutputArrayR_const__OutputArrayR_double(points1: *const c_void, points2: *const c_void, f: *const c_void, img_size: *const core::Size, h1: *const c_void, h2: *const c_void, threshold: f64, ocvrs_return: *mut Result); - pub fn cv_stereoRectify_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_Size_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(camera_matrix1: *const c_void, dist_coeffs1: *const c_void, camera_matrix2: *const c_void, dist_coeffs2: *const c_void, image_size: *const core::Size, r: *const c_void, t: *const c_void, r1: *const c_void, r2: *const c_void, p1: *const c_void, p2: *const c_void, q: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_stereoRectify_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_Size_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_int_double_Size_RectX_RectX(camera_matrix1: *const c_void, dist_coeffs1: *const c_void, camera_matrix2: *const c_void, dist_coeffs2: *const c_void, image_size: *const core::Size, r: *const c_void, t: *const c_void, r1: *const c_void, r2: *const c_void, p1: *const c_void, p2: *const c_void, q: *const c_void, flags: i32, alpha: f64, new_image_size: *const core::Size, valid_pix_roi1: *mut core::Rect, valid_pix_roi2: *mut core::Rect, ocvrs_return: *mut ResultVoid); - pub fn cv_triangulatePoints_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR(proj_matr1: *const c_void, proj_matr2: *const c_void, proj_points1: *const c_void, proj_points2: *const c_void, points4_d: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_undistortImagePoints_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR(src: *const c_void, dst: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_undistortImagePoints_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR_TermCriteria(src: *const c_void, dst: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, unnamed: *const core::TermCriteria, ocvrs_return: *mut ResultVoid); - pub fn cv_undistortPoints_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR(src: *const c_void, dst: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_undistortPoints_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR(src: *const c_void, dst: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, r: *const c_void, p: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_undistortPoints_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_TermCriteria(src: *const c_void, dst: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, r: *const c_void, p: *const c_void, criteria: *const core::TermCriteria, ocvrs_return: *mut ResultVoid); - pub fn cv_undistort_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR(src: *const c_void, dst: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_undistort_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR(src: *const c_void, dst: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, new_camera_matrix: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_validateDisparity_const__InputOutputArrayR_const__InputArrayR_int_int(disparity: *const c_void, cost: *const c_void, min_disparity: i32, number_of_disparities: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_validateDisparity_const__InputOutputArrayR_const__InputArrayR_int_int_int(disparity: *const c_void, cost: *const c_void, min_disparity: i32, number_of_disparities: i32, disp12_max_disp: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_stereoRectify_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_Size_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(camera_matrix1: *const c_void, dist_coeffs1: *const c_void, camera_matrix2: *const c_void, dist_coeffs2: *const c_void, image_size: *const core::Size, r: *const c_void, t: *const c_void, r1: *const c_void, r2: *const c_void, p1: *const c_void, p2: *const c_void, q: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_stereoRectify_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_Size_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_int_double_Size_RectX_RectX(camera_matrix1: *const c_void, dist_coeffs1: *const c_void, camera_matrix2: *const c_void, dist_coeffs2: *const c_void, image_size: *const core::Size, r: *const c_void, t: *const c_void, r1: *const c_void, r2: *const c_void, p1: *const c_void, p2: *const c_void, q: *const c_void, flags: i32, alpha: f64, new_image_size: *const core::Size, valid_pix_roi1: *mut core::Rect, valid_pix_roi2: *mut core::Rect, ocvrs_return: *mut Result<()>); + pub fn cv_triangulatePoints_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR(proj_matr1: *const c_void, proj_matr2: *const c_void, proj_points1: *const c_void, proj_points2: *const c_void, points4_d: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_undistortImagePoints_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR(src: *const c_void, dst: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_undistortImagePoints_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR_TermCriteria(src: *const c_void, dst: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, unnamed: *const core::TermCriteria, ocvrs_return: *mut Result<()>); + pub fn cv_undistortPoints_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR(src: *const c_void, dst: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_undistortPoints_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR(src: *const c_void, dst: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, r: *const c_void, p: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_undistortPoints_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_TermCriteria(src: *const c_void, dst: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, r: *const c_void, p: *const c_void, criteria: *const core::TermCriteria, ocvrs_return: *mut Result<()>); + pub fn cv_undistort_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR(src: *const c_void, dst: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_undistort_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR(src: *const c_void, dst: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, new_camera_matrix: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_validateDisparity_const__InputOutputArrayR_const__InputArrayR_int_int(disparity: *const c_void, cost: *const c_void, min_disparity: i32, number_of_disparities: i32, ocvrs_return: *mut Result<()>); + pub fn cv_validateDisparity_const__InputOutputArrayR_const__InputArrayR_int_int_int(disparity: *const c_void, cost: *const c_void, min_disparity: i32, number_of_disparities: i32, disp12_max_disp: i32, ocvrs_return: *mut Result<()>); pub fn cv_CirclesGridFinderParameters_CirclesGridFinderParameters(ocvrs_return: *mut Result); pub fn cv_LMSolver_run_const_const__InputOutputArrayR(instance: *const c_void, param: *const c_void, ocvrs_return: *mut Result); - pub fn cv_LMSolver_setMaxIters_int(instance: *mut c_void, max_iters: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_LMSolver_setMaxIters_int(instance: *mut c_void, max_iters: i32, ocvrs_return: *mut Result<()>); pub fn cv_LMSolver_getMaxIters_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_LMSolver_create_const_PtrLCallbackGR_int(cb: *const c_void, max_iters: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_LMSolver_create_const_PtrLCallbackGR_int_double(cb: *const c_void, max_iters: i32, eps: f64, ocvrs_return: *mut Result<*mut c_void>); @@ -462,53 +453,53 @@ mod calib3d_sys { pub fn cv_LMSolver_Callback_compute_const_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *const c_void, param: *const c_void, err: *const c_void, j: *const c_void, ocvrs_return: *mut Result); pub fn cv_LMSolver_Callback_delete(instance: *mut c_void); pub fn cv_StereoBM_getPreFilterType_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_StereoBM_setPreFilterType_int(instance: *mut c_void, pre_filter_type: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_StereoBM_setPreFilterType_int(instance: *mut c_void, pre_filter_type: i32, ocvrs_return: *mut Result<()>); pub fn cv_StereoBM_getPreFilterSize_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_StereoBM_setPreFilterSize_int(instance: *mut c_void, pre_filter_size: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_StereoBM_setPreFilterSize_int(instance: *mut c_void, pre_filter_size: i32, ocvrs_return: *mut Result<()>); pub fn cv_StereoBM_getPreFilterCap_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_StereoBM_setPreFilterCap_int(instance: *mut c_void, pre_filter_cap: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_StereoBM_setPreFilterCap_int(instance: *mut c_void, pre_filter_cap: i32, ocvrs_return: *mut Result<()>); pub fn cv_StereoBM_getTextureThreshold_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_StereoBM_setTextureThreshold_int(instance: *mut c_void, texture_threshold: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_StereoBM_setTextureThreshold_int(instance: *mut c_void, texture_threshold: i32, ocvrs_return: *mut Result<()>); pub fn cv_StereoBM_getUniquenessRatio_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_StereoBM_setUniquenessRatio_int(instance: *mut c_void, uniqueness_ratio: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_StereoBM_setUniquenessRatio_int(instance: *mut c_void, uniqueness_ratio: i32, ocvrs_return: *mut Result<()>); pub fn cv_StereoBM_getSmallerBlockSize_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_StereoBM_setSmallerBlockSize_int(instance: *mut c_void, block_size: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_StereoBM_setSmallerBlockSize_int(instance: *mut c_void, block_size: i32, ocvrs_return: *mut Result<()>); pub fn cv_StereoBM_getROI1_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_StereoBM_setROI1_Rect(instance: *mut c_void, roi1: *const core::Rect, ocvrs_return: *mut ResultVoid); + pub fn cv_StereoBM_setROI1_Rect(instance: *mut c_void, roi1: *const core::Rect, ocvrs_return: *mut Result<()>); pub fn cv_StereoBM_getROI2_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_StereoBM_setROI2_Rect(instance: *mut c_void, roi2: *const core::Rect, ocvrs_return: *mut ResultVoid); + pub fn cv_StereoBM_setROI2_Rect(instance: *mut c_void, roi2: *const core::Rect, ocvrs_return: *mut Result<()>); pub fn cv_StereoBM_create_int_int(num_disparities: i32, block_size: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_StereoBM_create(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_StereoBM_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_StereoBM_to_StereoMatcher(instance: *mut c_void) -> *mut c_void; pub fn cv_StereoBM_delete(instance: *mut c_void); - pub fn cv_StereoMatcher_compute_const__InputArrayR_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, left: *const c_void, right: *const c_void, disparity: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_StereoMatcher_compute_const__InputArrayR_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, left: *const c_void, right: *const c_void, disparity: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_StereoMatcher_getMinDisparity_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_StereoMatcher_setMinDisparity_int(instance: *mut c_void, min_disparity: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_StereoMatcher_setMinDisparity_int(instance: *mut c_void, min_disparity: i32, ocvrs_return: *mut Result<()>); pub fn cv_StereoMatcher_getNumDisparities_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_StereoMatcher_setNumDisparities_int(instance: *mut c_void, num_disparities: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_StereoMatcher_setNumDisparities_int(instance: *mut c_void, num_disparities: i32, ocvrs_return: *mut Result<()>); pub fn cv_StereoMatcher_getBlockSize_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_StereoMatcher_setBlockSize_int(instance: *mut c_void, block_size: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_StereoMatcher_setBlockSize_int(instance: *mut c_void, block_size: i32, ocvrs_return: *mut Result<()>); pub fn cv_StereoMatcher_getSpeckleWindowSize_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_StereoMatcher_setSpeckleWindowSize_int(instance: *mut c_void, speckle_window_size: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_StereoMatcher_setSpeckleWindowSize_int(instance: *mut c_void, speckle_window_size: i32, ocvrs_return: *mut Result<()>); pub fn cv_StereoMatcher_getSpeckleRange_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_StereoMatcher_setSpeckleRange_int(instance: *mut c_void, speckle_range: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_StereoMatcher_setSpeckleRange_int(instance: *mut c_void, speckle_range: i32, ocvrs_return: *mut Result<()>); pub fn cv_StereoMatcher_getDisp12MaxDiff_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_StereoMatcher_setDisp12MaxDiff_int(instance: *mut c_void, disp12_max_diff: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_StereoMatcher_setDisp12MaxDiff_int(instance: *mut c_void, disp12_max_diff: i32, ocvrs_return: *mut Result<()>); pub fn cv_StereoMatcher_to_StereoBM(instance: *mut c_void) -> *mut c_void; pub fn cv_StereoMatcher_to_StereoSGBM(instance: *mut c_void) -> *mut c_void; pub fn cv_StereoMatcher_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_StereoMatcher_delete(instance: *mut c_void); pub fn cv_StereoSGBM_getPreFilterCap_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_StereoSGBM_setPreFilterCap_int(instance: *mut c_void, pre_filter_cap: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_StereoSGBM_setPreFilterCap_int(instance: *mut c_void, pre_filter_cap: i32, ocvrs_return: *mut Result<()>); pub fn cv_StereoSGBM_getUniquenessRatio_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_StereoSGBM_setUniquenessRatio_int(instance: *mut c_void, uniqueness_ratio: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_StereoSGBM_setUniquenessRatio_int(instance: *mut c_void, uniqueness_ratio: i32, ocvrs_return: *mut Result<()>); pub fn cv_StereoSGBM_getP1_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_StereoSGBM_setP1_int(instance: *mut c_void, p1: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_StereoSGBM_setP1_int(instance: *mut c_void, p1: i32, ocvrs_return: *mut Result<()>); pub fn cv_StereoSGBM_getP2_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_StereoSGBM_setP2_int(instance: *mut c_void, p2: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_StereoSGBM_setP2_int(instance: *mut c_void, p2: i32, ocvrs_return: *mut Result<()>); pub fn cv_StereoSGBM_getMode_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_StereoSGBM_setMode_int(instance: *mut c_void, mode: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_StereoSGBM_setMode_int(instance: *mut c_void, mode: i32, ocvrs_return: *mut Result<()>); pub fn cv_StereoSGBM_create_int_int_int_int_int_int_int_int_int_int_int(min_disparity: i32, num_disparities: i32, block_size: i32, p1: i32, p2: i32, disp12_max_diff: i32, pre_filter_cap: i32, uniqueness_ratio: i32, speckle_window_size: i32, speckle_range: i32, mode: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_StereoSGBM_create(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_StereoSGBM_to_Algorithm(instance: *mut c_void) -> *mut c_void; @@ -543,36 +534,34 @@ mod calib3d_sys { pub fn cv_PtrLcv_StereoSGBMG_to_PtrOfStereoMatcher(instance: *mut c_void) -> *mut c_void; } } -#[cfg(ocvrs_has_module_calib3d)] pub use calib3d_sys::*; -#[cfg(ocvrs_has_module_ccalib)] mod ccalib_sys { use super::*; extern "C" { pub fn cv_omnidir_calibrate_const__InputArrayR_const__InputArrayR_Size_const__InputOutputArrayR_const__InputOutputArrayR_const__InputOutputArrayR_const__OutputArrayR_const__OutputArrayR_int_TermCriteria(object_points: *const c_void, image_points: *const c_void, size: *const core::Size, k: *const c_void, xi: *const c_void, d: *const c_void, rvecs: *const c_void, tvecs: *const c_void, flags: i32, criteria: *const core::TermCriteria, ocvrs_return: *mut Result); pub fn cv_omnidir_calibrate_const__InputArrayR_const__InputArrayR_Size_const__InputOutputArrayR_const__InputOutputArrayR_const__InputOutputArrayR_const__OutputArrayR_const__OutputArrayR_int_TermCriteria_const__OutputArrayR(object_points: *const c_void, image_points: *const c_void, size: *const core::Size, k: *const c_void, xi: *const c_void, d: *const c_void, rvecs: *const c_void, tvecs: *const c_void, flags: i32, criteria: *const core::TermCriteria, idx: *const c_void, ocvrs_return: *mut Result); - pub fn cv_omnidir_initUndistortRectifyMap_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const_SizeR_int_const__OutputArrayR_const__OutputArrayR_int(k: *const c_void, d: *const c_void, xi: *const c_void, r: *const c_void, p: *const c_void, size: *const core::Size, m1type: i32, map1: *const c_void, map2: *const c_void, flags: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_omnidir_projectPoints_const__InputArrayR_const__OutputArrayR_const_Affine3dR_const__InputArrayR_double_const__InputArrayR(object_points: *const c_void, image_points: *const c_void, affine: *const core::Affine3d, k: *const c_void, xi: f64, d: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_omnidir_projectPoints_const__InputArrayR_const__OutputArrayR_const_Affine3dR_const__InputArrayR_double_const__InputArrayR_const__OutputArrayR(object_points: *const c_void, image_points: *const c_void, affine: *const core::Affine3d, k: *const c_void, xi: f64, d: *const c_void, jacobian: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_omnidir_projectPoints_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_double_const__InputArrayR(object_points: *const c_void, image_points: *const c_void, rvec: *const c_void, tvec: *const c_void, k: *const c_void, xi: f64, d: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_omnidir_projectPoints_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_double_const__InputArrayR_const__OutputArrayR(object_points: *const c_void, image_points: *const c_void, rvec: *const c_void, tvec: *const c_void, k: *const c_void, xi: f64, d: *const c_void, jacobian: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_omnidir_initUndistortRectifyMap_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const_SizeR_int_const__OutputArrayR_const__OutputArrayR_int(k: *const c_void, d: *const c_void, xi: *const c_void, r: *const c_void, p: *const c_void, size: *const core::Size, m1type: i32, map1: *const c_void, map2: *const c_void, flags: i32, ocvrs_return: *mut Result<()>); + pub fn cv_omnidir_projectPoints_const__InputArrayR_const__OutputArrayR_const_Affine3dR_const__InputArrayR_double_const__InputArrayR(object_points: *const c_void, image_points: *const c_void, affine: *const core::Affine3d, k: *const c_void, xi: f64, d: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_omnidir_projectPoints_const__InputArrayR_const__OutputArrayR_const_Affine3dR_const__InputArrayR_double_const__InputArrayR_const__OutputArrayR(object_points: *const c_void, image_points: *const c_void, affine: *const core::Affine3d, k: *const c_void, xi: f64, d: *const c_void, jacobian: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_omnidir_projectPoints_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_double_const__InputArrayR(object_points: *const c_void, image_points: *const c_void, rvec: *const c_void, tvec: *const c_void, k: *const c_void, xi: f64, d: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_omnidir_projectPoints_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_double_const__InputArrayR_const__OutputArrayR(object_points: *const c_void, image_points: *const c_void, rvec: *const c_void, tvec: *const c_void, k: *const c_void, xi: f64, d: *const c_void, jacobian: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_omnidir_stereoCalibrate_const__InputOutputArrayR_const__InputOutputArrayR_const__InputOutputArrayR_const_SizeR_const_SizeR_const__InputOutputArrayR_const__InputOutputArrayR_const__InputOutputArrayR_const__InputOutputArrayR_const__InputOutputArrayR_const__InputOutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_int_TermCriteria(object_points: *const c_void, image_points1: *const c_void, image_points2: *const c_void, image_size1: *const core::Size, image_size2: *const core::Size, k1: *const c_void, xi1: *const c_void, d1: *const c_void, k2: *const c_void, xi2: *const c_void, d2: *const c_void, rvec: *const c_void, tvec: *const c_void, rvecs_l: *const c_void, tvecs_l: *const c_void, flags: i32, criteria: *const core::TermCriteria, ocvrs_return: *mut Result); pub fn cv_omnidir_stereoCalibrate_const__InputOutputArrayR_const__InputOutputArrayR_const__InputOutputArrayR_const_SizeR_const_SizeR_const__InputOutputArrayR_const__InputOutputArrayR_const__InputOutputArrayR_const__InputOutputArrayR_const__InputOutputArrayR_const__InputOutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_int_TermCriteria_const__OutputArrayR(object_points: *const c_void, image_points1: *const c_void, image_points2: *const c_void, image_size1: *const core::Size, image_size2: *const core::Size, k1: *const c_void, xi1: *const c_void, d1: *const c_void, k2: *const c_void, xi2: *const c_void, d2: *const c_void, rvec: *const c_void, tvec: *const c_void, rvecs_l: *const c_void, tvecs_l: *const c_void, flags: i32, criteria: *const core::TermCriteria, idx: *const c_void, ocvrs_return: *mut Result); - pub fn cv_omnidir_stereoReconstruct_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_int_int_int_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(image1: *const c_void, image2: *const c_void, k1: *const c_void, d1: *const c_void, xi1: *const c_void, k2: *const c_void, d2: *const c_void, xi2: *const c_void, r: *const c_void, t: *const c_void, flag: i32, num_disparities: i32, sad_window_size: i32, disparity: *const c_void, image1_rec: *const c_void, image2_rec: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_omnidir_stereoReconstruct_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_int_int_int_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const_SizeR_const__InputArrayR_const__OutputArrayR_int(image1: *const c_void, image2: *const c_void, k1: *const c_void, d1: *const c_void, xi1: *const c_void, k2: *const c_void, d2: *const c_void, xi2: *const c_void, r: *const c_void, t: *const c_void, flag: i32, num_disparities: i32, sad_window_size: i32, disparity: *const c_void, image1_rec: *const c_void, image2_rec: *const c_void, new_size: *const core::Size, knew: *const c_void, point_cloud: *const c_void, point_type: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_omnidir_stereoRectify_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(r: *const c_void, t: *const c_void, r1: *const c_void, r2: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_omnidir_undistortImage_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_int(distorted: *const c_void, undistorted: *const c_void, k: *const c_void, d: *const c_void, xi: *const c_void, flags: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_omnidir_undistortImage_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_int_const__InputArrayR_const_SizeR_const__InputArrayR(distorted: *const c_void, undistorted: *const c_void, k: *const c_void, d: *const c_void, xi: *const c_void, flags: i32, knew: *const c_void, new_size: *const core::Size, r: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_omnidir_undistortPoints_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR(distorted: *const c_void, undistorted: *const c_void, k: *const c_void, d: *const c_void, xi: *const c_void, r: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_omnidir_stereoReconstruct_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_int_int_int_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(image1: *const c_void, image2: *const c_void, k1: *const c_void, d1: *const c_void, xi1: *const c_void, k2: *const c_void, d2: *const c_void, xi2: *const c_void, r: *const c_void, t: *const c_void, flag: i32, num_disparities: i32, sad_window_size: i32, disparity: *const c_void, image1_rec: *const c_void, image2_rec: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_omnidir_stereoReconstruct_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_int_int_int_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const_SizeR_const__InputArrayR_const__OutputArrayR_int(image1: *const c_void, image2: *const c_void, k1: *const c_void, d1: *const c_void, xi1: *const c_void, k2: *const c_void, d2: *const c_void, xi2: *const c_void, r: *const c_void, t: *const c_void, flag: i32, num_disparities: i32, sad_window_size: i32, disparity: *const c_void, image1_rec: *const c_void, image2_rec: *const c_void, new_size: *const core::Size, knew: *const c_void, point_cloud: *const c_void, point_type: i32, ocvrs_return: *mut Result<()>); + pub fn cv_omnidir_stereoRectify_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(r: *const c_void, t: *const c_void, r1: *const c_void, r2: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_omnidir_undistortImage_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_int(distorted: *const c_void, undistorted: *const c_void, k: *const c_void, d: *const c_void, xi: *const c_void, flags: i32, ocvrs_return: *mut Result<()>); + pub fn cv_omnidir_undistortImage_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_int_const__InputArrayR_const_SizeR_const__InputArrayR(distorted: *const c_void, undistorted: *const c_void, k: *const c_void, d: *const c_void, xi: *const c_void, flags: i32, knew: *const c_void, new_size: *const core::Size, r: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_omnidir_undistortPoints_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR(distorted: *const c_void, undistorted: *const c_void, k: *const c_void, d: *const c_void, xi: *const c_void, r: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_ccalib_CustomPattern_CustomPattern(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ccalib_CustomPattern_create_const__InputArrayR_const_Size2f_const__OutputArrayR(instance: *mut c_void, pattern: *const c_void, board_size: *const core::Size2f, output: *const c_void, ocvrs_return: *mut Result); pub fn cv_ccalib_CustomPattern_create_const__InputArrayR_const_Size2f(instance: *mut c_void, pattern: *const c_void, board_size: *const core::Size2f, ocvrs_return: *mut Result); pub fn cv_ccalib_CustomPattern_findPattern_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const_double_const_double_const_bool_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, matched_features: *const c_void, pattern_points: *const c_void, ratio: f64, proj_error: f64, refine_position: bool, out: *const c_void, h: *const c_void, pattern_corners: *const c_void, ocvrs_return: *mut Result); pub fn cv_ccalib_CustomPattern_findPattern_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, matched_features: *const c_void, pattern_points: *const c_void, ocvrs_return: *mut Result); pub fn cv_ccalib_CustomPattern_isInitialized(instance: *mut c_void, ocvrs_return: *mut Result); - pub fn cv_ccalib_CustomPattern_getPatternPoints_vectorLKeyPointGR(instance: *mut c_void, original_points: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ccalib_CustomPattern_getPatternPoints_vectorLKeyPointGR(instance: *mut c_void, original_points: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_ccalib_CustomPattern_getPixelSize(instance: *mut c_void, ocvrs_return: *mut Result); pub fn cv_ccalib_CustomPattern_setFeatureDetector_PtrLFeature2DG(instance: *mut c_void, feature_detector: *mut c_void, ocvrs_return: *mut Result); pub fn cv_ccalib_CustomPattern_setDescriptorExtractor_PtrLFeature2DG(instance: *mut c_void, extractor: *mut c_void, ocvrs_return: *mut Result); @@ -590,17 +579,17 @@ mod ccalib_sys { pub fn cv_ccalib_CustomPattern_findRtRANSAC_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__InputOutputArrayR(instance: *mut c_void, object_points: *const c_void, image_points: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, rvec: *const c_void, tvec: *const c_void, ocvrs_return: *mut Result); pub fn cv_ccalib_CustomPattern_findRtRANSAC_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__InputOutputArrayR_bool_int_float_int_const__OutputArrayR_int(instance: *mut c_void, image: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, rvec: *const c_void, tvec: *const c_void, use_extrinsic_guess: bool, iterations_count: i32, reprojection_error: f32, min_inliers_count: i32, inliers: *const c_void, flags: i32, ocvrs_return: *mut Result); pub fn cv_ccalib_CustomPattern_findRtRANSAC_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__InputOutputArrayR(instance: *mut c_void, image: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, rvec: *const c_void, tvec: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ccalib_CustomPattern_drawOrientation_const__InputOutputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_double_int(instance: *mut c_void, image: *const c_void, tvec: *const c_void, rvec: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, axis_length: f64, axis_width: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_ccalib_CustomPattern_drawOrientation_const__InputOutputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR(instance: *mut c_void, image: *const c_void, tvec: *const c_void, rvec: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ccalib_CustomPattern_drawOrientation_const__InputOutputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_double_int(instance: *mut c_void, image: *const c_void, tvec: *const c_void, rvec: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, axis_length: f64, axis_width: i32, ocvrs_return: *mut Result<()>); + pub fn cv_ccalib_CustomPattern_drawOrientation_const__InputOutputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR(instance: *mut c_void, image: *const c_void, tvec: *const c_void, rvec: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_ccalib_CustomPattern_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_ccalib_CustomPattern_delete(instance: *mut c_void); pub fn cv_multicalib_MultiCameraCalibration_MultiCameraCalibration_int_int_const_stringR_float_float_int_int_int_int_TermCriteria_PtrLFeature2DG_PtrLFeature2DG_PtrLDescriptorMatcherG(camera_type: i32, n_cameras: i32, file_name: *const c_char, pattern_width: f32, pattern_height: f32, verbose: i32, show_extration: i32, n_mini_matches: i32, flags: i32, criteria: *const core::TermCriteria, detector: *mut c_void, descriptor: *mut c_void, matcher: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_multicalib_MultiCameraCalibration_MultiCameraCalibration_int_int_const_stringR_float_float(camera_type: i32, n_cameras: i32, file_name: *const c_char, pattern_width: f32, pattern_height: f32, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_multicalib_MultiCameraCalibration_loadImages(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_multicalib_MultiCameraCalibration_initialize(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_multicalib_MultiCameraCalibration_loadImages(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_multicalib_MultiCameraCalibration_initialize(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_multicalib_MultiCameraCalibration_optimizeExtrinsics(instance: *mut c_void, ocvrs_return: *mut Result); pub fn cv_multicalib_MultiCameraCalibration_run(instance: *mut c_void, ocvrs_return: *mut Result); - pub fn cv_multicalib_MultiCameraCalibration_writeParameters_const_stringR(instance: *mut c_void, filename: *const c_char, ocvrs_return: *mut ResultVoid); + pub fn cv_multicalib_MultiCameraCalibration_writeParameters_const_stringR(instance: *mut c_void, filename: *const c_char, ocvrs_return: *mut Result<()>); pub fn cv_multicalib_MultiCameraCalibration_delete(instance: *mut c_void); pub fn cv_multicalib_MultiCameraCalibration_edge_edge_int_int_int_Mat(cv: i32, pv: i32, pi: i32, trans: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_multicalib_MultiCameraCalibration_edge_propCameraVertex_const(instance: *const c_void) -> i32; @@ -621,15 +610,15 @@ mod ccalib_sys { pub fn cv_multicalib_MultiCameraCalibration_vertex_delete(instance: *mut c_void); pub fn cv_randpattern_RandomPatternCornerFinder_RandomPatternCornerFinder_float_float_int_int_int_int_PtrLFeature2DG_PtrLFeature2DG_PtrLDescriptorMatcherG(pattern_width: f32, pattern_height: f32, nmini_match: i32, depth: i32, verbose: i32, show_extraction: i32, detector: *mut c_void, descriptor: *mut c_void, matcher: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_randpattern_RandomPatternCornerFinder_RandomPatternCornerFinder_float_float(pattern_width: f32, pattern_height: f32, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_randpattern_RandomPatternCornerFinder_loadPattern_const_MatR(instance: *mut c_void, pattern_image: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_randpattern_RandomPatternCornerFinder_loadPattern_const_MatR_const_vectorLKeyPointGR_const_MatR(instance: *mut c_void, pattern_image: *const c_void, pattern_key_points: *const c_void, pattern_descriptors: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_randpattern_RandomPatternCornerFinder_computeObjectImagePoints_vectorLMatG(instance: *mut c_void, input_images: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_randpattern_RandomPatternCornerFinder_loadPattern_const_MatR(instance: *mut c_void, pattern_image: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_randpattern_RandomPatternCornerFinder_loadPattern_const_MatR_const_vectorLKeyPointGR_const_MatR(instance: *mut c_void, pattern_image: *const c_void, pattern_key_points: *const c_void, pattern_descriptors: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_randpattern_RandomPatternCornerFinder_computeObjectImagePoints_vectorLMatG(instance: *mut c_void, input_images: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_randpattern_RandomPatternCornerFinder_computeObjectImagePointsForSingle_Mat(instance: *mut c_void, input_image: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_randpattern_RandomPatternCornerFinder_getObjectPoints(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_randpattern_RandomPatternCornerFinder_getImagePoints(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_randpattern_RandomPatternCornerFinder_delete(instance: *mut c_void); pub fn cv_randpattern_RandomPatternGenerator_RandomPatternGenerator_int_int(image_width: i32, image_height: i32, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_randpattern_RandomPatternGenerator_generatePattern(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_randpattern_RandomPatternGenerator_generatePattern(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_randpattern_RandomPatternGenerator_getPattern(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_randpattern_RandomPatternGenerator_delete(instance: *mut c_void); pub fn cv_PtrLcv_ccalib_CustomPatternG_getInnerPtr_const(instance: *const c_void) -> *mut c_void; @@ -640,147 +629,145 @@ mod ccalib_sys { pub fn cv_PtrLcv_ccalib_CustomPatternG_new_const_CustomPattern(val: *mut c_void) -> *mut c_void; } } -#[cfg(ocvrs_has_module_ccalib)] pub use ccalib_sys::*; -#[cfg(ocvrs_has_module_core)] mod core_sys { use super::*; extern "C" { pub fn cv_Cholesky_doubleX_size_t_int_doubleX_size_t_int(a: *mut f64, astep: size_t, m: i32, b: *mut f64, bstep: size_t, n: i32, ocvrs_return: *mut Result); pub fn cv_Cholesky_floatX_size_t_int_floatX_size_t_int(a: *mut f32, astep: size_t, m: i32, b: *mut f32, bstep: size_t, n: i32, ocvrs_return: *mut Result); - pub fn cv_LUT_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src: *const c_void, lut: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_LUT_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src: *const c_void, lut: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_LU_doubleX_size_t_int_doubleX_size_t_int(a: *mut f64, astep: size_t, m: i32, b: *mut f64, bstep: size_t, n: i32, ocvrs_return: *mut Result); pub fn cv_LU_floatX_size_t_int_floatX_size_t_int(a: *mut f32, astep: size_t, m: i32, b: *mut f32, bstep: size_t, n: i32, ocvrs_return: *mut Result); pub fn cv_Mahalanobis_const__InputArrayR_const__InputArrayR_const__InputArrayR(v1: *const c_void, v2: *const c_void, icovar: *const c_void, ocvrs_return: *mut Result); - pub fn cv_PCABackProject_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR(data: *const c_void, mean: *const c_void, eigenvectors: *const c_void, result: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_PCACompute_const__InputArrayR_const__InputOutputArrayR_const__OutputArrayR(data: *const c_void, mean: *const c_void, eigenvectors: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_PCACompute_const__InputArrayR_const__InputOutputArrayR_const__OutputArrayR_const__OutputArrayR(data: *const c_void, mean: *const c_void, eigenvectors: *const c_void, eigenvalues: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_PCACompute_const__InputArrayR_const__InputOutputArrayR_const__OutputArrayR_const__OutputArrayR_double(data: *const c_void, mean: *const c_void, eigenvectors: *const c_void, eigenvalues: *const c_void, retained_variance: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_PCACompute_const__InputArrayR_const__InputOutputArrayR_const__OutputArrayR_const__OutputArrayR_int(data: *const c_void, mean: *const c_void, eigenvectors: *const c_void, eigenvalues: *const c_void, max_components: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_PCACompute_const__InputArrayR_const__InputOutputArrayR_const__OutputArrayR_double(data: *const c_void, mean: *const c_void, eigenvectors: *const c_void, retained_variance: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_PCACompute_const__InputArrayR_const__InputOutputArrayR_const__OutputArrayR_int(data: *const c_void, mean: *const c_void, eigenvectors: *const c_void, max_components: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_PCAProject_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR(data: *const c_void, mean: *const c_void, eigenvectors: *const c_void, result: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_PCABackProject_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR(data: *const c_void, mean: *const c_void, eigenvectors: *const c_void, result: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_PCACompute_const__InputArrayR_const__InputOutputArrayR_const__OutputArrayR(data: *const c_void, mean: *const c_void, eigenvectors: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_PCACompute_const__InputArrayR_const__InputOutputArrayR_const__OutputArrayR_const__OutputArrayR(data: *const c_void, mean: *const c_void, eigenvectors: *const c_void, eigenvalues: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_PCACompute_const__InputArrayR_const__InputOutputArrayR_const__OutputArrayR_const__OutputArrayR_double(data: *const c_void, mean: *const c_void, eigenvectors: *const c_void, eigenvalues: *const c_void, retained_variance: f64, ocvrs_return: *mut Result<()>); + pub fn cv_PCACompute_const__InputArrayR_const__InputOutputArrayR_const__OutputArrayR_const__OutputArrayR_int(data: *const c_void, mean: *const c_void, eigenvectors: *const c_void, eigenvalues: *const c_void, max_components: i32, ocvrs_return: *mut Result<()>); + pub fn cv_PCACompute_const__InputArrayR_const__InputOutputArrayR_const__OutputArrayR_double(data: *const c_void, mean: *const c_void, eigenvectors: *const c_void, retained_variance: f64, ocvrs_return: *mut Result<()>); + pub fn cv_PCACompute_const__InputArrayR_const__InputOutputArrayR_const__OutputArrayR_int(data: *const c_void, mean: *const c_void, eigenvectors: *const c_void, max_components: i32, ocvrs_return: *mut Result<()>); + pub fn cv_PCAProject_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR(data: *const c_void, mean: *const c_void, eigenvectors: *const c_void, result: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_PSNR_const__InputArrayR_const__InputArrayR(src1: *const c_void, src2: *const c_void, ocvrs_return: *mut Result); pub fn cv_PSNR_const__InputArrayR_const__InputArrayR_double(src1: *const c_void, src2: *const c_void, r: f64, ocvrs_return: *mut Result); - pub fn cv_SVBackSubst_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR(w: *const c_void, u: *const c_void, vt: *const c_void, rhs: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_SVDecomp_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(src: *const c_void, w: *const c_void, u: *const c_void, vt: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_SVDecomp_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_int(src: *const c_void, w: *const c_void, u: *const c_void, vt: *const c_void, flags: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_SVBackSubst_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR(w: *const c_void, u: *const c_void, vt: *const c_void, rhs: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_SVDecomp_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(src: *const c_void, w: *const c_void, u: *const c_void, vt: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_SVDecomp_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_int(src: *const c_void, w: *const c_void, u: *const c_void, vt: *const c_void, flags: i32, ocvrs_return: *mut Result<()>); pub fn cv_abs_const_MatExprR(e: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_abs_const_MatR(m: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_absdiff_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_addWeighted_const__InputArrayR_double_const__InputArrayR_double_double_const__OutputArrayR(src1: *const c_void, alpha: f64, src2: *const c_void, beta: f64, gamma: f64, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_addWeighted_const__InputArrayR_double_const__InputArrayR_double_double_const__OutputArrayR_int(src1: *const c_void, alpha: f64, src2: *const c_void, beta: f64, gamma: f64, dst: *const c_void, dtype: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_add_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_add_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__InputArrayR_int(src1: *const c_void, src2: *const c_void, dst: *const c_void, mask: *const c_void, dtype: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_batchDistance_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int_const__OutputArrayR(src1: *const c_void, src2: *const c_void, dist: *const c_void, dtype: i32, nidx: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_batchDistance_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int_const__OutputArrayR_int_int_const__InputArrayR_int_bool(src1: *const c_void, src2: *const c_void, dist: *const c_void, dtype: i32, nidx: *const c_void, norm_type: i32, k: i32, mask: *const c_void, update: i32, crosscheck: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_bitwise_and_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_bitwise_and_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__InputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, mask: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_bitwise_not_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_bitwise_not_const__InputArrayR_const__OutputArrayR_const__InputArrayR(src: *const c_void, dst: *const c_void, mask: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_bitwise_or_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_bitwise_or_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__InputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, mask: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_bitwise_xor_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_bitwise_xor_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__InputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, mask: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_absdiff_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_addWeighted_const__InputArrayR_double_const__InputArrayR_double_double_const__OutputArrayR(src1: *const c_void, alpha: f64, src2: *const c_void, beta: f64, gamma: f64, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_addWeighted_const__InputArrayR_double_const__InputArrayR_double_double_const__OutputArrayR_int(src1: *const c_void, alpha: f64, src2: *const c_void, beta: f64, gamma: f64, dst: *const c_void, dtype: i32, ocvrs_return: *mut Result<()>); + pub fn cv_add_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_add_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__InputArrayR_int(src1: *const c_void, src2: *const c_void, dst: *const c_void, mask: *const c_void, dtype: i32, ocvrs_return: *mut Result<()>); + pub fn cv_batchDistance_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int_const__OutputArrayR(src1: *const c_void, src2: *const c_void, dist: *const c_void, dtype: i32, nidx: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_batchDistance_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int_const__OutputArrayR_int_int_const__InputArrayR_int_bool(src1: *const c_void, src2: *const c_void, dist: *const c_void, dtype: i32, nidx: *const c_void, norm_type: i32, k: i32, mask: *const c_void, update: i32, crosscheck: bool, ocvrs_return: *mut Result<()>); + pub fn cv_bitwise_and_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_bitwise_and_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__InputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, mask: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_bitwise_not_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_bitwise_not_const__InputArrayR_const__OutputArrayR_const__InputArrayR(src: *const c_void, dst: *const c_void, mask: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_bitwise_or_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_bitwise_or_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__InputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, mask: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_bitwise_xor_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_bitwise_xor_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__InputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, mask: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_borderInterpolate_int_int_int(p: i32, len: i32, border_type: i32, ocvrs_return: *mut Result); - pub fn cv_broadcast_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src: *const c_void, shape: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_calcCovarMatrix_const__InputArrayR_const__OutputArrayR_const__InputOutputArrayR_int(samples: *const c_void, covar: *const c_void, mean: *const c_void, flags: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_calcCovarMatrix_const__InputArrayR_const__OutputArrayR_const__InputOutputArrayR_int_int(samples: *const c_void, covar: *const c_void, mean: *const c_void, flags: i32, ctype: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_cartToPolar_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(x: *const c_void, y: *const c_void, magnitude: *const c_void, angle: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cartToPolar_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_bool(x: *const c_void, y: *const c_void, magnitude: *const c_void, angle: *const c_void, angle_in_degrees: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_broadcast_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src: *const c_void, shape: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_calcCovarMatrix_const__InputArrayR_const__OutputArrayR_const__InputOutputArrayR_int(samples: *const c_void, covar: *const c_void, mean: *const c_void, flags: i32, ocvrs_return: *mut Result<()>); + pub fn cv_calcCovarMatrix_const__InputArrayR_const__OutputArrayR_const__InputOutputArrayR_int_int(samples: *const c_void, covar: *const c_void, mean: *const c_void, flags: i32, ctype: i32, ocvrs_return: *mut Result<()>); + pub fn cv_cartToPolar_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(x: *const c_void, y: *const c_void, magnitude: *const c_void, angle: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cartToPolar_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_bool(x: *const c_void, y: *const c_void, magnitude: *const c_void, angle: *const c_void, angle_in_degrees: bool, ocvrs_return: *mut Result<()>); pub fn cv_checkHardwareSupport_int(feature: i32, ocvrs_return: *mut Result); pub fn cv_checkRange_const__InputArrayR(a: *const c_void, ocvrs_return: *mut Result); pub fn cv_checkRange_const__InputArrayR_bool_PointX_double_double(a: *const c_void, quiet: bool, pos: *mut core::Point, min_val: f64, max_val: f64, ocvrs_return: *mut Result); - pub fn cv_compare_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int(src1: *const c_void, src2: *const c_void, dst: *const c_void, cmpop: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_completeSymm_const__InputOutputArrayR(m: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_completeSymm_const__InputOutputArrayR_bool(m: *const c_void, lower_to_upper: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_convertFp16_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_convertScaleAbs_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_convertScaleAbs_const__InputArrayR_const__OutputArrayR_double_double(src: *const c_void, dst: *const c_void, alpha: f64, beta: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_copyMakeBorder_const__InputArrayR_const__OutputArrayR_int_int_int_int_int(src: *const c_void, dst: *const c_void, top: i32, bottom: i32, left: i32, right: i32, border_type: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_copyMakeBorder_const__InputArrayR_const__OutputArrayR_int_int_int_int_int_const_ScalarR(src: *const c_void, dst: *const c_void, top: i32, bottom: i32, left: i32, right: i32, border_type: i32, value: *const core::Scalar, ocvrs_return: *mut ResultVoid); - pub fn cv_copyTo_const__InputArrayR_const__OutputArrayR_const__InputArrayR(src: *const c_void, dst: *const c_void, mask: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_compare_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int(src1: *const c_void, src2: *const c_void, dst: *const c_void, cmpop: i32, ocvrs_return: *mut Result<()>); + pub fn cv_completeSymm_const__InputOutputArrayR(m: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_completeSymm_const__InputOutputArrayR_bool(m: *const c_void, lower_to_upper: bool, ocvrs_return: *mut Result<()>); + pub fn cv_convertFp16_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_convertScaleAbs_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_convertScaleAbs_const__InputArrayR_const__OutputArrayR_double_double(src: *const c_void, dst: *const c_void, alpha: f64, beta: f64, ocvrs_return: *mut Result<()>); + pub fn cv_copyMakeBorder_const__InputArrayR_const__OutputArrayR_int_int_int_int_int(src: *const c_void, dst: *const c_void, top: i32, bottom: i32, left: i32, right: i32, border_type: i32, ocvrs_return: *mut Result<()>); + pub fn cv_copyMakeBorder_const__InputArrayR_const__OutputArrayR_int_int_int_int_int_const_ScalarR(src: *const c_void, dst: *const c_void, top: i32, bottom: i32, left: i32, right: i32, border_type: i32, value: *const core::Scalar, ocvrs_return: *mut Result<()>); + pub fn cv_copyTo_const__InputArrayR_const__OutputArrayR_const__InputArrayR(src: *const c_void, dst: *const c_void, mask: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_countNonZero_const__InputArrayR(src: *const c_void, ocvrs_return: *mut Result); pub fn cv_cubeRoot_float(val: f32, ocvrs_return: *mut Result); - pub fn cv_cuda_createContinuous_int_int_int_const__OutputArrayR(rows: i32, cols: i32, typ: i32, arr: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_createContinuous_int_int_int_const__OutputArrayR(rows: i32, cols: i32, typ: i32, arr: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_cuda_createGpuMatFromCudaMemory_Size_int_size_t(size: *const core::Size, typ: i32, cuda_memory_address: size_t, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_createGpuMatFromCudaMemory_Size_int_size_t_size_t(size: *const core::Size, typ: i32, cuda_memory_address: size_t, step: size_t, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_createGpuMatFromCudaMemory_int_int_int_size_t(rows: i32, cols: i32, typ: i32, cuda_memory_address: size_t, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_createGpuMatFromCudaMemory_int_int_int_size_t_size_t(rows: i32, cols: i32, typ: i32, cuda_memory_address: size_t, step: size_t, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_deviceSupports_FeatureSet(feature_set: core::FeatureSet, ocvrs_return: *mut Result); - pub fn cv_cuda_ensureSizeIsEnough_int_int_int_const__OutputArrayR(rows: i32, cols: i32, typ: i32, arr: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_ensureSizeIsEnough_int_int_int_const__OutputArrayR(rows: i32, cols: i32, typ: i32, arr: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_cuda_getCudaEnabledDeviceCount(ocvrs_return: *mut Result); pub fn cv_cuda_getDevice(ocvrs_return: *mut Result); - pub fn cv_cuda_printCudaDeviceInfo_int(device: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_printShortCudaDeviceInfo_int(device: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_registerPageLocked_MatR(m: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_resetDevice(ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_setBufferPoolConfig_int_size_t_int(device_id: i32, stack_size: size_t, stack_count: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_setBufferPoolUsage_bool(on: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_setDevice_int(device: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_setGlDevice(ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_setGlDevice_int(device: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_unregisterPageLocked_MatR(m: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_printCudaDeviceInfo_int(device: i32, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_printShortCudaDeviceInfo_int(device: i32, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_registerPageLocked_MatR(m: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_resetDevice(ocvrs_return: *mut Result<()>); + pub fn cv_cuda_setBufferPoolConfig_int_size_t_int(device_id: i32, stack_size: size_t, stack_count: i32, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_setBufferPoolUsage_bool(on: bool, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_setDevice_int(device: i32, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_setGlDevice(ocvrs_return: *mut Result<()>); + pub fn cv_cuda_setGlDevice_int(device: i32, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_unregisterPageLocked_MatR(m: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_cuda_wrapStream_size_t(cuda_stream_memory_address: size_t, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_dct_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_dct_const__InputArrayR_const__OutputArrayR_int(src: *const c_void, dst: *const c_void, flags: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_dct_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_dct_const__InputArrayR_const__OutputArrayR_int(src: *const c_void, dst: *const c_void, flags: i32, ocvrs_return: *mut Result<()>); pub fn cv_depthToString_int(depth: i32, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_detail_check_failed_MatChannels_const_int_const_CheckContextR(v: i32, ctx: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_check_failed_MatChannels_const_int_const_int_const_CheckContextR(v1: i32, v2: i32, ctx: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_check_failed_MatDepth_const_int_const_CheckContextR(v: i32, ctx: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_check_failed_MatDepth_const_int_const_int_const_CheckContextR(v1: i32, v2: i32, ctx: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_check_failed_MatType_const_int_const_CheckContextR(v: i32, ctx: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_check_failed_MatType_const_int_const_int_const_CheckContextR(v1: i32, v2: i32, ctx: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_check_failed_auto_const_Size_LintG_const_CheckContextR(v: *const core::Size_, ctx: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_check_failed_auto_const_Size_LintG_const_Size_LintG_const_CheckContextR(v1: *const core::Size_, v2: *const core::Size_, ctx: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_check_failed_auto_const_bool_const_bool_const_CheckContextR(v1: bool, v2: bool, ctx: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_check_failed_auto_const_double_const_CheckContextR(v: f64, ctx: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_check_failed_auto_const_double_const_double_const_CheckContextR(v1: f64, v2: f64, ctx: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_check_failed_auto_const_float_const_CheckContextR(v: f32, ctx: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_check_failed_auto_const_float_const_float_const_CheckContextR(v1: f32, v2: f32, ctx: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_check_failed_auto_const_int_const_CheckContextR(v: i32, ctx: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_check_failed_auto_const_int_const_int_const_CheckContextR(v1: i32, v2: i32, ctx: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_check_failed_auto_const_size_t_const_CheckContextR(v: size_t, ctx: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_check_failed_auto_const_size_t_const_size_t_const_CheckContextR(v1: size_t, v2: size_t, ctx: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_check_failed_auto_const_stringR_const_CheckContextR(v1: *const c_char, ctx: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_check_failed_false_const_bool_const_CheckContextR(v: bool, ctx: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_check_failed_true_const_bool_const_CheckContextR(v: bool, ctx: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_check_failed_MatChannels_const_int_const_CheckContextR(v: i32, ctx: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detail_check_failed_MatChannels_const_int_const_int_const_CheckContextR(v1: i32, v2: i32, ctx: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detail_check_failed_MatDepth_const_int_const_CheckContextR(v: i32, ctx: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detail_check_failed_MatDepth_const_int_const_int_const_CheckContextR(v1: i32, v2: i32, ctx: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detail_check_failed_MatType_const_int_const_CheckContextR(v: i32, ctx: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detail_check_failed_MatType_const_int_const_int_const_CheckContextR(v1: i32, v2: i32, ctx: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detail_check_failed_auto_const_Size_LintG_const_CheckContextR(v: *const core::Size_, ctx: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detail_check_failed_auto_const_Size_LintG_const_Size_LintG_const_CheckContextR(v1: *const core::Size_, v2: *const core::Size_, ctx: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detail_check_failed_auto_const_bool_const_bool_const_CheckContextR(v1: bool, v2: bool, ctx: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detail_check_failed_auto_const_double_const_CheckContextR(v: f64, ctx: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detail_check_failed_auto_const_double_const_double_const_CheckContextR(v1: f64, v2: f64, ctx: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detail_check_failed_auto_const_float_const_CheckContextR(v: f32, ctx: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detail_check_failed_auto_const_float_const_float_const_CheckContextR(v1: f32, v2: f32, ctx: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detail_check_failed_auto_const_int_const_CheckContextR(v: i32, ctx: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detail_check_failed_auto_const_int_const_int_const_CheckContextR(v1: i32, v2: i32, ctx: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detail_check_failed_auto_const_size_t_const_CheckContextR(v: size_t, ctx: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detail_check_failed_auto_const_size_t_const_size_t_const_CheckContextR(v1: size_t, v2: size_t, ctx: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detail_check_failed_auto_const_stringR_const_CheckContextR(v1: *const c_char, ctx: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detail_check_failed_false_const_bool_const_CheckContextR(v: bool, ctx: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detail_check_failed_true_const_bool_const_CheckContextR(v: bool, ctx: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_determinant_const__InputArrayR(mtx: *const c_void, ocvrs_return: *mut Result); - pub fn cv_dft_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_dft_const__InputArrayR_const__OutputArrayR_int_int(src: *const c_void, dst: *const c_void, flags: i32, nonzero_rows: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_directx_convertFromD3D10Texture2D_ID3D10Texture2DX_const__OutputArrayR(p_d3d10_texture_2d: *mut c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_directx_convertFromD3D11Texture2D_ID3D11Texture2DX_const__OutputArrayR(p_d3d11_texture_2d: *mut c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_directx_convertFromDirect3DSurface9_IDirect3DSurface9X_const__OutputArrayR(p_direct_3d_surface9: *mut c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_directx_convertFromDirect3DSurface9_IDirect3DSurface9X_const__OutputArrayR_voidX(p_direct_3d_surface9: *mut c_void, dst: *const c_void, surface_shared_handle: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_directx_convertToD3D10Texture2D_const__InputArrayR_ID3D10Texture2DX(src: *const c_void, p_d3d10_texture_2d: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_directx_convertToD3D11Texture2D_const__InputArrayR_ID3D11Texture2DX(src: *const c_void, p_d3d11_texture_2d: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_directx_convertToDirect3DSurface9_const__InputArrayR_IDirect3DSurface9X(src: *const c_void, p_direct_3d_surface9: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_directx_convertToDirect3DSurface9_const__InputArrayR_IDirect3DSurface9X_voidX(src: *const c_void, p_direct_3d_surface9: *mut c_void, surface_shared_handle: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_dft_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_dft_const__InputArrayR_const__OutputArrayR_int_int(src: *const c_void, dst: *const c_void, flags: i32, nonzero_rows: i32, ocvrs_return: *mut Result<()>); + pub fn cv_directx_convertFromD3D10Texture2D_ID3D10Texture2DX_const__OutputArrayR(p_d3d10_texture_2d: *mut c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_directx_convertFromD3D11Texture2D_ID3D11Texture2DX_const__OutputArrayR(p_d3d11_texture_2d: *mut c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_directx_convertFromDirect3DSurface9_IDirect3DSurface9X_const__OutputArrayR(p_direct_3d_surface9: *mut c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_directx_convertFromDirect3DSurface9_IDirect3DSurface9X_const__OutputArrayR_voidX(p_direct_3d_surface9: *mut c_void, dst: *const c_void, surface_shared_handle: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_directx_convertToD3D10Texture2D_const__InputArrayR_ID3D10Texture2DX(src: *const c_void, p_d3d10_texture_2d: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_directx_convertToD3D11Texture2D_const__InputArrayR_ID3D11Texture2DX(src: *const c_void, p_d3d11_texture_2d: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_directx_convertToDirect3DSurface9_const__InputArrayR_IDirect3DSurface9X(src: *const c_void, p_direct_3d_surface9: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_directx_convertToDirect3DSurface9_const__InputArrayR_IDirect3DSurface9X_voidX(src: *const c_void, p_direct_3d_surface9: *mut c_void, surface_shared_handle: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_directx_getTypeFromD3DFORMAT_const_int(id_3d_format: i32, ocvrs_return: *mut Result); pub fn cv_directx_getTypeFromDXGI_FORMAT_const_int(i_dxgi_format: i32, ocvrs_return: *mut Result); pub fn cv_directx_ocl_initializeContextFromD3D10Device_ID3D10DeviceX(p_d3d10_device: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_directx_ocl_initializeContextFromD3D11Device_ID3D11DeviceX(p_d3d11_device: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_directx_ocl_initializeContextFromDirect3DDevice9Ex_IDirect3DDevice9ExX(p_direct_3d_device9_ex: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_directx_ocl_initializeContextFromDirect3DDevice9_IDirect3DDevice9X(p_direct_3d_device9: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_divide_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_divide_const__InputArrayR_const__InputArrayR_const__OutputArrayR_double_int(src1: *const c_void, src2: *const c_void, dst: *const c_void, scale: f64, dtype: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_divide_double_const__InputArrayR_const__OutputArrayR(scale: f64, src2: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_divide_double_const__InputArrayR_const__OutputArrayR_int(scale: f64, src2: *const c_void, dst: *const c_void, dtype: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_eigenNonSymmetric_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(src: *const c_void, eigenvalues: *const c_void, eigenvectors: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_divide_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_divide_const__InputArrayR_const__InputArrayR_const__OutputArrayR_double_int(src1: *const c_void, src2: *const c_void, dst: *const c_void, scale: f64, dtype: i32, ocvrs_return: *mut Result<()>); + pub fn cv_divide_double_const__InputArrayR_const__OutputArrayR(scale: f64, src2: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_divide_double_const__InputArrayR_const__OutputArrayR_int(scale: f64, src2: *const c_void, dst: *const c_void, dtype: i32, ocvrs_return: *mut Result<()>); + pub fn cv_eigenNonSymmetric_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(src: *const c_void, eigenvalues: *const c_void, eigenvectors: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_eigen_const__InputArrayR_const__OutputArrayR(src: *const c_void, eigenvalues: *const c_void, ocvrs_return: *mut Result); pub fn cv_eigen_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(src: *const c_void, eigenvalues: *const c_void, eigenvectors: *const c_void, ocvrs_return: *mut Result); - pub fn cv_error_const_ExceptionR(exc: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_error_int_const_StringR_const_charX_const_charX_int(code: i32, err: *const c_char, func: *const c_char, file: *const c_char, line: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_exp_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_extractChannel_const__InputArrayR_const__OutputArrayR_int(src: *const c_void, dst: *const c_void, coi: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_error_const_ExceptionR(exc: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_error_int_const_StringR_const_charX_const_charX_int(code: i32, err: *const c_char, func: *const c_char, file: *const c_char, line: i32, ocvrs_return: *mut Result<()>); + pub fn cv_exp_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_extractChannel_const__InputArrayR_const__OutputArrayR_int(src: *const c_void, dst: *const c_void, coi: i32, ocvrs_return: *mut Result<()>); pub fn cv_fastAtan2_float_float(y: f32, x: f32, ocvrs_return: *mut Result); - pub fn cv_findNonZero_const__InputArrayR_const__OutputArrayR(src: *const c_void, idx: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_flipND_const__InputArrayR_const__OutputArrayR_int(src: *const c_void, dst: *const c_void, axis: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_flip_const__InputArrayR_const__OutputArrayR_int(src: *const c_void, dst: *const c_void, flip_code: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_gemm_const__InputArrayR_const__InputArrayR_double_const__InputArrayR_double_const__OutputArrayR(src1: *const c_void, src2: *const c_void, alpha: f64, src3: *const c_void, beta: f64, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_gemm_const__InputArrayR_const__InputArrayR_double_const__InputArrayR_double_const__OutputArrayR_int(src1: *const c_void, src2: *const c_void, alpha: f64, src3: *const c_void, beta: f64, dst: *const c_void, flags: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_findNonZero_const__InputArrayR_const__OutputArrayR(src: *const c_void, idx: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_flipND_const__InputArrayR_const__OutputArrayR_int(src: *const c_void, dst: *const c_void, axis: i32, ocvrs_return: *mut Result<()>); + pub fn cv_flip_const__InputArrayR_const__OutputArrayR_int(src: *const c_void, dst: *const c_void, flip_code: i32, ocvrs_return: *mut Result<()>); + pub fn cv_gemm_const__InputArrayR_const__InputArrayR_double_const__InputArrayR_double_const__OutputArrayR(src1: *const c_void, src2: *const c_void, alpha: f64, src3: *const c_void, beta: f64, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_gemm_const__InputArrayR_const__InputArrayR_double_const__InputArrayR_double_const__OutputArrayR_int(src1: *const c_void, src2: *const c_void, alpha: f64, src3: *const c_void, beta: f64, dst: *const c_void, flags: i32, ocvrs_return: *mut Result<()>); pub fn cv_getBuildInformation(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_getCPUFeaturesLine(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_getCPUTickCount(ocvrs_return: *mut Result); @@ -798,22 +785,22 @@ mod core_sys { pub fn cv_getVersionMinor() -> i32; pub fn cv_getVersionRevision() -> i32; pub fn cv_getVersionString(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_glob_String_vectorLStringGR(pattern: *const c_char, result: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_glob_String_vectorLStringGR_bool(pattern: *const c_char, result: *mut c_void, recursive: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_glob_String_vectorLStringGR(pattern: *const c_char, result: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_glob_String_vectorLStringGR_bool(pattern: *const c_char, result: *mut c_void, recursive: bool, ocvrs_return: *mut Result<()>); pub fn cv_hasNonZero_const__InputArrayR(src: *const c_void, ocvrs_return: *mut Result); pub fn cv_haveOpenVX(ocvrs_return: *mut Result); - pub fn cv_hconcat_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_hconcat_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_idct_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_idct_const__InputArrayR_const__OutputArrayR_int(src: *const c_void, dst: *const c_void, flags: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_idft_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_idft_const__InputArrayR_const__OutputArrayR_int_int(src: *const c_void, dst: *const c_void, flags: i32, nonzero_rows: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_inRange_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src: *const c_void, lowerb: *const c_void, upperb: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_insertChannel_const__InputArrayR_const__InputOutputArrayR_int(src: *const c_void, dst: *const c_void, coi: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_hconcat_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_hconcat_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_idct_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_idct_const__InputArrayR_const__OutputArrayR_int(src: *const c_void, dst: *const c_void, flags: i32, ocvrs_return: *mut Result<()>); + pub fn cv_idft_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_idft_const__InputArrayR_const__OutputArrayR_int_int(src: *const c_void, dst: *const c_void, flags: i32, nonzero_rows: i32, ocvrs_return: *mut Result<()>); + pub fn cv_inRange_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src: *const c_void, lowerb: *const c_void, upperb: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_insertChannel_const__InputArrayR_const__InputOutputArrayR_int(src: *const c_void, dst: *const c_void, coi: i32, ocvrs_return: *mut Result<()>); pub fn cv_instr_getFlags(ocvrs_return: *mut Result); - pub fn cv_instr_resetTrace(ocvrs_return: *mut ResultVoid); - pub fn cv_instr_setFlags_FLAGS(mode_flags: core::FLAGS, ocvrs_return: *mut ResultVoid); - pub fn cv_instr_setUseInstrumentation_bool(flag: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_instr_resetTrace(ocvrs_return: *mut Result<()>); + pub fn cv_instr_setFlags_FLAGS(mode_flags: core::FLAGS, ocvrs_return: *mut Result<()>); + pub fn cv_instr_setUseInstrumentation_bool(flag: bool, ocvrs_return: *mut Result<()>); pub fn cv_instr_useInstrumentation(ocvrs_return: *mut Result); pub fn cv_invert_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result); pub fn cv_invert_const__InputArrayR_const__OutputArrayR_int(src: *const c_void, dst: *const c_void, flags: i32, ocvrs_return: *mut Result); @@ -821,67 +808,67 @@ mod core_sys { pub fn cv_ipp_getIppFeatures(ocvrs_return: *mut Result); pub fn cv_ipp_getIppStatus(ocvrs_return: *mut Result); pub fn cv_ipp_getIppVersion(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_ipp_setIppStatus_int(status: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_ipp_setIppStatus_int_const_charX_const_charX_int(status: i32, funcname: *const c_char, filename: *const c_char, line: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_ipp_setUseIPP_NotExact_bool(flag: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_ipp_setUseIPP_bool(flag: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_ipp_setIppStatus_int(status: i32, ocvrs_return: *mut Result<()>); + pub fn cv_ipp_setIppStatus_int_const_charX_const_charX_int(status: i32, funcname: *const c_char, filename: *const c_char, line: i32, ocvrs_return: *mut Result<()>); + pub fn cv_ipp_setUseIPP_NotExact_bool(flag: bool, ocvrs_return: *mut Result<()>); + pub fn cv_ipp_setUseIPP_bool(flag: bool, ocvrs_return: *mut Result<()>); pub fn cv_ipp_useIPP(ocvrs_return: *mut Result); pub fn cv_ipp_useIPP_NotExact(ocvrs_return: *mut Result); pub fn cv_kmeans_const__InputArrayR_int_const__InputOutputArrayR_TermCriteria_int_int(data: *const c_void, k: i32, best_labels: *const c_void, criteria: *const core::TermCriteria, attempts: i32, flags: i32, ocvrs_return: *mut Result); pub fn cv_kmeans_const__InputArrayR_int_const__InputOutputArrayR_TermCriteria_int_int_const__OutputArrayR(data: *const c_void, k: i32, best_labels: *const c_void, criteria: *const core::TermCriteria, attempts: i32, flags: i32, centers: *const c_void, ocvrs_return: *mut Result); - pub fn cv_log_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_magnitude_const__InputArrayR_const__InputArrayR_const__OutputArrayR(x: *const c_void, y: *const c_void, magnitude: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_log_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_magnitude_const__InputArrayR_const__InputArrayR_const__OutputArrayR(x: *const c_void, y: *const c_void, magnitude: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_max_const_MatR_const_MatR(a: *const c_void, b: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_max_const_MatR_const_MatR_MatR(src1: *const c_void, src2: *const c_void, dst: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_max_const_MatR_const_MatR_MatR(src1: *const c_void, src2: *const c_void, dst: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_max_const_MatR_double(a: *const c_void, s: f64, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_max_const_UMatR_const_UMatR_UMatR(src1: *const c_void, src2: *const c_void, dst: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_max_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_max_const_UMatR_const_UMatR_UMatR(src1: *const c_void, src2: *const c_void, dst: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_max_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_max_double_const_MatR(s: f64, a: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_meanStdDev_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(src: *const c_void, mean: *const c_void, stddev: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_meanStdDev_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__InputArrayR(src: *const c_void, mean: *const c_void, stddev: *const c_void, mask: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_meanStdDev_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(src: *const c_void, mean: *const c_void, stddev: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_meanStdDev_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__InputArrayR(src: *const c_void, mean: *const c_void, stddev: *const c_void, mask: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_mean_const__InputArrayR(src: *const c_void, ocvrs_return: *mut Result); pub fn cv_mean_const__InputArrayR_const__InputArrayR(src: *const c_void, mask: *const c_void, ocvrs_return: *mut Result); - pub fn cv_merge_const__InputArrayR_const__OutputArrayR(mv: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_minMaxIdx_const__InputArrayR_doubleX(src: *const c_void, min_val: *mut f64, ocvrs_return: *mut ResultVoid); - pub fn cv_minMaxIdx_const__InputArrayR_doubleX_doubleX_intX_intX_const__InputArrayR(src: *const c_void, min_val: *mut f64, max_val: *mut f64, min_idx: *mut i32, max_idx: *mut i32, mask: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_minMaxLoc_const_SparseMatR_doubleX_doubleX(a: *const c_void, min_val: *mut f64, max_val: *mut f64, ocvrs_return: *mut ResultVoid); - pub fn cv_minMaxLoc_const_SparseMatR_doubleX_doubleX_intX_intX(a: *const c_void, min_val: *mut f64, max_val: *mut f64, min_idx: *mut i32, max_idx: *mut i32, ocvrs_return: *mut ResultVoid); - pub fn cv_minMaxLoc_const__InputArrayR_doubleX(src: *const c_void, min_val: *mut f64, ocvrs_return: *mut ResultVoid); - pub fn cv_minMaxLoc_const__InputArrayR_doubleX_doubleX_PointX_PointX_const__InputArrayR(src: *const c_void, min_val: *mut f64, max_val: *mut f64, min_loc: *mut core::Point, max_loc: *mut core::Point, mask: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_merge_const__InputArrayR_const__OutputArrayR(mv: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_minMaxIdx_const__InputArrayR_doubleX(src: *const c_void, min_val: *mut f64, ocvrs_return: *mut Result<()>); + pub fn cv_minMaxIdx_const__InputArrayR_doubleX_doubleX_intX_intX_const__InputArrayR(src: *const c_void, min_val: *mut f64, max_val: *mut f64, min_idx: *mut i32, max_idx: *mut i32, mask: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_minMaxLoc_const_SparseMatR_doubleX_doubleX(a: *const c_void, min_val: *mut f64, max_val: *mut f64, ocvrs_return: *mut Result<()>); + pub fn cv_minMaxLoc_const_SparseMatR_doubleX_doubleX_intX_intX(a: *const c_void, min_val: *mut f64, max_val: *mut f64, min_idx: *mut i32, max_idx: *mut i32, ocvrs_return: *mut Result<()>); + pub fn cv_minMaxLoc_const__InputArrayR_doubleX(src: *const c_void, min_val: *mut f64, ocvrs_return: *mut Result<()>); + pub fn cv_minMaxLoc_const__InputArrayR_doubleX_doubleX_PointX_PointX_const__InputArrayR(src: *const c_void, min_val: *mut f64, max_val: *mut f64, min_loc: *mut core::Point, max_loc: *mut core::Point, mask: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_min_const_MatR_const_MatR(a: *const c_void, b: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_min_const_MatR_const_MatR_MatR(src1: *const c_void, src2: *const c_void, dst: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_min_const_MatR_const_MatR_MatR(src1: *const c_void, src2: *const c_void, dst: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_min_const_MatR_double(a: *const c_void, s: f64, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_min_const_UMatR_const_UMatR_UMatR(src1: *const c_void, src2: *const c_void, dst: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_min_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_min_const_UMatR_const_UMatR_UMatR(src1: *const c_void, src2: *const c_void, dst: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_min_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_min_double_const_MatR(s: f64, a: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_mixChannels_const__InputArrayR_const__InputOutputArrayR_const_intX_size_t(src: *const c_void, dst: *const c_void, from_to: *const i32, npairs: size_t, ocvrs_return: *mut ResultVoid); - pub fn cv_mixChannels_const__InputArrayR_const__InputOutputArrayR_const_vectorLintGR(src: *const c_void, dst: *const c_void, from_to: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_mulSpectrums_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int(a: *const c_void, b: *const c_void, c: *const c_void, flags: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_mulSpectrums_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int_bool(a: *const c_void, b: *const c_void, c: *const c_void, flags: i32, conj_b: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_mulTransposed_const__InputArrayR_const__OutputArrayR_bool(src: *const c_void, dst: *const c_void, a_ta: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_mulTransposed_const__InputArrayR_const__OutputArrayR_bool_const__InputArrayR_double_int(src: *const c_void, dst: *const c_void, a_ta: bool, delta: *const c_void, scale: f64, dtype: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_multiply_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_multiply_const__InputArrayR_const__InputArrayR_const__OutputArrayR_double_int(src1: *const c_void, src2: *const c_void, dst: *const c_void, scale: f64, dtype: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_mixChannels_const__InputArrayR_const__InputOutputArrayR_const_intX_size_t(src: *const c_void, dst: *const c_void, from_to: *const i32, npairs: size_t, ocvrs_return: *mut Result<()>); + pub fn cv_mixChannels_const__InputArrayR_const__InputOutputArrayR_const_vectorLintGR(src: *const c_void, dst: *const c_void, from_to: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_mulSpectrums_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int(a: *const c_void, b: *const c_void, c: *const c_void, flags: i32, ocvrs_return: *mut Result<()>); + pub fn cv_mulSpectrums_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int_bool(a: *const c_void, b: *const c_void, c: *const c_void, flags: i32, conj_b: bool, ocvrs_return: *mut Result<()>); + pub fn cv_mulTransposed_const__InputArrayR_const__OutputArrayR_bool(src: *const c_void, dst: *const c_void, a_ta: bool, ocvrs_return: *mut Result<()>); + pub fn cv_mulTransposed_const__InputArrayR_const__OutputArrayR_bool_const__InputArrayR_double_int(src: *const c_void, dst: *const c_void, a_ta: bool, delta: *const c_void, scale: f64, dtype: i32, ocvrs_return: *mut Result<()>); + pub fn cv_multiply_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_multiply_const__InputArrayR_const__InputArrayR_const__OutputArrayR_double_int(src1: *const c_void, src2: *const c_void, dst: *const c_void, scale: f64, dtype: i32, ocvrs_return: *mut Result<()>); pub fn cv_noArray() -> *mut c_void; pub fn cv_norm_const_SparseMatR_int(src: *const c_void, norm_type: i32, ocvrs_return: *mut Result); pub fn cv_norm_const__InputArrayR(src1: *const c_void, ocvrs_return: *mut Result); pub fn cv_norm_const__InputArrayR_const__InputArrayR(src1: *const c_void, src2: *const c_void, ocvrs_return: *mut Result); pub fn cv_norm_const__InputArrayR_const__InputArrayR_int_const__InputArrayR(src1: *const c_void, src2: *const c_void, norm_type: i32, mask: *const c_void, ocvrs_return: *mut Result); pub fn cv_norm_const__InputArrayR_int_const__InputArrayR(src1: *const c_void, norm_type: i32, mask: *const c_void, ocvrs_return: *mut Result); - pub fn cv_normalize_const_SparseMatR_SparseMatR_double_int(src: *const c_void, dst: *mut c_void, alpha: f64, norm_type: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_normalize_const__InputArrayR_const__InputOutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_normalize_const__InputArrayR_const__InputOutputArrayR_double_double_int_int_const__InputArrayR(src: *const c_void, dst: *const c_void, alpha: f64, beta: f64, norm_type: i32, dtype: i32, mask: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ocl_attachContext_const_StringR_voidX_voidX_voidX(platform_name: *const c_char, platform_id: *mut c_void, context: *mut c_void, device_id: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ocl_buildOptionsAddMatrixDescription_StringR_const_StringR_const__InputArrayR(build_options: *mut *mut c_void, name: *const c_char, _m: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_normalize_const_SparseMatR_SparseMatR_double_int(src: *const c_void, dst: *mut c_void, alpha: f64, norm_type: i32, ocvrs_return: *mut Result<()>); + pub fn cv_normalize_const__InputArrayR_const__InputOutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_normalize_const__InputArrayR_const__InputOutputArrayR_double_double_int_int_const__InputArrayR(src: *const c_void, dst: *const c_void, alpha: f64, beta: f64, norm_type: i32, dtype: i32, mask: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ocl_attachContext_const_StringR_voidX_voidX_voidX(platform_name: *const c_char, platform_id: *mut c_void, context: *mut c_void, device_id: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ocl_buildOptionsAddMatrixDescription_StringR_const_StringR_const__InputArrayR(build_options: *mut *mut c_void, name: *const c_char, _m: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_ocl_checkOptimalVectorWidth_const_intX_const__InputArrayR(vector_widths: *const i32, src1: *const c_void, ocvrs_return: *mut Result); pub fn cv_ocl_checkOptimalVectorWidth_const_intX_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_OclVectorStrategy(vector_widths: *const i32, src1: *const c_void, src2: *const c_void, src3: *const c_void, src4: *const c_void, src5: *const c_void, src6: *const c_void, src7: *const c_void, src8: *const c_void, src9: *const c_void, strat: core::OclVectorStrategy, ocvrs_return: *mut Result); - pub fn cv_ocl_convertFromBuffer_voidX_size_t_int_int_int_UMatR(cl_mem_buffer: *mut c_void, step: size_t, rows: i32, cols: i32, typ: i32, dst: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ocl_convertFromImage_voidX_UMatR(cl_mem_image: *mut c_void, dst: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ocl_convertFromBuffer_voidX_size_t_int_int_int_UMatR(cl_mem_buffer: *mut c_void, step: size_t, rows: i32, cols: i32, typ: i32, dst: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ocl_convertFromImage_voidX_UMatR(cl_mem_image: *mut c_void, dst: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_ocl_convertTypeStr_int_int_int_charX(sdepth: i32, ddepth: i32, cn: i32, buf: *mut *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ocl_convertTypeStr_int_int_int_charX_size_t(sdepth: i32, ddepth: i32, cn: i32, buf: *mut *mut c_void, buf_size: size_t, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_ocl_finish(ocvrs_return: *mut ResultVoid); + pub fn cv_ocl_finish(ocvrs_return: *mut Result<()>); pub fn cv_ocl_getOpenCLErrorString_int(error_code: i32, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_ocl_getPlatfomsInfo_vectorLPlatformInfoGR(platform_info: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ocl_getPlatfomsInfo_vectorLPlatformInfoGR(platform_info: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_ocl_haveAmdBlas(ocvrs_return: *mut Result); pub fn cv_ocl_haveAmdFft(ocvrs_return: *mut Result); pub fn cv_ocl_haveOpenCL(ocvrs_return: *mut Result); @@ -893,22 +880,22 @@ mod core_sys { pub fn cv_ocl_predictOptimalVectorWidthMax_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR(src1: *const c_void, src2: *const c_void, src3: *const c_void, src4: *const c_void, src5: *const c_void, src6: *const c_void, src7: *const c_void, src8: *const c_void, src9: *const c_void, ocvrs_return: *mut Result); pub fn cv_ocl_predictOptimalVectorWidth_const__InputArrayR(src1: *const c_void, ocvrs_return: *mut Result); pub fn cv_ocl_predictOptimalVectorWidth_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_OclVectorStrategy(src1: *const c_void, src2: *const c_void, src3: *const c_void, src4: *const c_void, src5: *const c_void, src6: *const c_void, src7: *const c_void, src8: *const c_void, src9: *const c_void, strat: core::OclVectorStrategy, ocvrs_return: *mut Result); - pub fn cv_ocl_setUseOpenCL_bool(flag: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_ocl_setUseOpenCL_bool(flag: bool, ocvrs_return: *mut Result<()>); pub fn cv_ocl_typeToStr_int(t: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ocl_useOpenCL(ocvrs_return: *mut Result); pub fn cv_ocl_vecopTypeToStr_int(t: i32, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_ogl_convertFromGLTexture2D_const_Texture2DR_const__OutputArrayR(texture: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ogl_convertToGLTexture2D_const__InputArrayR_Texture2DR(src: *const c_void, texture: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ogl_convertFromGLTexture2D_const_Texture2DR_const__OutputArrayR(texture: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ogl_convertToGLTexture2D_const__InputArrayR_Texture2DR(src: *const c_void, texture: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_ogl_mapGLBuffer_const_BufferR(buffer: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ogl_mapGLBuffer_const_BufferR_AccessFlag(buffer: *const c_void, access_flags: core::AccessFlag, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ogl_ocl_initializeContextFromGL(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_ogl_render_const_ArraysR(arr: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ogl_render_const_ArraysR_const__InputArrayR(arr: *const c_void, indices: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ogl_render_const_ArraysR_const__InputArrayR_int_Scalar(arr: *const c_void, indices: *const c_void, mode: i32, color: *const core::Scalar, ocvrs_return: *mut ResultVoid); - pub fn cv_ogl_render_const_ArraysR_int_Scalar(arr: *const c_void, mode: i32, color: *const core::Scalar, ocvrs_return: *mut ResultVoid); - pub fn cv_ogl_render_const_Texture2DR(tex: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ogl_render_const_Texture2DR_Rect_LdoubleG_Rect_LdoubleG(tex: *const c_void, wnd_rect: *const core::Rect_, tex_rect: *const core::Rect_, ocvrs_return: *mut ResultVoid); - pub fn cv_ogl_unmapGLBuffer_UMatR(u: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ogl_render_const_ArraysR(arr: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ogl_render_const_ArraysR_const__InputArrayR(arr: *const c_void, indices: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ogl_render_const_ArraysR_const__InputArrayR_int_Scalar(arr: *const c_void, indices: *const c_void, mode: i32, color: *const core::Scalar, ocvrs_return: *mut Result<()>); + pub fn cv_ogl_render_const_ArraysR_int_Scalar(arr: *const c_void, mode: i32, color: *const core::Scalar, ocvrs_return: *mut Result<()>); + pub fn cv_ogl_render_const_Texture2DR(tex: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ogl_render_const_Texture2DR_Rect_LdoubleG_Rect_LdoubleG(tex: *const c_void, wnd_rect: *const core::Rect_, tex_rect: *const core::Rect_, ocvrs_return: *mut Result<()>); + pub fn cv_ogl_unmapGLBuffer_UMatR(u: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_operatorA_const_MatExprR_const_MatExprR(e1: *const c_void, e2: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_operatorA_const_MatExprR_const_MatR(e: *const c_void, m: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_operatorA_const_MatExprR_const_ScalarR(e: *const c_void, s: *const core::Scalar, ocvrs_return: *mut Result<*mut c_void>); @@ -973,58 +960,58 @@ mod core_sys { pub fn cv_operatorX_const_MatR_double(a: *const c_void, s: f64, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_operatorX_double_const_MatExprR(s: f64, e: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_operatorX_double_const_MatR(s: f64, a: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_parallel_for__const_RangeR_const_ParallelLoopBodyR(range: *const c_void, body: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_parallel_for__const_RangeR_const_ParallelLoopBodyR_double(range: *const c_void, body: *const c_void, nstripes: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_patchNaNs_const__InputOutputArrayR(a: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_patchNaNs_const__InputOutputArrayR_double(a: *const c_void, val: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_perspectiveTransform_const__InputArrayR_const__OutputArrayR_const__InputArrayR(src: *const c_void, dst: *const c_void, m: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_phase_const__InputArrayR_const__InputArrayR_const__OutputArrayR(x: *const c_void, y: *const c_void, angle: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_phase_const__InputArrayR_const__InputArrayR_const__OutputArrayR_bool(x: *const c_void, y: *const c_void, angle: *const c_void, angle_in_degrees: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_polarToCart_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(magnitude: *const c_void, angle: *const c_void, x: *const c_void, y: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_polarToCart_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_bool(magnitude: *const c_void, angle: *const c_void, x: *const c_void, y: *const c_void, angle_in_degrees: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_pow_const__InputArrayR_double_const__OutputArrayR(src: *const c_void, power: f64, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_randShuffle_const__InputOutputArrayR(dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_randShuffle_const__InputOutputArrayR_double_RNGX(dst: *const c_void, iter_factor: f64, rng: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_randn_const__InputOutputArrayR_const__InputArrayR_const__InputArrayR(dst: *const c_void, mean: *const c_void, stddev: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_randu_const__InputOutputArrayR_const__InputArrayR_const__InputArrayR(dst: *const c_void, low: *const c_void, high: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_read_const_FileNodeR_DMatchR_const_DMatchR(node: *const c_void, value: *mut core::DMatch, default_value: *const core::DMatch, ocvrs_return: *mut ResultVoid); - pub fn cv_read_const_FileNodeR_KeyPointR_const_KeyPointR(node: *const c_void, value: *mut c_void, default_value: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_read_const_FileNodeR_MatR(node: *const c_void, mat: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_read_const_FileNodeR_MatR_const_MatR(node: *const c_void, mat: *mut c_void, default_mat: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_read_const_FileNodeR_SparseMatR(node: *const c_void, mat: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_read_const_FileNodeR_SparseMatR_const_SparseMatR(node: *const c_void, mat: *mut c_void, default_mat: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_read_const_FileNodeR_doubleR_double(node: *const c_void, value: *mut f64, default_value: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_read_const_FileNodeR_floatR_float(node: *const c_void, value: *mut f32, default_value: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_read_const_FileNodeR_int64_tR_int64_t(node: *const c_void, value: *mut i64, default_value: i64, ocvrs_return: *mut ResultVoid); - pub fn cv_read_const_FileNodeR_intR_int(node: *const c_void, value: *mut i32, default_value: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_read_const_FileNodeR_stringR_const_stringR(node: *const c_void, value: *mut *mut c_void, default_value: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_read_const_FileNodeR_vectorLDMatchGR(node: *const c_void, matches: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_read_const_FileNodeR_vectorLKeyPointGR(node: *const c_void, keypoints: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_parallel_for__const_RangeR_const_ParallelLoopBodyR(range: *const c_void, body: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_parallel_for__const_RangeR_const_ParallelLoopBodyR_double(range: *const c_void, body: *const c_void, nstripes: f64, ocvrs_return: *mut Result<()>); + pub fn cv_patchNaNs_const__InputOutputArrayR(a: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_patchNaNs_const__InputOutputArrayR_double(a: *const c_void, val: f64, ocvrs_return: *mut Result<()>); + pub fn cv_perspectiveTransform_const__InputArrayR_const__OutputArrayR_const__InputArrayR(src: *const c_void, dst: *const c_void, m: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_phase_const__InputArrayR_const__InputArrayR_const__OutputArrayR(x: *const c_void, y: *const c_void, angle: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_phase_const__InputArrayR_const__InputArrayR_const__OutputArrayR_bool(x: *const c_void, y: *const c_void, angle: *const c_void, angle_in_degrees: bool, ocvrs_return: *mut Result<()>); + pub fn cv_polarToCart_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(magnitude: *const c_void, angle: *const c_void, x: *const c_void, y: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_polarToCart_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_bool(magnitude: *const c_void, angle: *const c_void, x: *const c_void, y: *const c_void, angle_in_degrees: bool, ocvrs_return: *mut Result<()>); + pub fn cv_pow_const__InputArrayR_double_const__OutputArrayR(src: *const c_void, power: f64, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_randShuffle_const__InputOutputArrayR(dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_randShuffle_const__InputOutputArrayR_double_RNGX(dst: *const c_void, iter_factor: f64, rng: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_randn_const__InputOutputArrayR_const__InputArrayR_const__InputArrayR(dst: *const c_void, mean: *const c_void, stddev: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_randu_const__InputOutputArrayR_const__InputArrayR_const__InputArrayR(dst: *const c_void, low: *const c_void, high: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_read_const_FileNodeR_DMatchR_const_DMatchR(node: *const c_void, value: *mut core::DMatch, default_value: *const core::DMatch, ocvrs_return: *mut Result<()>); + pub fn cv_read_const_FileNodeR_KeyPointR_const_KeyPointR(node: *const c_void, value: *mut c_void, default_value: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_read_const_FileNodeR_MatR(node: *const c_void, mat: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_read_const_FileNodeR_MatR_const_MatR(node: *const c_void, mat: *mut c_void, default_mat: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_read_const_FileNodeR_SparseMatR(node: *const c_void, mat: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_read_const_FileNodeR_SparseMatR_const_SparseMatR(node: *const c_void, mat: *mut c_void, default_mat: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_read_const_FileNodeR_doubleR_double(node: *const c_void, value: *mut f64, default_value: f64, ocvrs_return: *mut Result<()>); + pub fn cv_read_const_FileNodeR_floatR_float(node: *const c_void, value: *mut f32, default_value: f32, ocvrs_return: *mut Result<()>); + pub fn cv_read_const_FileNodeR_int64_tR_int64_t(node: *const c_void, value: *mut i64, default_value: i64, ocvrs_return: *mut Result<()>); + pub fn cv_read_const_FileNodeR_intR_int(node: *const c_void, value: *mut i32, default_value: i32, ocvrs_return: *mut Result<()>); + pub fn cv_read_const_FileNodeR_stringR_const_stringR(node: *const c_void, value: *mut *mut c_void, default_value: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_read_const_FileNodeR_vectorLDMatchGR(node: *const c_void, matches: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_read_const_FileNodeR_vectorLKeyPointGR(node: *const c_void, keypoints: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_rectangleIntersectionArea_const_Rect2dR_const_Rect2dR(a: *const core::Rect2d, b: *const core::Rect2d, ocvrs_return: *mut Result); - pub fn cv_reduceArgMax_const__InputArrayR_const__OutputArrayR_int(src: *const c_void, dst: *const c_void, axis: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_reduceArgMax_const__InputArrayR_const__OutputArrayR_int_bool(src: *const c_void, dst: *const c_void, axis: i32, last_index: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_reduceArgMin_const__InputArrayR_const__OutputArrayR_int(src: *const c_void, dst: *const c_void, axis: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_reduceArgMin_const__InputArrayR_const__OutputArrayR_int_bool(src: *const c_void, dst: *const c_void, axis: i32, last_index: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_reduce_const__InputArrayR_const__OutputArrayR_int_int(src: *const c_void, dst: *const c_void, dim: i32, rtype: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_reduce_const__InputArrayR_const__OutputArrayR_int_int_int(src: *const c_void, dst: *const c_void, dim: i32, rtype: i32, dtype: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_reduceArgMax_const__InputArrayR_const__OutputArrayR_int(src: *const c_void, dst: *const c_void, axis: i32, ocvrs_return: *mut Result<()>); + pub fn cv_reduceArgMax_const__InputArrayR_const__OutputArrayR_int_bool(src: *const c_void, dst: *const c_void, axis: i32, last_index: bool, ocvrs_return: *mut Result<()>); + pub fn cv_reduceArgMin_const__InputArrayR_const__OutputArrayR_int(src: *const c_void, dst: *const c_void, axis: i32, ocvrs_return: *mut Result<()>); + pub fn cv_reduceArgMin_const__InputArrayR_const__OutputArrayR_int_bool(src: *const c_void, dst: *const c_void, axis: i32, last_index: bool, ocvrs_return: *mut Result<()>); + pub fn cv_reduce_const__InputArrayR_const__OutputArrayR_int_int(src: *const c_void, dst: *const c_void, dim: i32, rtype: i32, ocvrs_return: *mut Result<()>); + pub fn cv_reduce_const__InputArrayR_const__OutputArrayR_int_int_int(src: *const c_void, dst: *const c_void, dim: i32, rtype: i32, dtype: i32, ocvrs_return: *mut Result<()>); pub fn cv_repeat_const_MatR_int_int(src: *const c_void, ny: i32, nx: i32, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_repeat_const__InputArrayR_int_int_const__OutputArrayR(src: *const c_void, ny: i32, nx: i32, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_rotate_const__InputArrayR_const__OutputArrayR_int(src: *const c_void, dst: *const c_void, rotate_code: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_samples_addSamplesDataSearchPath_const_StringR(path: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_samples_addSamplesDataSearchSubDirectory_const_StringR(subdir: *const c_char, ocvrs_return: *mut ResultVoid); + pub fn cv_repeat_const__InputArrayR_int_int_const__OutputArrayR(src: *const c_void, ny: i32, nx: i32, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_rotate_const__InputArrayR_const__OutputArrayR_int(src: *const c_void, dst: *const c_void, rotate_code: i32, ocvrs_return: *mut Result<()>); + pub fn cv_samples_addSamplesDataSearchPath_const_StringR(path: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_samples_addSamplesDataSearchSubDirectory_const_StringR(subdir: *const c_char, ocvrs_return: *mut Result<()>); pub fn cv_samples_findFileOrKeep_const_StringR(relative_path: *const c_char, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_samples_findFileOrKeep_const_StringR_bool(relative_path: *const c_char, silent_mode: bool, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_samples_findFile_const_StringR(relative_path: *const c_char, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_samples_findFile_const_StringR_bool_bool(relative_path: *const c_char, required: bool, silent_mode: bool, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_scaleAdd_const__InputArrayR_double_const__InputArrayR_const__OutputArrayR(src1: *const c_void, alpha: f64, src2: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_scaleAdd_const__InputArrayR_double_const__InputArrayR_const__OutputArrayR(src1: *const c_void, alpha: f64, src2: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_setBreakOnError_bool(flag: bool, ocvrs_return: *mut Result); - pub fn cv_setIdentity_const__InputOutputArrayR(mtx: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_setIdentity_const__InputOutputArrayR_const_ScalarR(mtx: *const c_void, s: *const core::Scalar, ocvrs_return: *mut ResultVoid); + pub fn cv_setIdentity_const__InputOutputArrayR(mtx: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_setIdentity_const__InputOutputArrayR_const_ScalarR(mtx: *const c_void, s: *const core::Scalar, ocvrs_return: *mut Result<()>); pub fn cv_setLogLevel_int(level: i32, ocvrs_return: *mut Result); - pub fn cv_setNumThreads_int(nthreads: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_setRNGSeed_int(seed: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_setUseOpenVX_bool(flag: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_setUseOptimized_bool(onoff: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_setNumThreads_int(nthreads: i32, ocvrs_return: *mut Result<()>); + pub fn cv_setRNGSeed_int(seed: i32, ocvrs_return: *mut Result<()>); + pub fn cv_setUseOpenVX_bool(flag: bool, ocvrs_return: *mut Result<()>); + pub fn cv_setUseOptimized_bool(onoff: bool, ocvrs_return: *mut Result<()>); pub fn cv_solveCubic_const__InputArrayR_const__OutputArrayR(coeffs: *const c_void, roots: *const c_void, ocvrs_return: *mut Result); pub fn cv_solveLP_const__InputArrayR_const__InputArrayR_const__OutputArrayR(func: *const c_void, constr: *const c_void, z: *const c_void, ocvrs_return: *mut Result); pub fn cv_solveLP_const__InputArrayR_const__InputArrayR_const__OutputArrayR_double(func: *const c_void, constr: *const c_void, z: *const c_void, constr_eps: f64, ocvrs_return: *mut Result); @@ -1032,29 +1019,29 @@ mod core_sys { pub fn cv_solvePoly_const__InputArrayR_const__OutputArrayR_int(coeffs: *const c_void, roots: *const c_void, max_iters: i32, ocvrs_return: *mut Result); pub fn cv_solve_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, ocvrs_return: *mut Result); pub fn cv_solve_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int(src1: *const c_void, src2: *const c_void, dst: *const c_void, flags: i32, ocvrs_return: *mut Result); - pub fn cv_sortIdx_const__InputArrayR_const__OutputArrayR_int(src: *const c_void, dst: *const c_void, flags: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_sort_const__InputArrayR_const__OutputArrayR_int(src: *const c_void, dst: *const c_void, flags: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_split_const_MatR_MatX(src: *const c_void, mvbegin: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_split_const__InputArrayR_const__OutputArrayR(m: *const c_void, mv: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_sqrt_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_subtract_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_subtract_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__InputArrayR_int(src1: *const c_void, src2: *const c_void, dst: *const c_void, mask: *const c_void, dtype: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_sortIdx_const__InputArrayR_const__OutputArrayR_int(src: *const c_void, dst: *const c_void, flags: i32, ocvrs_return: *mut Result<()>); + pub fn cv_sort_const__InputArrayR_const__OutputArrayR_int(src: *const c_void, dst: *const c_void, flags: i32, ocvrs_return: *mut Result<()>); + pub fn cv_split_const_MatR_MatX(src: *const c_void, mvbegin: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_split_const__InputArrayR_const__OutputArrayR(m: *const c_void, mv: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_sqrt_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_subtract_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_subtract_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__InputArrayR_int(src1: *const c_void, src2: *const c_void, dst: *const c_void, mask: *const c_void, dtype: i32, ocvrs_return: *mut Result<()>); pub fn cv_sum_const__InputArrayR(src: *const c_void, ocvrs_return: *mut Result); - pub fn cv_swap_MatR_MatR(a: *mut c_void, b: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_swap_UMatR_UMatR(a: *mut c_void, b: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_swap_MatR_MatR(a: *mut c_void, b: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_swap_UMatR_UMatR(a: *mut c_void, b: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_tempfile(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_tempfile_const_charX(suffix: *const c_char, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_terminate_int_const_StringR_const_charX_const_charX_int(code: i32, err: *const c_char, func: *const c_char, file: *const c_char, line: i32); pub fn cv_theRNG(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_trace_const__InputArrayR(mtx: *const c_void, ocvrs_return: *mut Result); - pub fn cv_transform_const__InputArrayR_const__OutputArrayR_const__InputArrayR(src: *const c_void, dst: *const c_void, m: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_transposeND_const__InputArrayR_const_vectorLintGR_const__OutputArrayR(src: *const c_void, order: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_transpose_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_transform_const__InputArrayR_const__OutputArrayR_const__InputArrayR(src: *const c_void, dst: *const c_void, m: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_transposeND_const__InputArrayR_const_vectorLintGR_const__OutputArrayR(src: *const c_void, order: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_transpose_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_typeToString_int(typ: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_useOpenVX(ocvrs_return: *mut Result); pub fn cv_useOptimized(ocvrs_return: *mut Result); pub fn cv_utils_copyMatAndDumpNamedArguments_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_utils_copyMatAndDumpNamedArguments_const__InputArrayR_const__OutputArrayR_const_FunctionParamsR(src: *const c_void, dst: *const c_void, params: *const c_void, ocvrs_return: *mut Result<*mut c_void>); + pub fn cv_utils_copyMatAndDumpNamedArguments_const__InputArrayR_const__OutputArrayR_const_FunctionParamsR(src: *const c_void, dst: *const c_void, params: *const core::FunctionParams, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_utils_dumpBool_bool(argument: bool, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_utils_dumpCString_const_charX(argument: *const c_char, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_utils_dumpDouble_double(argument: f64, ocvrs_return: *mut Result<*mut c_void>); @@ -1077,18 +1064,18 @@ mod core_sys { pub fn cv_utils_dumpVectorOfInt_const_vectorLintGR(vec: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_utils_dumpVectorOfRect_const_vectorLRectGR(vec: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_utils_fs_getCacheDirectoryForDownloads(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_utils_generateVectorOfInt_size_t_vectorLintGR(len: size_t, vec: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_utils_generateVectorOfMat_size_t_int_int_int_vectorLMatGR(len: size_t, rows: i32, cols: i32, dtype: i32, vec: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_utils_generateVectorOfRect_size_t_vectorLRectGR(len: size_t, vec: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_utils_generateVectorOfInt_size_t_vectorLintGR(len: size_t, vec: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_utils_generateVectorOfMat_size_t_int_int_int_vectorLMatGR(len: size_t, rows: i32, cols: i32, dtype: i32, vec: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_utils_generateVectorOfRect_size_t_vectorLRectGR(len: size_t, vec: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_utils_getThreadID(ocvrs_return: *mut Result); pub fn cv_utils_logging_getLogLevel(ocvrs_return: *mut Result); pub fn cv_utils_logging_getLogTagLevel_const_charX(tag: *const c_char, ocvrs_return: *mut Result); pub fn cv_utils_logging_internal_getGlobalLogTag(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_utils_logging_internal_writeLogMessageEx_LogLevel_const_charX_const_charX_int_const_charX_const_charX(log_level: core::LogLevel, tag: *const c_char, file: *const c_char, line: i32, func: *const c_char, message: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_utils_logging_internal_writeLogMessage_LogLevel_const_charX(log_level: core::LogLevel, message: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_utils_logging_registerLogTag_LogTagX(plogtag: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_utils_logging_internal_writeLogMessageEx_LogLevel_const_charX_const_charX_int_const_charX_const_charX(log_level: core::LogLevel, tag: *const c_char, file: *const c_char, line: i32, func: *const c_char, message: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_utils_logging_internal_writeLogMessage_LogLevel_const_charX(log_level: core::LogLevel, message: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_utils_logging_registerLogTag_LogTagX(plogtag: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_utils_logging_setLogLevel_LogLevel(log_level: core::LogLevel, ocvrs_return: *mut Result); - pub fn cv_utils_logging_setLogTagLevel_const_charX_LogLevel(tag: *const c_char, level: core::LogLevel, ocvrs_return: *mut ResultVoid); + pub fn cv_utils_logging_setLogTagLevel_const_charX_LogLevel(tag: *const c_char, level: core::LogLevel, ocvrs_return: *mut Result<()>); pub fn cv_utils_nested_testEchoBooleanFunction_bool(flag: bool, ocvrs_return: *mut Result); pub fn cv_utils_testAsyncArray_const__InputArrayR(argument: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_utils_testAsyncException(ocvrs_return: *mut Result<*mut c_void>); @@ -1096,40 +1083,40 @@ mod core_sys { pub fn cv_utils_testOverloadResolution_int(value: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_utils_testOverloadResolution_int_const_PointR(value: i32, point: *const core::Point, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_utils_testOverwriteNativeMethod_int(argument: i32, ocvrs_return: *mut Result); - pub fn cv_utils_testRaiseGeneralException(ocvrs_return: *mut ResultVoid); + pub fn cv_utils_testRaiseGeneralException(ocvrs_return: *mut Result<()>); pub fn cv_utils_testReservedKeywordConversion_int(positional_argument: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_utils_testReservedKeywordConversion_int_int_int(positional_argument: i32, lambda: i32, from: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_utils_testRotatedRectVector_float_float_float_float_float(x: f32, y: f32, w: f32, h: f32, angle: f32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_utils_testRotatedRect_float_float_float_float_float(x: f32, y: f32, w: f32, h: f32, angle: f32, ocvrs_return: *mut Result); - pub fn cv_va_intel_convertFromVASurface_VADisplay_VASurfaceID_Size_const__OutputArrayR(display: core::VADisplay, surface: core::VASurfaceID, size: *const core::Size, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_va_intel_convertToVASurface_VADisplay_const__InputArrayR_VASurfaceID_Size(display: core::VADisplay, src: *const c_void, surface: core::VASurfaceID, size: *const core::Size, ocvrs_return: *mut ResultVoid); + pub fn cv_va_intel_convertFromVASurface_VADisplay_VASurfaceID_Size_const__OutputArrayR(display: core::VADisplay, surface: core::VASurfaceID, size: *const core::Size, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_va_intel_convertToVASurface_VADisplay_const__InputArrayR_VASurfaceID_Size(display: core::VADisplay, src: *const c_void, surface: core::VASurfaceID, size: *const core::Size, ocvrs_return: *mut Result<()>); pub fn cv_va_intel_ocl_initializeContextFromVA_VADisplay(display: core::VADisplay, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_va_intel_ocl_initializeContextFromVA_VADisplay_bool(display: core::VADisplay, try_interop: bool, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_vconcat_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_vconcat_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_writeScalar_FileStorageR_const_StringR(fs: *mut c_void, value: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_writeScalar_FileStorageR_double(fs: *mut c_void, value: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_writeScalar_FileStorageR_float(fs: *mut c_void, value: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_writeScalar_FileStorageR_int(fs: *mut c_void, value: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_writeScalar_FileStorageR_int64_t(fs: *mut c_void, value: i64, ocvrs_return: *mut ResultVoid); - pub fn cv_write_FileStorageR_const_StringR_const_MatR(fs: *mut c_void, name: *const c_char, value: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_write_FileStorageR_const_StringR_const_SparseMatR(fs: *mut c_void, name: *const c_char, value: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_write_FileStorageR_const_StringR_const_StringR(fs: *mut c_void, name: *const c_char, value: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_write_FileStorageR_const_StringR_const_vectorLDMatchGR(fs: *mut c_void, name: *const c_char, value: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_write_FileStorageR_const_StringR_const_vectorLKeyPointGR(fs: *mut c_void, name: *const c_char, value: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_write_FileStorageR_const_StringR_double(fs: *mut c_void, name: *const c_char, value: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_write_FileStorageR_const_StringR_float(fs: *mut c_void, name: *const c_char, value: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_write_FileStorageR_const_StringR_int(fs: *mut c_void, name: *const c_char, value: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_write_FileStorageR_const_StringR_int64_t(fs: *mut c_void, name: *const c_char, value: i64, ocvrs_return: *mut ResultVoid); + pub fn cv_vconcat_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_vconcat_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_writeScalar_FileStorageR_const_StringR(fs: *mut c_void, value: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_writeScalar_FileStorageR_double(fs: *mut c_void, value: f64, ocvrs_return: *mut Result<()>); + pub fn cv_writeScalar_FileStorageR_float(fs: *mut c_void, value: f32, ocvrs_return: *mut Result<()>); + pub fn cv_writeScalar_FileStorageR_int(fs: *mut c_void, value: i32, ocvrs_return: *mut Result<()>); + pub fn cv_writeScalar_FileStorageR_int64_t(fs: *mut c_void, value: i64, ocvrs_return: *mut Result<()>); + pub fn cv_write_FileStorageR_const_StringR_const_MatR(fs: *mut c_void, name: *const c_char, value: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_write_FileStorageR_const_StringR_const_SparseMatR(fs: *mut c_void, name: *const c_char, value: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_write_FileStorageR_const_StringR_const_StringR(fs: *mut c_void, name: *const c_char, value: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_write_FileStorageR_const_StringR_const_vectorLDMatchGR(fs: *mut c_void, name: *const c_char, value: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_write_FileStorageR_const_StringR_const_vectorLKeyPointGR(fs: *mut c_void, name: *const c_char, value: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_write_FileStorageR_const_StringR_double(fs: *mut c_void, name: *const c_char, value: f64, ocvrs_return: *mut Result<()>); + pub fn cv_write_FileStorageR_const_StringR_float(fs: *mut c_void, name: *const c_char, value: f32, ocvrs_return: *mut Result<()>); + pub fn cv_write_FileStorageR_const_StringR_int(fs: *mut c_void, name: *const c_char, value: i32, ocvrs_return: *mut Result<()>); + pub fn cv_write_FileStorageR_const_StringR_int64_t(fs: *mut c_void, name: *const c_char, value: i64, ocvrs_return: *mut Result<()>); pub fn cv_Algorithm_Algorithm(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_Algorithm_clear(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_Algorithm_write_const_FileStorageR(instance: *const c_void, fs: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_Algorithm_write_const_FileStorageR_const_StringR(instance: *const c_void, fs: *mut c_void, name: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_Algorithm_write_const_const_PtrLFileStorageGR_const_StringR(instance: *const c_void, fs: *const c_void, name: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_Algorithm_write_const_const_PtrLFileStorageGR(instance: *const c_void, fs: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_Algorithm_read_const_FileNodeR(instance: *mut c_void, fn_: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_Algorithm_clear(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_Algorithm_write_const_FileStorageR(instance: *const c_void, fs: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_Algorithm_write_const_FileStorageR_const_StringR(instance: *const c_void, fs: *mut c_void, name: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_Algorithm_write_const_const_PtrLFileStorageGR_const_StringR(instance: *const c_void, fs: *const c_void, name: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_Algorithm_write_const_const_PtrLFileStorageGR(instance: *const c_void, fs: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_Algorithm_read_const_FileNodeR(instance: *mut c_void, fn_: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_Algorithm_empty_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_Algorithm_save_const_const_StringR(instance: *const c_void, filename: *const c_char, ocvrs_return: *mut ResultVoid); + pub fn cv_Algorithm_save_const_const_StringR(instance: *const c_void, filename: *const c_char, ocvrs_return: *mut Result<()>); pub fn cv_Algorithm_getDefaultName_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_Algorithm_to_ConjGradSolver(instance: *mut c_void) -> *mut c_void; pub fn cv_Algorithm_to_DownhillSolver(instance: *mut c_void) -> *mut c_void; @@ -1139,7 +1126,7 @@ mod core_sys { pub fn cv_AsyncArray_AsyncArray_const_AsyncArrayR(o: *const c_void) -> *mut c_void; pub fn cv_AsyncArray_operatorST_const_AsyncArrayR(instance: *mut c_void, o: *const c_void); pub fn cv_AsyncArray_release(instance: *mut c_void); - pub fn cv_AsyncArray_get_const_const__OutputArrayR(instance: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_AsyncArray_get_const_const__OutputArrayR(instance: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_AsyncArray_get_const_const__OutputArrayR_int64_t(instance: *const c_void, dst: *const c_void, timeout_ns: i64, ocvrs_return: *mut Result); pub fn cv_AsyncArray_get_const_const__OutputArrayR_double(instance: *const c_void, dst: *const c_void, timeout_ns: f64, ocvrs_return: *mut Result); pub fn cv_AsyncArray_wait_for_const_int64_t(instance: *const c_void, timeout_ns: i64, ocvrs_return: *mut Result); @@ -1153,15 +1140,15 @@ mod core_sys { pub fn cv_AsyncPromise_operatorST_const_AsyncPromiseR(instance: *mut c_void, o: *const c_void); pub fn cv_AsyncPromise_release(instance: *mut c_void); pub fn cv_AsyncPromise_getArrayResult(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_AsyncPromise_setValue_const__InputArrayR(instance: *mut c_void, value: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_AsyncPromise_setException_const_ExceptionR(instance: *mut c_void, exception: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_AsyncPromise_setValue_const__InputArrayR(instance: *mut c_void, value: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_AsyncPromise_setException_const_ExceptionR(instance: *mut c_void, exception: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_AsyncPromise_AsyncPromise_AsyncPromiseRR(o: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_AsyncPromise_operatorST_AsyncPromiseRR(instance: *mut c_void, o: *mut c_void); pub fn cv_AsyncPromise__getImpl_const(instance: *const c_void) -> *mut c_void; pub fn cv_AsyncPromise_delete(instance: *mut c_void); pub fn cv_CommandLineParser_CommandLineParser_int_const_charXX_const_StringR(argc: i32, argv: *const *const c_char, keys: *const c_char, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_CommandLineParser_CommandLineParser_const_CommandLineParserR(parser: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_CommandLineParser_operatorST_const_CommandLineParserR(instance: *mut c_void, parser: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_CommandLineParser_operatorST_const_CommandLineParserR(instance: *mut c_void, parser: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_CommandLineParser_getPathToApplication_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_CommandLineParser_get_bool_const_const_StringR_bool(instance: *const c_void, name: *const c_char, space_delete: bool, ocvrs_return: *mut Result); pub fn cv_CommandLineParser_get_bool_const_const_StringR(instance: *const c_void, name: *const c_char, ocvrs_return: *mut Result); @@ -1185,9 +1172,9 @@ mod core_sys { pub fn cv_CommandLineParser_get_uint64_t_const_int(instance: *const c_void, index: i32, ocvrs_return: *mut Result); pub fn cv_CommandLineParser_has_const_const_StringR(instance: *const c_void, name: *const c_char, ocvrs_return: *mut Result); pub fn cv_CommandLineParser_check_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_CommandLineParser_about_const_StringR(instance: *mut c_void, message: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_CommandLineParser_printMessage_const(instance: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_CommandLineParser_printErrors_const(instance: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_CommandLineParser_about_const_StringR(instance: *mut c_void, message: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_CommandLineParser_printMessage_const(instance: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_CommandLineParser_printErrors_const(instance: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_CommandLineParser_delete(instance: *mut c_void); pub fn cv_ConjGradSolver_create_const_PtrLFunctionGR_TermCriteria(f: *const c_void, termcrit: *const core::TermCriteria, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ConjGradSolver_create(ocvrs_return: *mut Result<*mut c_void>); @@ -1198,8 +1185,8 @@ mod core_sys { pub fn cv_DMatch_DMatch_int_int_float(_query_idx: i32, _train_idx: i32, _distance: f32, ocvrs_return: *mut Result); pub fn cv_DMatch_DMatch_int_int_int_float(_query_idx: i32, _train_idx: i32, _img_idx: i32, _distance: f32, ocvrs_return: *mut Result); pub fn cv_DMatch_operatorL_const_const_DMatchR(instance: *const core::DMatch, m: *const core::DMatch, ocvrs_return: *mut Result); - pub fn cv_DownhillSolver_getInitStep_const_const__OutputArrayR(instance: *const c_void, step: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_DownhillSolver_setInitStep_const__InputArrayR(instance: *mut c_void, step: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_DownhillSolver_getInitStep_const_const__OutputArrayR(instance: *const c_void, step: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_DownhillSolver_setInitStep_const__InputArrayR(instance: *mut c_void, step: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_DownhillSolver_create_const_PtrLFunctionGR_const__InputArrayR_TermCriteria(f: *const c_void, init_step: *const c_void, termcrit: *const core::TermCriteria, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_DownhillSolver_create(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_DownhillSolver_to_Algorithm(instance: *mut c_void) -> *mut c_void; @@ -1208,7 +1195,7 @@ mod core_sys { pub fn cv_Exception_Exception(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_Exception_Exception_int_const_StringR_const_StringR_const_StringR_int(_code: i32, _err: *const c_char, _func: *const c_char, _file: *const c_char, _line: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_Exception_what_const(instance: *const c_void) -> *mut c_void; - pub fn cv_Exception_formatMessage(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_Exception_formatMessage(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_Exception_propMsg_const(instance: *const c_void) -> *mut c_void; pub fn cv_Exception_propMsg_const_String(instance: *mut c_void, val: *const c_char); pub fn cv_Exception_propCode_const(instance: *const c_void) -> i32; @@ -1225,7 +1212,7 @@ mod core_sys { pub fn cv_FileNode_FileNode(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_FileNode_FileNode_const_FileStorageX_size_t_size_t(fs: *const c_void, block_idx: size_t, ofs: size_t, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_FileNode_FileNode_const_FileNodeR(node: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_FileNode_operatorST_const_FileNodeR(instance: *mut c_void, node: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_FileNode_operatorST_const_FileNodeR(instance: *mut c_void, node: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_FileNode_operator___const_const_StringR(instance: *const c_void, nodename: *const c_char, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_FileNode_operator___const_const_charX(instance: *const c_void, nodename: *const c_char, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_FileNode_operator___const_int(instance: *const c_void, i: i32, ocvrs_return: *mut Result<*mut c_void>); @@ -1256,8 +1243,8 @@ mod core_sys { pub fn cv_FileNode_ptr_const(instance: *const c_void, ocvrs_return: *mut Result<*const u8>); pub fn cv_FileNode_begin_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_FileNode_end_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_FileNode_readRaw_const_const_StringR_voidX_size_t(instance: *const c_void, fmt: *const c_char, vec: *mut c_void, len: size_t, ocvrs_return: *mut ResultVoid); - pub fn cv_FileNode_setValue_int_const_voidX_int(instance: *mut c_void, typ: i32, value: *const c_void, len: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_FileNode_readRaw_const_const_StringR_voidX_size_t(instance: *const c_void, fmt: *const c_char, vec: *mut c_void, len: size_t, ocvrs_return: *mut Result<()>); + pub fn cv_FileNode_setValue_int_const_voidX_int(instance: *mut c_void, typ: i32, value: *const c_void, len: i32, ocvrs_return: *mut Result<()>); pub fn cv_FileNode_real_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_FileNode_string_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_FileNode_mat_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); @@ -1270,7 +1257,7 @@ mod core_sys { pub fn cv_FileNodeIterator_FileNodeIterator(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_FileNodeIterator_FileNodeIterator_const_FileNodeR_bool(node: *const c_void, seek_end: bool, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_FileNodeIterator_FileNodeIterator_const_FileNodeIteratorR(it: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_FileNodeIterator_operatorST_const_FileNodeIteratorR(instance: *mut c_void, it: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_FileNodeIterator_operatorST_const_FileNodeIteratorR(instance: *mut c_void, it: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_FileNodeIterator_operatorX_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_FileNodeIterator_operatorAA(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_FileNodeIterator_readRaw_const_StringR_voidX_size_t(instance: *mut c_void, fmt: *const c_char, vec: *mut c_void, len: size_t, ocvrs_return: *mut Result<*mut c_void>); @@ -1283,25 +1270,25 @@ mod core_sys { pub fn cv_FileStorage_open_const_StringR_int_const_StringR(instance: *mut c_void, filename: *const c_char, flags: i32, encoding: *const c_char, ocvrs_return: *mut Result); pub fn cv_FileStorage_open_const_StringR_int(instance: *mut c_void, filename: *const c_char, flags: i32, ocvrs_return: *mut Result); pub fn cv_FileStorage_isOpened_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_FileStorage_release(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_FileStorage_release(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_FileStorage_releaseAndGetString(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_FileStorage_getFirstTopLevelNode_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_FileStorage_root_const_int(instance: *const c_void, streamidx: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_FileStorage_root_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_FileStorage_operator___const_const_StringR(instance: *const c_void, nodename: *const c_char, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_FileStorage_operator___const_const_charX(instance: *const c_void, nodename: *const c_char, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_FileStorage_write_const_StringR_int(instance: *mut c_void, name: *const c_char, val: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_FileStorage_write_const_StringR_int64_t(instance: *mut c_void, name: *const c_char, val: i64, ocvrs_return: *mut ResultVoid); - pub fn cv_FileStorage_write_const_StringR_double(instance: *mut c_void, name: *const c_char, val: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_FileStorage_write_const_StringR_const_StringR(instance: *mut c_void, name: *const c_char, val: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_FileStorage_write_const_StringR_const_MatR(instance: *mut c_void, name: *const c_char, val: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_FileStorage_write_const_StringR_const_vectorLStringGR(instance: *mut c_void, name: *const c_char, val: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_FileStorage_writeRaw_const_StringR_const_voidX_size_t(instance: *mut c_void, fmt: *const c_char, vec: *const c_void, len: size_t, ocvrs_return: *mut ResultVoid); - pub fn cv_FileStorage_writeComment_const_StringR_bool(instance: *mut c_void, comment: *const c_char, append: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_FileStorage_writeComment_const_StringR(instance: *mut c_void, comment: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_FileStorage_startWriteStruct_const_StringR_int_const_StringR(instance: *mut c_void, name: *const c_char, flags: i32, type_name: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_FileStorage_startWriteStruct_const_StringR_int(instance: *mut c_void, name: *const c_char, flags: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_FileStorage_endWriteStruct(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_FileStorage_write_const_StringR_int(instance: *mut c_void, name: *const c_char, val: i32, ocvrs_return: *mut Result<()>); + pub fn cv_FileStorage_write_const_StringR_int64_t(instance: *mut c_void, name: *const c_char, val: i64, ocvrs_return: *mut Result<()>); + pub fn cv_FileStorage_write_const_StringR_double(instance: *mut c_void, name: *const c_char, val: f64, ocvrs_return: *mut Result<()>); + pub fn cv_FileStorage_write_const_StringR_const_StringR(instance: *mut c_void, name: *const c_char, val: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_FileStorage_write_const_StringR_const_MatR(instance: *mut c_void, name: *const c_char, val: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_FileStorage_write_const_StringR_const_vectorLStringGR(instance: *mut c_void, name: *const c_char, val: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_FileStorage_writeRaw_const_StringR_const_voidX_size_t(instance: *mut c_void, fmt: *const c_char, vec: *const c_void, len: size_t, ocvrs_return: *mut Result<()>); + pub fn cv_FileStorage_writeComment_const_StringR_bool(instance: *mut c_void, comment: *const c_char, append: bool, ocvrs_return: *mut Result<()>); + pub fn cv_FileStorage_writeComment_const_StringR(instance: *mut c_void, comment: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_FileStorage_startWriteStruct_const_StringR_int_const_StringR(instance: *mut c_void, name: *const c_char, flags: i32, type_name: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_FileStorage_startWriteStruct_const_StringR_int(instance: *mut c_void, name: *const c_char, flags: i32, ocvrs_return: *mut Result<()>); + pub fn cv_FileStorage_endWriteStruct(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_FileStorage_getDefaultObjectName_const_StringR(filename: *const c_char, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_FileStorage_getFormat_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_FileStorage_propState_const(instance: *const c_void) -> i32; @@ -1310,17 +1297,17 @@ mod core_sys { pub fn cv_FileStorage_propElname_const_string(instance: *mut c_void, val: *const c_char); pub fn cv_FileStorage_delete(instance: *mut c_void); pub fn cv_Formatted_next(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_Formatted_reset(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_Formatted_reset(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_Formatted_delete(instance: *mut c_void); pub fn cv_Formatter_format_const_const_MatR(instance: *const c_void, mtx: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_Formatter_set16fPrecision_int(instance: *mut c_void, p: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_Formatter_set16fPrecision(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_Formatter_set32fPrecision_int(instance: *mut c_void, p: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_Formatter_set32fPrecision(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_Formatter_set64fPrecision_int(instance: *mut c_void, p: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_Formatter_set64fPrecision(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_Formatter_setMultiline_bool(instance: *mut c_void, ml: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_Formatter_setMultiline(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_Formatter_set16fPrecision_int(instance: *mut c_void, p: i32, ocvrs_return: *mut Result<()>); + pub fn cv_Formatter_set16fPrecision(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_Formatter_set32fPrecision_int(instance: *mut c_void, p: i32, ocvrs_return: *mut Result<()>); + pub fn cv_Formatter_set32fPrecision(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_Formatter_set64fPrecision_int(instance: *mut c_void, p: i32, ocvrs_return: *mut Result<()>); + pub fn cv_Formatter_set64fPrecision(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_Formatter_setMultiline_bool(instance: *mut c_void, ml: bool, ocvrs_return: *mut Result<()>); + pub fn cv_Formatter_setMultiline(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_Formatter_get_FormatType(fmt: core::Formatter_FormatType, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_Formatter_get(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_Formatter_delete(instance: *mut c_void); @@ -1333,10 +1320,10 @@ mod core_sys { pub fn cv_KeyPoint_KeyPoint_float_float_float_float_float_int_int(x: f32, y: f32, size: f32, angle: f32, response: f32, octave: i32, class_id: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_KeyPoint_KeyPoint_float_float_float(x: f32, y: f32, size: f32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_KeyPoint_hash_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_KeyPoint_convert_const_vectorLKeyPointGR_vectorLPoint2fGR_const_vectorLintGR(keypoints: *const c_void, points2f: *mut c_void, keypoint_indexes: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_KeyPoint_convert_const_vectorLKeyPointGR_vectorLPoint2fGR(keypoints: *const c_void, points2f: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_KeyPoint_convert_const_vectorLPoint2fGR_vectorLKeyPointGR_float_float_int_int(points2f: *const c_void, keypoints: *mut c_void, size: f32, response: f32, octave: i32, class_id: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_KeyPoint_convert_const_vectorLPoint2fGR_vectorLKeyPointGR(points2f: *const c_void, keypoints: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_KeyPoint_convert_const_vectorLKeyPointGR_vectorLPoint2fGR_const_vectorLintGR(keypoints: *const c_void, points2f: *mut c_void, keypoint_indexes: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_KeyPoint_convert_const_vectorLKeyPointGR_vectorLPoint2fGR(keypoints: *const c_void, points2f: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_KeyPoint_convert_const_vectorLPoint2fGR_vectorLKeyPointGR_float_float_int_int(points2f: *const c_void, keypoints: *mut c_void, size: f32, response: f32, octave: i32, class_id: i32, ocvrs_return: *mut Result<()>); + pub fn cv_KeyPoint_convert_const_vectorLPoint2fGR_vectorLKeyPointGR(points2f: *const c_void, keypoints: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_KeyPoint_overlap_const_KeyPointR_const_KeyPointR(kp1: *const c_void, kp2: *const c_void, ocvrs_return: *mut Result); pub fn cv_KeyPoint_implicitClone_const(instance: *const c_void) -> *mut c_void; pub fn cv_KeyPoint_propPt_const(instance: *const c_void, ocvrs_return: *mut core::Point2f); @@ -1356,11 +1343,11 @@ mod core_sys { pub fn cv_LDA_LDA(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_LDA_LDA_const__InputArrayR_const__InputArrayR_int(src: *const c_void, labels: *const c_void, num_components: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_LDA_LDA_const__InputArrayR_const__InputArrayR(src: *const c_void, labels: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_LDA_save_const_const_StringR(instance: *const c_void, filename: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_LDA_load_const_StringR(instance: *mut c_void, filename: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_LDA_save_const_FileStorageR(instance: *const c_void, fs: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_LDA_load_const_FileStorageR(instance: *mut c_void, node: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_LDA_compute_const__InputArrayR_const__InputArrayR(instance: *mut c_void, src: *const c_void, labels: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_LDA_save_const_const_StringR(instance: *const c_void, filename: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_LDA_load_const_StringR(instance: *mut c_void, filename: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_LDA_save_const_FileStorageR(instance: *const c_void, fs: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_LDA_load_const_FileStorageR(instance: *mut c_void, node: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_LDA_compute_const__InputArrayR_const__InputArrayR(instance: *mut c_void, src: *const c_void, labels: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_LDA_project_const__InputArrayR(instance: *mut c_void, src: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_LDA_reconstruct_const__InputArrayR(instance: *mut c_void, src: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_LDA_eigenvectors_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); @@ -1396,8 +1383,7 @@ mod core_sys { pub fn cv_Mat_Mat_const_MatR_const_vectorLRangeGR(m: *const c_void, ranges: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_Mat_Mat_MatR_const_vectorLRangeGR(m: *mut c_void, ranges: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_Mat_Mat_const_GpuMatR(m: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_Mat_Mat_GpuMatR(m: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_Mat_operatorST_const_MatExprR(instance: *mut c_void, expr: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_Mat_operatorST_const_MatExprR(instance: *mut c_void, expr: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_Mat_getUMat_const_AccessFlag_UMatUsageFlags(instance: *const c_void, access_flags: core::AccessFlag, usage_flags: core::UMatUsageFlags, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_Mat_getUMat_const_AccessFlag(instance: *const c_void, access_flags: core::AccessFlag, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_Mat_row_const_int(instance: *const c_void, y: i32, ocvrs_return: *mut Result<*mut c_void>); @@ -1418,13 +1404,13 @@ mod core_sys { pub fn cv_Mat_diag_int(instance: *mut c_void, d: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_Mat_diag_const_MatR(d: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_Mat_clone_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_Mat_copyTo_const_const__OutputArrayR(instance: *const c_void, m: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_Mat_copyTo_const_const__OutputArrayR_const__InputArrayR(instance: *const c_void, m: *const c_void, mask: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_Mat_convertTo_const_const__OutputArrayR_int_double_double(instance: *const c_void, m: *const c_void, rtype: i32, alpha: f64, beta: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_Mat_convertTo_const_const__OutputArrayR_int(instance: *const c_void, m: *const c_void, rtype: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_Mat_assignTo_const_MatR_int(instance: *const c_void, m: *mut c_void, typ: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_Mat_assignTo_const_MatR(instance: *const c_void, m: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_Mat_operatorST_const_ScalarR(instance: *mut c_void, s: *const core::Scalar, ocvrs_return: *mut ResultVoid); + pub fn cv_Mat_copyTo_const_const__OutputArrayR(instance: *const c_void, m: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_Mat_copyTo_const_const__OutputArrayR_const__InputArrayR(instance: *const c_void, m: *const c_void, mask: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_Mat_convertTo_const_const__OutputArrayR_int_double_double(instance: *const c_void, m: *const c_void, rtype: i32, alpha: f64, beta: f64, ocvrs_return: *mut Result<()>); + pub fn cv_Mat_convertTo_const_const__OutputArrayR_int(instance: *const c_void, m: *const c_void, rtype: i32, ocvrs_return: *mut Result<()>); + pub fn cv_Mat_assignTo_const_MatR_int(instance: *const c_void, m: *mut c_void, typ: i32, ocvrs_return: *mut Result<()>); + pub fn cv_Mat_assignTo_const_MatR(instance: *const c_void, m: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_Mat_operatorST_const_ScalarR(instance: *mut c_void, s: *const core::Scalar, ocvrs_return: *mut Result<()>); pub fn cv_Mat_setTo_const__InputArrayR_const__InputArrayR(instance: *mut c_void, value: *const c_void, mask: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_Mat_setTo_const__InputArrayR(instance: *mut c_void, value: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_Mat_reshape_const_int_int(instance: *const c_void, cn: i32, rows: i32, ocvrs_return: *mut Result<*mut c_void>); @@ -1450,21 +1436,21 @@ mod core_sys { pub fn cv_Mat_ones_int_const_intX_int(ndims: i32, sz: *const i32, typ: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_Mat_eye_int_int_int(rows: i32, cols: i32, typ: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_Mat_eye_Size_int(size: *const core::Size, typ: i32, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_Mat_create_int_int_int(instance: *mut c_void, rows: i32, cols: i32, typ: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_Mat_create_Size_int(instance: *mut c_void, size: *const core::Size, typ: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_Mat_create_int_const_intX_int(instance: *mut c_void, ndims: i32, sizes: *const i32, typ: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_Mat_create_const_vectorLintGR_int(instance: *mut c_void, sizes: *const c_void, typ: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_Mat_addref(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_Mat_release(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_Mat_deallocate(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_Mat_reserve_size_t(instance: *mut c_void, sz: size_t, ocvrs_return: *mut ResultVoid); - pub fn cv_Mat_reserveBuffer_size_t(instance: *mut c_void, sz: size_t, ocvrs_return: *mut ResultVoid); - pub fn cv_Mat_resize_size_t(instance: *mut c_void, sz: size_t, ocvrs_return: *mut ResultVoid); - pub fn cv_Mat_resize_size_t_const_ScalarR(instance: *mut c_void, sz: size_t, s: *const core::Scalar, ocvrs_return: *mut ResultVoid); - pub fn cv_Mat_push_back_const_MatR(instance: *mut c_void, m: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_Mat_pop_back_size_t(instance: *mut c_void, nelems: size_t, ocvrs_return: *mut ResultVoid); - pub fn cv_Mat_pop_back(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_Mat_locateROI_const_SizeR_PointR(instance: *const c_void, whole_size: *mut core::Size, ofs: *mut core::Point, ocvrs_return: *mut ResultVoid); + pub fn cv_Mat_create_int_int_int(instance: *mut c_void, rows: i32, cols: i32, typ: i32, ocvrs_return: *mut Result<()>); + pub fn cv_Mat_create_Size_int(instance: *mut c_void, size: *const core::Size, typ: i32, ocvrs_return: *mut Result<()>); + pub fn cv_Mat_create_int_const_intX_int(instance: *mut c_void, ndims: i32, sizes: *const i32, typ: i32, ocvrs_return: *mut Result<()>); + pub fn cv_Mat_create_const_vectorLintGR_int(instance: *mut c_void, sizes: *const c_void, typ: i32, ocvrs_return: *mut Result<()>); + pub fn cv_Mat_addref(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_Mat_release(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_Mat_deallocate(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_Mat_reserve_size_t(instance: *mut c_void, sz: size_t, ocvrs_return: *mut Result<()>); + pub fn cv_Mat_reserveBuffer_size_t(instance: *mut c_void, sz: size_t, ocvrs_return: *mut Result<()>); + pub fn cv_Mat_resize_size_t(instance: *mut c_void, sz: size_t, ocvrs_return: *mut Result<()>); + pub fn cv_Mat_resize_size_t_const_ScalarR(instance: *mut c_void, sz: size_t, s: *const core::Scalar, ocvrs_return: *mut Result<()>); + pub fn cv_Mat_push_back_const_MatR(instance: *mut c_void, m: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_Mat_pop_back_size_t(instance: *mut c_void, nelems: size_t, ocvrs_return: *mut Result<()>); + pub fn cv_Mat_pop_back(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_Mat_locateROI_const_SizeR_PointR(instance: *const c_void, whole_size: *mut core::Size, ofs: *mut core::Point, ocvrs_return: *mut Result<()>); pub fn cv_Mat_adjustROI_int_int_int_int(instance: *mut c_void, dtop: i32, dbottom: i32, dleft: i32, dright: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_Mat_operator___const_Range_Range(instance: *const c_void, row_range: *mut c_void, col_range: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_Mat_operator___Range_Range(instance: *mut c_void, row_range: *mut c_void, col_range: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); @@ -1497,8 +1483,8 @@ mod core_sys { pub fn cv_Mat_ptr_const_int_int_int(instance: *const c_void, i0: i32, i1: i32, i2: i32, ocvrs_return: *mut Result<*const u8>); pub fn cv_Mat_ptr_const_intX(instance: *mut c_void, idx: *const i32, ocvrs_return: *mut Result<*mut u8>); pub fn cv_Mat_ptr_const_const_intX(instance: *const c_void, idx: *const i32, ocvrs_return: *mut Result<*const u8>); - pub fn cv_Mat_operatorST_MatRR(instance: *mut c_void, m: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_Mat_updateContinuityFlag(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_Mat_operatorST_MatRR(instance: *mut c_void, m: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_Mat_updateContinuityFlag(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_Mat_size_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_Mat_getDataDump_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_Mat_propFlags_const(instance: *const c_void) -> i32; @@ -1527,18 +1513,18 @@ mod core_sys { pub fn cv_MatConstIterator_MatConstIterator_const_MatX_int(_m: *const c_void, _row: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_MatConstIterator_MatConstIterator_const_MatX_Point(_m: *const c_void, _pt: *const core::Point, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_MatConstIterator_MatConstIterator_const_MatConstIteratorR(it: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_MatConstIterator_operatorST_const_MatConstIteratorR(instance: *mut c_void, it: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_MatConstIterator_operatorST_const_MatConstIteratorR(instance: *mut c_void, it: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_MatConstIterator_operatorX_const(instance: *const c_void, ocvrs_return: *mut Result<*const u8>); pub fn cv_MatConstIterator_operator___const_ptrdiff_t(instance: *const c_void, i: ptrdiff_t, ocvrs_return: *mut Result<*const u8>); pub fn cv_MatConstIterator_operatorSS(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_MatConstIterator_operatorAA(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_MatConstIterator_pos_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_MatConstIterator_pos_const_intX(instance: *const c_void, _idx: *mut i32, ocvrs_return: *mut ResultVoid); + pub fn cv_MatConstIterator_pos_const_intX(instance: *const c_void, _idx: *mut i32, ocvrs_return: *mut Result<()>); pub fn cv_MatConstIterator_lpos_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_MatConstIterator_seek_ptrdiff_t_bool(instance: *mut c_void, ofs: ptrdiff_t, relative: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_MatConstIterator_seek_ptrdiff_t(instance: *mut c_void, ofs: ptrdiff_t, ocvrs_return: *mut ResultVoid); - pub fn cv_MatConstIterator_seek_const_intX_bool(instance: *mut c_void, _idx: *const i32, relative: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_MatConstIterator_seek_const_intX(instance: *mut c_void, _idx: *const i32, ocvrs_return: *mut ResultVoid); + pub fn cv_MatConstIterator_seek_ptrdiff_t_bool(instance: *mut c_void, ofs: ptrdiff_t, relative: bool, ocvrs_return: *mut Result<()>); + pub fn cv_MatConstIterator_seek_ptrdiff_t(instance: *mut c_void, ofs: ptrdiff_t, ocvrs_return: *mut Result<()>); + pub fn cv_MatConstIterator_seek_const_intX_bool(instance: *mut c_void, _idx: *const i32, relative: bool, ocvrs_return: *mut Result<()>); + pub fn cv_MatConstIterator_seek_const_intX(instance: *mut c_void, _idx: *const i32, ocvrs_return: *mut Result<()>); pub fn cv_MatConstIterator_type_const(instance: *const c_void) -> i32; pub fn cv_MatConstIterator_propM_const(instance: *const c_void) -> *mut c_void; pub fn cv_MatConstIterator_propElemSize_const(instance: *const c_void) -> size_t; @@ -1569,7 +1555,7 @@ mod core_sys { pub fn cv_MatExpr_mul_const_const_MatR(instance: *const c_void, m: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_MatExpr_cross_const_const_MatR(instance: *const c_void, m: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_MatExpr_dot_const_const_MatR(instance: *const c_void, m: *const c_void, ocvrs_return: *mut Result); - pub fn cv_MatExpr_swap_MatExprR(instance: *mut c_void, b: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_MatExpr_swap_MatExprR(instance: *mut c_void, b: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_MatExpr_propFlags_const(instance: *const c_void) -> i32; pub fn cv_MatExpr_propFlags_const_int(instance: *mut c_void, val: i32); pub fn cv_MatExpr_propA_const(instance: *const c_void) -> *mut c_void; @@ -1586,31 +1572,31 @@ mod core_sys { pub fn cv_MatExpr_propS_const_Scalar(instance: *mut c_void, val: *const core::Scalar); pub fn cv_MatExpr_delete(instance: *mut c_void); pub fn cv_MatOp_elementWise_const_const_MatExprR(instance: *const c_void, expr: *const c_void, ocvrs_return: *mut Result); - pub fn cv_MatOp_assign_const_const_MatExprR_MatR_int(instance: *const c_void, expr: *const c_void, m: *mut c_void, typ: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_MatOp_assign_const_const_MatExprR_MatR(instance: *const c_void, expr: *const c_void, m: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_MatOp_roi_const_const_MatExprR_const_RangeR_const_RangeR_MatExprR(instance: *const c_void, expr: *const c_void, row_range: *const c_void, col_range: *const c_void, res: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_MatOp_diag_const_const_MatExprR_int_MatExprR(instance: *const c_void, expr: *const c_void, d: i32, res: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_MatOp_augAssignAdd_const_const_MatExprR_MatR(instance: *const c_void, expr: *const c_void, m: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_MatOp_augAssignSubtract_const_const_MatExprR_MatR(instance: *const c_void, expr: *const c_void, m: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_MatOp_augAssignMultiply_const_const_MatExprR_MatR(instance: *const c_void, expr: *const c_void, m: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_MatOp_augAssignDivide_const_const_MatExprR_MatR(instance: *const c_void, expr: *const c_void, m: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_MatOp_augAssignAnd_const_const_MatExprR_MatR(instance: *const c_void, expr: *const c_void, m: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_MatOp_augAssignOr_const_const_MatExprR_MatR(instance: *const c_void, expr: *const c_void, m: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_MatOp_augAssignXor_const_const_MatExprR_MatR(instance: *const c_void, expr: *const c_void, m: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_MatOp_add_const_const_MatExprR_const_MatExprR_MatExprR(instance: *const c_void, expr1: *const c_void, expr2: *const c_void, res: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_MatOp_add_const_const_MatExprR_const_ScalarR_MatExprR(instance: *const c_void, expr1: *const c_void, s: *const core::Scalar, res: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_MatOp_subtract_const_const_MatExprR_const_MatExprR_MatExprR(instance: *const c_void, expr1: *const c_void, expr2: *const c_void, res: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_MatOp_subtract_const_const_ScalarR_const_MatExprR_MatExprR(instance: *const c_void, s: *const core::Scalar, expr: *const c_void, res: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_MatOp_multiply_const_const_MatExprR_const_MatExprR_MatExprR_double(instance: *const c_void, expr1: *const c_void, expr2: *const c_void, res: *mut c_void, scale: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_MatOp_multiply_const_const_MatExprR_const_MatExprR_MatExprR(instance: *const c_void, expr1: *const c_void, expr2: *const c_void, res: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_MatOp_multiply_const_const_MatExprR_double_MatExprR(instance: *const c_void, expr1: *const c_void, s: f64, res: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_MatOp_divide_const_const_MatExprR_const_MatExprR_MatExprR_double(instance: *const c_void, expr1: *const c_void, expr2: *const c_void, res: *mut c_void, scale: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_MatOp_divide_const_const_MatExprR_const_MatExprR_MatExprR(instance: *const c_void, expr1: *const c_void, expr2: *const c_void, res: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_MatOp_divide_const_double_const_MatExprR_MatExprR(instance: *const c_void, s: f64, expr: *const c_void, res: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_MatOp_abs_const_const_MatExprR_MatExprR(instance: *const c_void, expr: *const c_void, res: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_MatOp_transpose_const_const_MatExprR_MatExprR(instance: *const c_void, expr: *const c_void, res: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_MatOp_matmul_const_const_MatExprR_const_MatExprR_MatExprR(instance: *const c_void, expr1: *const c_void, expr2: *const c_void, res: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_MatOp_invert_const_const_MatExprR_int_MatExprR(instance: *const c_void, expr: *const c_void, method: i32, res: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_MatOp_assign_const_const_MatExprR_MatR_int(instance: *const c_void, expr: *const c_void, m: *mut c_void, typ: i32, ocvrs_return: *mut Result<()>); + pub fn cv_MatOp_assign_const_const_MatExprR_MatR(instance: *const c_void, expr: *const c_void, m: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_MatOp_roi_const_const_MatExprR_const_RangeR_const_RangeR_MatExprR(instance: *const c_void, expr: *const c_void, row_range: *const c_void, col_range: *const c_void, res: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_MatOp_diag_const_const_MatExprR_int_MatExprR(instance: *const c_void, expr: *const c_void, d: i32, res: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_MatOp_augAssignAdd_const_const_MatExprR_MatR(instance: *const c_void, expr: *const c_void, m: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_MatOp_augAssignSubtract_const_const_MatExprR_MatR(instance: *const c_void, expr: *const c_void, m: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_MatOp_augAssignMultiply_const_const_MatExprR_MatR(instance: *const c_void, expr: *const c_void, m: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_MatOp_augAssignDivide_const_const_MatExprR_MatR(instance: *const c_void, expr: *const c_void, m: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_MatOp_augAssignAnd_const_const_MatExprR_MatR(instance: *const c_void, expr: *const c_void, m: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_MatOp_augAssignOr_const_const_MatExprR_MatR(instance: *const c_void, expr: *const c_void, m: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_MatOp_augAssignXor_const_const_MatExprR_MatR(instance: *const c_void, expr: *const c_void, m: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_MatOp_add_const_const_MatExprR_const_MatExprR_MatExprR(instance: *const c_void, expr1: *const c_void, expr2: *const c_void, res: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_MatOp_add_const_const_MatExprR_const_ScalarR_MatExprR(instance: *const c_void, expr1: *const c_void, s: *const core::Scalar, res: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_MatOp_subtract_const_const_MatExprR_const_MatExprR_MatExprR(instance: *const c_void, expr1: *const c_void, expr2: *const c_void, res: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_MatOp_subtract_const_const_ScalarR_const_MatExprR_MatExprR(instance: *const c_void, s: *const core::Scalar, expr: *const c_void, res: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_MatOp_multiply_const_const_MatExprR_const_MatExprR_MatExprR_double(instance: *const c_void, expr1: *const c_void, expr2: *const c_void, res: *mut c_void, scale: f64, ocvrs_return: *mut Result<()>); + pub fn cv_MatOp_multiply_const_const_MatExprR_const_MatExprR_MatExprR(instance: *const c_void, expr1: *const c_void, expr2: *const c_void, res: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_MatOp_multiply_const_const_MatExprR_double_MatExprR(instance: *const c_void, expr1: *const c_void, s: f64, res: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_MatOp_divide_const_const_MatExprR_const_MatExprR_MatExprR_double(instance: *const c_void, expr1: *const c_void, expr2: *const c_void, res: *mut c_void, scale: f64, ocvrs_return: *mut Result<()>); + pub fn cv_MatOp_divide_const_const_MatExprR_const_MatExprR_MatExprR(instance: *const c_void, expr1: *const c_void, expr2: *const c_void, res: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_MatOp_divide_const_double_const_MatExprR_MatExprR(instance: *const c_void, s: f64, expr: *const c_void, res: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_MatOp_abs_const_const_MatExprR_MatExprR(instance: *const c_void, expr: *const c_void, res: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_MatOp_transpose_const_const_MatExprR_MatExprR(instance: *const c_void, expr: *const c_void, res: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_MatOp_matmul_const_const_MatExprR_const_MatExprR_MatExprR(instance: *const c_void, expr1: *const c_void, expr2: *const c_void, res: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_MatOp_invert_const_const_MatExprR_int_MatExprR(instance: *const c_void, expr: *const c_void, method: i32, res: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_MatOp_size_const_const_MatExprR(instance: *const c_void, expr: *const c_void, ocvrs_return: *mut Result); pub fn cv_MatOp_type_const_const_MatExprR(instance: *const c_void, expr: *const c_void, ocvrs_return: *mut Result); pub fn cv_MatOp_delete(instance: *mut c_void); @@ -1631,7 +1617,7 @@ mod core_sys { pub fn cv_MatStep_operator___const_int(instance: *const c_void, i: i32) -> size_t; pub fn cv_MatStep_operator___int(instance: *mut c_void, i: i32) -> size_t; pub fn cv_MatStep_operator_size_t_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_MatStep_operatorST_size_t(instance: *mut c_void, s: size_t, ocvrs_return: *mut ResultVoid); + pub fn cv_MatStep_operatorST_size_t(instance: *mut c_void, s: size_t, ocvrs_return: *mut Result<()>); pub fn cv_MatStep_propP_const(instance: *const c_void) -> *const size_t; pub fn cv_MatStep_propP(instance: *mut c_void) -> *mut size_t; pub fn cv_MatStep_propP_size_tX(instance: *mut c_void, val: *const size_t); @@ -1660,9 +1646,9 @@ mod core_sys { pub fn cv_Matx_TOp_Matx_TOp_const_Matx_TOpR(unnamed: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_Matx_TOp_delete(instance: *mut c_void); pub fn cv_MinProblemSolver_getFunction_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_MinProblemSolver_setFunction_const_PtrLFunctionGR(instance: *mut c_void, f: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_MinProblemSolver_setFunction_const_PtrLFunctionGR(instance: *mut c_void, f: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_MinProblemSolver_getTermCriteria_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_MinProblemSolver_setTermCriteria_const_TermCriteriaR(instance: *mut c_void, termcrit: *const core::TermCriteria, ocvrs_return: *mut ResultVoid); + pub fn cv_MinProblemSolver_setTermCriteria_const_TermCriteriaR(instance: *mut c_void, termcrit: *const core::TermCriteria, ocvrs_return: *mut Result<()>); pub fn cv_MinProblemSolver_minimize_const__InputOutputArrayR(instance: *mut c_void, x: *const c_void, ocvrs_return: *mut Result); pub fn cv_MinProblemSolver_to_ConjGradSolver(instance: *mut c_void) -> *mut c_void; pub fn cv_MinProblemSolver_to_DownhillSolver(instance: *mut c_void) -> *mut c_void; @@ -1671,7 +1657,7 @@ mod core_sys { pub fn cv_MinProblemSolver_Function_getDims_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_MinProblemSolver_Function_getGradientEps_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_MinProblemSolver_Function_calc_const_const_doubleX(instance: *const c_void, x: *const f64, ocvrs_return: *mut Result); - pub fn cv_MinProblemSolver_Function_getGradient_const_doubleX_doubleX(instance: *mut c_void, x: *const f64, grad: *mut f64, ocvrs_return: *mut ResultVoid); + pub fn cv_MinProblemSolver_Function_getGradient_const_doubleX_doubleX(instance: *mut c_void, x: *const f64, grad: *mut f64, ocvrs_return: *mut Result<()>); pub fn cv_MinProblemSolver_Function_delete(instance: *mut c_void); pub fn cv_Moments_Moments(ocvrs_return: *mut Result); pub fn cv_Moments_Moments_double_double_double_double_double_double_double_double_double_double(m00: f64, m10: f64, m01: f64, m20: f64, m11: f64, m02: f64, m30: f64, m21: f64, m12: f64, m03: f64, ocvrs_return: *mut Result); @@ -1683,11 +1669,11 @@ mod core_sys { pub fn cv_PCA_operator___const__InputArrayR_const__InputArrayR_int(instance: *mut c_void, data: *const c_void, mean: *const c_void, flags: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_PCA_operator___const__InputArrayR_const__InputArrayR_int_double(instance: *mut c_void, data: *const c_void, mean: *const c_void, flags: i32, retained_variance: f64, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_PCA_project_const_const__InputArrayR(instance: *const c_void, vec: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_PCA_project_const_const__InputArrayR_const__OutputArrayR(instance: *const c_void, vec: *const c_void, result: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_PCA_project_const_const__InputArrayR_const__OutputArrayR(instance: *const c_void, vec: *const c_void, result: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_PCA_backProject_const_const__InputArrayR(instance: *const c_void, vec: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_PCA_backProject_const_const__InputArrayR_const__OutputArrayR(instance: *const c_void, vec: *const c_void, result: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_PCA_write_const_FileStorageR(instance: *const c_void, fs: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_PCA_read_const_FileNodeR(instance: *mut c_void, fn_: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_PCA_backProject_const_const__InputArrayR_const__OutputArrayR(instance: *const c_void, vec: *const c_void, result: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_PCA_write_const_FileStorageR(instance: *const c_void, fs: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_PCA_read_const_FileNodeR(instance: *mut c_void, fn_: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_PCA_propEigenvectors_const(instance: *const c_void) -> *mut c_void; pub fn cv_PCA_propEigenvectors_const_Mat(instance: *mut c_void, val: *const c_void); pub fn cv_PCA_propEigenvalues_const(instance: *const c_void) -> *mut c_void; @@ -1695,7 +1681,7 @@ mod core_sys { pub fn cv_PCA_propMean_const(instance: *const c_void) -> *mut c_void; pub fn cv_PCA_propMean_const_Mat(instance: *mut c_void, val: *const c_void); pub fn cv_PCA_delete(instance: *mut c_void); - pub fn cv_ParallelLoopBody_operator___const_const_RangeR(instance: *const c_void, range: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ParallelLoopBody_operator___const_const_RangeR(instance: *const c_void, range: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_ParallelLoopBody_delete(instance: *mut c_void); pub fn cv_RNG_RNG(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_RNG_RNG_uint64_t(state: u64, ocvrs_return: *mut Result<*mut c_void>); @@ -1713,8 +1699,8 @@ mod core_sys { pub fn cv_RNG_uniform_int_int(instance: *mut c_void, a: i32, b: i32, ocvrs_return: *mut Result); pub fn cv_RNG_uniform_float_float(instance: *mut c_void, a: f32, b: f32, ocvrs_return: *mut Result); pub fn cv_RNG_uniform_double_double(instance: *mut c_void, a: f64, b: f64, ocvrs_return: *mut Result); - pub fn cv_RNG_fill_const__InputOutputArrayR_int_const__InputArrayR_const__InputArrayR_bool(instance: *mut c_void, mat: *const c_void, dist_type: i32, a: *const c_void, b: *const c_void, saturate_range: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_RNG_fill_const__InputOutputArrayR_int_const__InputArrayR_const__InputArrayR(instance: *mut c_void, mat: *const c_void, dist_type: i32, a: *const c_void, b: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_RNG_fill_const__InputOutputArrayR_int_const__InputArrayR_const__InputArrayR_bool(instance: *mut c_void, mat: *const c_void, dist_type: i32, a: *const c_void, b: *const c_void, saturate_range: bool, ocvrs_return: *mut Result<()>); + pub fn cv_RNG_fill_const__InputOutputArrayR_int_const__InputArrayR_const__InputArrayR(instance: *mut c_void, mat: *const c_void, dist_type: i32, a: *const c_void, b: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_RNG_gaussian_double(instance: *mut c_void, sigma: f64, ocvrs_return: *mut Result); pub fn cv_RNG_operatorEQ_const_const_RNGR(instance: *const c_void, other: *const c_void, ocvrs_return: *mut Result); pub fn cv_RNG_propState_const(instance: *const c_void) -> u64; @@ -1722,7 +1708,7 @@ mod core_sys { pub fn cv_RNG_delete(instance: *mut c_void); pub fn cv_RNG_MT19937_RNG_MT19937(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_RNG_MT19937_RNG_MT19937_unsigned_int(s: u32, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_RNG_MT19937_seed_unsigned_int(instance: *mut c_void, s: u32, ocvrs_return: *mut ResultVoid); + pub fn cv_RNG_MT19937_seed_unsigned_int(instance: *mut c_void, s: u32, ocvrs_return: *mut Result<()>); pub fn cv_RNG_MT19937_next(instance: *mut c_void, ocvrs_return: *mut Result); pub fn cv_RNG_MT19937_operator_int(instance: *mut c_void, ocvrs_return: *mut Result); pub fn cv_RNG_MT19937_operator_unsigned_int(instance: *mut c_void, ocvrs_return: *mut Result); @@ -1746,8 +1732,8 @@ mod core_sys { pub fn cv_RotatedRect_RotatedRect(ocvrs_return: *mut Result); pub fn cv_RotatedRect_RotatedRect_const_Point2fR_const_Size2fR_float(center: *const core::Point2f, size: *const core::Size2f, angle: f32, ocvrs_return: *mut Result); pub fn cv_RotatedRect_RotatedRect_const_Point2fR_const_Point2fR_const_Point2fR(point1: *const core::Point2f, point2: *const core::Point2f, point3: *const core::Point2f, ocvrs_return: *mut Result); - pub fn cv_RotatedRect_points_const_Point2fXX(instance: *const core::RotatedRect, pts: *mut [core::Point2f; 4], ocvrs_return: *mut ResultVoid); - pub fn cv_RotatedRect_points_const_vectorLPoint2fGR(instance: *const core::RotatedRect, pts: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_RotatedRect_points_const_Point2fXX(instance: *const core::RotatedRect, pts: *mut [core::Point2f; 4], ocvrs_return: *mut Result<()>); + pub fn cv_RotatedRect_points_const_vectorLPoint2fGR(instance: *const core::RotatedRect, pts: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_RotatedRect_boundingRect_const(instance: *const core::RotatedRect, ocvrs_return: *mut Result); pub fn cv_RotatedRect_boundingRect2f_const(instance: *const core::RotatedRect, ocvrs_return: *mut Result); pub fn cv_SVD_SVD(ocvrs_return: *mut Result<*mut c_void>); @@ -1755,13 +1741,13 @@ mod core_sys { pub fn cv_SVD_SVD_const__InputArrayR(src: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_SVD_operator___const__InputArrayR_int(instance: *mut c_void, src: *const c_void, flags: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_SVD_operator___const__InputArrayR(instance: *mut c_void, src: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_SVD_compute_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_int(src: *const c_void, w: *const c_void, u: *const c_void, vt: *const c_void, flags: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_SVD_compute_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(src: *const c_void, w: *const c_void, u: *const c_void, vt: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_SVD_compute_const__InputArrayR_const__OutputArrayR_int(src: *const c_void, w: *const c_void, flags: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_SVD_compute_const__InputArrayR_const__OutputArrayR(src: *const c_void, w: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_SVD_backSubst_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR(w: *const c_void, u: *const c_void, vt: *const c_void, rhs: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_SVD_solveZ_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_SVD_backSubst_const_const__InputArrayR_const__OutputArrayR(instance: *const c_void, rhs: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_SVD_compute_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_int(src: *const c_void, w: *const c_void, u: *const c_void, vt: *const c_void, flags: i32, ocvrs_return: *mut Result<()>); + pub fn cv_SVD_compute_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(src: *const c_void, w: *const c_void, u: *const c_void, vt: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_SVD_compute_const__InputArrayR_const__OutputArrayR_int(src: *const c_void, w: *const c_void, flags: i32, ocvrs_return: *mut Result<()>); + pub fn cv_SVD_compute_const__InputArrayR_const__OutputArrayR(src: *const c_void, w: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_SVD_backSubst_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR(w: *const c_void, u: *const c_void, vt: *const c_void, rhs: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_SVD_solveZ_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_SVD_backSubst_const_const__InputArrayR_const__OutputArrayR(instance: *const c_void, rhs: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_SVD_propU_const(instance: *const c_void) -> *mut c_void; pub fn cv_SVD_propU_const_Mat(instance: *mut c_void, val: *const c_void); pub fn cv_SVD_propW_const(instance: *const c_void) -> *mut c_void; @@ -1773,21 +1759,21 @@ mod core_sys { pub fn cv_SparseMat_SparseMat_int_const_intX_int(dims: i32, _sizes: *const i32, _type: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_SparseMat_SparseMat_const_SparseMatR(m: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_SparseMat_SparseMat_const_MatR(m: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_SparseMat_operatorST_const_SparseMatR(instance: *mut c_void, m: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_SparseMat_operatorST_const_MatR(instance: *mut c_void, m: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_SparseMat_operatorST_const_SparseMatR(instance: *mut c_void, m: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_SparseMat_operatorST_const_MatR(instance: *mut c_void, m: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_SparseMat_clone_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_SparseMat_copyTo_const_SparseMatR(instance: *const c_void, m: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_SparseMat_copyTo_const_MatR(instance: *const c_void, m: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_SparseMat_convertTo_const_SparseMatR_int_double(instance: *const c_void, m: *mut c_void, rtype: i32, alpha: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_SparseMat_convertTo_const_SparseMatR_int(instance: *const c_void, m: *mut c_void, rtype: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_SparseMat_convertTo_const_MatR_int_double_double(instance: *const c_void, m: *mut c_void, rtype: i32, alpha: f64, beta: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_SparseMat_convertTo_const_MatR_int(instance: *const c_void, m: *mut c_void, rtype: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_SparseMat_assignTo_const_SparseMatR_int(instance: *const c_void, m: *mut c_void, typ: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_SparseMat_assignTo_const_SparseMatR(instance: *const c_void, m: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_SparseMat_create_int_const_intX_int(instance: *mut c_void, dims: i32, _sizes: *const i32, _type: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_SparseMat_clear(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_SparseMat_addref(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_SparseMat_release(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_SparseMat_copyTo_const_SparseMatR(instance: *const c_void, m: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_SparseMat_copyTo_const_MatR(instance: *const c_void, m: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_SparseMat_convertTo_const_SparseMatR_int_double(instance: *const c_void, m: *mut c_void, rtype: i32, alpha: f64, ocvrs_return: *mut Result<()>); + pub fn cv_SparseMat_convertTo_const_SparseMatR_int(instance: *const c_void, m: *mut c_void, rtype: i32, ocvrs_return: *mut Result<()>); + pub fn cv_SparseMat_convertTo_const_MatR_int_double_double(instance: *const c_void, m: *mut c_void, rtype: i32, alpha: f64, beta: f64, ocvrs_return: *mut Result<()>); + pub fn cv_SparseMat_convertTo_const_MatR_int(instance: *const c_void, m: *mut c_void, rtype: i32, ocvrs_return: *mut Result<()>); + pub fn cv_SparseMat_assignTo_const_SparseMatR_int(instance: *const c_void, m: *mut c_void, typ: i32, ocvrs_return: *mut Result<()>); + pub fn cv_SparseMat_assignTo_const_SparseMatR(instance: *const c_void, m: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_SparseMat_create_int_const_intX_int(instance: *mut c_void, dims: i32, _sizes: *const i32, _type: i32, ocvrs_return: *mut Result<()>); + pub fn cv_SparseMat_clear(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_SparseMat_addref(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_SparseMat_release(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_SparseMat_elemSize_const(instance: *const c_void) -> size_t; pub fn cv_SparseMat_elemSize1_const(instance: *const c_void) -> size_t; pub fn cv_SparseMat_type_const(instance: *const c_void) -> i32; @@ -1809,12 +1795,12 @@ mod core_sys { pub fn cv_SparseMat_ptr_int_int_int_bool(instance: *mut c_void, i0: i32, i1: i32, i2: i32, create_missing: bool, ocvrs_return: *mut Result<*mut u8>); pub fn cv_SparseMat_ptr_const_intX_bool_size_tX(instance: *mut c_void, idx: *const i32, create_missing: bool, hashval: *mut size_t, ocvrs_return: *mut Result<*mut u8>); pub fn cv_SparseMat_ptr_const_intX_bool(instance: *mut c_void, idx: *const i32, create_missing: bool, ocvrs_return: *mut Result<*mut u8>); - pub fn cv_SparseMat_erase_int_int_size_tX(instance: *mut c_void, i0: i32, i1: i32, hashval: *mut size_t, ocvrs_return: *mut ResultVoid); - pub fn cv_SparseMat_erase_int_int(instance: *mut c_void, i0: i32, i1: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_SparseMat_erase_int_int_int_size_tX(instance: *mut c_void, i0: i32, i1: i32, i2: i32, hashval: *mut size_t, ocvrs_return: *mut ResultVoid); - pub fn cv_SparseMat_erase_int_int_int(instance: *mut c_void, i0: i32, i1: i32, i2: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_SparseMat_erase_const_intX_size_tX(instance: *mut c_void, idx: *const i32, hashval: *mut size_t, ocvrs_return: *mut ResultVoid); - pub fn cv_SparseMat_erase_const_intX(instance: *mut c_void, idx: *const i32, ocvrs_return: *mut ResultVoid); + pub fn cv_SparseMat_erase_int_int_size_tX(instance: *mut c_void, i0: i32, i1: i32, hashval: *mut size_t, ocvrs_return: *mut Result<()>); + pub fn cv_SparseMat_erase_int_int(instance: *mut c_void, i0: i32, i1: i32, ocvrs_return: *mut Result<()>); + pub fn cv_SparseMat_erase_int_int_int_size_tX(instance: *mut c_void, i0: i32, i1: i32, i2: i32, hashval: *mut size_t, ocvrs_return: *mut Result<()>); + pub fn cv_SparseMat_erase_int_int_int(instance: *mut c_void, i0: i32, i1: i32, i2: i32, ocvrs_return: *mut Result<()>); + pub fn cv_SparseMat_erase_const_intX_size_tX(instance: *mut c_void, idx: *const i32, hashval: *mut size_t, ocvrs_return: *mut Result<()>); + pub fn cv_SparseMat_erase_const_intX(instance: *mut c_void, idx: *const i32, ocvrs_return: *mut Result<()>); pub fn cv_SparseMat_begin(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_SparseMat_begin_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_SparseMat_end(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); @@ -1822,15 +1808,15 @@ mod core_sys { pub fn cv_SparseMat_node_size_t(instance: *mut c_void, nidx: size_t, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_SparseMat_node_const_size_t(instance: *const c_void, nidx: size_t, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_SparseMat_newNode_const_intX_size_t(instance: *mut c_void, idx: *const i32, hashval: size_t, ocvrs_return: *mut Result<*mut u8>); - pub fn cv_SparseMat_removeNode_size_t_size_t_size_t(instance: *mut c_void, hidx: size_t, nidx: size_t, previdx: size_t, ocvrs_return: *mut ResultVoid); - pub fn cv_SparseMat_resizeHashTab_size_t(instance: *mut c_void, newsize: size_t, ocvrs_return: *mut ResultVoid); + pub fn cv_SparseMat_removeNode_size_t_size_t_size_t(instance: *mut c_void, hidx: size_t, nidx: size_t, previdx: size_t, ocvrs_return: *mut Result<()>); + pub fn cv_SparseMat_resizeHashTab_size_t(instance: *mut c_void, newsize: size_t, ocvrs_return: *mut Result<()>); pub fn cv_SparseMat_propFlags_const(instance: *const c_void) -> i32; pub fn cv_SparseMat_propFlags_const_int(instance: *mut c_void, val: i32); pub fn cv_SparseMat_propHdr(instance: *mut c_void) -> *mut c_void; pub fn cv_SparseMat_propHdr_HdrX(instance: *mut c_void, val: *const c_void); pub fn cv_SparseMat_delete(instance: *mut c_void); pub fn cv_SparseMat_Hdr_Hdr_int_const_intX_int(_dims: i32, _sizes: *const i32, _type: i32, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_SparseMat_Hdr_clear(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_SparseMat_Hdr_clear(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_SparseMat_Hdr_propRefcount_const(instance: *const c_void) -> i32; pub fn cv_SparseMat_Hdr_propRefcount_const_int(instance: *mut c_void, val: i32); pub fn cv_SparseMat_Hdr_propDims_const(instance: *const c_void) -> i32; @@ -1861,10 +1847,10 @@ mod core_sys { pub fn cv_SparseMatConstIterator_SparseMatConstIterator(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_SparseMatConstIterator_SparseMatConstIterator_const_SparseMatX(_m: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_SparseMatConstIterator_SparseMatConstIterator_const_SparseMatConstIteratorR(it: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_SparseMatConstIterator_operatorST_const_SparseMatConstIteratorR(instance: *mut c_void, it: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_SparseMatConstIterator_operatorST_const_SparseMatConstIteratorR(instance: *mut c_void, it: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_SparseMatConstIterator_node_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_SparseMatConstIterator_operatorAA(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_SparseMatConstIterator_seekEnd(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_SparseMatConstIterator_seekEnd(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_SparseMatConstIterator_propM_const(instance: *const c_void) -> *mut c_void; pub fn cv_SparseMatConstIterator_propHashidx_const(instance: *const c_void) -> size_t; pub fn cv_SparseMatConstIterator_propHashidx_const_size_t(instance: *mut c_void, val: size_t); @@ -1875,7 +1861,7 @@ mod core_sys { pub fn cv_SparseMatIterator_SparseMatIterator(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_SparseMatIterator_SparseMatIterator_SparseMatX(_m: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_SparseMatIterator_SparseMatIterator_const_SparseMatIteratorR(it: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_SparseMatIterator_operatorST_const_SparseMatIteratorR(instance: *mut c_void, it: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_SparseMatIterator_operatorST_const_SparseMatIteratorR(instance: *mut c_void, it: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_SparseMatIterator_node_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_SparseMatIterator_operatorAA(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_SparseMatIterator_to_SparseMatConstIterator(instance: *mut c_void) -> *mut c_void; @@ -1884,8 +1870,8 @@ mod core_sys { pub fn cv_TermCriteria_TermCriteria_int_int_double(typ: i32, max_count: i32, epsilon: f64, ocvrs_return: *mut Result); pub fn cv_TermCriteria_isValid_const(instance: *const core::TermCriteria, ocvrs_return: *mut Result); pub fn cv_TickMeter_TickMeter(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_TickMeter_start(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_TickMeter_stop(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_TickMeter_start(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_TickMeter_stop(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_TickMeter_getTimeTicks_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_TickMeter_getTimeMicro_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_TickMeter_getTimeMilli_const(instance: *const c_void, ocvrs_return: *mut Result); @@ -1898,7 +1884,7 @@ mod core_sys { pub fn cv_TickMeter_getFPS_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_TickMeter_getAvgTimeSec_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_TickMeter_getAvgTimeMilli_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_TickMeter_reset(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_TickMeter_reset(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_TickMeter_delete(instance: *mut c_void); pub fn cv_UMat_UMat_UMatUsageFlags(usage_flags: core::UMatUsageFlags) -> *mut c_void; pub fn cv_UMat_UMat() -> *mut c_void; @@ -1923,7 +1909,7 @@ mod core_sys { pub fn cv_UMat_UMat_UMatR_const_RectR(m: *mut c_void, roi: *const core::Rect, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_UMat_UMat_const_UMatR_const_vectorLRangeGR(m: *const c_void, ranges: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_UMat_UMat_UMatR_const_vectorLRangeGR(m: *mut c_void, ranges: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_UMat_operatorST_const_UMatR(instance: *mut c_void, m: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_UMat_operatorST_const_UMatR(instance: *mut c_void, m: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_UMat_getMat_const_AccessFlag(instance: *const c_void, flags: core::AccessFlag, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_UMat_row_const_int(instance: *const c_void, y: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_UMat_row_int(instance: *mut c_void, y: i32, ocvrs_return: *mut Result<*mut c_void>); @@ -1944,13 +1930,13 @@ mod core_sys { pub fn cv_UMat_diag_const_UMatR_UMatUsageFlags(d: *const c_void, usage_flags: core::UMatUsageFlags, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_UMat_diag_const_UMatR(d: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_UMat_clone_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_UMat_copyTo_const_const__OutputArrayR(instance: *const c_void, m: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_UMat_copyTo_const_const__OutputArrayR_const__InputArrayR(instance: *const c_void, m: *const c_void, mask: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_UMat_convertTo_const_const__OutputArrayR_int_double_double(instance: *const c_void, m: *const c_void, rtype: i32, alpha: f64, beta: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_UMat_convertTo_const_const__OutputArrayR_int(instance: *const c_void, m: *const c_void, rtype: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_UMat_assignTo_const_UMatR_int(instance: *const c_void, m: *mut c_void, typ: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_UMat_assignTo_const_UMatR(instance: *const c_void, m: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_UMat_operatorST_const_ScalarR(instance: *mut c_void, s: *const core::Scalar, ocvrs_return: *mut ResultVoid); + pub fn cv_UMat_copyTo_const_const__OutputArrayR(instance: *const c_void, m: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_UMat_copyTo_const_const__OutputArrayR_const__InputArrayR(instance: *const c_void, m: *const c_void, mask: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_UMat_convertTo_const_const__OutputArrayR_int_double_double(instance: *const c_void, m: *const c_void, rtype: i32, alpha: f64, beta: f64, ocvrs_return: *mut Result<()>); + pub fn cv_UMat_convertTo_const_const__OutputArrayR_int(instance: *const c_void, m: *const c_void, rtype: i32, ocvrs_return: *mut Result<()>); + pub fn cv_UMat_assignTo_const_UMatR_int(instance: *const c_void, m: *mut c_void, typ: i32, ocvrs_return: *mut Result<()>); + pub fn cv_UMat_assignTo_const_UMatR(instance: *const c_void, m: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_UMat_operatorST_const_ScalarR(instance: *mut c_void, s: *const core::Scalar, ocvrs_return: *mut Result<()>); pub fn cv_UMat_setTo_const__InputArrayR_const__InputArrayR(instance: *mut c_void, value: *const c_void, mask: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_UMat_setTo_const__InputArrayR(instance: *mut c_void, value: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_UMat_reshape_const_int_int(instance: *const c_void, cn: i32, rows: i32, ocvrs_return: *mut Result<*mut c_void>); @@ -1981,18 +1967,18 @@ mod core_sys { pub fn cv_UMat_eye_Size_int_UMatUsageFlags(size: *const core::Size, typ: i32, usage_flags: core::UMatUsageFlags, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_UMat_eye_int_int_int(rows: i32, cols: i32, typ: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_UMat_eye_Size_int(size: *const core::Size, typ: i32, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_UMat_create_int_int_int_UMatUsageFlags(instance: *mut c_void, rows: i32, cols: i32, typ: i32, usage_flags: core::UMatUsageFlags, ocvrs_return: *mut ResultVoid); - pub fn cv_UMat_create_int_int_int(instance: *mut c_void, rows: i32, cols: i32, typ: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_UMat_create_Size_int_UMatUsageFlags(instance: *mut c_void, size: *const core::Size, typ: i32, usage_flags: core::UMatUsageFlags, ocvrs_return: *mut ResultVoid); - pub fn cv_UMat_create_Size_int(instance: *mut c_void, size: *const core::Size, typ: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_UMat_create_int_const_intX_int_UMatUsageFlags(instance: *mut c_void, ndims: i32, sizes: *const i32, typ: i32, usage_flags: core::UMatUsageFlags, ocvrs_return: *mut ResultVoid); - pub fn cv_UMat_create_int_const_intX_int(instance: *mut c_void, ndims: i32, sizes: *const i32, typ: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_UMat_create_const_vectorLintGR_int_UMatUsageFlags(instance: *mut c_void, sizes: *const c_void, typ: i32, usage_flags: core::UMatUsageFlags, ocvrs_return: *mut ResultVoid); - pub fn cv_UMat_create_const_vectorLintGR_int(instance: *mut c_void, sizes: *const c_void, typ: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_UMat_addref(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_UMat_release(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_UMat_deallocate(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_UMat_locateROI_const_SizeR_PointR(instance: *const c_void, whole_size: *mut core::Size, ofs: *mut core::Point, ocvrs_return: *mut ResultVoid); + pub fn cv_UMat_create_int_int_int_UMatUsageFlags(instance: *mut c_void, rows: i32, cols: i32, typ: i32, usage_flags: core::UMatUsageFlags, ocvrs_return: *mut Result<()>); + pub fn cv_UMat_create_int_int_int(instance: *mut c_void, rows: i32, cols: i32, typ: i32, ocvrs_return: *mut Result<()>); + pub fn cv_UMat_create_Size_int_UMatUsageFlags(instance: *mut c_void, size: *const core::Size, typ: i32, usage_flags: core::UMatUsageFlags, ocvrs_return: *mut Result<()>); + pub fn cv_UMat_create_Size_int(instance: *mut c_void, size: *const core::Size, typ: i32, ocvrs_return: *mut Result<()>); + pub fn cv_UMat_create_int_const_intX_int_UMatUsageFlags(instance: *mut c_void, ndims: i32, sizes: *const i32, typ: i32, usage_flags: core::UMatUsageFlags, ocvrs_return: *mut Result<()>); + pub fn cv_UMat_create_int_const_intX_int(instance: *mut c_void, ndims: i32, sizes: *const i32, typ: i32, ocvrs_return: *mut Result<()>); + pub fn cv_UMat_create_const_vectorLintGR_int_UMatUsageFlags(instance: *mut c_void, sizes: *const c_void, typ: i32, usage_flags: core::UMatUsageFlags, ocvrs_return: *mut Result<()>); + pub fn cv_UMat_create_const_vectorLintGR_int(instance: *mut c_void, sizes: *const c_void, typ: i32, ocvrs_return: *mut Result<()>); + pub fn cv_UMat_addref(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_UMat_release(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_UMat_deallocate(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_UMat_locateROI_const_SizeR_PointR(instance: *const c_void, whole_size: *mut core::Size, ofs: *mut core::Point, ocvrs_return: *mut Result<()>); pub fn cv_UMat_adjustROI_int_int_int_int(instance: *mut c_void, dtop: i32, dbottom: i32, dleft: i32, dright: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_UMat_operator___const_Range_Range(instance: *const c_void, row_range: *mut c_void, col_range: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_UMat_operator___Range_Range(instance: *mut c_void, row_range: *mut c_void, col_range: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); @@ -2014,10 +2000,10 @@ mod core_sys { pub fn cv_UMat_checkVector_const_int_int_bool(instance: *const c_void, elem_channels: i32, depth: i32, require_continuous: bool, ocvrs_return: *mut Result); pub fn cv_UMat_checkVector_const_int(instance: *const c_void, elem_channels: i32, ocvrs_return: *mut Result); pub fn cv_UMat_UMat_UMatRR(m: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_UMat_operatorST_UMatRR(instance: *mut c_void, m: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_UMat_operatorST_UMatRR(instance: *mut c_void, m: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_UMat_handle_const_AccessFlag(instance: *const c_void, access_flags: core::AccessFlag, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_UMat_ndoffset_const_size_tX(instance: *const c_void, ofs: *mut size_t, ocvrs_return: *mut ResultVoid); - pub fn cv_UMat_updateContinuityFlag(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_UMat_ndoffset_const_size_tX(instance: *const c_void, ofs: *mut size_t, ocvrs_return: *mut Result<()>); + pub fn cv_UMat_updateContinuityFlag(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_UMat_size_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_UMat_propFlags_const(instance: *const c_void) -> i32; pub fn cv_UMat_propFlags_const_int(instance: *mut c_void, val: i32); @@ -2037,17 +2023,17 @@ mod core_sys { pub fn cv_UMat_propSize_const_MatSize(instance: *mut c_void, val: *const c_void); pub fn cv_UMat_propStep_const(instance: *const c_void) -> *mut c_void; pub fn cv_UMat_delete(instance: *mut c_void); - pub fn cv_UMatData_lock(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_UMatData_unlock(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_UMatData_lock(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_UMatData_unlock(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_UMatData_hostCopyObsolete_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_UMatData_deviceCopyObsolete_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_UMatData_deviceMemMapped_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_UMatData_copyOnMap_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_UMatData_tempUMat_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_UMatData_tempCopiedUMat_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_UMatData_markHostCopyObsolete_bool(instance: *mut c_void, flag: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_UMatData_markDeviceCopyObsolete_bool(instance: *mut c_void, flag: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_UMatData_markDeviceMemMapped_bool(instance: *mut c_void, flag: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_UMatData_markHostCopyObsolete_bool(instance: *mut c_void, flag: bool, ocvrs_return: *mut Result<()>); + pub fn cv_UMatData_markDeviceCopyObsolete_bool(instance: *mut c_void, flag: bool, ocvrs_return: *mut Result<()>); + pub fn cv_UMatData_markDeviceMemMapped_bool(instance: *mut c_void, flag: bool, ocvrs_return: *mut Result<()>); pub fn cv_UMatData_propUrefcount_const(instance: *const c_void) -> i32; pub fn cv_UMatData_propUrefcount_const_int(instance: *mut c_void, val: i32); pub fn cv_UMatData_propRefcount_const(instance: *const c_void) -> i32; @@ -2092,9 +2078,9 @@ mod core_sys { pub fn cv__InputArray_getMat__const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv__InputArray_getUMat_const_int(instance: *const c_void, idx: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv__InputArray_getUMat_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv__InputArray_getMatVector_const_vectorLMatGR(instance: *const c_void, mv: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv__InputArray_getUMatVector_const_vectorLUMatGR(instance: *const c_void, umv: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv__InputArray_getGpuMatVector_const_vectorLGpuMatGR(instance: *const c_void, gpumv: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv__InputArray_getMatVector_const_vectorLMatGR(instance: *const c_void, mv: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv__InputArray_getUMatVector_const_vectorLUMatGR(instance: *const c_void, umv: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv__InputArray_getGpuMatVector_const_vectorLGpuMatGR(instance: *const c_void, gpumv: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv__InputArray_getGpuMat_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv__InputArray_getOGlBuffer_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv__InputArray_getFlags_const(instance: *const c_void, ocvrs_return: *mut Result); @@ -2125,8 +2111,8 @@ mod core_sys { pub fn cv__InputArray_isSubmatrix_const_int(instance: *const c_void, i: i32, ocvrs_return: *mut Result); pub fn cv__InputArray_isSubmatrix_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv__InputArray_empty_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv__InputArray_copyTo_const_const__OutputArrayR(instance: *const c_void, arr: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv__InputArray_copyTo_const_const__OutputArrayR_const__InputArrayR(instance: *const c_void, arr: *const c_void, mask: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv__InputArray_copyTo_const_const__OutputArrayR(instance: *const c_void, arr: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv__InputArray_copyTo_const_const__OutputArrayR_const__InputArrayR(instance: *const c_void, arr: *const c_void, mask: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv__InputArray_offset_const_int(instance: *const c_void, i: i32, ocvrs_return: *mut Result); pub fn cv__InputArray_offset_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv__InputArray_step_const_int(instance: *const c_void, i: i32, ocvrs_return: *mut Result); @@ -2189,23 +2175,23 @@ mod core_sys { pub fn cv__OutputArray_getGpuMatVecRef_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv__OutputArray_getOGlBufferRef_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv__OutputArray_getHostMemRef_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv__OutputArray_create_const_Size_int_int_bool_DepthMask(instance: *const c_void, sz: *const core::Size, typ: i32, i: i32, allow_transposed: bool, fixed_depth_mask: core::_OutputArray_DepthMask, ocvrs_return: *mut ResultVoid); - pub fn cv__OutputArray_create_const_Size_int(instance: *const c_void, sz: *const core::Size, typ: i32, ocvrs_return: *mut ResultVoid); - pub fn cv__OutputArray_create_const_int_int_int_int_bool_DepthMask(instance: *const c_void, rows: i32, cols: i32, typ: i32, i: i32, allow_transposed: bool, fixed_depth_mask: core::_OutputArray_DepthMask, ocvrs_return: *mut ResultVoid); - pub fn cv__OutputArray_create_const_int_int_int(instance: *const c_void, rows: i32, cols: i32, typ: i32, ocvrs_return: *mut ResultVoid); - pub fn cv__OutputArray_create_const_int_const_intX_int_int_bool_DepthMask(instance: *const c_void, dims: i32, size: *const i32, typ: i32, i: i32, allow_transposed: bool, fixed_depth_mask: core::_OutputArray_DepthMask, ocvrs_return: *mut ResultVoid); - pub fn cv__OutputArray_create_const_int_const_intX_int(instance: *const c_void, dims: i32, size: *const i32, typ: i32, ocvrs_return: *mut ResultVoid); - pub fn cv__OutputArray_createSameSize_const_const__InputArrayR_int(instance: *const c_void, arr: *const c_void, mtype: i32, ocvrs_return: *mut ResultVoid); - pub fn cv__OutputArray_release_const(instance: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv__OutputArray_clear_const(instance: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv__OutputArray_setTo_const_const__InputArrayR_const__InputArrayR(instance: *const c_void, value: *const c_void, mask: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv__OutputArray_setTo_const_const__InputArrayR(instance: *const c_void, value: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv__OutputArray_assign_const_const_UMatR(instance: *const c_void, u: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv__OutputArray_assign_const_const_MatR(instance: *const c_void, m: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv__OutputArray_assign_const_const_vectorLUMatGR(instance: *const c_void, v: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv__OutputArray_assign_const_const_vectorLMatGR(instance: *const c_void, v: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv__OutputArray_move_const_UMatR(instance: *const c_void, u: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv__OutputArray_move_const_MatR(instance: *const c_void, m: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv__OutputArray_create_const_Size_int_int_bool_DepthMask(instance: *const c_void, sz: *const core::Size, typ: i32, i: i32, allow_transposed: bool, fixed_depth_mask: core::_OutputArray_DepthMask, ocvrs_return: *mut Result<()>); + pub fn cv__OutputArray_create_const_Size_int(instance: *const c_void, sz: *const core::Size, typ: i32, ocvrs_return: *mut Result<()>); + pub fn cv__OutputArray_create_const_int_int_int_int_bool_DepthMask(instance: *const c_void, rows: i32, cols: i32, typ: i32, i: i32, allow_transposed: bool, fixed_depth_mask: core::_OutputArray_DepthMask, ocvrs_return: *mut Result<()>); + pub fn cv__OutputArray_create_const_int_int_int(instance: *const c_void, rows: i32, cols: i32, typ: i32, ocvrs_return: *mut Result<()>); + pub fn cv__OutputArray_create_const_int_const_intX_int_int_bool_DepthMask(instance: *const c_void, dims: i32, size: *const i32, typ: i32, i: i32, allow_transposed: bool, fixed_depth_mask: core::_OutputArray_DepthMask, ocvrs_return: *mut Result<()>); + pub fn cv__OutputArray_create_const_int_const_intX_int(instance: *const c_void, dims: i32, size: *const i32, typ: i32, ocvrs_return: *mut Result<()>); + pub fn cv__OutputArray_createSameSize_const_const__InputArrayR_int(instance: *const c_void, arr: *const c_void, mtype: i32, ocvrs_return: *mut Result<()>); + pub fn cv__OutputArray_release_const(instance: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv__OutputArray_clear_const(instance: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv__OutputArray_setTo_const_const__InputArrayR_const__InputArrayR(instance: *const c_void, value: *const c_void, mask: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv__OutputArray_setTo_const_const__InputArrayR(instance: *const c_void, value: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv__OutputArray_assign_const_const_UMatR(instance: *const c_void, u: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv__OutputArray_assign_const_const_MatR(instance: *const c_void, m: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv__OutputArray_assign_const_const_vectorLUMatGR(instance: *const c_void, v: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv__OutputArray_assign_const_const_vectorLMatGR(instance: *const c_void, v: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv__OutputArray_move_const_UMatR(instance: *const c_void, u: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv__OutputArray_move_const_MatR(instance: *const c_void, m: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv__OutputArray_to__InputArray(instance: *mut c_void) -> *mut c_void; pub fn cv__OutputArray_delete(instance: *mut c_void); pub fn cv_cuda_BufferPool_BufferPool_StreamR(stream: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); @@ -2268,7 +2254,7 @@ mod core_sys { pub fn cv_cuda_DeviceInfo_memoryBusWidth_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_cuda_DeviceInfo_l2CacheSize_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_cuda_DeviceInfo_maxThreadsPerMultiProcessor_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_DeviceInfo_queryMemory_const_size_tR_size_tR(instance: *const c_void, total_memory: *mut size_t, free_memory: *mut size_t, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_DeviceInfo_queryMemory_const_size_tR_size_tR(instance: *const c_void, total_memory: *mut size_t, free_memory: *mut size_t, ocvrs_return: *mut Result<()>); pub fn cv_cuda_DeviceInfo_freeMemory_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_cuda_DeviceInfo_totalMemory_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_cuda_DeviceInfo_supports_const_FeatureSet(instance: *const c_void, feature_set: core::FeatureSet, ocvrs_return: *mut Result); @@ -2276,10 +2262,10 @@ mod core_sys { pub fn cv_cuda_DeviceInfo_delete(instance: *mut c_void); pub fn cv_cuda_Event_Event_const_CreateFlags(flags: core::Event_CreateFlags, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_Event_Event(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_cuda_Event_record_StreamR(instance: *mut c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_Event_record(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_Event_record_StreamR(instance: *mut c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_Event_record(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_cuda_Event_queryIfComplete_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_Event_waitForCompletion(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_Event_waitForCompletion(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_cuda_Event_elapsedTime_const_EventR_const_EventR(start: *const c_void, end: *const c_void, ocvrs_return: *mut Result); pub fn cv_cuda_Event_delete(instance: *mut c_void); pub fn cv_cuda_GpuData_GpuData_size_t(_size: size_t, ocvrs_return: *mut Result<*mut c_void>); @@ -2290,7 +2276,7 @@ mod core_sys { pub fn cv_cuda_GpuData_propSize_const_size_t(instance: *mut c_void, val: size_t); pub fn cv_cuda_GpuData_delete(instance: *mut c_void); pub fn cv_cuda_GpuMat_defaultAllocator(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_cuda_GpuMat_setDefaultAllocator_AllocatorX(allocator: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_GpuMat_setDefaultAllocator_AllocatorX(allocator: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_cuda_GpuMat_getStdAllocator(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_GpuMat_GpuMat_AllocatorX(allocator: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_GpuMat_GpuMat(ocvrs_return: *mut Result<*mut c_void>); @@ -2313,40 +2299,40 @@ mod core_sys { pub fn cv_cuda_GpuMat_GpuMat_GpuMatR_Rect(m: *mut c_void, roi: *const core::Rect, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_GpuMat_GpuMat_const__InputArrayR_AllocatorX(arr: *const c_void, allocator: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_GpuMat_GpuMat_const__InputArrayR(arr: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_cuda_GpuMat_operatorST_const_GpuMatR(instance: *mut c_void, m: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_GpuMat_create_int_int_int(instance: *mut c_void, rows: i32, cols: i32, typ: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_GpuMat_create_Size_int(instance: *mut c_void, size: *const core::Size, typ: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_GpuMat_release(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_GpuMat_swap_GpuMatR(instance: *mut c_void, mat: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_GpuMat_upload_const__InputArrayR(instance: *mut c_void, arr: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_GpuMat_upload_const__InputArrayR_StreamR(instance: *mut c_void, arr: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_GpuMat_download_const_const__OutputArrayR(instance: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_GpuMat_download_const_const__OutputArrayR_StreamR(instance: *const c_void, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_GpuMat_operatorST_const_GpuMatR(instance: *mut c_void, m: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_GpuMat_create_int_int_int(instance: *mut c_void, rows: i32, cols: i32, typ: i32, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_GpuMat_create_Size_int(instance: *mut c_void, size: *const core::Size, typ: i32, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_GpuMat_release(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_GpuMat_swap_GpuMatR(instance: *mut c_void, mat: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_GpuMat_upload_const__InputArrayR(instance: *mut c_void, arr: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_GpuMat_upload_const__InputArrayR_StreamR(instance: *mut c_void, arr: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_GpuMat_download_const_const__OutputArrayR(instance: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_GpuMat_download_const_const__OutputArrayR_StreamR(instance: *const c_void, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_cuda_GpuMat_clone_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_cuda_GpuMat_copyTo_const_const__OutputArrayR(instance: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_GpuMat_copyTo_const_GpuMatR(instance: *const c_void, dst: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_GpuMat_copyTo_const_const__OutputArrayR_StreamR(instance: *const c_void, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_GpuMat_copyTo_const_GpuMatR_StreamR(instance: *const c_void, dst: *mut c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_GpuMat_copyTo_const_const__OutputArrayR_const__InputArrayR(instance: *const c_void, dst: *const c_void, mask: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_GpuMat_copyTo_const_GpuMatR_GpuMatR(instance: *const c_void, dst: *mut c_void, mask: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_GpuMat_copyTo_const_const__OutputArrayR_const__InputArrayR_StreamR(instance: *const c_void, dst: *const c_void, mask: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_GpuMat_copyTo_const_GpuMatR_GpuMatR_StreamR(instance: *const c_void, dst: *mut c_void, mask: *mut c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_GpuMat_copyTo_const_const__OutputArrayR(instance: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_GpuMat_copyTo_const_GpuMatR(instance: *const c_void, dst: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_GpuMat_copyTo_const_const__OutputArrayR_StreamR(instance: *const c_void, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_GpuMat_copyTo_const_GpuMatR_StreamR(instance: *const c_void, dst: *mut c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_GpuMat_copyTo_const_const__OutputArrayR_const__InputArrayR(instance: *const c_void, dst: *const c_void, mask: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_GpuMat_copyTo_const_GpuMatR_GpuMatR(instance: *const c_void, dst: *mut c_void, mask: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_GpuMat_copyTo_const_const__OutputArrayR_const__InputArrayR_StreamR(instance: *const c_void, dst: *const c_void, mask: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_GpuMat_copyTo_const_GpuMatR_GpuMatR_StreamR(instance: *const c_void, dst: *mut c_void, mask: *mut c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_cuda_GpuMat_setTo_Scalar(instance: *mut c_void, s: *const core::Scalar, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_GpuMat_setTo_Scalar_StreamR(instance: *mut c_void, s: *const core::Scalar, stream: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_GpuMat_setTo_Scalar_const__InputArrayR(instance: *mut c_void, s: *const core::Scalar, mask: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_GpuMat_setTo_Scalar_const__InputArrayR_StreamR(instance: *mut c_void, s: *const core::Scalar, mask: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_cuda_GpuMat_convertTo_const_const__OutputArrayR_int(instance: *const c_void, dst: *const c_void, rtype: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_GpuMat_convertTo_const_const__OutputArrayR_int_StreamR(instance: *const c_void, dst: *const c_void, rtype: i32, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_GpuMat_convertTo_const_GpuMatR_int_StreamR(instance: *const c_void, dst: *mut c_void, rtype: i32, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_GpuMat_convertTo_const_const__OutputArrayR_int_double_double(instance: *const c_void, dst: *const c_void, rtype: i32, alpha: f64, beta: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_GpuMat_convertTo_const_const__OutputArrayR_int_double(instance: *const c_void, dst: *const c_void, rtype: i32, alpha: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_GpuMat_convertTo_const_GpuMatR_int_double_double(instance: *const c_void, dst: *mut c_void, rtype: i32, alpha: f64, beta: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_GpuMat_convertTo_const_GpuMatR_int(instance: *const c_void, dst: *mut c_void, rtype: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_GpuMat_convertTo_const_const__OutputArrayR_int_double_StreamR(instance: *const c_void, dst: *const c_void, rtype: i32, alpha: f64, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_GpuMat_convertTo_const_const__OutputArrayR_int_double_double_StreamR(instance: *const c_void, dst: *const c_void, rtype: i32, alpha: f64, beta: f64, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_GpuMat_convertTo_const_GpuMatR_int_double_double_StreamR(instance: *const c_void, dst: *mut c_void, rtype: i32, alpha: f64, beta: f64, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_GpuMat_assignTo_const_GpuMatR_int(instance: *const c_void, m: *mut c_void, typ: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_GpuMat_assignTo_const_GpuMatR(instance: *const c_void, m: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_GpuMat_convertTo_const_const__OutputArrayR_int(instance: *const c_void, dst: *const c_void, rtype: i32, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_GpuMat_convertTo_const_const__OutputArrayR_int_StreamR(instance: *const c_void, dst: *const c_void, rtype: i32, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_GpuMat_convertTo_const_GpuMatR_int_StreamR(instance: *const c_void, dst: *mut c_void, rtype: i32, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_GpuMat_convertTo_const_const__OutputArrayR_int_double_double(instance: *const c_void, dst: *const c_void, rtype: i32, alpha: f64, beta: f64, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_GpuMat_convertTo_const_const__OutputArrayR_int_double(instance: *const c_void, dst: *const c_void, rtype: i32, alpha: f64, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_GpuMat_convertTo_const_GpuMatR_int_double_double(instance: *const c_void, dst: *mut c_void, rtype: i32, alpha: f64, beta: f64, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_GpuMat_convertTo_const_GpuMatR_int(instance: *const c_void, dst: *mut c_void, rtype: i32, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_GpuMat_convertTo_const_const__OutputArrayR_int_double_StreamR(instance: *const c_void, dst: *const c_void, rtype: i32, alpha: f64, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_GpuMat_convertTo_const_const__OutputArrayR_int_double_double_StreamR(instance: *const c_void, dst: *const c_void, rtype: i32, alpha: f64, beta: f64, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_GpuMat_convertTo_const_GpuMatR_int_double_double_StreamR(instance: *const c_void, dst: *mut c_void, rtype: i32, alpha: f64, beta: f64, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_GpuMat_assignTo_const_GpuMatR_int(instance: *const c_void, m: *mut c_void, typ: i32, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_GpuMat_assignTo_const_GpuMatR(instance: *const c_void, m: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_cuda_GpuMat_ptr_int(instance: *mut c_void, y: i32, ocvrs_return: *mut Result<*mut u8>); pub fn cv_cuda_GpuMat_ptr(instance: *mut c_void, ocvrs_return: *mut Result<*mut u8>); pub fn cv_cuda_GpuMat_ptr_const_int(instance: *const c_void, y: i32, ocvrs_return: *mut Result<*const u8>); @@ -2371,7 +2357,7 @@ mod core_sys { pub fn cv_cuda_GpuMat_reshape_int(instance: *mut c_void, cn: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_GpuMat_reshape_const_int(instance: *const c_void, cn: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_GpuMat_reshape_int_int(instance: *mut c_void, cn: i32, rows: i32, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_cuda_GpuMat_locateROI_const_SizeR_PointR(instance: *const c_void, whole_size: *mut core::Size, ofs: *mut core::Point, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_GpuMat_locateROI_const_SizeR_PointR(instance: *const c_void, whole_size: *mut core::Size, ofs: *mut core::Point, ocvrs_return: *mut Result<()>); pub fn cv_cuda_GpuMat_adjustROI_int_int_int_int(instance: *mut c_void, dtop: i32, dbottom: i32, dleft: i32, dright: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_GpuMat_isContinuous_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_cuda_GpuMat_elemSize_const(instance: *const c_void, ocvrs_return: *mut Result); @@ -2383,7 +2369,7 @@ mod core_sys { pub fn cv_cuda_GpuMat_size_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_cuda_GpuMat_empty_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_cuda_GpuMat_cudaPtr_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_cuda_GpuMat_updateContinuityFlag(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_GpuMat_updateContinuityFlag(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_cuda_GpuMat_propFlags_const(instance: *const c_void) -> i32; pub fn cv_cuda_GpuMat_propFlags_const_int(instance: *mut c_void, val: i32); pub fn cv_cuda_GpuMat_propRows_const(instance: *const c_void) -> i32; @@ -2406,14 +2392,14 @@ mod core_sys { pub fn cv_cuda_GpuMat_propAllocator_AllocatorX(instance: *mut c_void, val: *const c_void); pub fn cv_cuda_GpuMat_delete(instance: *mut c_void); pub fn cv_cuda_GpuMat_Allocator_allocate_GpuMatX_int_int_size_t(instance: *mut c_void, mat: *mut c_void, rows: i32, cols: i32, elem_size: size_t, ocvrs_return: *mut Result); - pub fn cv_cuda_GpuMat_Allocator_free_GpuMatX(instance: *mut c_void, mat: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_GpuMat_Allocator_free_GpuMatX(instance: *mut c_void, mat: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_cuda_GpuMat_Allocator_delete(instance: *mut c_void); pub fn cv_cuda_GpuMatND_GpuMatND(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_GpuMatND_GpuMatND_SizeArray_int(size: *mut c_void, typ: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_GpuMatND_GpuMatND_SizeArray_int_voidX_StepArray(size: *mut c_void, typ: i32, data: *mut c_void, step: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_GpuMatND_GpuMatND_SizeArray_int_voidX(size: *mut c_void, typ: i32, data: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_cuda_GpuMatND_create_SizeArray_int(instance: *mut c_void, size: *mut c_void, typ: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_GpuMatND_release(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_GpuMatND_create_SizeArray_int(instance: *mut c_void, size: *mut c_void, typ: i32, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_GpuMatND_release(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_cuda_GpuMatND_swap_GpuMatNDR(instance: *mut c_void, m: *mut c_void); pub fn cv_cuda_GpuMatND_clone_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_GpuMatND_clone_const_StreamR(instance: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); @@ -2430,10 +2416,10 @@ mod core_sys { pub fn cv_cuda_GpuMatND_operatorST_const_GpuMatNDR(instance: *mut c_void, unnamed: *const c_void); pub fn cv_cuda_GpuMatND_GpuMatND_GpuMatNDRR(unnamed: *mut c_void) -> *mut c_void; pub fn cv_cuda_GpuMatND_operatorST_GpuMatNDRR(instance: *mut c_void, unnamed: *mut c_void); - pub fn cv_cuda_GpuMatND_upload_const__InputArrayR(instance: *mut c_void, src: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_GpuMatND_upload_const__InputArrayR_StreamR(instance: *mut c_void, src: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_GpuMatND_download_const_const__OutputArrayR(instance: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_GpuMatND_download_const_const__OutputArrayR_StreamR(instance: *const c_void, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_GpuMatND_upload_const__InputArrayR(instance: *mut c_void, src: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_GpuMatND_upload_const__InputArrayR_StreamR(instance: *mut c_void, src: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_GpuMatND_download_const_const__OutputArrayR(instance: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_GpuMatND_download_const_const__OutputArrayR_StreamR(instance: *const c_void, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_cuda_GpuMatND_isContinuous_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_cuda_GpuMatND_isSubmatrix_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_cuda_GpuMatND_elemSize_const(instance: *const c_void, ocvrs_return: *mut Result); @@ -2462,14 +2448,14 @@ mod core_sys { pub fn cv_cuda_HostMem_HostMem_Size_int(size: *const core::Size, typ: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_HostMem_HostMem_const__InputArrayR_AllocType(arr: *const c_void, alloc_type: core::HostMem_AllocType, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_HostMem_HostMem_const__InputArrayR(arr: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_cuda_HostMem_operatorST_const_HostMemR(instance: *mut c_void, m: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_HostMem_swap_HostMemR(instance: *mut c_void, b: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_HostMem_operatorST_const_HostMemR(instance: *mut c_void, m: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_HostMem_swap_HostMemR(instance: *mut c_void, b: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_cuda_HostMem_clone_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_cuda_HostMem_create_int_int_int(instance: *mut c_void, rows: i32, cols: i32, typ: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_HostMem_create_Size_int(instance: *mut c_void, size: *const core::Size, typ: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_HostMem_create_int_int_int(instance: *mut c_void, rows: i32, cols: i32, typ: i32, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_HostMem_create_Size_int(instance: *mut c_void, size: *const core::Size, typ: i32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_HostMem_reshape_const_int_int(instance: *const c_void, cn: i32, rows: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_HostMem_reshape_const_int(instance: *const c_void, cn: i32, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_cuda_HostMem_release(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_HostMem_release(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_cuda_HostMem_createMatHeader_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_HostMem_createGpuMatHeader_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_HostMem_isContinuous_const(instance: *const c_void, ocvrs_return: *mut Result); @@ -2506,9 +2492,9 @@ mod core_sys { pub fn cv_cuda_Stream_Stream_const_PtrLAllocatorGR(allocator: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_Stream_Stream_const_size_t(cuda_flags: size_t, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_Stream_queryIfComplete_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_Stream_waitForCompletion(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_Stream_waitEvent_const_EventR(instance: *mut c_void, event: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_Stream_enqueueHostCallback_StreamCallback_voidX(instance: *mut c_void, callback: Option ()>, user_data: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_Stream_waitForCompletion(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_Stream_waitEvent_const_EventR(instance: *mut c_void, event: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_Stream_enqueueHostCallback_StreamCallback_voidX(instance: *mut c_void, callback: Option ()>, user_data: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_cuda_Stream_Null(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_Stream_cudaPtr_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_Stream_delete(instance: *mut c_void); @@ -2540,7 +2526,7 @@ mod core_sys { pub fn cv_instr_NodeData_NodeData_const_charX_const_charX_int_voidX_bool_TYPE_IMPL(fun_name: *const c_char, file_name: *const c_char, line_num: i32, ret_address: *mut c_void, always_expand: bool, instr_type: core::TYPE, impl_type: core::IMPL, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_instr_NodeData_NodeData(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_instr_NodeData_NodeData_NodeDataR(ref_: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_instr_NodeData_operatorST_const_NodeDataR(instance: *mut c_void, unnamed: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_instr_NodeData_operatorST_const_NodeDataR(instance: *mut c_void, unnamed: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_instr_NodeData_getTotalMs_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_instr_NodeData_getMeanMs_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_instr_NodeData_propM_funName_const(instance: *const c_void) -> *mut c_void; @@ -2571,7 +2557,7 @@ mod core_sys { pub fn cv_ocl_Context_Context() -> *mut c_void; pub fn cv_ocl_Context_Context_int(dtype: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ocl_Context_Context_const_ContextR(c: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_ocl_Context_operatorST_const_ContextR(instance: *mut c_void, c: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ocl_Context_operatorST_const_ContextR(instance: *mut c_void, c: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_ocl_Context_Context_ContextRR(c: *mut c_void) -> *mut c_void; pub fn cv_ocl_Context_operatorST_ContextRR(instance: *mut c_void, c: *mut c_void); pub fn cv_ocl_Context_create(instance: *mut c_void, ocvrs_return: *mut Result); @@ -2579,17 +2565,17 @@ mod core_sys { pub fn cv_ocl_Context_ndevices_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_ocl_Context_device_const_size_t(instance: *const c_void, idx: size_t, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ocl_Context_getProg_const_ProgramSourceR_const_StringR_StringR(instance: *mut c_void, prog: *const c_void, buildopt: *const c_char, errmsg: *mut *mut c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_ocl_Context_unloadProg_ProgramR(instance: *mut c_void, prog: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ocl_Context_unloadProg_ProgramR(instance: *mut c_void, prog: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_ocl_Context_getDefault_bool(initialize: bool, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ocl_Context_getDefault(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ocl_Context_ptr_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ocl_Context_getOpenCLContextProperty_const_int(instance: *const c_void, property_id: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ocl_Context_useSVM_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ocl_Context_setUseSVM_bool(instance: *mut c_void, enabled: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_ocl_Context_setUseSVM_bool(instance: *mut c_void, enabled: bool, ocvrs_return: *mut Result<()>); pub fn cv_ocl_Context_fromHandle_voidX(context: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ocl_Context_fromDevice_const_DeviceR(device: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ocl_Context_create_const_stringR(configuration: *const c_char, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_ocl_Context_release(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ocl_Context_release(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_ocl_Context_empty_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_ocl_Context_delete(instance: *mut c_void); pub fn cv_ocl_Context_UserContext_defaultNew_const() -> *mut c_void; @@ -2597,10 +2583,10 @@ mod core_sys { pub fn cv_ocl_Device_Device() -> *mut c_void; pub fn cv_ocl_Device_Device_voidX(d: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ocl_Device_Device_const_DeviceR(d: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_ocl_Device_operatorST_const_DeviceR(instance: *mut c_void, d: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ocl_Device_operatorST_const_DeviceR(instance: *mut c_void, d: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_ocl_Device_Device_DeviceRR(d: *mut c_void) -> *mut c_void; pub fn cv_ocl_Device_operatorST_DeviceRR(instance: *mut c_void, d: *mut c_void); - pub fn cv_ocl_Device_set_voidX(instance: *mut c_void, d: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ocl_Device_set_voidX(instance: *mut c_void, d: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_ocl_Device_name_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ocl_Device_extensions_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ocl_Device_isExtensionSupported_const_const_StringR(instance: *const c_void, extension_name: *const c_char, ocvrs_return: *mut Result); @@ -2659,7 +2645,7 @@ mod core_sys { pub fn cv_ocl_Device_maxSamplers_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_ocl_Device_maxWorkGroupSize_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_ocl_Device_maxWorkItemDims_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ocl_Device_maxWorkItemSizes_const_size_tX(instance: *const c_void, unnamed: *mut size_t, ocvrs_return: *mut ResultVoid); + pub fn cv_ocl_Device_maxWorkItemSizes_const_size_tX(instance: *const c_void, unnamed: *mut size_t, ocvrs_return: *mut Result<()>); pub fn cv_ocl_Device_memBaseAddrAlign_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_ocl_Device_nativeVectorWidthChar_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_ocl_Device_nativeVectorWidthShort_const(instance: *const c_void, ocvrs_return: *mut Result); @@ -2686,7 +2672,7 @@ mod core_sys { pub fn cv_ocl_Image2D_Image2D_const_UMatR_bool_bool(src: *const c_void, norm: bool, alias: bool, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ocl_Image2D_Image2D_const_UMatR(src: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ocl_Image2D_Image2D_const_Image2DR(i: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_ocl_Image2D_operatorST_const_Image2DR(instance: *mut c_void, i: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ocl_Image2D_operatorST_const_Image2DR(instance: *mut c_void, i: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_ocl_Image2D_Image2D_Image2DRR(unnamed: *mut c_void) -> *mut c_void; pub fn cv_ocl_Image2D_operatorST_Image2DRR(instance: *mut c_void, unnamed: *mut c_void); pub fn cv_ocl_Image2D_canCreateAlias_const_UMatR(u: *const c_void, ocvrs_return: *mut Result); @@ -2698,7 +2684,7 @@ mod core_sys { pub fn cv_ocl_Kernel_Kernel_const_charX_const_ProgramSourceR_const_StringR_StringX(kname: *const c_char, prog: *const c_void, buildopts: *const c_char, errmsg: *mut *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ocl_Kernel_Kernel_const_charX_const_ProgramSourceR(kname: *const c_char, prog: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ocl_Kernel_Kernel_const_KernelR(k: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_ocl_Kernel_operatorST_const_KernelR(instance: *mut c_void, k: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ocl_Kernel_operatorST_const_KernelR(instance: *mut c_void, k: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_ocl_Kernel_Kernel_KernelRR(k: *mut c_void) -> *mut c_void; pub fn cv_ocl_Kernel_operatorST_KernelRR(instance: *mut c_void, k: *mut c_void); pub fn cv_ocl_Kernel_empty_const(instance: *const c_void, ocvrs_return: *mut Result); @@ -2764,21 +2750,21 @@ mod core_sys { pub fn cv_ocl_OpenCLExecutionContext_getDevice_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ocl_OpenCLExecutionContext_getQueue_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ocl_OpenCLExecutionContext_useOpenCL_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ocl_OpenCLExecutionContext_setUseOpenCL_bool(instance: *mut c_void, flag: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_ocl_OpenCLExecutionContext_setUseOpenCL_bool(instance: *mut c_void, flag: bool, ocvrs_return: *mut Result<()>); pub fn cv_ocl_OpenCLExecutionContext_getCurrent(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ocl_OpenCLExecutionContext_getCurrentRef(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_ocl_OpenCLExecutionContext_bind_const(instance: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ocl_OpenCLExecutionContext_bind_const(instance: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_ocl_OpenCLExecutionContext_cloneWithNewQueue_const_const_QueueR(instance: *const c_void, q: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ocl_OpenCLExecutionContext_cloneWithNewQueue_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ocl_OpenCLExecutionContext_create_const_stringR_voidX_voidX_voidX(platform_name: *const c_char, platform_id: *mut c_void, context: *mut c_void, device_id: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ocl_OpenCLExecutionContext_create_const_ContextR_const_DeviceR_const_QueueR(context: *const c_void, device: *const c_void, queue: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ocl_OpenCLExecutionContext_create_const_ContextR_const_DeviceR(context: *const c_void, device: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ocl_OpenCLExecutionContext_empty_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ocl_OpenCLExecutionContext_release(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ocl_OpenCLExecutionContext_release(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_ocl_OpenCLExecutionContext_delete(instance: *mut c_void); pub fn cv_ocl_Platform_Platform() -> *mut c_void; pub fn cv_ocl_Platform_Platform_const_PlatformR(p: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_ocl_Platform_operatorST_const_PlatformR(instance: *mut c_void, p: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ocl_Platform_operatorST_const_PlatformR(instance: *mut c_void, p: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_ocl_Platform_Platform_PlatformRR(p: *mut c_void) -> *mut c_void; pub fn cv_ocl_Platform_operatorST_PlatformRR(instance: *mut c_void, p: *mut c_void); pub fn cv_ocl_Platform_ptr_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); @@ -2788,7 +2774,7 @@ mod core_sys { pub fn cv_ocl_PlatformInfo_PlatformInfo() -> *mut c_void; pub fn cv_ocl_PlatformInfo_PlatformInfo_voidX(id: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ocl_PlatformInfo_PlatformInfo_const_PlatformInfoR(i: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_ocl_PlatformInfo_operatorST_const_PlatformInfoR(instance: *mut c_void, i: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ocl_PlatformInfo_operatorST_const_PlatformInfoR(instance: *mut c_void, i: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_ocl_PlatformInfo_PlatformInfo_PlatformInfoRR(i: *mut c_void) -> *mut c_void; pub fn cv_ocl_PlatformInfo_operatorST_PlatformInfoRR(instance: *mut c_void, i: *mut c_void); pub fn cv_ocl_PlatformInfo_name_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); @@ -2797,18 +2783,18 @@ mod core_sys { pub fn cv_ocl_PlatformInfo_versionMajor_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_ocl_PlatformInfo_versionMinor_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_ocl_PlatformInfo_deviceNumber_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ocl_PlatformInfo_getDevice_const_DeviceR_int(instance: *const c_void, device: *mut c_void, d: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_ocl_PlatformInfo_getDevice_const_DeviceR_int(instance: *const c_void, device: *mut c_void, d: i32, ocvrs_return: *mut Result<()>); pub fn cv_ocl_PlatformInfo_empty_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_ocl_PlatformInfo_delete(instance: *mut c_void); pub fn cv_ocl_Program_Program() -> *mut c_void; pub fn cv_ocl_Program_Program_const_ProgramSourceR_const_StringR_StringR(src: *const c_void, buildflags: *const c_char, errmsg: *mut *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ocl_Program_Program_const_ProgramR(prog: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_ocl_Program_operatorST_const_ProgramR(instance: *mut c_void, prog: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ocl_Program_operatorST_const_ProgramR(instance: *mut c_void, prog: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_ocl_Program_Program_ProgramRR(prog: *mut c_void) -> *mut c_void; pub fn cv_ocl_Program_operatorST_ProgramRR(instance: *mut c_void, prog: *mut c_void); pub fn cv_ocl_Program_create_const_ProgramSourceR_const_StringR_StringR(instance: *mut c_void, src: *const c_void, buildflags: *const c_char, errmsg: *mut *mut c_void, ocvrs_return: *mut Result); pub fn cv_ocl_Program_ptr_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_ocl_Program_getBinary_const_vectorLcharGR(instance: *const c_void, binary: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ocl_Program_getBinary_const_vectorLcharGR(instance: *const c_void, binary: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_ocl_Program_empty_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_ocl_Program_read_const_StringR_const_StringR(instance: *mut c_void, buf: *const c_char, buildflags: *const c_char, ocvrs_return: *mut Result); pub fn cv_ocl_Program_write_const_StringR(instance: *const c_void, buf: *mut *mut c_void, ocvrs_return: *mut Result); @@ -2820,7 +2806,7 @@ mod core_sys { pub fn cv_ocl_ProgramSource_ProgramSource_const_StringR_const_StringR_const_StringR_const_StringR(module: *const c_char, name: *const c_char, code_str: *const c_char, code_hash: *const c_char, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ocl_ProgramSource_ProgramSource_const_StringR(prog: *const c_char, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ocl_ProgramSource_ProgramSource_const_ProgramSourceR(prog: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_ocl_ProgramSource_operatorST_const_ProgramSourceR(instance: *mut c_void, prog: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ocl_ProgramSource_operatorST_const_ProgramSourceR(instance: *mut c_void, prog: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_ocl_ProgramSource_ProgramSource_ProgramSourceRR(prog: *mut c_void) -> *mut c_void; pub fn cv_ocl_ProgramSource_operatorST_ProgramSourceRR(instance: *mut c_void, prog: *mut c_void); pub fn cv_ocl_ProgramSource_source_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); @@ -2835,34 +2821,34 @@ mod core_sys { pub fn cv_ocl_Queue_Queue_const_ContextR_const_DeviceR(c: *const c_void, d: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ocl_Queue_Queue_const_ContextR(c: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ocl_Queue_Queue_const_QueueR(q: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_ocl_Queue_operatorST_const_QueueR(instance: *mut c_void, q: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ocl_Queue_operatorST_const_QueueR(instance: *mut c_void, q: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_ocl_Queue_Queue_QueueRR(q: *mut c_void) -> *mut c_void; pub fn cv_ocl_Queue_operatorST_QueueRR(instance: *mut c_void, q: *mut c_void); pub fn cv_ocl_Queue_create_const_ContextR_const_DeviceR(instance: *mut c_void, c: *const c_void, d: *const c_void, ocvrs_return: *mut Result); pub fn cv_ocl_Queue_create(instance: *mut c_void, ocvrs_return: *mut Result); - pub fn cv_ocl_Queue_finish(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ocl_Queue_finish(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_ocl_Queue_ptr_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ocl_Queue_getDefault(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ocl_Queue_getProfilingQueue_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ocl_Queue_empty_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_ocl_Queue_delete(instance: *mut c_void); pub fn cv_ocl_Timer_Timer_const_QueueR(q: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_ocl_Timer_start(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ocl_Timer_stop(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ocl_Timer_start(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ocl_Timer_stop(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_ocl_Timer_durationNS_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_ocl_Timer_delete(instance: *mut c_void); pub fn cv_ogl_Arrays_Arrays(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_ogl_Arrays_setVertexArray_const__InputArrayR(instance: *mut c_void, vertex: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ogl_Arrays_resetVertexArray(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ogl_Arrays_setColorArray_const__InputArrayR(instance: *mut c_void, color: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ogl_Arrays_resetColorArray(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ogl_Arrays_setNormalArray_const__InputArrayR(instance: *mut c_void, normal: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ogl_Arrays_resetNormalArray(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ogl_Arrays_setTexCoordArray_const__InputArrayR(instance: *mut c_void, tex_coord: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ogl_Arrays_resetTexCoordArray(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ogl_Arrays_release(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ogl_Arrays_setAutoRelease_bool(instance: *mut c_void, flag: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_ogl_Arrays_bind_const(instance: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ogl_Arrays_setVertexArray_const__InputArrayR(instance: *mut c_void, vertex: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ogl_Arrays_resetVertexArray(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ogl_Arrays_setColorArray_const__InputArrayR(instance: *mut c_void, color: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ogl_Arrays_resetColorArray(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ogl_Arrays_setNormalArray_const__InputArrayR(instance: *mut c_void, normal: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ogl_Arrays_resetNormalArray(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ogl_Arrays_setTexCoordArray_const__InputArrayR(instance: *mut c_void, tex_coord: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ogl_Arrays_resetTexCoordArray(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ogl_Arrays_release(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ogl_Arrays_setAutoRelease_bool(instance: *mut c_void, flag: bool, ocvrs_return: *mut Result<()>); + pub fn cv_ogl_Arrays_bind_const(instance: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_ogl_Arrays_size_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_ogl_Arrays_empty_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_ogl_Arrays_delete(instance: *mut c_void); @@ -2877,28 +2863,28 @@ mod core_sys { pub fn cv_ogl_Buffer_Buffer_Size_int(asize: *const core::Size, atype: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ogl_Buffer_Buffer_const__InputArrayR_Target_bool(arr: *const c_void, target: core::Buffer_Target, auto_release: bool, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ogl_Buffer_Buffer_const__InputArrayR(arr: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_ogl_Buffer_create_int_int_int_Target_bool(instance: *mut c_void, arows: i32, acols: i32, atype: i32, target: core::Buffer_Target, auto_release: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_ogl_Buffer_create_int_int_int(instance: *mut c_void, arows: i32, acols: i32, atype: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_ogl_Buffer_create_Size_int_Target_bool(instance: *mut c_void, asize: *const core::Size, atype: i32, target: core::Buffer_Target, auto_release: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_ogl_Buffer_create_Size_int(instance: *mut c_void, asize: *const core::Size, atype: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_ogl_Buffer_release(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ogl_Buffer_setAutoRelease_bool(instance: *mut c_void, flag: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_ogl_Buffer_copyFrom_const__InputArrayR_Target_bool(instance: *mut c_void, arr: *const c_void, target: core::Buffer_Target, auto_release: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_ogl_Buffer_copyFrom_const__InputArrayR(instance: *mut c_void, arr: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ogl_Buffer_copyFrom_const__InputArrayR_StreamR_Target_bool(instance: *mut c_void, arr: *const c_void, stream: *mut c_void, target: core::Buffer_Target, auto_release: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_ogl_Buffer_copyFrom_const__InputArrayR_StreamR(instance: *mut c_void, arr: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ogl_Buffer_copyTo_const_const__OutputArrayR(instance: *const c_void, arr: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ogl_Buffer_copyTo_const_const__OutputArrayR_StreamR(instance: *const c_void, arr: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ogl_Buffer_create_int_int_int_Target_bool(instance: *mut c_void, arows: i32, acols: i32, atype: i32, target: core::Buffer_Target, auto_release: bool, ocvrs_return: *mut Result<()>); + pub fn cv_ogl_Buffer_create_int_int_int(instance: *mut c_void, arows: i32, acols: i32, atype: i32, ocvrs_return: *mut Result<()>); + pub fn cv_ogl_Buffer_create_Size_int_Target_bool(instance: *mut c_void, asize: *const core::Size, atype: i32, target: core::Buffer_Target, auto_release: bool, ocvrs_return: *mut Result<()>); + pub fn cv_ogl_Buffer_create_Size_int(instance: *mut c_void, asize: *const core::Size, atype: i32, ocvrs_return: *mut Result<()>); + pub fn cv_ogl_Buffer_release(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ogl_Buffer_setAutoRelease_bool(instance: *mut c_void, flag: bool, ocvrs_return: *mut Result<()>); + pub fn cv_ogl_Buffer_copyFrom_const__InputArrayR_Target_bool(instance: *mut c_void, arr: *const c_void, target: core::Buffer_Target, auto_release: bool, ocvrs_return: *mut Result<()>); + pub fn cv_ogl_Buffer_copyFrom_const__InputArrayR(instance: *mut c_void, arr: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ogl_Buffer_copyFrom_const__InputArrayR_StreamR_Target_bool(instance: *mut c_void, arr: *const c_void, stream: *mut c_void, target: core::Buffer_Target, auto_release: bool, ocvrs_return: *mut Result<()>); + pub fn cv_ogl_Buffer_copyFrom_const__InputArrayR_StreamR(instance: *mut c_void, arr: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ogl_Buffer_copyTo_const_const__OutputArrayR(instance: *const c_void, arr: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ogl_Buffer_copyTo_const_const__OutputArrayR_StreamR(instance: *const c_void, arr: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_ogl_Buffer_clone_const_Target_bool(instance: *const c_void, target: core::Buffer_Target, auto_release: bool, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ogl_Buffer_clone_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_ogl_Buffer_bind_const_Target(instance: *const c_void, target: core::Buffer_Target, ocvrs_return: *mut ResultVoid); - pub fn cv_ogl_Buffer_unbind_Target(target: core::Buffer_Target, ocvrs_return: *mut ResultVoid); + pub fn cv_ogl_Buffer_bind_const_Target(instance: *const c_void, target: core::Buffer_Target, ocvrs_return: *mut Result<()>); + pub fn cv_ogl_Buffer_unbind_Target(target: core::Buffer_Target, ocvrs_return: *mut Result<()>); pub fn cv_ogl_Buffer_mapHost_Access(instance: *mut c_void, access: core::Buffer_Access, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_ogl_Buffer_unmapHost(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ogl_Buffer_unmapHost(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_ogl_Buffer_mapDevice(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_ogl_Buffer_unmapDevice(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ogl_Buffer_unmapDevice(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_ogl_Buffer_mapDevice_StreamR(instance: *mut c_void, stream: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_ogl_Buffer_unmapDevice_StreamR(instance: *mut c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ogl_Buffer_unmapDevice_StreamR(instance: *mut c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_ogl_Buffer_rows_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_ogl_Buffer_cols_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_ogl_Buffer_size_const(instance: *const c_void, ocvrs_return: *mut Result); @@ -2921,17 +2907,17 @@ mod core_sys { pub fn cv_ogl_Texture2D_Texture2D_Size_Format(asize: *const core::Size, aformat: core::Texture2D_Format, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ogl_Texture2D_Texture2D_const__InputArrayR_bool(arr: *const c_void, auto_release: bool, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ogl_Texture2D_Texture2D_const__InputArrayR(arr: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_ogl_Texture2D_create_int_int_Format_bool(instance: *mut c_void, arows: i32, acols: i32, aformat: core::Texture2D_Format, auto_release: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_ogl_Texture2D_create_int_int_Format(instance: *mut c_void, arows: i32, acols: i32, aformat: core::Texture2D_Format, ocvrs_return: *mut ResultVoid); - pub fn cv_ogl_Texture2D_create_Size_Format_bool(instance: *mut c_void, asize: *const core::Size, aformat: core::Texture2D_Format, auto_release: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_ogl_Texture2D_create_Size_Format(instance: *mut c_void, asize: *const core::Size, aformat: core::Texture2D_Format, ocvrs_return: *mut ResultVoid); - pub fn cv_ogl_Texture2D_release(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ogl_Texture2D_setAutoRelease_bool(instance: *mut c_void, flag: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_ogl_Texture2D_copyFrom_const__InputArrayR_bool(instance: *mut c_void, arr: *const c_void, auto_release: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_ogl_Texture2D_copyFrom_const__InputArrayR(instance: *mut c_void, arr: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ogl_Texture2D_copyTo_const_const__OutputArrayR_int_bool(instance: *const c_void, arr: *const c_void, ddepth: i32, auto_release: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_ogl_Texture2D_copyTo_const_const__OutputArrayR(instance: *const c_void, arr: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ogl_Texture2D_bind_const(instance: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ogl_Texture2D_create_int_int_Format_bool(instance: *mut c_void, arows: i32, acols: i32, aformat: core::Texture2D_Format, auto_release: bool, ocvrs_return: *mut Result<()>); + pub fn cv_ogl_Texture2D_create_int_int_Format(instance: *mut c_void, arows: i32, acols: i32, aformat: core::Texture2D_Format, ocvrs_return: *mut Result<()>); + pub fn cv_ogl_Texture2D_create_Size_Format_bool(instance: *mut c_void, asize: *const core::Size, aformat: core::Texture2D_Format, auto_release: bool, ocvrs_return: *mut Result<()>); + pub fn cv_ogl_Texture2D_create_Size_Format(instance: *mut c_void, asize: *const core::Size, aformat: core::Texture2D_Format, ocvrs_return: *mut Result<()>); + pub fn cv_ogl_Texture2D_release(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ogl_Texture2D_setAutoRelease_bool(instance: *mut c_void, flag: bool, ocvrs_return: *mut Result<()>); + pub fn cv_ogl_Texture2D_copyFrom_const__InputArrayR_bool(instance: *mut c_void, arr: *const c_void, auto_release: bool, ocvrs_return: *mut Result<()>); + pub fn cv_ogl_Texture2D_copyFrom_const__InputArrayR(instance: *mut c_void, arr: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ogl_Texture2D_copyTo_const_const__OutputArrayR_int_bool(instance: *const c_void, arr: *const c_void, ddepth: i32, auto_release: bool, ocvrs_return: *mut Result<()>); + pub fn cv_ogl_Texture2D_copyTo_const_const__OutputArrayR(instance: *const c_void, arr: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ogl_Texture2D_bind_const(instance: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_ogl_Texture2D_rows_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_ogl_Texture2D_cols_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_ogl_Texture2D_size_const(instance: *const c_void, ocvrs_return: *mut Result); @@ -2941,14 +2927,8 @@ mod core_sys { pub fn cv_ogl_Texture2D_delete(instance: *mut c_void); pub fn cv_utils_ClassWithKeywordProperties_ClassWithKeywordProperties_int_int(lambda_arg: i32, except_arg: i32, ocvrs_return: *mut Result); pub fn cv_utils_ClassWithKeywordProperties_ClassWithKeywordProperties(ocvrs_return: *mut Result); - pub fn cv_utils_FunctionParams_setLambda_int(instance: *mut c_void, value: i32) -> *mut c_void; - pub fn cv_utils_FunctionParams_setSigma_float(instance: *mut c_void, value: f32) -> *mut c_void; - pub fn cv_utils_FunctionParams_defaultNew_const() -> *mut c_void; - pub fn cv_utils_FunctionParams_propLambda_const(instance: *const c_void) -> i32; - pub fn cv_utils_FunctionParams_propLambda_const_int(instance: *mut c_void, val: i32); - pub fn cv_utils_FunctionParams_propSigma_const(instance: *const c_void) -> f32; - pub fn cv_utils_FunctionParams_propSigma_const_float(instance: *mut c_void, val: f32); - pub fn cv_utils_FunctionParams_delete(instance: *mut c_void); + pub fn cv_utils_FunctionParams_setLambda_int(instance: *const core::FunctionParams, value: i32, ocvrs_return: *mut core::FunctionParams); + pub fn cv_utils_FunctionParams_setSigma_float(instance: *const core::FunctionParams, value: f32, ocvrs_return: *mut core::FunctionParams); pub fn cv_utils_logging_LogTag_LogTag_const_charX_LogLevel(_name: *const c_char, _level: core::LogLevel, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_utils_logging_LogTag_propName_const(instance: *const c_void) -> *mut c_void; pub fn cv_utils_logging_LogTag_propLevel_const(instance: *const c_void, ocvrs_return: *mut core::LogLevel); @@ -2998,6 +2978,11 @@ mod core_sys { pub fn cv_PtrLcv_cuda_GpuMat_AllocatorG_getInnerPtrMut(instance: *mut c_void) -> *mut c_void; pub fn cv_PtrLcv_cuda_GpuMat_AllocatorG_new_null_const() -> *mut c_void; pub fn cv_PtrLcv_cuda_GpuMat_AllocatorG_delete(instance: *mut c_void); + pub fn cv_PtrLcv_KeyPointG_getInnerPtr_const(instance: *const c_void) -> *mut c_void; + pub fn cv_PtrLcv_KeyPointG_getInnerPtrMut(instance: *mut c_void) -> *mut c_void; + pub fn cv_PtrLcv_KeyPointG_new_null_const() -> *mut c_void; + pub fn cv_PtrLcv_KeyPointG_delete(instance: *mut c_void); + pub fn cv_PtrLcv_KeyPointG_new_const_KeyPoint(val: *mut c_void) -> *mut c_void; pub fn cv_PtrLcv_MinProblemSolverG_getInnerPtr_const(instance: *const c_void) -> *mut c_void; pub fn cv_PtrLcv_MinProblemSolverG_getInnerPtrMut(instance: *mut c_void) -> *mut c_void; pub fn cv_PtrLcv_MinProblemSolverG_new_null_const() -> *mut c_void; @@ -4092,193 +4077,191 @@ mod core_sys { pub fn std_vectorLuint8_tG_inputOutputArray(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); } } -#[cfg(ocvrs_has_module_core)] pub use core_sys::*; -#[cfg(ocvrs_has_module_cudaarithm)] mod cudaarithm_sys { use super::*; extern "C" { pub fn cv_cuda_absSum_const__InputArrayR(src: *const c_void, ocvrs_return: *mut Result); pub fn cv_cuda_absSum_const__InputArrayR_const__InputArrayR(src: *const c_void, mask: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_abs_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_abs_const__InputArrayR_const__OutputArrayR_StreamR(src: *const c_void, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_absdiffWithScalar_const__InputArrayR_Scalar_const__OutputArrayR(src1: *const c_void, src2: *const core::Scalar, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_absdiffWithScalar_const__InputArrayR_Scalar_const__OutputArrayR_StreamR(src1: *const c_void, src2: *const core::Scalar, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_absdiff_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_absdiff_const__InputArrayR_const__InputArrayR_const__OutputArrayR_StreamR(src1: *const c_void, src2: *const c_void, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_addWeighted_const__InputArrayR_double_const__InputArrayR_double_double_const__OutputArrayR(src1: *const c_void, alpha: f64, src2: *const c_void, beta: f64, gamma: f64, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_addWeighted_const__InputArrayR_double_const__InputArrayR_double_double_const__OutputArrayR_int_StreamR(src1: *const c_void, alpha: f64, src2: *const c_void, beta: f64, gamma: f64, dst: *const c_void, dtype: i32, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_addWithScalar_const__InputArrayR_Scalar_const__OutputArrayR(src1: *const c_void, src2: *const core::Scalar, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_addWithScalar_const__InputArrayR_Scalar_const__OutputArrayR_const__InputArrayR_int_StreamR(src1: *const c_void, src2: *const core::Scalar, dst: *const c_void, mask: *const c_void, dtype: i32, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_add_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_add_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__InputArrayR_int_StreamR(src1: *const c_void, src2: *const c_void, dst: *const c_void, mask: *const c_void, dtype: i32, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_bitwise_and_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_bitwise_and_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__InputArrayR_StreamR(src1: *const c_void, src2: *const c_void, dst: *const c_void, mask: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_bitwise_and_with_scalar_const__InputArrayR_Scalar_const__OutputArrayR(src1: *const c_void, src2: *const core::Scalar, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_bitwise_and_with_scalar_const__InputArrayR_Scalar_const__OutputArrayR_const__InputArrayR_StreamR(src1: *const c_void, src2: *const core::Scalar, dst: *const c_void, mask: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_bitwise_not_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_bitwise_not_const__InputArrayR_const__OutputArrayR_const__InputArrayR_StreamR(src: *const c_void, dst: *const c_void, mask: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_bitwise_or_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_bitwise_or_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__InputArrayR_StreamR(src1: *const c_void, src2: *const c_void, dst: *const c_void, mask: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_bitwise_or_with_scalar_const__InputArrayR_Scalar_const__OutputArrayR(src1: *const c_void, src2: *const core::Scalar, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_bitwise_or_with_scalar_const__InputArrayR_Scalar_const__OutputArrayR_const__InputArrayR_StreamR(src1: *const c_void, src2: *const core::Scalar, dst: *const c_void, mask: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_bitwise_xor_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_bitwise_xor_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__InputArrayR_StreamR(src1: *const c_void, src2: *const c_void, dst: *const c_void, mask: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_bitwise_xor_with_scalar_const__InputArrayR_Scalar_const__OutputArrayR(src1: *const c_void, src2: *const core::Scalar, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_bitwise_xor_with_scalar_const__InputArrayR_Scalar_const__OutputArrayR_const__InputArrayR_StreamR(src1: *const c_void, src2: *const core::Scalar, dst: *const c_void, mask: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_calcAbsSum_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_calcAbsSum_const__InputArrayR_const__OutputArrayR_const__InputArrayR_StreamR(src: *const c_void, dst: *const c_void, mask: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_calcNormDiff_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_calcNormDiff_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int_StreamR(src1: *const c_void, src2: *const c_void, dst: *const c_void, norm_type: i32, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_calcNorm_const__InputArrayR_const__OutputArrayR_int(src: *const c_void, dst: *const c_void, norm_type: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_calcNorm_const__InputArrayR_const__OutputArrayR_int_const__InputArrayR_StreamR(src: *const c_void, dst: *const c_void, norm_type: i32, mask: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_calcSqrSum_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_calcSqrSum_const__InputArrayR_const__OutputArrayR_const__InputArrayR_StreamR(src: *const c_void, dst: *const c_void, mask: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_calcSum_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_calcSum_const__InputArrayR_const__OutputArrayR_const__InputArrayR_StreamR(src: *const c_void, dst: *const c_void, mask: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_cartToPolar_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(x: *const c_void, y: *const c_void, magnitude: *const c_void, angle: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_cartToPolar_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_bool_StreamR(x: *const c_void, y: *const c_void, magnitude: *const c_void, angle: *const c_void, angle_in_degrees: bool, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_cartToPolar_const__InputArrayR_const__OutputArrayR(xy: *const c_void, magnitude_angle: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_cartToPolar_const__InputArrayR_const__OutputArrayR_bool_StreamR(xy: *const c_void, magnitude_angle: *const c_void, angle_in_degrees: bool, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_cartToPolar_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(xy: *const c_void, magnitude: *const c_void, angle: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_cartToPolar_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_bool_StreamR(xy: *const c_void, magnitude: *const c_void, angle: *const c_void, angle_in_degrees: bool, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_compareWithScalar_const__InputArrayR_Scalar_const__OutputArrayR_int(src1: *const c_void, src2: *const core::Scalar, dst: *const c_void, cmpop: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_compareWithScalar_const__InputArrayR_Scalar_const__OutputArrayR_int_StreamR(src1: *const c_void, src2: *const core::Scalar, dst: *const c_void, cmpop: i32, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_compare_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int(src1: *const c_void, src2: *const c_void, dst: *const c_void, cmpop: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_compare_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int_StreamR(src1: *const c_void, src2: *const c_void, dst: *const c_void, cmpop: i32, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_copyMakeBorder_const__InputArrayR_const__OutputArrayR_int_int_int_int_int(src: *const c_void, dst: *const c_void, top: i32, bottom: i32, left: i32, right: i32, border_type: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_copyMakeBorder_const__InputArrayR_const__OutputArrayR_int_int_int_int_int_Scalar_StreamR(src: *const c_void, dst: *const c_void, top: i32, bottom: i32, left: i32, right: i32, border_type: i32, value: *const core::Scalar, stream: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_abs_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_abs_const__InputArrayR_const__OutputArrayR_StreamR(src: *const c_void, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_absdiffWithScalar_const__InputArrayR_Scalar_const__OutputArrayR(src1: *const c_void, src2: *const core::Scalar, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_absdiffWithScalar_const__InputArrayR_Scalar_const__OutputArrayR_StreamR(src1: *const c_void, src2: *const core::Scalar, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_absdiff_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_absdiff_const__InputArrayR_const__InputArrayR_const__OutputArrayR_StreamR(src1: *const c_void, src2: *const c_void, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_addWeighted_const__InputArrayR_double_const__InputArrayR_double_double_const__OutputArrayR(src1: *const c_void, alpha: f64, src2: *const c_void, beta: f64, gamma: f64, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_addWeighted_const__InputArrayR_double_const__InputArrayR_double_double_const__OutputArrayR_int_StreamR(src1: *const c_void, alpha: f64, src2: *const c_void, beta: f64, gamma: f64, dst: *const c_void, dtype: i32, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_addWithScalar_const__InputArrayR_Scalar_const__OutputArrayR(src1: *const c_void, src2: *const core::Scalar, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_addWithScalar_const__InputArrayR_Scalar_const__OutputArrayR_const__InputArrayR_int_StreamR(src1: *const c_void, src2: *const core::Scalar, dst: *const c_void, mask: *const c_void, dtype: i32, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_add_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_add_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__InputArrayR_int_StreamR(src1: *const c_void, src2: *const c_void, dst: *const c_void, mask: *const c_void, dtype: i32, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_bitwise_and_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_bitwise_and_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__InputArrayR_StreamR(src1: *const c_void, src2: *const c_void, dst: *const c_void, mask: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_bitwise_and_with_scalar_const__InputArrayR_Scalar_const__OutputArrayR(src1: *const c_void, src2: *const core::Scalar, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_bitwise_and_with_scalar_const__InputArrayR_Scalar_const__OutputArrayR_const__InputArrayR_StreamR(src1: *const c_void, src2: *const core::Scalar, dst: *const c_void, mask: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_bitwise_not_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_bitwise_not_const__InputArrayR_const__OutputArrayR_const__InputArrayR_StreamR(src: *const c_void, dst: *const c_void, mask: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_bitwise_or_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_bitwise_or_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__InputArrayR_StreamR(src1: *const c_void, src2: *const c_void, dst: *const c_void, mask: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_bitwise_or_with_scalar_const__InputArrayR_Scalar_const__OutputArrayR(src1: *const c_void, src2: *const core::Scalar, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_bitwise_or_with_scalar_const__InputArrayR_Scalar_const__OutputArrayR_const__InputArrayR_StreamR(src1: *const c_void, src2: *const core::Scalar, dst: *const c_void, mask: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_bitwise_xor_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_bitwise_xor_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__InputArrayR_StreamR(src1: *const c_void, src2: *const c_void, dst: *const c_void, mask: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_bitwise_xor_with_scalar_const__InputArrayR_Scalar_const__OutputArrayR(src1: *const c_void, src2: *const core::Scalar, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_bitwise_xor_with_scalar_const__InputArrayR_Scalar_const__OutputArrayR_const__InputArrayR_StreamR(src1: *const c_void, src2: *const core::Scalar, dst: *const c_void, mask: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_calcAbsSum_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_calcAbsSum_const__InputArrayR_const__OutputArrayR_const__InputArrayR_StreamR(src: *const c_void, dst: *const c_void, mask: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_calcNormDiff_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_calcNormDiff_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int_StreamR(src1: *const c_void, src2: *const c_void, dst: *const c_void, norm_type: i32, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_calcNorm_const__InputArrayR_const__OutputArrayR_int(src: *const c_void, dst: *const c_void, norm_type: i32, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_calcNorm_const__InputArrayR_const__OutputArrayR_int_const__InputArrayR_StreamR(src: *const c_void, dst: *const c_void, norm_type: i32, mask: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_calcSqrSum_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_calcSqrSum_const__InputArrayR_const__OutputArrayR_const__InputArrayR_StreamR(src: *const c_void, dst: *const c_void, mask: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_calcSum_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_calcSum_const__InputArrayR_const__OutputArrayR_const__InputArrayR_StreamR(src: *const c_void, dst: *const c_void, mask: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_cartToPolar_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(x: *const c_void, y: *const c_void, magnitude: *const c_void, angle: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_cartToPolar_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_bool_StreamR(x: *const c_void, y: *const c_void, magnitude: *const c_void, angle: *const c_void, angle_in_degrees: bool, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_cartToPolar_const__InputArrayR_const__OutputArrayR(xy: *const c_void, magnitude_angle: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_cartToPolar_const__InputArrayR_const__OutputArrayR_bool_StreamR(xy: *const c_void, magnitude_angle: *const c_void, angle_in_degrees: bool, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_cartToPolar_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(xy: *const c_void, magnitude: *const c_void, angle: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_cartToPolar_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_bool_StreamR(xy: *const c_void, magnitude: *const c_void, angle: *const c_void, angle_in_degrees: bool, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_compareWithScalar_const__InputArrayR_Scalar_const__OutputArrayR_int(src1: *const c_void, src2: *const core::Scalar, dst: *const c_void, cmpop: i32, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_compareWithScalar_const__InputArrayR_Scalar_const__OutputArrayR_int_StreamR(src1: *const c_void, src2: *const core::Scalar, dst: *const c_void, cmpop: i32, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_compare_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int(src1: *const c_void, src2: *const c_void, dst: *const c_void, cmpop: i32, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_compare_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int_StreamR(src1: *const c_void, src2: *const c_void, dst: *const c_void, cmpop: i32, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_copyMakeBorder_const__InputArrayR_const__OutputArrayR_int_int_int_int_int(src: *const c_void, dst: *const c_void, top: i32, bottom: i32, left: i32, right: i32, border_type: i32, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_copyMakeBorder_const__InputArrayR_const__OutputArrayR_int_int_int_int_int_Scalar_StreamR(src: *const c_void, dst: *const c_void, top: i32, bottom: i32, left: i32, right: i32, border_type: i32, value: *const core::Scalar, stream: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_cuda_countNonZero_const__InputArrayR(src: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_countNonZero_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_countNonZero_const__InputArrayR_const__OutputArrayR_StreamR(src: *const c_void, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_countNonZero_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_countNonZero_const__InputArrayR_const__OutputArrayR_StreamR(src: *const c_void, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_cuda_createConvolution(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_createConvolution_Size(user_block_size: *const core::Size, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_createDFT_Size_int(dft_size: *const core::Size, flags: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_createLookUpTable_const__InputArrayR(lut: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_cuda_dft_const__InputArrayR_const__OutputArrayR_Size(src: *const c_void, dst: *const c_void, dft_size: *const core::Size, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_dft_const__InputArrayR_const__OutputArrayR_Size_int_StreamR(src: *const c_void, dst: *const c_void, dft_size: *const core::Size, flags: i32, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_divideWithScalar_const__InputArrayR_Scalar_const__OutputArrayR(src1: *const c_void, src2: *const core::Scalar, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_divideWithScalar_const__InputArrayR_Scalar_const__OutputArrayR_double_int_StreamR(src1: *const c_void, src2: *const core::Scalar, dst: *const c_void, scale: f64, dtype: i32, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_divide_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_divide_const__InputArrayR_const__InputArrayR_const__OutputArrayR_double_int_StreamR(src1: *const c_void, src2: *const c_void, dst: *const c_void, scale: f64, dtype: i32, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_exp_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_exp_const__InputArrayR_const__OutputArrayR_StreamR(src: *const c_void, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_findMinMaxLoc_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(src: *const c_void, min_max_vals: *const c_void, loc: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_findMinMaxLoc_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__InputArrayR_StreamR(src: *const c_void, min_max_vals: *const c_void, loc: *const c_void, mask: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_findMinMax_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_findMinMax_const__InputArrayR_const__OutputArrayR_const__InputArrayR_StreamR(src: *const c_void, dst: *const c_void, mask: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_flip_const__InputArrayR_const__OutputArrayR_int(src: *const c_void, dst: *const c_void, flip_code: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_flip_const__InputArrayR_const__OutputArrayR_int_StreamR(src: *const c_void, dst: *const c_void, flip_code: i32, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_gemm_const__InputArrayR_const__InputArrayR_double_const__InputArrayR_double_const__OutputArrayR(src1: *const c_void, src2: *const c_void, alpha: f64, src3: *const c_void, beta: f64, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_gemm_const__InputArrayR_const__InputArrayR_double_const__InputArrayR_double_const__OutputArrayR_int_StreamR(src1: *const c_void, src2: *const c_void, alpha: f64, src3: *const c_void, beta: f64, dst: *const c_void, flags: i32, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_inRange_const__InputArrayR_const_ScalarR_const_ScalarR_const__OutputArrayR(src: *const c_void, lowerb: *const core::Scalar, upperb: *const core::Scalar, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_inRange_const__InputArrayR_const_ScalarR_const_ScalarR_const__OutputArrayR_StreamR(src: *const c_void, lowerb: *const core::Scalar, upperb: *const core::Scalar, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_integral_const__InputArrayR_const__OutputArrayR(src: *const c_void, sum: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_integral_const__InputArrayR_const__OutputArrayR_StreamR(src: *const c_void, sum: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_log_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_log_const__InputArrayR_const__OutputArrayR_StreamR(src: *const c_void, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_lshift_const__InputArrayR_Scalar_LintG_const__OutputArrayR(src: *const c_void, val: *const core::Scalar_, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_lshift_const__InputArrayR_Scalar_LintG_const__OutputArrayR_StreamR(src: *const c_void, val: *const core::Scalar_, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_lshift_const__InputArrayR_Scalar_const__OutputArrayR(src: *const c_void, val: *const core::Scalar, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_lshift_const__InputArrayR_Scalar_const__OutputArrayR_StreamR(src: *const c_void, val: *const core::Scalar, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_magnitudeSqr_const__InputArrayR_const__InputArrayR_const__OutputArrayR(x: *const c_void, y: *const c_void, magnitude: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_magnitudeSqr_const__InputArrayR_const__InputArrayR_const__OutputArrayR_StreamR(x: *const c_void, y: *const c_void, magnitude: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_magnitudeSqr_const__InputArrayR_const__OutputArrayR(xy: *const c_void, magnitude: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_magnitudeSqr_const__InputArrayR_const__OutputArrayR_StreamR(xy: *const c_void, magnitude: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_magnitude_const__InputArrayR_const__InputArrayR_const__OutputArrayR(x: *const c_void, y: *const c_void, magnitude: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_magnitude_const__InputArrayR_const__InputArrayR_const__OutputArrayR_StreamR(x: *const c_void, y: *const c_void, magnitude: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_magnitude_const__InputArrayR_const__OutputArrayR(xy: *const c_void, magnitude: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_magnitude_const__InputArrayR_const__OutputArrayR_StreamR(xy: *const c_void, magnitude: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_maxWithScalar_const__InputArrayR_Scalar_const__OutputArrayR(src1: *const c_void, src2: *const core::Scalar, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_maxWithScalar_const__InputArrayR_Scalar_const__OutputArrayR_StreamR(src1: *const c_void, src2: *const core::Scalar, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_max_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_max_const__InputArrayR_const__InputArrayR_const__OutputArrayR_StreamR(src1: *const c_void, src2: *const c_void, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_meanStdDev_const__InputArrayR_ScalarR_ScalarR(mtx: *const c_void, mean: *mut core::Scalar, stddev: *mut core::Scalar, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_meanStdDev_const__InputArrayR_ScalarR_ScalarR_const__InputArrayR(src: *const c_void, mean: *mut core::Scalar, stddev: *mut core::Scalar, mask: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_meanStdDev_const__InputArrayR_const__OutputArrayR(mtx: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_meanStdDev_const__InputArrayR_const__OutputArrayR_StreamR(mtx: *const c_void, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_meanStdDev_const__InputArrayR_const__OutputArrayR_const__InputArrayR(src: *const c_void, dst: *const c_void, mask: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_meanStdDev_const__InputArrayR_const__OutputArrayR_const__InputArrayR_StreamR(src: *const c_void, dst: *const c_void, mask: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_merge_const_GpuMatX_size_t_const__OutputArrayR(src: *const c_void, n: size_t, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_merge_const_GpuMatX_size_t_const__OutputArrayR_StreamR(src: *const c_void, n: size_t, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_merge_const_vectorLGpuMatGR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_merge_const_vectorLGpuMatGR_const__OutputArrayR_StreamR(src: *const c_void, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_minMaxLoc_const__InputArrayR_doubleX_doubleX_PointX_PointX(src: *const c_void, min_val: *mut f64, max_val: *mut f64, min_loc: *mut core::Point, max_loc: *mut core::Point, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_minMaxLoc_const__InputArrayR_doubleX_doubleX_PointX_PointX_const__InputArrayR(src: *const c_void, min_val: *mut f64, max_val: *mut f64, min_loc: *mut core::Point, max_loc: *mut core::Point, mask: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_minMax_const__InputArrayR_doubleX_doubleX(src: *const c_void, min_val: *mut f64, max_val: *mut f64, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_minMax_const__InputArrayR_doubleX_doubleX_const__InputArrayR(src: *const c_void, min_val: *mut f64, max_val: *mut f64, mask: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_minWithScalar_const__InputArrayR_Scalar_const__OutputArrayR(src1: *const c_void, src2: *const core::Scalar, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_minWithScalar_const__InputArrayR_Scalar_const__OutputArrayR_StreamR(src1: *const c_void, src2: *const core::Scalar, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_min_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_min_const__InputArrayR_const__InputArrayR_const__OutputArrayR_StreamR(src1: *const c_void, src2: *const c_void, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_mulAndScaleSpectrums_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int_float(src1: *const c_void, src2: *const c_void, dst: *const c_void, flags: i32, scale: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_mulAndScaleSpectrums_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int_float_bool_StreamR(src1: *const c_void, src2: *const c_void, dst: *const c_void, flags: i32, scale: f32, conj_b: bool, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_mulSpectrums_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int(src1: *const c_void, src2: *const c_void, dst: *const c_void, flags: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_mulSpectrums_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int_bool_StreamR(src1: *const c_void, src2: *const c_void, dst: *const c_void, flags: i32, conj_b: bool, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_multiplyWithScalar_const__InputArrayR_Scalar_const__OutputArrayR(src1: *const c_void, src2: *const core::Scalar, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_multiplyWithScalar_const__InputArrayR_Scalar_const__OutputArrayR_double_int_StreamR(src1: *const c_void, src2: *const core::Scalar, dst: *const c_void, scale: f64, dtype: i32, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_multiply_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_multiply_const__InputArrayR_const__InputArrayR_const__OutputArrayR_double_int_StreamR(src1: *const c_void, src2: *const c_void, dst: *const c_void, scale: f64, dtype: i32, stream: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_dft_const__InputArrayR_const__OutputArrayR_Size(src: *const c_void, dst: *const c_void, dft_size: *const core::Size, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_dft_const__InputArrayR_const__OutputArrayR_Size_int_StreamR(src: *const c_void, dst: *const c_void, dft_size: *const core::Size, flags: i32, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_divideWithScalar_const__InputArrayR_Scalar_const__OutputArrayR(src1: *const c_void, src2: *const core::Scalar, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_divideWithScalar_const__InputArrayR_Scalar_const__OutputArrayR_double_int_StreamR(src1: *const c_void, src2: *const core::Scalar, dst: *const c_void, scale: f64, dtype: i32, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_divide_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_divide_const__InputArrayR_const__InputArrayR_const__OutputArrayR_double_int_StreamR(src1: *const c_void, src2: *const c_void, dst: *const c_void, scale: f64, dtype: i32, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_exp_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_exp_const__InputArrayR_const__OutputArrayR_StreamR(src: *const c_void, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_findMinMaxLoc_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(src: *const c_void, min_max_vals: *const c_void, loc: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_findMinMaxLoc_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__InputArrayR_StreamR(src: *const c_void, min_max_vals: *const c_void, loc: *const c_void, mask: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_findMinMax_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_findMinMax_const__InputArrayR_const__OutputArrayR_const__InputArrayR_StreamR(src: *const c_void, dst: *const c_void, mask: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_flip_const__InputArrayR_const__OutputArrayR_int(src: *const c_void, dst: *const c_void, flip_code: i32, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_flip_const__InputArrayR_const__OutputArrayR_int_StreamR(src: *const c_void, dst: *const c_void, flip_code: i32, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_gemm_const__InputArrayR_const__InputArrayR_double_const__InputArrayR_double_const__OutputArrayR(src1: *const c_void, src2: *const c_void, alpha: f64, src3: *const c_void, beta: f64, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_gemm_const__InputArrayR_const__InputArrayR_double_const__InputArrayR_double_const__OutputArrayR_int_StreamR(src1: *const c_void, src2: *const c_void, alpha: f64, src3: *const c_void, beta: f64, dst: *const c_void, flags: i32, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_inRange_const__InputArrayR_const_ScalarR_const_ScalarR_const__OutputArrayR(src: *const c_void, lowerb: *const core::Scalar, upperb: *const core::Scalar, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_inRange_const__InputArrayR_const_ScalarR_const_ScalarR_const__OutputArrayR_StreamR(src: *const c_void, lowerb: *const core::Scalar, upperb: *const core::Scalar, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_integral_const__InputArrayR_const__OutputArrayR(src: *const c_void, sum: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_integral_const__InputArrayR_const__OutputArrayR_StreamR(src: *const c_void, sum: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_log_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_log_const__InputArrayR_const__OutputArrayR_StreamR(src: *const c_void, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_lshift_const__InputArrayR_Scalar_LintG_const__OutputArrayR(src: *const c_void, val: *const core::Scalar_, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_lshift_const__InputArrayR_Scalar_LintG_const__OutputArrayR_StreamR(src: *const c_void, val: *const core::Scalar_, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_lshift_const__InputArrayR_Scalar_const__OutputArrayR(src: *const c_void, val: *const core::Scalar, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_lshift_const__InputArrayR_Scalar_const__OutputArrayR_StreamR(src: *const c_void, val: *const core::Scalar, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_magnitudeSqr_const__InputArrayR_const__InputArrayR_const__OutputArrayR(x: *const c_void, y: *const c_void, magnitude: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_magnitudeSqr_const__InputArrayR_const__InputArrayR_const__OutputArrayR_StreamR(x: *const c_void, y: *const c_void, magnitude: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_magnitudeSqr_const__InputArrayR_const__OutputArrayR(xy: *const c_void, magnitude: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_magnitudeSqr_const__InputArrayR_const__OutputArrayR_StreamR(xy: *const c_void, magnitude: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_magnitude_const__InputArrayR_const__InputArrayR_const__OutputArrayR(x: *const c_void, y: *const c_void, magnitude: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_magnitude_const__InputArrayR_const__InputArrayR_const__OutputArrayR_StreamR(x: *const c_void, y: *const c_void, magnitude: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_magnitude_const__InputArrayR_const__OutputArrayR(xy: *const c_void, magnitude: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_magnitude_const__InputArrayR_const__OutputArrayR_StreamR(xy: *const c_void, magnitude: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_maxWithScalar_const__InputArrayR_Scalar_const__OutputArrayR(src1: *const c_void, src2: *const core::Scalar, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_maxWithScalar_const__InputArrayR_Scalar_const__OutputArrayR_StreamR(src1: *const c_void, src2: *const core::Scalar, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_max_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_max_const__InputArrayR_const__InputArrayR_const__OutputArrayR_StreamR(src1: *const c_void, src2: *const c_void, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_meanStdDev_const__InputArrayR_ScalarR_ScalarR(mtx: *const c_void, mean: *mut core::Scalar, stddev: *mut core::Scalar, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_meanStdDev_const__InputArrayR_ScalarR_ScalarR_const__InputArrayR(src: *const c_void, mean: *mut core::Scalar, stddev: *mut core::Scalar, mask: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_meanStdDev_const__InputArrayR_const__OutputArrayR(mtx: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_meanStdDev_const__InputArrayR_const__OutputArrayR_StreamR(mtx: *const c_void, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_meanStdDev_const__InputArrayR_const__OutputArrayR_const__InputArrayR(src: *const c_void, dst: *const c_void, mask: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_meanStdDev_const__InputArrayR_const__OutputArrayR_const__InputArrayR_StreamR(src: *const c_void, dst: *const c_void, mask: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_merge_const_GpuMatX_size_t_const__OutputArrayR(src: *const c_void, n: size_t, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_merge_const_GpuMatX_size_t_const__OutputArrayR_StreamR(src: *const c_void, n: size_t, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_merge_const_vectorLGpuMatGR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_merge_const_vectorLGpuMatGR_const__OutputArrayR_StreamR(src: *const c_void, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_minMaxLoc_const__InputArrayR_doubleX_doubleX_PointX_PointX(src: *const c_void, min_val: *mut f64, max_val: *mut f64, min_loc: *mut core::Point, max_loc: *mut core::Point, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_minMaxLoc_const__InputArrayR_doubleX_doubleX_PointX_PointX_const__InputArrayR(src: *const c_void, min_val: *mut f64, max_val: *mut f64, min_loc: *mut core::Point, max_loc: *mut core::Point, mask: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_minMax_const__InputArrayR_doubleX_doubleX(src: *const c_void, min_val: *mut f64, max_val: *mut f64, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_minMax_const__InputArrayR_doubleX_doubleX_const__InputArrayR(src: *const c_void, min_val: *mut f64, max_val: *mut f64, mask: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_minWithScalar_const__InputArrayR_Scalar_const__OutputArrayR(src1: *const c_void, src2: *const core::Scalar, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_minWithScalar_const__InputArrayR_Scalar_const__OutputArrayR_StreamR(src1: *const c_void, src2: *const core::Scalar, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_min_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_min_const__InputArrayR_const__InputArrayR_const__OutputArrayR_StreamR(src1: *const c_void, src2: *const c_void, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_mulAndScaleSpectrums_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int_float(src1: *const c_void, src2: *const c_void, dst: *const c_void, flags: i32, scale: f32, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_mulAndScaleSpectrums_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int_float_bool_StreamR(src1: *const c_void, src2: *const c_void, dst: *const c_void, flags: i32, scale: f32, conj_b: bool, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_mulSpectrums_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int(src1: *const c_void, src2: *const c_void, dst: *const c_void, flags: i32, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_mulSpectrums_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int_bool_StreamR(src1: *const c_void, src2: *const c_void, dst: *const c_void, flags: i32, conj_b: bool, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_multiplyWithScalar_const__InputArrayR_Scalar_const__OutputArrayR(src1: *const c_void, src2: *const core::Scalar, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_multiplyWithScalar_const__InputArrayR_Scalar_const__OutputArrayR_double_int_StreamR(src1: *const c_void, src2: *const core::Scalar, dst: *const c_void, scale: f64, dtype: i32, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_multiply_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_multiply_const__InputArrayR_const__InputArrayR_const__OutputArrayR_double_int_StreamR(src1: *const c_void, src2: *const c_void, dst: *const c_void, scale: f64, dtype: i32, stream: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_cuda_norm_const__InputArrayR_const__InputArrayR(src1: *const c_void, src2: *const c_void, ocvrs_return: *mut Result); pub fn cv_cuda_norm_const__InputArrayR_const__InputArrayR_int(src1: *const c_void, src2: *const c_void, norm_type: i32, ocvrs_return: *mut Result); pub fn cv_cuda_norm_const__InputArrayR_int(src1: *const c_void, norm_type: i32, ocvrs_return: *mut Result); pub fn cv_cuda_norm_const__InputArrayR_int_const__InputArrayR(src1: *const c_void, norm_type: i32, mask: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_normalize_const__InputArrayR_const__OutputArrayR_double_double_int_int(src: *const c_void, dst: *const c_void, alpha: f64, beta: f64, norm_type: i32, dtype: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_normalize_const__InputArrayR_const__OutputArrayR_double_double_int_int_const__InputArrayR_StreamR(src: *const c_void, dst: *const c_void, alpha: f64, beta: f64, norm_type: i32, dtype: i32, mask: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_phase_const__InputArrayR_const__InputArrayR_const__OutputArrayR(x: *const c_void, y: *const c_void, angle: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_phase_const__InputArrayR_const__InputArrayR_const__OutputArrayR_bool_StreamR(x: *const c_void, y: *const c_void, angle: *const c_void, angle_in_degrees: bool, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_phase_const__InputArrayR_const__OutputArrayR(xy: *const c_void, angle: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_phase_const__InputArrayR_const__OutputArrayR_bool_StreamR(xy: *const c_void, angle: *const c_void, angle_in_degrees: bool, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_polarToCart_const__InputArrayR_const__InputArrayR_const__OutputArrayR(magnitude: *const c_void, angle: *const c_void, xy: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_polarToCart_const__InputArrayR_const__InputArrayR_const__OutputArrayR_bool_StreamR(magnitude: *const c_void, angle: *const c_void, xy: *const c_void, angle_in_degrees: bool, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_polarToCart_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(magnitude: *const c_void, angle: *const c_void, x: *const c_void, y: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_polarToCart_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_bool_StreamR(magnitude: *const c_void, angle: *const c_void, x: *const c_void, y: *const c_void, angle_in_degrees: bool, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_polarToCart_const__InputArrayR_const__OutputArrayR(magnitude_angle: *const c_void, xy: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_polarToCart_const__InputArrayR_const__OutputArrayR_bool_StreamR(magnitude_angle: *const c_void, xy: *const c_void, angle_in_degrees: bool, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_pow_const__InputArrayR_double_const__OutputArrayR(src: *const c_void, power: f64, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_pow_const__InputArrayR_double_const__OutputArrayR_StreamR(src: *const c_void, power: f64, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_rectStdDev_const__InputArrayR_const__InputArrayR_const__OutputArrayR_Rect(src: *const c_void, sqr: *const c_void, dst: *const c_void, rect: *const core::Rect, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_rectStdDev_const__InputArrayR_const__InputArrayR_const__OutputArrayR_Rect_StreamR(src: *const c_void, sqr: *const c_void, dst: *const c_void, rect: *const core::Rect, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_reduce_const__InputArrayR_const__OutputArrayR_int_int(mtx: *const c_void, vec: *const c_void, dim: i32, reduce_op: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_reduce_const__InputArrayR_const__OutputArrayR_int_int_int_StreamR(mtx: *const c_void, vec: *const c_void, dim: i32, reduce_op: i32, dtype: i32, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_rshift_const__InputArrayR_Scalar_LintG_const__OutputArrayR(src: *const c_void, val: *const core::Scalar_, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_rshift_const__InputArrayR_Scalar_LintG_const__OutputArrayR_StreamR(src: *const c_void, val: *const core::Scalar_, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_rshift_const__InputArrayR_Scalar_const__OutputArrayR(src: *const c_void, val: *const core::Scalar, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_rshift_const__InputArrayR_Scalar_const__OutputArrayR_StreamR(src: *const c_void, val: *const core::Scalar, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_split_const__InputArrayR_GpuMatX(src: *const c_void, dst: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_split_const__InputArrayR_GpuMatX_StreamR(src: *const c_void, dst: *mut c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_split_const__InputArrayR_vectorLGpuMatGR(src: *const c_void, dst: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_split_const__InputArrayR_vectorLGpuMatGR_StreamR(src: *const c_void, dst: *mut c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_sqrIntegral_const__InputArrayR_const__OutputArrayR(src: *const c_void, sqsum: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_sqrIntegral_const__InputArrayR_const__OutputArrayR_StreamR(src: *const c_void, sqsum: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_normalize_const__InputArrayR_const__OutputArrayR_double_double_int_int(src: *const c_void, dst: *const c_void, alpha: f64, beta: f64, norm_type: i32, dtype: i32, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_normalize_const__InputArrayR_const__OutputArrayR_double_double_int_int_const__InputArrayR_StreamR(src: *const c_void, dst: *const c_void, alpha: f64, beta: f64, norm_type: i32, dtype: i32, mask: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_phase_const__InputArrayR_const__InputArrayR_const__OutputArrayR(x: *const c_void, y: *const c_void, angle: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_phase_const__InputArrayR_const__InputArrayR_const__OutputArrayR_bool_StreamR(x: *const c_void, y: *const c_void, angle: *const c_void, angle_in_degrees: bool, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_phase_const__InputArrayR_const__OutputArrayR(xy: *const c_void, angle: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_phase_const__InputArrayR_const__OutputArrayR_bool_StreamR(xy: *const c_void, angle: *const c_void, angle_in_degrees: bool, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_polarToCart_const__InputArrayR_const__InputArrayR_const__OutputArrayR(magnitude: *const c_void, angle: *const c_void, xy: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_polarToCart_const__InputArrayR_const__InputArrayR_const__OutputArrayR_bool_StreamR(magnitude: *const c_void, angle: *const c_void, xy: *const c_void, angle_in_degrees: bool, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_polarToCart_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(magnitude: *const c_void, angle: *const c_void, x: *const c_void, y: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_polarToCart_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_bool_StreamR(magnitude: *const c_void, angle: *const c_void, x: *const c_void, y: *const c_void, angle_in_degrees: bool, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_polarToCart_const__InputArrayR_const__OutputArrayR(magnitude_angle: *const c_void, xy: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_polarToCart_const__InputArrayR_const__OutputArrayR_bool_StreamR(magnitude_angle: *const c_void, xy: *const c_void, angle_in_degrees: bool, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_pow_const__InputArrayR_double_const__OutputArrayR(src: *const c_void, power: f64, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_pow_const__InputArrayR_double_const__OutputArrayR_StreamR(src: *const c_void, power: f64, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_rectStdDev_const__InputArrayR_const__InputArrayR_const__OutputArrayR_Rect(src: *const c_void, sqr: *const c_void, dst: *const c_void, rect: *const core::Rect, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_rectStdDev_const__InputArrayR_const__InputArrayR_const__OutputArrayR_Rect_StreamR(src: *const c_void, sqr: *const c_void, dst: *const c_void, rect: *const core::Rect, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_reduce_const__InputArrayR_const__OutputArrayR_int_int(mtx: *const c_void, vec: *const c_void, dim: i32, reduce_op: i32, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_reduce_const__InputArrayR_const__OutputArrayR_int_int_int_StreamR(mtx: *const c_void, vec: *const c_void, dim: i32, reduce_op: i32, dtype: i32, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_rshift_const__InputArrayR_Scalar_LintG_const__OutputArrayR(src: *const c_void, val: *const core::Scalar_, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_rshift_const__InputArrayR_Scalar_LintG_const__OutputArrayR_StreamR(src: *const c_void, val: *const core::Scalar_, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_rshift_const__InputArrayR_Scalar_const__OutputArrayR(src: *const c_void, val: *const core::Scalar, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_rshift_const__InputArrayR_Scalar_const__OutputArrayR_StreamR(src: *const c_void, val: *const core::Scalar, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_split_const__InputArrayR_GpuMatX(src: *const c_void, dst: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_split_const__InputArrayR_GpuMatX_StreamR(src: *const c_void, dst: *mut c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_split_const__InputArrayR_vectorLGpuMatGR(src: *const c_void, dst: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_split_const__InputArrayR_vectorLGpuMatGR_StreamR(src: *const c_void, dst: *mut c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_sqrIntegral_const__InputArrayR_const__OutputArrayR(src: *const c_void, sqsum: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_sqrIntegral_const__InputArrayR_const__OutputArrayR_StreamR(src: *const c_void, sqsum: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_cuda_sqrSum_const__InputArrayR(src: *const c_void, ocvrs_return: *mut Result); pub fn cv_cuda_sqrSum_const__InputArrayR_const__InputArrayR(src: *const c_void, mask: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_sqr_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_sqr_const__InputArrayR_const__OutputArrayR_StreamR(src: *const c_void, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_sqrt_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_sqrt_const__InputArrayR_const__OutputArrayR_StreamR(src: *const c_void, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_subtractWithScalar_const__InputArrayR_Scalar_const__OutputArrayR(src1: *const c_void, src2: *const core::Scalar, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_subtractWithScalar_const__InputArrayR_Scalar_const__OutputArrayR_const__InputArrayR_int_StreamR(src1: *const c_void, src2: *const core::Scalar, dst: *const c_void, mask: *const c_void, dtype: i32, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_subtract_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_subtract_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__InputArrayR_int_StreamR(src1: *const c_void, src2: *const c_void, dst: *const c_void, mask: *const c_void, dtype: i32, stream: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_sqr_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_sqr_const__InputArrayR_const__OutputArrayR_StreamR(src: *const c_void, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_sqrt_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_sqrt_const__InputArrayR_const__OutputArrayR_StreamR(src: *const c_void, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_subtractWithScalar_const__InputArrayR_Scalar_const__OutputArrayR(src1: *const c_void, src2: *const core::Scalar, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_subtractWithScalar_const__InputArrayR_Scalar_const__OutputArrayR_const__InputArrayR_int_StreamR(src1: *const c_void, src2: *const core::Scalar, dst: *const c_void, mask: *const c_void, dtype: i32, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_subtract_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_subtract_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__InputArrayR_int_StreamR(src1: *const c_void, src2: *const c_void, dst: *const c_void, mask: *const c_void, dtype: i32, stream: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_cuda_sum_const__InputArrayR(src: *const c_void, ocvrs_return: *mut Result); pub fn cv_cuda_sum_const__InputArrayR_const__InputArrayR(src: *const c_void, mask: *const c_void, ocvrs_return: *mut Result); pub fn cv_cuda_threshold_const__InputArrayR_const__OutputArrayR_double_double_int(src: *const c_void, dst: *const c_void, thresh: f64, maxval: f64, typ: i32, ocvrs_return: *mut Result); pub fn cv_cuda_threshold_const__InputArrayR_const__OutputArrayR_double_double_int_StreamR(src: *const c_void, dst: *const c_void, thresh: f64, maxval: f64, typ: i32, stream: *mut c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_transpose_const__InputArrayR_const__OutputArrayR(src1: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_transpose_const__InputArrayR_const__OutputArrayR_StreamR(src1: *const c_void, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_Convolution_convolve_const__InputArrayR_const__InputArrayR_const__OutputArrayR_bool_StreamR(instance: *mut c_void, image: *const c_void, templ: *const c_void, result: *const c_void, ccorr: bool, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_Convolution_convolve_const__InputArrayR_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, templ: *const c_void, result: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_transpose_const__InputArrayR_const__OutputArrayR(src1: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_transpose_const__InputArrayR_const__OutputArrayR_StreamR(src1: *const c_void, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_Convolution_convolve_const__InputArrayR_const__InputArrayR_const__OutputArrayR_bool_StreamR(instance: *mut c_void, image: *const c_void, templ: *const c_void, result: *const c_void, ccorr: bool, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_Convolution_convolve_const__InputArrayR_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, templ: *const c_void, result: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_cuda_Convolution_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_Convolution_delete(instance: *mut c_void); - pub fn cv_cuda_DFT_compute_const__InputArrayR_const__OutputArrayR_StreamR(instance: *mut c_void, image: *const c_void, result: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_DFT_compute_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, result: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_DFT_compute_const__InputArrayR_const__OutputArrayR_StreamR(instance: *mut c_void, image: *const c_void, result: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_DFT_compute_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, result: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_cuda_DFT_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_DFT_delete(instance: *mut c_void); - pub fn cv_cuda_LookUpTable_transform_const__InputArrayR_const__OutputArrayR_StreamR(instance: *mut c_void, src: *const c_void, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_LookUpTable_transform_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_LookUpTable_transform_const__InputArrayR_const__OutputArrayR_StreamR(instance: *mut c_void, src: *const c_void, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_LookUpTable_transform_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_cuda_LookUpTable_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_LookUpTable_delete(instance: *mut c_void); pub fn cv_PtrLcv_cuda_ConvolutionG_getInnerPtr_const(instance: *const c_void) -> *mut c_void; @@ -4298,10 +4281,8 @@ mod cudaarithm_sys { pub fn cv_PtrLcv_cuda_LookUpTableG_to_PtrOfAlgorithm(instance: *mut c_void) -> *mut c_void; } } -#[cfg(ocvrs_has_module_cudaarithm)] pub use cudaarithm_sys::*; -#[cfg(ocvrs_has_module_cudabgsegm)] mod cudabgsegm_sys { use super::*; @@ -4310,23 +4291,23 @@ mod cudabgsegm_sys { pub fn cv_cuda_createBackgroundSubtractorMOG2(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_createBackgroundSubtractorMOG2_int_double_bool(history: i32, var_threshold: f64, detect_shadows: bool, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_createBackgroundSubtractorMOG_int_int_double_double(history: i32, nmixtures: i32, background_ratio: f64, noise_sigma: f64, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_cuda_BackgroundSubtractorMOG_apply_const__InputArrayR_const__OutputArrayR_double_StreamR(instance: *mut c_void, image: *const c_void, fgmask: *const c_void, learning_rate: f64, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_BackgroundSubtractorMOG_getBackgroundImage_const_const__OutputArrayR_StreamR(instance: *const c_void, background_image: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_BackgroundSubtractorMOG_getBackgroundImage_GpuMatR_StreamR(instance: *mut c_void, background_image: *mut c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_BackgroundSubtractorMOG_apply_const__InputArrayR_const__OutputArrayR_double_StreamR(instance: *mut c_void, image: *const c_void, fgmask: *const c_void, learning_rate: f64, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_BackgroundSubtractorMOG_getBackgroundImage_const_const__OutputArrayR_StreamR(instance: *const c_void, background_image: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_BackgroundSubtractorMOG_getBackgroundImage_GpuMatR_StreamR(instance: *mut c_void, background_image: *mut c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_cuda_BackgroundSubtractorMOG_getHistory_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_BackgroundSubtractorMOG_setHistory_int(instance: *mut c_void, nframes: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_BackgroundSubtractorMOG_setHistory_int(instance: *mut c_void, nframes: i32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_BackgroundSubtractorMOG_getNMixtures_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_BackgroundSubtractorMOG_setNMixtures_int(instance: *mut c_void, nmix: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_BackgroundSubtractorMOG_setNMixtures_int(instance: *mut c_void, nmix: i32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_BackgroundSubtractorMOG_getBackgroundRatio_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_BackgroundSubtractorMOG_setBackgroundRatio_double(instance: *mut c_void, background_ratio: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_BackgroundSubtractorMOG_setBackgroundRatio_double(instance: *mut c_void, background_ratio: f64, ocvrs_return: *mut Result<()>); pub fn cv_cuda_BackgroundSubtractorMOG_getNoiseSigma_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_BackgroundSubtractorMOG_setNoiseSigma_double(instance: *mut c_void, noise_sigma: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_BackgroundSubtractorMOG_setNoiseSigma_double(instance: *mut c_void, noise_sigma: f64, ocvrs_return: *mut Result<()>); pub fn cv_cuda_BackgroundSubtractorMOG_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_BackgroundSubtractorMOG_to_BackgroundSubtractor(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_BackgroundSubtractorMOG_delete(instance: *mut c_void); - pub fn cv_cuda_BackgroundSubtractorMOG2_apply_const__InputArrayR_const__OutputArrayR_double_StreamR(instance: *mut c_void, image: *const c_void, fgmask: *const c_void, learning_rate: f64, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_BackgroundSubtractorMOG2_getBackgroundImage_const_const__OutputArrayR_StreamR(instance: *const c_void, background_image: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_BackgroundSubtractorMOG2_getBackgroundImage_GpuMatR_StreamR(instance: *mut c_void, background_image: *mut c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_BackgroundSubtractorMOG2_apply_const__InputArrayR_const__OutputArrayR_double_StreamR(instance: *mut c_void, image: *const c_void, fgmask: *const c_void, learning_rate: f64, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_BackgroundSubtractorMOG2_getBackgroundImage_const_const__OutputArrayR_StreamR(instance: *const c_void, background_image: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_BackgroundSubtractorMOG2_getBackgroundImage_GpuMatR_StreamR(instance: *mut c_void, background_image: *mut c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_cuda_BackgroundSubtractorMOG2_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_BackgroundSubtractorMOG2_to_BackgroundSubtractor(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_BackgroundSubtractorMOG2_to_BackgroundSubtractorMOG2(instance: *mut c_void) -> *mut c_void; @@ -4346,15 +4327,13 @@ mod cudabgsegm_sys { pub fn cv_PtrLcv_cuda_BackgroundSubtractorMOG2G_to_PtrOfBackgroundSubtractorMOG2(instance: *mut c_void) -> *mut c_void; } } -#[cfg(ocvrs_has_module_cudabgsegm)] pub use cudabgsegm_sys::*; -#[cfg(ocvrs_has_module_cudacodec)] mod cudacodec_sys { use super::*; extern "C" { - pub fn cv_cudacodec_MapHist_const_GpuMatR_MatR(hist: *const c_void, hist_full: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_cudacodec_MapHist_const_GpuMatR_MatR(hist: *const c_void, hist_full: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_cudacodec_createNVSurfaceToColorConverter_const_ColorSpaceStandard(color_space: crate::cudacodec::CUDA_ColorSpaceStandard, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cudacodec_createNVSurfaceToColorConverter_const_ColorSpaceStandard_const_bool(color_space: crate::cudacodec::CUDA_ColorSpaceStandard, video_full_range_flag: bool, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cudacodec_createVideoReader_const_PtrLRawVideoSourceGR(source: *const c_void, ocvrs_return: *mut Result<*mut c_void>); @@ -4366,9 +4345,9 @@ mod cudacodec_sys { pub fn cv_cudacodec_createVideoWriter_const_StringR_const_Size_const_Codec_const_double_const_ColorFormat_const_EncoderParamsR(file_name: *const c_char, frame_size: *const core::Size, codec: crate::cudacodec::CUDA_Codec, fps: f64, color_format: crate::cudacodec::CUDA_ColorFormat, params: *const crate::cudacodec::CUDA_EncoderParams, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cudacodec_createVideoWriter_const_StringR_const_Size_const_Codec_const_double_const_ColorFormat_const_EncoderParamsR_PtrLEncoderCallbackG_const_StreamR(file_name: *const c_char, frame_size: *const core::Size, codec: crate::cudacodec::CUDA_Codec, fps: f64, color_format: crate::cudacodec::CUDA_ColorFormat, params: *const crate::cudacodec::CUDA_EncoderParams, encoder_callback: *mut c_void, stream: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cudacodec_operatorEQ_const_EncoderParamsR_const_EncoderParamsR(lhs: *const crate::cudacodec::CUDA_EncoderParams, rhs: *const crate::cudacodec::CUDA_EncoderParams, ocvrs_return: *mut Result); - pub fn cv_cudacodec_EncoderCallback_onEncoded_const_vectorLvectorLuint8_tGGR_const_vectorLuint64_tGR(instance: *mut c_void, v_packet: *const c_void, pts: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_cudacodec_EncoderCallback_onEncoded_const_vectorLvectorLuint8_tGGR_const_vectorLuint64_tGR(instance: *mut c_void, v_packet: *const c_void, pts: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_cudacodec_EncoderCallback_setFrameIntervalP_const_int(instance: *mut c_void, frame_interval_p: i32, ocvrs_return: *mut Result); - pub fn cv_cudacodec_EncoderCallback_onEncodingFinished(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_cudacodec_EncoderCallback_onEncodingFinished(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_cudacodec_EncoderCallback_delete(instance: *mut c_void); pub fn cv_cudacodec_EncoderParams_EncoderParams(ocvrs_return: *mut Result); pub fn cv_cudacodec_FormatInfo_FormatInfo(ocvrs_return: *mut Result); @@ -4378,8 +4357,8 @@ mod cudacodec_sys { pub fn cv_cudacodec_RawVideoSource_getNextPacket_unsigned_charXX_size_tX(instance: *mut c_void, data: *mut *mut u8, size: *mut size_t, ocvrs_return: *mut Result); pub fn cv_cudacodec_RawVideoSource_lastPacketContainsKeyFrame_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_cudacodec_RawVideoSource_format_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cudacodec_RawVideoSource_updateFormat_const_FormatInfoR(instance: *mut c_void, video_format: *const crate::cudacodec::CUDA_FormatInfo, ocvrs_return: *mut ResultVoid); - pub fn cv_cudacodec_RawVideoSource_getExtraData_const_MatR(instance: *const c_void, extra_data: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_cudacodec_RawVideoSource_updateFormat_const_FormatInfoR(instance: *mut c_void, video_format: *const crate::cudacodec::CUDA_FormatInfo, ocvrs_return: *mut Result<()>); + pub fn cv_cudacodec_RawVideoSource_getExtraData_const_MatR(instance: *const c_void, extra_data: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_cudacodec_RawVideoSource_get_const_const_int_doubleR(instance: *const c_void, property_id: i32, property_val: *mut f64, ocvrs_return: *mut Result); pub fn cv_cudacodec_RawVideoSource_getFirstFrameIdx_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_cudacodec_RawVideoSource_delete(instance: *mut c_void); @@ -4404,9 +4383,9 @@ mod cudacodec_sys { pub fn cv_cudacodec_VideoReader_get_const_const_int_doubleR(instance: *const c_void, property_id: i32, property_val: *mut f64, ocvrs_return: *mut Result); pub fn cv_cudacodec_VideoReader_delete(instance: *mut c_void); pub fn cv_cudacodec_VideoReaderInitParams_VideoReaderInitParams(ocvrs_return: *mut Result); - pub fn cv_cudacodec_VideoWriter_write_const__InputArrayR(instance: *mut c_void, frame: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_cudacodec_VideoWriter_write_const__InputArrayR(instance: *mut c_void, frame: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_cudacodec_VideoWriter_getEncoderParams_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cudacodec_VideoWriter_release(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_cudacodec_VideoWriter_release(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_cudacodec_VideoWriter_delete(instance: *mut c_void); pub fn cv_PtrLcv_cudacodec_EncoderCallbackG_getInnerPtr_const(instance: *const c_void) -> *mut c_void; pub fn cv_PtrLcv_cudacodec_EncoderCallbackG_getInnerPtrMut(instance: *mut c_void) -> *mut c_void; @@ -4430,10 +4409,8 @@ mod cudacodec_sys { pub fn cv_PtrLcv_cudacodec_VideoWriterG_delete(instance: *mut c_void); } } -#[cfg(ocvrs_has_module_cudacodec)] pub use cudacodec_sys::*; -#[cfg(ocvrs_has_module_cudafeatures2d)] mod cudafeatures2d_sys { use super::*; @@ -4441,58 +4418,58 @@ mod cudafeatures2d_sys { pub fn cv_cuda_DescriptorMatcher_createBFMatcher_int(norm_type: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_DescriptorMatcher_createBFMatcher(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_DescriptorMatcher_isMaskSupported_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_DescriptorMatcher_add_const_vectorLGpuMatGR(instance: *mut c_void, descriptors: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_DescriptorMatcher_add_const_vectorLGpuMatGR(instance: *mut c_void, descriptors: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_cuda_DescriptorMatcher_getTrainDescriptors_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_cuda_DescriptorMatcher_clear(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_DescriptorMatcher_clear(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_cuda_DescriptorMatcher_empty_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_DescriptorMatcher_train(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_DescriptorMatcher_match_const__InputArrayR_const__InputArrayR_vectorLDMatchGR_const__InputArrayR(instance: *mut c_void, query_descriptors: *const c_void, train_descriptors: *const c_void, matches: *mut c_void, mask: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_DescriptorMatcher_match_const__InputArrayR_const__InputArrayR_vectorLDMatchGR(instance: *mut c_void, query_descriptors: *const c_void, train_descriptors: *const c_void, matches: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_DescriptorMatcher_match_const__InputArrayR_vectorLDMatchGR_const_vectorLGpuMatGR(instance: *mut c_void, query_descriptors: *const c_void, matches: *mut c_void, masks: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_DescriptorMatcher_match_const__InputArrayR_vectorLDMatchGR(instance: *mut c_void, query_descriptors: *const c_void, matches: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_DescriptorMatcher_matchAsync_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__InputArrayR_StreamR(instance: *mut c_void, query_descriptors: *const c_void, train_descriptors: *const c_void, matches: *const c_void, mask: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_DescriptorMatcher_matchAsync_const__InputArrayR_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, query_descriptors: *const c_void, train_descriptors: *const c_void, matches: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_DescriptorMatcher_matchAsync_const__InputArrayR_const__OutputArrayR_const_vectorLGpuMatGR_StreamR(instance: *mut c_void, query_descriptors: *const c_void, matches: *const c_void, masks: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_DescriptorMatcher_matchAsync_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, query_descriptors: *const c_void, matches: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_DescriptorMatcher_matchConvert_const__InputArrayR_vectorLDMatchGR(instance: *mut c_void, gpu_matches: *const c_void, matches: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_DescriptorMatcher_knnMatch_const__InputArrayR_const__InputArrayR_vectorLvectorLDMatchGGR_int_const__InputArrayR_bool(instance: *mut c_void, query_descriptors: *const c_void, train_descriptors: *const c_void, matches: *mut c_void, k: i32, mask: *const c_void, compact_result: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_DescriptorMatcher_knnMatch_const__InputArrayR_const__InputArrayR_vectorLvectorLDMatchGGR_int(instance: *mut c_void, query_descriptors: *const c_void, train_descriptors: *const c_void, matches: *mut c_void, k: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_DescriptorMatcher_knnMatch_const__InputArrayR_vectorLvectorLDMatchGGR_int_const_vectorLGpuMatGR_bool(instance: *mut c_void, query_descriptors: *const c_void, matches: *mut c_void, k: i32, masks: *const c_void, compact_result: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_DescriptorMatcher_knnMatch_const__InputArrayR_vectorLvectorLDMatchGGR_int(instance: *mut c_void, query_descriptors: *const c_void, matches: *mut c_void, k: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_DescriptorMatcher_knnMatchAsync_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int_const__InputArrayR_StreamR(instance: *mut c_void, query_descriptors: *const c_void, train_descriptors: *const c_void, matches: *const c_void, k: i32, mask: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_DescriptorMatcher_knnMatchAsync_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int(instance: *mut c_void, query_descriptors: *const c_void, train_descriptors: *const c_void, matches: *const c_void, k: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_DescriptorMatcher_knnMatchAsync_const__InputArrayR_const__OutputArrayR_int_const_vectorLGpuMatGR_StreamR(instance: *mut c_void, query_descriptors: *const c_void, matches: *const c_void, k: i32, masks: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_DescriptorMatcher_knnMatchAsync_const__InputArrayR_const__OutputArrayR_int(instance: *mut c_void, query_descriptors: *const c_void, matches: *const c_void, k: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_DescriptorMatcher_knnMatchConvert_const__InputArrayR_vectorLvectorLDMatchGGR_bool(instance: *mut c_void, gpu_matches: *const c_void, matches: *mut c_void, compact_result: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_DescriptorMatcher_knnMatchConvert_const__InputArrayR_vectorLvectorLDMatchGGR(instance: *mut c_void, gpu_matches: *const c_void, matches: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_DescriptorMatcher_radiusMatch_const__InputArrayR_const__InputArrayR_vectorLvectorLDMatchGGR_float_const__InputArrayR_bool(instance: *mut c_void, query_descriptors: *const c_void, train_descriptors: *const c_void, matches: *mut c_void, max_distance: f32, mask: *const c_void, compact_result: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_DescriptorMatcher_radiusMatch_const__InputArrayR_const__InputArrayR_vectorLvectorLDMatchGGR_float(instance: *mut c_void, query_descriptors: *const c_void, train_descriptors: *const c_void, matches: *mut c_void, max_distance: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_DescriptorMatcher_radiusMatch_const__InputArrayR_vectorLvectorLDMatchGGR_float_const_vectorLGpuMatGR_bool(instance: *mut c_void, query_descriptors: *const c_void, matches: *mut c_void, max_distance: f32, masks: *const c_void, compact_result: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_DescriptorMatcher_radiusMatch_const__InputArrayR_vectorLvectorLDMatchGGR_float(instance: *mut c_void, query_descriptors: *const c_void, matches: *mut c_void, max_distance: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_DescriptorMatcher_radiusMatchAsync_const__InputArrayR_const__InputArrayR_const__OutputArrayR_float_const__InputArrayR_StreamR(instance: *mut c_void, query_descriptors: *const c_void, train_descriptors: *const c_void, matches: *const c_void, max_distance: f32, mask: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_DescriptorMatcher_radiusMatchAsync_const__InputArrayR_const__InputArrayR_const__OutputArrayR_float(instance: *mut c_void, query_descriptors: *const c_void, train_descriptors: *const c_void, matches: *const c_void, max_distance: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_DescriptorMatcher_radiusMatchAsync_const__InputArrayR_const__OutputArrayR_float_const_vectorLGpuMatGR_StreamR(instance: *mut c_void, query_descriptors: *const c_void, matches: *const c_void, max_distance: f32, masks: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_DescriptorMatcher_radiusMatchAsync_const__InputArrayR_const__OutputArrayR_float(instance: *mut c_void, query_descriptors: *const c_void, matches: *const c_void, max_distance: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_DescriptorMatcher_radiusMatchConvert_const__InputArrayR_vectorLvectorLDMatchGGR_bool(instance: *mut c_void, gpu_matches: *const c_void, matches: *mut c_void, compact_result: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_DescriptorMatcher_radiusMatchConvert_const__InputArrayR_vectorLvectorLDMatchGGR(instance: *mut c_void, gpu_matches: *const c_void, matches: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_DescriptorMatcher_train(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_DescriptorMatcher_match_const__InputArrayR_const__InputArrayR_vectorLDMatchGR_const__InputArrayR(instance: *mut c_void, query_descriptors: *const c_void, train_descriptors: *const c_void, matches: *mut c_void, mask: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_DescriptorMatcher_match_const__InputArrayR_const__InputArrayR_vectorLDMatchGR(instance: *mut c_void, query_descriptors: *const c_void, train_descriptors: *const c_void, matches: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_DescriptorMatcher_match_const__InputArrayR_vectorLDMatchGR_const_vectorLGpuMatGR(instance: *mut c_void, query_descriptors: *const c_void, matches: *mut c_void, masks: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_DescriptorMatcher_match_const__InputArrayR_vectorLDMatchGR(instance: *mut c_void, query_descriptors: *const c_void, matches: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_DescriptorMatcher_matchAsync_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__InputArrayR_StreamR(instance: *mut c_void, query_descriptors: *const c_void, train_descriptors: *const c_void, matches: *const c_void, mask: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_DescriptorMatcher_matchAsync_const__InputArrayR_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, query_descriptors: *const c_void, train_descriptors: *const c_void, matches: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_DescriptorMatcher_matchAsync_const__InputArrayR_const__OutputArrayR_const_vectorLGpuMatGR_StreamR(instance: *mut c_void, query_descriptors: *const c_void, matches: *const c_void, masks: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_DescriptorMatcher_matchAsync_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, query_descriptors: *const c_void, matches: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_DescriptorMatcher_matchConvert_const__InputArrayR_vectorLDMatchGR(instance: *mut c_void, gpu_matches: *const c_void, matches: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_DescriptorMatcher_knnMatch_const__InputArrayR_const__InputArrayR_vectorLvectorLDMatchGGR_int_const__InputArrayR_bool(instance: *mut c_void, query_descriptors: *const c_void, train_descriptors: *const c_void, matches: *mut c_void, k: i32, mask: *const c_void, compact_result: bool, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_DescriptorMatcher_knnMatch_const__InputArrayR_const__InputArrayR_vectorLvectorLDMatchGGR_int(instance: *mut c_void, query_descriptors: *const c_void, train_descriptors: *const c_void, matches: *mut c_void, k: i32, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_DescriptorMatcher_knnMatch_const__InputArrayR_vectorLvectorLDMatchGGR_int_const_vectorLGpuMatGR_bool(instance: *mut c_void, query_descriptors: *const c_void, matches: *mut c_void, k: i32, masks: *const c_void, compact_result: bool, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_DescriptorMatcher_knnMatch_const__InputArrayR_vectorLvectorLDMatchGGR_int(instance: *mut c_void, query_descriptors: *const c_void, matches: *mut c_void, k: i32, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_DescriptorMatcher_knnMatchAsync_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int_const__InputArrayR_StreamR(instance: *mut c_void, query_descriptors: *const c_void, train_descriptors: *const c_void, matches: *const c_void, k: i32, mask: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_DescriptorMatcher_knnMatchAsync_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int(instance: *mut c_void, query_descriptors: *const c_void, train_descriptors: *const c_void, matches: *const c_void, k: i32, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_DescriptorMatcher_knnMatchAsync_const__InputArrayR_const__OutputArrayR_int_const_vectorLGpuMatGR_StreamR(instance: *mut c_void, query_descriptors: *const c_void, matches: *const c_void, k: i32, masks: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_DescriptorMatcher_knnMatchAsync_const__InputArrayR_const__OutputArrayR_int(instance: *mut c_void, query_descriptors: *const c_void, matches: *const c_void, k: i32, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_DescriptorMatcher_knnMatchConvert_const__InputArrayR_vectorLvectorLDMatchGGR_bool(instance: *mut c_void, gpu_matches: *const c_void, matches: *mut c_void, compact_result: bool, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_DescriptorMatcher_knnMatchConvert_const__InputArrayR_vectorLvectorLDMatchGGR(instance: *mut c_void, gpu_matches: *const c_void, matches: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_DescriptorMatcher_radiusMatch_const__InputArrayR_const__InputArrayR_vectorLvectorLDMatchGGR_float_const__InputArrayR_bool(instance: *mut c_void, query_descriptors: *const c_void, train_descriptors: *const c_void, matches: *mut c_void, max_distance: f32, mask: *const c_void, compact_result: bool, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_DescriptorMatcher_radiusMatch_const__InputArrayR_const__InputArrayR_vectorLvectorLDMatchGGR_float(instance: *mut c_void, query_descriptors: *const c_void, train_descriptors: *const c_void, matches: *mut c_void, max_distance: f32, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_DescriptorMatcher_radiusMatch_const__InputArrayR_vectorLvectorLDMatchGGR_float_const_vectorLGpuMatGR_bool(instance: *mut c_void, query_descriptors: *const c_void, matches: *mut c_void, max_distance: f32, masks: *const c_void, compact_result: bool, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_DescriptorMatcher_radiusMatch_const__InputArrayR_vectorLvectorLDMatchGGR_float(instance: *mut c_void, query_descriptors: *const c_void, matches: *mut c_void, max_distance: f32, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_DescriptorMatcher_radiusMatchAsync_const__InputArrayR_const__InputArrayR_const__OutputArrayR_float_const__InputArrayR_StreamR(instance: *mut c_void, query_descriptors: *const c_void, train_descriptors: *const c_void, matches: *const c_void, max_distance: f32, mask: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_DescriptorMatcher_radiusMatchAsync_const__InputArrayR_const__InputArrayR_const__OutputArrayR_float(instance: *mut c_void, query_descriptors: *const c_void, train_descriptors: *const c_void, matches: *const c_void, max_distance: f32, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_DescriptorMatcher_radiusMatchAsync_const__InputArrayR_const__OutputArrayR_float_const_vectorLGpuMatGR_StreamR(instance: *mut c_void, query_descriptors: *const c_void, matches: *const c_void, max_distance: f32, masks: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_DescriptorMatcher_radiusMatchAsync_const__InputArrayR_const__OutputArrayR_float(instance: *mut c_void, query_descriptors: *const c_void, matches: *const c_void, max_distance: f32, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_DescriptorMatcher_radiusMatchConvert_const__InputArrayR_vectorLvectorLDMatchGGR_bool(instance: *mut c_void, gpu_matches: *const c_void, matches: *mut c_void, compact_result: bool, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_DescriptorMatcher_radiusMatchConvert_const__InputArrayR_vectorLvectorLDMatchGGR(instance: *mut c_void, gpu_matches: *const c_void, matches: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_cuda_DescriptorMatcher_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_DescriptorMatcher_delete(instance: *mut c_void); pub fn cv_cuda_FastFeatureDetector_create_int_bool_int_int(threshold: i32, nonmax_suppression: bool, typ: i32, max_npoints: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_FastFeatureDetector_create(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_cuda_FastFeatureDetector_setThreshold_int(instance: *mut c_void, threshold: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_FastFeatureDetector_setMaxNumPoints_int(instance: *mut c_void, max_npoints: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_FastFeatureDetector_setThreshold_int(instance: *mut c_void, threshold: i32, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_FastFeatureDetector_setMaxNumPoints_int(instance: *mut c_void, max_npoints: i32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_FastFeatureDetector_getMaxNumPoints_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_cuda_FastFeatureDetector_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_FastFeatureDetector_to_Feature2D(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_FastFeatureDetector_to_CUDA_Feature2DAsync(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_FastFeatureDetector_delete(instance: *mut c_void); - pub fn cv_cuda_Feature2DAsync_detectAsync_const__InputArrayR_const__OutputArrayR_const__InputArrayR_StreamR(instance: *mut c_void, image: *const c_void, keypoints: *const c_void, mask: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_Feature2DAsync_detectAsync_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, keypoints: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_Feature2DAsync_computeAsync_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_StreamR(instance: *mut c_void, image: *const c_void, keypoints: *const c_void, descriptors: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_Feature2DAsync_computeAsync_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, keypoints: *const c_void, descriptors: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_Feature2DAsync_detectAndComputeAsync_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_bool_StreamR(instance: *mut c_void, image: *const c_void, mask: *const c_void, keypoints: *const c_void, descriptors: *const c_void, use_provided_keypoints: bool, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_Feature2DAsync_detectAndComputeAsync_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, mask: *const c_void, keypoints: *const c_void, descriptors: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_Feature2DAsync_convert_const__InputArrayR_vectorLKeyPointGR(instance: *mut c_void, gpu_keypoints: *const c_void, keypoints: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_Feature2DAsync_detectAsync_const__InputArrayR_const__OutputArrayR_const__InputArrayR_StreamR(instance: *mut c_void, image: *const c_void, keypoints: *const c_void, mask: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_Feature2DAsync_detectAsync_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, keypoints: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_Feature2DAsync_computeAsync_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_StreamR(instance: *mut c_void, image: *const c_void, keypoints: *const c_void, descriptors: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_Feature2DAsync_computeAsync_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, keypoints: *const c_void, descriptors: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_Feature2DAsync_detectAndComputeAsync_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_bool_StreamR(instance: *mut c_void, image: *const c_void, mask: *const c_void, keypoints: *const c_void, descriptors: *const c_void, use_provided_keypoints: bool, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_Feature2DAsync_detectAndComputeAsync_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, mask: *const c_void, keypoints: *const c_void, descriptors: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_Feature2DAsync_convert_const__InputArrayR_vectorLKeyPointGR(instance: *mut c_void, gpu_keypoints: *const c_void, keypoints: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_cuda_Feature2DAsync_to_CUDA_FastFeatureDetector(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_Feature2DAsync_to_CUDA_ORB(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_Feature2DAsync_to_Algorithm(instance: *mut c_void) -> *mut c_void; @@ -4500,25 +4477,25 @@ mod cudafeatures2d_sys { pub fn cv_cuda_Feature2DAsync_delete(instance: *mut c_void); pub fn cv_cuda_ORB_create_int_float_int_int_int_int_int_int_int_bool(nfeatures: i32, scale_factor: f32, nlevels: i32, edge_threshold: i32, first_level: i32, wta_k: i32, score_type: i32, patch_size: i32, fast_threshold: i32, blur_for_descriptor: bool, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_ORB_create(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_cuda_ORB_setMaxFeatures_int(instance: *mut c_void, max_features: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_ORB_setMaxFeatures_int(instance: *mut c_void, max_features: i32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_ORB_getMaxFeatures_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_ORB_setScaleFactor_double(instance: *mut c_void, scale_factor: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_ORB_setScaleFactor_double(instance: *mut c_void, scale_factor: f64, ocvrs_return: *mut Result<()>); pub fn cv_cuda_ORB_getScaleFactor_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_ORB_setNLevels_int(instance: *mut c_void, nlevels: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_ORB_setNLevels_int(instance: *mut c_void, nlevels: i32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_ORB_getNLevels_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_ORB_setEdgeThreshold_int(instance: *mut c_void, edge_threshold: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_ORB_setEdgeThreshold_int(instance: *mut c_void, edge_threshold: i32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_ORB_getEdgeThreshold_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_ORB_setFirstLevel_int(instance: *mut c_void, first_level: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_ORB_setFirstLevel_int(instance: *mut c_void, first_level: i32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_ORB_getFirstLevel_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_ORB_setWTA_K_int(instance: *mut c_void, wta_k: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_ORB_setWTA_K_int(instance: *mut c_void, wta_k: i32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_ORB_getWTA_K_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_ORB_setScoreType_int(instance: *mut c_void, score_type: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_ORB_setScoreType_int(instance: *mut c_void, score_type: i32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_ORB_getScoreType_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_ORB_setPatchSize_int(instance: *mut c_void, patch_size: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_ORB_setPatchSize_int(instance: *mut c_void, patch_size: i32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_ORB_getPatchSize_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_ORB_setFastThreshold_int(instance: *mut c_void, fast_threshold: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_ORB_setFastThreshold_int(instance: *mut c_void, fast_threshold: i32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_ORB_getFastThreshold_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_ORB_setBlurForDescriptor_bool(instance: *mut c_void, blur_for_descriptor: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_ORB_setBlurForDescriptor_bool(instance: *mut c_void, blur_for_descriptor: bool, ocvrs_return: *mut Result<()>); pub fn cv_cuda_ORB_getBlurForDescriptor_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_cuda_ORB_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_ORB_to_Feature2D(instance: *mut c_void) -> *mut c_void; @@ -4551,10 +4528,8 @@ mod cudafeatures2d_sys { pub fn cv_PtrLcv_cuda_ORBG_to_PtrOfCUDA_Feature2DAsync(instance: *mut c_void) -> *mut c_void; } } -#[cfg(ocvrs_has_module_cudafeatures2d)] pub use cudafeatures2d_sys::*; -#[cfg(ocvrs_has_module_cudafilters)] mod cudafilters_sys { use super::*; @@ -4587,8 +4562,8 @@ mod cudafilters_sys { pub fn cv_cuda_createSeparableLinearFilter_int_int_const__InputArrayR_const__InputArrayR_Point_int_int(src_type: i32, dst_type: i32, row_kernel: *const c_void, column_kernel: *const c_void, anchor: *const core::Point, row_border_mode: i32, column_border_mode: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_createSobelFilter_int_int_int_int(src_type: i32, dst_type: i32, dx: i32, dy: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_createSobelFilter_int_int_int_int_int_double_int_int(src_type: i32, dst_type: i32, dx: i32, dy: i32, ksize: i32, scale: f64, row_border_mode: i32, column_border_mode: i32, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_cuda_Filter_apply_const__InputArrayR_const__OutputArrayR_StreamR(instance: *mut c_void, src: *const c_void, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_Filter_apply_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_Filter_apply_const__InputArrayR_const__OutputArrayR_StreamR(instance: *mut c_void, src: *const c_void, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_Filter_apply_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_cuda_Filter_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_Filter_delete(instance: *mut c_void); pub fn cv_PtrLcv_cuda_FilterG_getInnerPtr_const(instance: *const c_void) -> *mut c_void; @@ -4598,27 +4573,25 @@ mod cudafilters_sys { pub fn cv_PtrLcv_cuda_FilterG_to_PtrOfAlgorithm(instance: *mut c_void) -> *mut c_void; } } -#[cfg(ocvrs_has_module_cudafilters)] pub use cudafilters_sys::*; -#[cfg(ocvrs_has_module_cudaimgproc)] mod cudaimgproc_sys { use super::*; extern "C" { - pub fn cv_cuda_alphaComp_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int(img1: *const c_void, img2: *const c_void, dst: *const c_void, alpha_op: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_alphaComp_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int_StreamR(img1: *const c_void, img2: *const c_void, dst: *const c_void, alpha_op: i32, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_bilateralFilter_const__InputArrayR_const__OutputArrayR_int_float_float(src: *const c_void, dst: *const c_void, kernel_size: i32, sigma_color: f32, sigma_spatial: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_bilateralFilter_const__InputArrayR_const__OutputArrayR_int_float_float_int_StreamR(src: *const c_void, dst: *const c_void, kernel_size: i32, sigma_color: f32, sigma_spatial: f32, border_mode: i32, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_blendLinear_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR(img1: *const c_void, img2: *const c_void, weights1: *const c_void, weights2: *const c_void, result: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_blendLinear_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR_StreamR(img1: *const c_void, img2: *const c_void, weights1: *const c_void, weights2: *const c_void, result: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_calcHist_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src: *const c_void, mask: *const c_void, hist: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_calcHist_const__InputArrayR_const__InputArrayR_const__OutputArrayR_StreamR(src: *const c_void, mask: *const c_void, hist: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_calcHist_const__InputArrayR_const__OutputArrayR(src: *const c_void, hist: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_calcHist_const__InputArrayR_const__OutputArrayR_StreamR(src: *const c_void, hist: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_connectedComponents_const__InputArrayR_const__OutputArrayR(image: *const c_void, labels: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_connectedComponents_const__InputArrayR_const__OutputArrayR_int_int(image: *const c_void, labels: *const c_void, connectivity: i32, ltype: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_connectedComponents_const__InputArrayR_const__OutputArrayR_int_int_ConnectedComponentsAlgorithmsTypes(image: *const c_void, labels: *const c_void, connectivity: i32, ltype: i32, ccltype: crate::cudaimgproc::CUDA_ConnectedComponentsAlgorithmsTypes, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_alphaComp_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int(img1: *const c_void, img2: *const c_void, dst: *const c_void, alpha_op: i32, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_alphaComp_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int_StreamR(img1: *const c_void, img2: *const c_void, dst: *const c_void, alpha_op: i32, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_bilateralFilter_const__InputArrayR_const__OutputArrayR_int_float_float(src: *const c_void, dst: *const c_void, kernel_size: i32, sigma_color: f32, sigma_spatial: f32, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_bilateralFilter_const__InputArrayR_const__OutputArrayR_int_float_float_int_StreamR(src: *const c_void, dst: *const c_void, kernel_size: i32, sigma_color: f32, sigma_spatial: f32, border_mode: i32, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_blendLinear_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR(img1: *const c_void, img2: *const c_void, weights1: *const c_void, weights2: *const c_void, result: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_blendLinear_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR_StreamR(img1: *const c_void, img2: *const c_void, weights1: *const c_void, weights2: *const c_void, result: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_calcHist_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src: *const c_void, mask: *const c_void, hist: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_calcHist_const__InputArrayR_const__InputArrayR_const__OutputArrayR_StreamR(src: *const c_void, mask: *const c_void, hist: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_calcHist_const__InputArrayR_const__OutputArrayR(src: *const c_void, hist: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_calcHist_const__InputArrayR_const__OutputArrayR_StreamR(src: *const c_void, hist: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_connectedComponents_const__InputArrayR_const__OutputArrayR(image: *const c_void, labels: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_connectedComponents_const__InputArrayR_const__OutputArrayR_int_int(image: *const c_void, labels: *const c_void, connectivity: i32, ltype: i32, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_connectedComponents_const__InputArrayR_const__OutputArrayR_int_int_ConnectedComponentsAlgorithmsTypes(image: *const c_void, labels: *const c_void, connectivity: i32, ltype: i32, ccltype: crate::cudaimgproc::CUDA_ConnectedComponentsAlgorithmsTypes, ocvrs_return: *mut Result<()>); pub fn cv_cuda_convertSpatialMoments_Mat_const_MomentsOrder_const_int(spatial_moments: *mut c_void, order: crate::cudaimgproc::CUDA_MomentsOrder, moments_type: i32, ocvrs_return: *mut Result); pub fn cv_cuda_createCLAHE(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_createCLAHE_double_Size(clip_limit: f64, tile_grid_size: *const core::Size, ocvrs_return: *mut Result<*mut c_void>); @@ -4640,113 +4613,113 @@ mod cudaimgproc_sys { pub fn cv_cuda_createMinEigenValCorner_int_int_int_int(src_type: i32, block_size: i32, ksize: i32, border_type: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_createTemplateMatching_int_int(src_type: i32, method: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_createTemplateMatching_int_int_Size(src_type: i32, method: i32, user_block_size: *const core::Size, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_cuda_cvtColor_const__InputArrayR_const__OutputArrayR_int(src: *const c_void, dst: *const c_void, code: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_cvtColor_const__InputArrayR_const__OutputArrayR_int_int_StreamR(src: *const c_void, dst: *const c_void, code: i32, dcn: i32, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_demosaicing_const__InputArrayR_const__OutputArrayR_int(src: *const c_void, dst: *const c_void, code: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_demosaicing_const__InputArrayR_const__OutputArrayR_int_int_StreamR(src: *const c_void, dst: *const c_void, code: i32, dcn: i32, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_equalizeHist_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_equalizeHist_const__InputArrayR_const__OutputArrayR_StreamR(src: *const c_void, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_evenLevels_const__OutputArrayR_int_int_int(levels: *const c_void, n_levels: i32, lower_level: i32, upper_level: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_evenLevels_const__OutputArrayR_int_int_int_StreamR(levels: *const c_void, n_levels: i32, lower_level: i32, upper_level: i32, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_gammaCorrection_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_gammaCorrection_const__InputArrayR_const__OutputArrayR_bool_StreamR(src: *const c_void, dst: *const c_void, forward: bool, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_histEven_const__InputArrayR_const__OutputArrayR_int_int_int(src: *const c_void, hist: *const c_void, hist_size: i32, lower_level: i32, upper_level: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_histEven_const__InputArrayR_const__OutputArrayR_int_int_int_StreamR(src: *const c_void, hist: *const c_void, hist_size: i32, lower_level: i32, upper_level: i32, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_histRange_const__InputArrayR_const__OutputArrayR_const__InputArrayR(src: *const c_void, hist: *const c_void, levels: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_histRange_const__InputArrayR_const__OutputArrayR_const__InputArrayR_StreamR(src: *const c_void, hist: *const c_void, levels: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_meanShiftFiltering_const__InputArrayR_const__OutputArrayR_int_int(src: *const c_void, dst: *const c_void, sp: i32, sr: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_meanShiftFiltering_const__InputArrayR_const__OutputArrayR_int_int_TermCriteria_StreamR(src: *const c_void, dst: *const c_void, sp: i32, sr: i32, criteria: *const core::TermCriteria, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_meanShiftProc_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_int_int(src: *const c_void, dstr: *const c_void, dstsp: *const c_void, sp: i32, sr: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_meanShiftProc_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_int_int_TermCriteria_StreamR(src: *const c_void, dstr: *const c_void, dstsp: *const c_void, sp: i32, sr: i32, criteria: *const core::TermCriteria, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_meanShiftSegmentation_const__InputArrayR_const__OutputArrayR_int_int_int(src: *const c_void, dst: *const c_void, sp: i32, sr: i32, minsize: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_meanShiftSegmentation_const__InputArrayR_const__OutputArrayR_int_int_int_TermCriteria_StreamR(src: *const c_void, dst: *const c_void, sp: i32, sr: i32, minsize: i32, criteria: *const core::TermCriteria, stream: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_cvtColor_const__InputArrayR_const__OutputArrayR_int(src: *const c_void, dst: *const c_void, code: i32, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_cvtColor_const__InputArrayR_const__OutputArrayR_int_int_StreamR(src: *const c_void, dst: *const c_void, code: i32, dcn: i32, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_demosaicing_const__InputArrayR_const__OutputArrayR_int(src: *const c_void, dst: *const c_void, code: i32, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_demosaicing_const__InputArrayR_const__OutputArrayR_int_int_StreamR(src: *const c_void, dst: *const c_void, code: i32, dcn: i32, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_equalizeHist_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_equalizeHist_const__InputArrayR_const__OutputArrayR_StreamR(src: *const c_void, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_evenLevels_const__OutputArrayR_int_int_int(levels: *const c_void, n_levels: i32, lower_level: i32, upper_level: i32, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_evenLevels_const__OutputArrayR_int_int_int_StreamR(levels: *const c_void, n_levels: i32, lower_level: i32, upper_level: i32, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_gammaCorrection_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_gammaCorrection_const__InputArrayR_const__OutputArrayR_bool_StreamR(src: *const c_void, dst: *const c_void, forward: bool, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_histEven_const__InputArrayR_const__OutputArrayR_int_int_int(src: *const c_void, hist: *const c_void, hist_size: i32, lower_level: i32, upper_level: i32, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_histEven_const__InputArrayR_const__OutputArrayR_int_int_int_StreamR(src: *const c_void, hist: *const c_void, hist_size: i32, lower_level: i32, upper_level: i32, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_histRange_const__InputArrayR_const__OutputArrayR_const__InputArrayR(src: *const c_void, hist: *const c_void, levels: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_histRange_const__InputArrayR_const__OutputArrayR_const__InputArrayR_StreamR(src: *const c_void, hist: *const c_void, levels: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_meanShiftFiltering_const__InputArrayR_const__OutputArrayR_int_int(src: *const c_void, dst: *const c_void, sp: i32, sr: i32, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_meanShiftFiltering_const__InputArrayR_const__OutputArrayR_int_int_TermCriteria_StreamR(src: *const c_void, dst: *const c_void, sp: i32, sr: i32, criteria: *const core::TermCriteria, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_meanShiftProc_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_int_int(src: *const c_void, dstr: *const c_void, dstsp: *const c_void, sp: i32, sr: i32, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_meanShiftProc_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_int_int_TermCriteria_StreamR(src: *const c_void, dstr: *const c_void, dstsp: *const c_void, sp: i32, sr: i32, criteria: *const core::TermCriteria, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_meanShiftSegmentation_const__InputArrayR_const__OutputArrayR_int_int_int(src: *const c_void, dst: *const c_void, sp: i32, sr: i32, minsize: i32, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_meanShiftSegmentation_const__InputArrayR_const__OutputArrayR_int_int_int_TermCriteria_StreamR(src: *const c_void, dst: *const c_void, sp: i32, sr: i32, minsize: i32, criteria: *const core::TermCriteria, stream: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_cuda_moments_const__InputArrayR(src: *const c_void, ocvrs_return: *mut Result); pub fn cv_cuda_moments_const__InputArrayR_const_bool_const_MomentsOrder_const_int(src: *const c_void, binary_image: bool, order: crate::cudaimgproc::CUDA_MomentsOrder, moments_type: i32, ocvrs_return: *mut Result); pub fn cv_cuda_numMoments_const_MomentsOrder(order: crate::cudaimgproc::CUDA_MomentsOrder, ocvrs_return: *mut Result); - pub fn cv_cuda_spatialMoments_const__InputArrayR_const__OutputArrayR(src: *const c_void, moments: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_spatialMoments_const__InputArrayR_const__OutputArrayR_const_bool_const_MomentsOrder_const_int_StreamR(src: *const c_void, moments: *const c_void, binary_image: bool, order: crate::cudaimgproc::CUDA_MomentsOrder, moments_type: i32, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_swapChannels_const__InputOutputArrayR_const_intXX(image: *const c_void, dst_order: *const [i32; 4], ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_swapChannels_const__InputOutputArrayR_const_intXX_StreamR(image: *const c_void, dst_order: *const [i32; 4], stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_CLAHE_apply_const__InputArrayR_const__OutputArrayR_StreamR(instance: *mut c_void, src: *const c_void, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_spatialMoments_const__InputArrayR_const__OutputArrayR(src: *const c_void, moments: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_spatialMoments_const__InputArrayR_const__OutputArrayR_const_bool_const_MomentsOrder_const_int_StreamR(src: *const c_void, moments: *const c_void, binary_image: bool, order: crate::cudaimgproc::CUDA_MomentsOrder, moments_type: i32, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_swapChannels_const__InputOutputArrayR_const_intXX(image: *const c_void, dst_order: *const [i32; 4], ocvrs_return: *mut Result<()>); + pub fn cv_cuda_swapChannels_const__InputOutputArrayR_const_intXX_StreamR(image: *const c_void, dst_order: *const [i32; 4], stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_CLAHE_apply_const__InputArrayR_const__OutputArrayR_StreamR(instance: *mut c_void, src: *const c_void, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_cuda_CLAHE_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_CLAHE_to_CLAHE(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_CLAHE_delete(instance: *mut c_void); - pub fn cv_cuda_CannyEdgeDetector_detect_const__InputArrayR_const__OutputArrayR_StreamR(instance: *mut c_void, image: *const c_void, edges: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_CannyEdgeDetector_detect_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, edges: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_CannyEdgeDetector_detect_const__InputArrayR_const__InputArrayR_const__OutputArrayR_StreamR(instance: *mut c_void, dx: *const c_void, dy: *const c_void, edges: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_CannyEdgeDetector_detect_const__InputArrayR_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, dx: *const c_void, dy: *const c_void, edges: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_CannyEdgeDetector_setLowThreshold_double(instance: *mut c_void, low_thresh: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_CannyEdgeDetector_detect_const__InputArrayR_const__OutputArrayR_StreamR(instance: *mut c_void, image: *const c_void, edges: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_CannyEdgeDetector_detect_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, edges: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_CannyEdgeDetector_detect_const__InputArrayR_const__InputArrayR_const__OutputArrayR_StreamR(instance: *mut c_void, dx: *const c_void, dy: *const c_void, edges: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_CannyEdgeDetector_detect_const__InputArrayR_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, dx: *const c_void, dy: *const c_void, edges: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_CannyEdgeDetector_setLowThreshold_double(instance: *mut c_void, low_thresh: f64, ocvrs_return: *mut Result<()>); pub fn cv_cuda_CannyEdgeDetector_getLowThreshold_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_CannyEdgeDetector_setHighThreshold_double(instance: *mut c_void, high_thresh: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_CannyEdgeDetector_setHighThreshold_double(instance: *mut c_void, high_thresh: f64, ocvrs_return: *mut Result<()>); pub fn cv_cuda_CannyEdgeDetector_getHighThreshold_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_CannyEdgeDetector_setAppertureSize_int(instance: *mut c_void, apperture_size: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_CannyEdgeDetector_setAppertureSize_int(instance: *mut c_void, apperture_size: i32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_CannyEdgeDetector_getAppertureSize_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_CannyEdgeDetector_setL2Gradient_bool(instance: *mut c_void, l2gradient: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_CannyEdgeDetector_setL2Gradient_bool(instance: *mut c_void, l2gradient: bool, ocvrs_return: *mut Result<()>); pub fn cv_cuda_CannyEdgeDetector_getL2Gradient_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_cuda_CannyEdgeDetector_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_CannyEdgeDetector_delete(instance: *mut c_void); - pub fn cv_cuda_CornernessCriteria_compute_const__InputArrayR_const__OutputArrayR_StreamR(instance: *mut c_void, src: *const c_void, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_CornernessCriteria_compute_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_CornernessCriteria_compute_const__InputArrayR_const__OutputArrayR_StreamR(instance: *mut c_void, src: *const c_void, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_CornernessCriteria_compute_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_cuda_CornernessCriteria_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_CornernessCriteria_delete(instance: *mut c_void); - pub fn cv_cuda_CornersDetector_detect_const__InputArrayR_const__OutputArrayR_const__InputArrayR_StreamR(instance: *mut c_void, image: *const c_void, corners: *const c_void, mask: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_CornersDetector_detect_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, corners: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_CornersDetector_setMaxCorners_int(instance: *mut c_void, max_corners: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_CornersDetector_setMinDistance_double(instance: *mut c_void, min_distance: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_CornersDetector_detect_const__InputArrayR_const__OutputArrayR_const__InputArrayR_StreamR(instance: *mut c_void, image: *const c_void, corners: *const c_void, mask: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_CornersDetector_detect_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, corners: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_CornersDetector_setMaxCorners_int(instance: *mut c_void, max_corners: i32, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_CornersDetector_setMinDistance_double(instance: *mut c_void, min_distance: f64, ocvrs_return: *mut Result<()>); pub fn cv_cuda_CornersDetector_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_CornersDetector_delete(instance: *mut c_void); - pub fn cv_cuda_HoughCirclesDetector_detect_const__InputArrayR_const__OutputArrayR_StreamR(instance: *mut c_void, src: *const c_void, circles: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_HoughCirclesDetector_detect_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, src: *const c_void, circles: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_HoughCirclesDetector_setDp_float(instance: *mut c_void, dp: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_HoughCirclesDetector_detect_const__InputArrayR_const__OutputArrayR_StreamR(instance: *mut c_void, src: *const c_void, circles: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_HoughCirclesDetector_detect_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, src: *const c_void, circles: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_HoughCirclesDetector_setDp_float(instance: *mut c_void, dp: f32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_HoughCirclesDetector_getDp_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_HoughCirclesDetector_setMinDist_float(instance: *mut c_void, min_dist: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_HoughCirclesDetector_setMinDist_float(instance: *mut c_void, min_dist: f32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_HoughCirclesDetector_getMinDist_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_HoughCirclesDetector_setCannyThreshold_int(instance: *mut c_void, canny_threshold: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_HoughCirclesDetector_setCannyThreshold_int(instance: *mut c_void, canny_threshold: i32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_HoughCirclesDetector_getCannyThreshold_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_HoughCirclesDetector_setVotesThreshold_int(instance: *mut c_void, votes_threshold: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_HoughCirclesDetector_setVotesThreshold_int(instance: *mut c_void, votes_threshold: i32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_HoughCirclesDetector_getVotesThreshold_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_HoughCirclesDetector_setMinRadius_int(instance: *mut c_void, min_radius: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_HoughCirclesDetector_setMinRadius_int(instance: *mut c_void, min_radius: i32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_HoughCirclesDetector_getMinRadius_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_HoughCirclesDetector_setMaxRadius_int(instance: *mut c_void, max_radius: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_HoughCirclesDetector_setMaxRadius_int(instance: *mut c_void, max_radius: i32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_HoughCirclesDetector_getMaxRadius_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_HoughCirclesDetector_setMaxCircles_int(instance: *mut c_void, max_circles: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_HoughCirclesDetector_setMaxCircles_int(instance: *mut c_void, max_circles: i32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_HoughCirclesDetector_getMaxCircles_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_cuda_HoughCirclesDetector_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_HoughCirclesDetector_delete(instance: *mut c_void); - pub fn cv_cuda_HoughLinesDetector_detect_const__InputArrayR_const__OutputArrayR_StreamR(instance: *mut c_void, src: *const c_void, lines: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_HoughLinesDetector_detect_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, src: *const c_void, lines: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_HoughLinesDetector_downloadResults_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_StreamR(instance: *mut c_void, d_lines: *const c_void, h_lines: *const c_void, h_votes: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_HoughLinesDetector_downloadResults_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, d_lines: *const c_void, h_lines: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_HoughLinesDetector_setRho_float(instance: *mut c_void, rho: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_HoughLinesDetector_detect_const__InputArrayR_const__OutputArrayR_StreamR(instance: *mut c_void, src: *const c_void, lines: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_HoughLinesDetector_detect_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, src: *const c_void, lines: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_HoughLinesDetector_downloadResults_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_StreamR(instance: *mut c_void, d_lines: *const c_void, h_lines: *const c_void, h_votes: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_HoughLinesDetector_downloadResults_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, d_lines: *const c_void, h_lines: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_HoughLinesDetector_setRho_float(instance: *mut c_void, rho: f32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_HoughLinesDetector_getRho_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_HoughLinesDetector_setTheta_float(instance: *mut c_void, theta: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_HoughLinesDetector_setTheta_float(instance: *mut c_void, theta: f32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_HoughLinesDetector_getTheta_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_HoughLinesDetector_setThreshold_int(instance: *mut c_void, threshold: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_HoughLinesDetector_setThreshold_int(instance: *mut c_void, threshold: i32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_HoughLinesDetector_getThreshold_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_HoughLinesDetector_setDoSort_bool(instance: *mut c_void, do_sort: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_HoughLinesDetector_setDoSort_bool(instance: *mut c_void, do_sort: bool, ocvrs_return: *mut Result<()>); pub fn cv_cuda_HoughLinesDetector_getDoSort_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_HoughLinesDetector_setMaxLines_int(instance: *mut c_void, max_lines: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_HoughLinesDetector_setMaxLines_int(instance: *mut c_void, max_lines: i32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_HoughLinesDetector_getMaxLines_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_cuda_HoughLinesDetector_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_HoughLinesDetector_delete(instance: *mut c_void); - pub fn cv_cuda_HoughSegmentDetector_detect_const__InputArrayR_const__OutputArrayR_StreamR(instance: *mut c_void, src: *const c_void, lines: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_HoughSegmentDetector_detect_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, src: *const c_void, lines: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_HoughSegmentDetector_setRho_float(instance: *mut c_void, rho: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_HoughSegmentDetector_detect_const__InputArrayR_const__OutputArrayR_StreamR(instance: *mut c_void, src: *const c_void, lines: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_HoughSegmentDetector_detect_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, src: *const c_void, lines: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_HoughSegmentDetector_setRho_float(instance: *mut c_void, rho: f32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_HoughSegmentDetector_getRho_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_HoughSegmentDetector_setTheta_float(instance: *mut c_void, theta: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_HoughSegmentDetector_setTheta_float(instance: *mut c_void, theta: f32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_HoughSegmentDetector_getTheta_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_HoughSegmentDetector_setMinLineLength_int(instance: *mut c_void, min_line_length: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_HoughSegmentDetector_setMinLineLength_int(instance: *mut c_void, min_line_length: i32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_HoughSegmentDetector_getMinLineLength_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_HoughSegmentDetector_setMaxLineGap_int(instance: *mut c_void, max_line_gap: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_HoughSegmentDetector_setMaxLineGap_int(instance: *mut c_void, max_line_gap: i32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_HoughSegmentDetector_getMaxLineGap_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_HoughSegmentDetector_setMaxLines_int(instance: *mut c_void, max_lines: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_HoughSegmentDetector_setMaxLines_int(instance: *mut c_void, max_lines: i32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_HoughSegmentDetector_getMaxLines_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_HoughSegmentDetector_setThreshold_int(instance: *mut c_void, threshold: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_HoughSegmentDetector_setThreshold_int(instance: *mut c_void, threshold: i32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_HoughSegmentDetector_getThreshold_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_cuda_HoughSegmentDetector_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_HoughSegmentDetector_delete(instance: *mut c_void); - pub fn cv_cuda_TemplateMatching_match_const__InputArrayR_const__InputArrayR_const__OutputArrayR_StreamR(instance: *mut c_void, image: *const c_void, templ: *const c_void, result: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_TemplateMatching_match_const__InputArrayR_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, templ: *const c_void, result: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_TemplateMatching_match_const__InputArrayR_const__InputArrayR_const__OutputArrayR_StreamR(instance: *mut c_void, image: *const c_void, templ: *const c_void, result: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_TemplateMatching_match_const__InputArrayR_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, templ: *const c_void, result: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_cuda_TemplateMatching_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_TemplateMatching_delete(instance: *mut c_void); pub fn cv_PtrLcv_cuda_CLAHEG_getInnerPtr_const(instance: *const c_void) -> *mut c_void; @@ -4792,68 +4765,182 @@ mod cudaimgproc_sys { pub fn cv_PtrLcv_cuda_TemplateMatchingG_to_PtrOfAlgorithm(instance: *mut c_void) -> *mut c_void; } } -#[cfg(ocvrs_has_module_cudaimgproc)] pub use cudaimgproc_sys::*; -#[cfg(ocvrs_has_module_cudaobjdetect)] +mod cudalegacy_sys { + use super::*; + + extern "C" { + pub fn cv_cuda_calcOpticalFlowBM_const_GpuMatR_const_GpuMatR_Size_Size_Size_bool_GpuMatR_GpuMatR_GpuMatR(prev: *const c_void, curr: *const c_void, block_size: *const core::Size, shift_size: *const core::Size, max_range: *const core::Size, use_previous: bool, velx: *mut c_void, vely: *mut c_void, buf: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_calcOpticalFlowBM_const_GpuMatR_const_GpuMatR_Size_Size_Size_bool_GpuMatR_GpuMatR_GpuMatR_StreamR(prev: *const c_void, curr: *const c_void, block_size: *const core::Size, shift_size: *const core::Size, max_range: *const core::Size, use_previous: bool, velx: *mut c_void, vely: *mut c_void, buf: *mut c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_connectivityMask_const_GpuMatR_GpuMatR_const_ScalarR_const_ScalarR(image: *const c_void, mask: *mut c_void, lo: *const core::Scalar, hi: *const core::Scalar, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_connectivityMask_const_GpuMatR_GpuMatR_const_ScalarR_const_ScalarR_StreamR(image: *const c_void, mask: *mut c_void, lo: *const core::Scalar, hi: *const core::Scalar, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_createBackgroundSubtractorFGD(ocvrs_return: *mut Result<*mut c_void>); + pub fn cv_cuda_createBackgroundSubtractorFGD_const_FGDParamsR(params: *const c_void, ocvrs_return: *mut Result<*mut c_void>); + pub fn cv_cuda_createBackgroundSubtractorGMG(ocvrs_return: *mut Result<*mut c_void>); + pub fn cv_cuda_createBackgroundSubtractorGMG_int_double(initialization_frames: i32, decision_threshold: f64, ocvrs_return: *mut Result<*mut c_void>); + pub fn cv_cuda_createImagePyramid_const__InputArrayR(img: *const c_void, ocvrs_return: *mut Result<*mut c_void>); + pub fn cv_cuda_createImagePyramid_const__InputArrayR_int_StreamR(img: *const c_void, n_layers: i32, stream: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); + pub fn cv_cuda_createOpticalFlowNeedleMap_const_GpuMatR_const_GpuMatR_GpuMatR_GpuMatR(u: *const c_void, v: *const c_void, vertex: *mut c_void, colors: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_graphcut_GpuMatR_GpuMatR_GpuMatR_GpuMatR_GpuMatR_GpuMatR_GpuMatR(terminals: *mut c_void, left_transp: *mut c_void, right_transp: *mut c_void, top: *mut c_void, bottom: *mut c_void, labels: *mut c_void, buf: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_graphcut_GpuMatR_GpuMatR_GpuMatR_GpuMatR_GpuMatR_GpuMatR_GpuMatR_GpuMatR_GpuMatR_GpuMatR_GpuMatR(terminals: *mut c_void, left_transp: *mut c_void, right_transp: *mut c_void, top: *mut c_void, top_left: *mut c_void, top_right: *mut c_void, bottom: *mut c_void, bottom_left: *mut c_void, bottom_right: *mut c_void, labels: *mut c_void, buf: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_graphcut_GpuMatR_GpuMatR_GpuMatR_GpuMatR_GpuMatR_GpuMatR_GpuMatR_GpuMatR_GpuMatR_GpuMatR_GpuMatR_StreamR(terminals: *mut c_void, left_transp: *mut c_void, right_transp: *mut c_void, top: *mut c_void, top_left: *mut c_void, top_right: *mut c_void, bottom: *mut c_void, bottom_left: *mut c_void, bottom_right: *mut c_void, labels: *mut c_void, buf: *mut c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_graphcut_GpuMatR_GpuMatR_GpuMatR_GpuMatR_GpuMatR_GpuMatR_GpuMatR_StreamR(terminals: *mut c_void, left_transp: *mut c_void, right_transp: *mut c_void, top: *mut c_void, bottom: *mut c_void, labels: *mut c_void, buf: *mut c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_interpolateFrames_const_GpuMatR_const_GpuMatR_const_GpuMatR_const_GpuMatR_const_GpuMatR_const_GpuMatR_float_GpuMatR_GpuMatR(frame0: *const c_void, frame1: *const c_void, fu: *const c_void, fv: *const c_void, bu: *const c_void, bv: *const c_void, pos: f32, new_frame: *mut c_void, buf: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_interpolateFrames_const_GpuMatR_const_GpuMatR_const_GpuMatR_const_GpuMatR_const_GpuMatR_const_GpuMatR_float_GpuMatR_GpuMatR_StreamR(frame0: *const c_void, frame1: *const c_void, fu: *const c_void, fv: *const c_void, bu: *const c_void, bv: *const c_void, pos: f32, new_frame: *mut c_void, buf: *mut c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_labelComponents_const_GpuMatR_GpuMatR(mask: *const c_void, components: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_labelComponents_const_GpuMatR_GpuMatR_int_StreamR(mask: *const c_void, components: *mut c_void, flags: i32, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_projectPoints_const_GpuMatR_const_MatR_const_MatR_const_MatR_const_MatR_GpuMatR(src: *const c_void, rvec: *const c_void, tvec: *const c_void, camera_mat: *const c_void, dist_coef: *const c_void, dst: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_projectPoints_const_GpuMatR_const_MatR_const_MatR_const_MatR_const_MatR_GpuMatR_StreamR(src: *const c_void, rvec: *const c_void, tvec: *const c_void, camera_mat: *const c_void, dist_coef: *const c_void, dst: *mut c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_solvePnPRansac_const_MatR_const_MatR_const_MatR_const_MatR_MatR_MatR(object: *const c_void, image: *const c_void, camera_mat: *const c_void, dist_coef: *const c_void, rvec: *mut c_void, tvec: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_solvePnPRansac_const_MatR_const_MatR_const_MatR_const_MatR_MatR_MatR_bool_int_float_int_vectorLintGX(object: *const c_void, image: *const c_void, camera_mat: *const c_void, dist_coef: *const c_void, rvec: *mut c_void, tvec: *mut c_void, use_extrinsic_guess: bool, num_iters: i32, max_dist: f32, min_inlier_count: i32, inliers: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_transformPoints_const_GpuMatR_const_MatR_const_MatR_GpuMatR(src: *const c_void, rvec: *const c_void, tvec: *const c_void, dst: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_transformPoints_const_GpuMatR_const_MatR_const_MatR_GpuMatR_StreamR(src: *const c_void, rvec: *const c_void, tvec: *const c_void, dst: *mut c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_BackgroundSubtractorFGD_getForegroundRegions_const__OutputArrayR(instance: *mut c_void, foreground_regions: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_BackgroundSubtractorFGD_to_Algorithm(instance: *mut c_void) -> *mut c_void; + pub fn cv_cuda_BackgroundSubtractorFGD_to_BackgroundSubtractor(instance: *mut c_void) -> *mut c_void; + pub fn cv_cuda_BackgroundSubtractorFGD_delete(instance: *mut c_void); + pub fn cv_cuda_BackgroundSubtractorGMG_apply_const__InputArrayR_const__OutputArrayR_double_StreamR(instance: *mut c_void, image: *const c_void, fgmask: *const c_void, learning_rate: f64, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_BackgroundSubtractorGMG_getMaxFeatures_const(instance: *const c_void, ocvrs_return: *mut Result); + pub fn cv_cuda_BackgroundSubtractorGMG_setMaxFeatures_int(instance: *mut c_void, max_features: i32, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_BackgroundSubtractorGMG_getDefaultLearningRate_const(instance: *const c_void, ocvrs_return: *mut Result); + pub fn cv_cuda_BackgroundSubtractorGMG_setDefaultLearningRate_double(instance: *mut c_void, lr: f64, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_BackgroundSubtractorGMG_getNumFrames_const(instance: *const c_void, ocvrs_return: *mut Result); + pub fn cv_cuda_BackgroundSubtractorGMG_setNumFrames_int(instance: *mut c_void, nframes: i32, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_BackgroundSubtractorGMG_getQuantizationLevels_const(instance: *const c_void, ocvrs_return: *mut Result); + pub fn cv_cuda_BackgroundSubtractorGMG_setQuantizationLevels_int(instance: *mut c_void, nlevels: i32, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_BackgroundSubtractorGMG_getBackgroundPrior_const(instance: *const c_void, ocvrs_return: *mut Result); + pub fn cv_cuda_BackgroundSubtractorGMG_setBackgroundPrior_double(instance: *mut c_void, bgprior: f64, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_BackgroundSubtractorGMG_getSmoothingRadius_const(instance: *const c_void, ocvrs_return: *mut Result); + pub fn cv_cuda_BackgroundSubtractorGMG_setSmoothingRadius_int(instance: *mut c_void, radius: i32, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_BackgroundSubtractorGMG_getDecisionThreshold_const(instance: *const c_void, ocvrs_return: *mut Result); + pub fn cv_cuda_BackgroundSubtractorGMG_setDecisionThreshold_double(instance: *mut c_void, thresh: f64, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_BackgroundSubtractorGMG_getUpdateBackgroundModel_const(instance: *const c_void, ocvrs_return: *mut Result); + pub fn cv_cuda_BackgroundSubtractorGMG_setUpdateBackgroundModel_bool(instance: *mut c_void, update: bool, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_BackgroundSubtractorGMG_getMinVal_const(instance: *const c_void, ocvrs_return: *mut Result); + pub fn cv_cuda_BackgroundSubtractorGMG_setMinVal_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_BackgroundSubtractorGMG_getMaxVal_const(instance: *const c_void, ocvrs_return: *mut Result); + pub fn cv_cuda_BackgroundSubtractorGMG_setMaxVal_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_BackgroundSubtractorGMG_to_Algorithm(instance: *mut c_void) -> *mut c_void; + pub fn cv_cuda_BackgroundSubtractorGMG_to_BackgroundSubtractor(instance: *mut c_void) -> *mut c_void; + pub fn cv_cuda_BackgroundSubtractorGMG_delete(instance: *mut c_void); + pub fn cv_cuda_FGDParams_FGDParams(ocvrs_return: *mut Result<*mut c_void>); + pub fn cv_cuda_FGDParams_propLc_const(instance: *const c_void) -> i32; + pub fn cv_cuda_FGDParams_propLc_const_int(instance: *mut c_void, val: i32); + pub fn cv_cuda_FGDParams_propN1c_const(instance: *const c_void) -> i32; + pub fn cv_cuda_FGDParams_propN1c_const_int(instance: *mut c_void, val: i32); + pub fn cv_cuda_FGDParams_propN2c_const(instance: *const c_void) -> i32; + pub fn cv_cuda_FGDParams_propN2c_const_int(instance: *mut c_void, val: i32); + pub fn cv_cuda_FGDParams_propLcc_const(instance: *const c_void) -> i32; + pub fn cv_cuda_FGDParams_propLcc_const_int(instance: *mut c_void, val: i32); + pub fn cv_cuda_FGDParams_propN1cc_const(instance: *const c_void) -> i32; + pub fn cv_cuda_FGDParams_propN1cc_const_int(instance: *mut c_void, val: i32); + pub fn cv_cuda_FGDParams_propN2cc_const(instance: *const c_void) -> i32; + pub fn cv_cuda_FGDParams_propN2cc_const_int(instance: *mut c_void, val: i32); + pub fn cv_cuda_FGDParams_propIs_obj_without_holes_const(instance: *const c_void) -> bool; + pub fn cv_cuda_FGDParams_propIs_obj_without_holes_const_bool(instance: *mut c_void, val: bool); + pub fn cv_cuda_FGDParams_propPerform_morphing_const(instance: *const c_void) -> i32; + pub fn cv_cuda_FGDParams_propPerform_morphing_const_int(instance: *mut c_void, val: i32); + pub fn cv_cuda_FGDParams_propAlpha1_const(instance: *const c_void) -> f32; + pub fn cv_cuda_FGDParams_propAlpha1_const_float(instance: *mut c_void, val: f32); + pub fn cv_cuda_FGDParams_propAlpha2_const(instance: *const c_void) -> f32; + pub fn cv_cuda_FGDParams_propAlpha2_const_float(instance: *mut c_void, val: f32); + pub fn cv_cuda_FGDParams_propAlpha3_const(instance: *const c_void) -> f32; + pub fn cv_cuda_FGDParams_propAlpha3_const_float(instance: *mut c_void, val: f32); + pub fn cv_cuda_FGDParams_propDelta_const(instance: *const c_void) -> f32; + pub fn cv_cuda_FGDParams_propDelta_const_float(instance: *mut c_void, val: f32); + pub fn cv_cuda_FGDParams_propT_const(instance: *const c_void) -> f32; + pub fn cv_cuda_FGDParams_propT_const_float(instance: *mut c_void, val: f32); + pub fn cv_cuda_FGDParams_propMinArea_const(instance: *const c_void) -> f32; + pub fn cv_cuda_FGDParams_propMinArea_const_float(instance: *mut c_void, val: f32); + pub fn cv_cuda_FGDParams_delete(instance: *mut c_void); + pub fn cv_cuda_FastOpticalFlowBM_operator___const_GpuMatR_const_GpuMatR_GpuMatR_GpuMatR_int_int_StreamR(instance: *mut c_void, i0: *const c_void, i1: *const c_void, flowx: *mut c_void, flowy: *mut c_void, search_window: i32, block_window: i32, s: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_FastOpticalFlowBM_operator___const_GpuMatR_const_GpuMatR_GpuMatR_GpuMatR(instance: *mut c_void, i0: *const c_void, i1: *const c_void, flowx: *mut c_void, flowy: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_FastOpticalFlowBM_defaultNew_const() -> *mut c_void; + pub fn cv_cuda_FastOpticalFlowBM_delete(instance: *mut c_void); + pub fn cv_cuda_ImagePyramid_getLayer_const_const__OutputArrayR_Size_StreamR(instance: *const c_void, out_img: *const c_void, out_roi: *const core::Size, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_ImagePyramid_getLayer_const_const__OutputArrayR_Size(instance: *const c_void, out_img: *const c_void, out_roi: *const core::Size, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_ImagePyramid_to_Algorithm(instance: *mut c_void) -> *mut c_void; + pub fn cv_cuda_ImagePyramid_delete(instance: *mut c_void); + pub fn cv_PtrLcv_cuda_BackgroundSubtractorFGDG_getInnerPtr_const(instance: *const c_void) -> *mut c_void; + pub fn cv_PtrLcv_cuda_BackgroundSubtractorFGDG_getInnerPtrMut(instance: *mut c_void) -> *mut c_void; + pub fn cv_PtrLcv_cuda_BackgroundSubtractorFGDG_new_null_const() -> *mut c_void; + pub fn cv_PtrLcv_cuda_BackgroundSubtractorFGDG_delete(instance: *mut c_void); + pub fn cv_PtrLcv_cuda_BackgroundSubtractorFGDG_to_PtrOfAlgorithm(instance: *mut c_void) -> *mut c_void; + pub fn cv_PtrLcv_cuda_BackgroundSubtractorFGDG_to_PtrOfBackgroundSubtractor(instance: *mut c_void) -> *mut c_void; + pub fn cv_PtrLcv_cuda_BackgroundSubtractorGMGG_getInnerPtr_const(instance: *const c_void) -> *mut c_void; + pub fn cv_PtrLcv_cuda_BackgroundSubtractorGMGG_getInnerPtrMut(instance: *mut c_void) -> *mut c_void; + pub fn cv_PtrLcv_cuda_BackgroundSubtractorGMGG_new_null_const() -> *mut c_void; + pub fn cv_PtrLcv_cuda_BackgroundSubtractorGMGG_delete(instance: *mut c_void); + pub fn cv_PtrLcv_cuda_BackgroundSubtractorGMGG_to_PtrOfAlgorithm(instance: *mut c_void) -> *mut c_void; + pub fn cv_PtrLcv_cuda_BackgroundSubtractorGMGG_to_PtrOfBackgroundSubtractor(instance: *mut c_void) -> *mut c_void; + pub fn cv_PtrLcv_cuda_ImagePyramidG_getInnerPtr_const(instance: *const c_void) -> *mut c_void; + pub fn cv_PtrLcv_cuda_ImagePyramidG_getInnerPtrMut(instance: *mut c_void) -> *mut c_void; + pub fn cv_PtrLcv_cuda_ImagePyramidG_new_null_const() -> *mut c_void; + pub fn cv_PtrLcv_cuda_ImagePyramidG_delete(instance: *mut c_void); + pub fn cv_PtrLcv_cuda_ImagePyramidG_to_PtrOfAlgorithm(instance: *mut c_void) -> *mut c_void; + } +} +pub use cudalegacy_sys::*; + mod cudaobjdetect_sys { use super::*; extern "C" { pub fn cv_cuda_CascadeClassifier_create_const_StringR(filename: *const c_char, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_CascadeClassifier_create_const_FileStorageR(file: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_cuda_CascadeClassifier_setMaxObjectSize_Size(instance: *mut c_void, max_object_size: *const core::Size, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_CascadeClassifier_setMaxObjectSize_Size(instance: *mut c_void, max_object_size: *const core::Size, ocvrs_return: *mut Result<()>); pub fn cv_cuda_CascadeClassifier_getMaxObjectSize_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_CascadeClassifier_setMinObjectSize_Size(instance: *mut c_void, min_size: *const core::Size, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_CascadeClassifier_setMinObjectSize_Size(instance: *mut c_void, min_size: *const core::Size, ocvrs_return: *mut Result<()>); pub fn cv_cuda_CascadeClassifier_getMinObjectSize_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_CascadeClassifier_setScaleFactor_double(instance: *mut c_void, scale_factor: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_CascadeClassifier_setScaleFactor_double(instance: *mut c_void, scale_factor: f64, ocvrs_return: *mut Result<()>); pub fn cv_cuda_CascadeClassifier_getScaleFactor_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_CascadeClassifier_setMinNeighbors_int(instance: *mut c_void, min_neighbors: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_CascadeClassifier_setMinNeighbors_int(instance: *mut c_void, min_neighbors: i32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_CascadeClassifier_getMinNeighbors_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_CascadeClassifier_setFindLargestObject_bool(instance: *mut c_void, find_largest_object: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_CascadeClassifier_setFindLargestObject_bool(instance: *mut c_void, find_largest_object: bool, ocvrs_return: *mut Result<()>); pub fn cv_cuda_CascadeClassifier_getFindLargestObject(instance: *mut c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_CascadeClassifier_setMaxNumObjects_int(instance: *mut c_void, max_num_objects: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_CascadeClassifier_setMaxNumObjects_int(instance: *mut c_void, max_num_objects: i32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_CascadeClassifier_getMaxNumObjects_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_cuda_CascadeClassifier_getClassifierSize_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_CascadeClassifier_detectMultiScale_const__InputArrayR_const__OutputArrayR_StreamR(instance: *mut c_void, image: *const c_void, objects: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_CascadeClassifier_detectMultiScale_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, objects: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_CascadeClassifier_convert_const__OutputArrayR_vectorLRectGR(instance: *mut c_void, gpu_objects: *const c_void, objects: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_CascadeClassifier_detectMultiScale_const__InputArrayR_const__OutputArrayR_StreamR(instance: *mut c_void, image: *const c_void, objects: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_CascadeClassifier_detectMultiScale_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, objects: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_CascadeClassifier_convert_const__OutputArrayR_vectorLRectGR(instance: *mut c_void, gpu_objects: *const c_void, objects: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_cuda_CascadeClassifier_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_CascadeClassifier_delete(instance: *mut c_void); pub fn cv_cuda_HOG_create_Size_Size_Size_Size_int(win_size: *const core::Size, block_size: *const core::Size, block_stride: *const core::Size, cell_size: *const core::Size, nbins: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_HOG_create(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_cuda_HOG_setWinSigma_double(instance: *mut c_void, win_sigma: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_HOG_setWinSigma_double(instance: *mut c_void, win_sigma: f64, ocvrs_return: *mut Result<()>); pub fn cv_cuda_HOG_getWinSigma_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_HOG_setL2HysThreshold_double(instance: *mut c_void, threshold_l2hys: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_HOG_setL2HysThreshold_double(instance: *mut c_void, threshold_l2hys: f64, ocvrs_return: *mut Result<()>); pub fn cv_cuda_HOG_getL2HysThreshold_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_HOG_setGammaCorrection_bool(instance: *mut c_void, gamma_correction: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_HOG_setGammaCorrection_bool(instance: *mut c_void, gamma_correction: bool, ocvrs_return: *mut Result<()>); pub fn cv_cuda_HOG_getGammaCorrection_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_HOG_setNumLevels_int(instance: *mut c_void, nlevels: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_HOG_setNumLevels_int(instance: *mut c_void, nlevels: i32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_HOG_getNumLevels_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_HOG_setHitThreshold_double(instance: *mut c_void, hit_threshold: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_HOG_setHitThreshold_double(instance: *mut c_void, hit_threshold: f64, ocvrs_return: *mut Result<()>); pub fn cv_cuda_HOG_getHitThreshold_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_HOG_setWinStride_Size(instance: *mut c_void, win_stride: *const core::Size, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_HOG_setWinStride_Size(instance: *mut c_void, win_stride: *const core::Size, ocvrs_return: *mut Result<()>); pub fn cv_cuda_HOG_getWinStride_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_HOG_setScaleFactor_double(instance: *mut c_void, scale0: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_HOG_setScaleFactor_double(instance: *mut c_void, scale0: f64, ocvrs_return: *mut Result<()>); pub fn cv_cuda_HOG_getScaleFactor_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_HOG_setGroupThreshold_int(instance: *mut c_void, group_threshold: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_HOG_setGroupThreshold_int(instance: *mut c_void, group_threshold: i32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_HOG_getGroupThreshold_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_HOG_setDescriptorFormat_DescriptorStorageFormat(instance: *mut c_void, descr_format: crate::objdetect::HOGDescriptor_DescriptorStorageFormat, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_HOG_setDescriptorFormat_DescriptorStorageFormat(instance: *mut c_void, descr_format: crate::objdetect::HOGDescriptor_DescriptorStorageFormat, ocvrs_return: *mut Result<()>); pub fn cv_cuda_HOG_getDescriptorFormat_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_cuda_HOG_getDescriptorSize_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_cuda_HOG_getBlockHistogramSize_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_HOG_setSVMDetector_const__InputArrayR(instance: *mut c_void, detector: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_HOG_setSVMDetector_const__InputArrayR(instance: *mut c_void, detector: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_cuda_HOG_getDefaultPeopleDetector_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_cuda_HOG_detect_const__InputArrayR_vectorLPointGR_vectorLdoubleGX(instance: *mut c_void, img: *const c_void, found_locations: *mut c_void, confidences: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_HOG_detect_const__InputArrayR_vectorLPointGR(instance: *mut c_void, img: *const c_void, found_locations: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_HOG_detect_const__InputArrayR_vectorLPointGR_vectorLdoubleGR(instance: *mut c_void, img: *const c_void, found_locations: *mut c_void, confidences: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_HOG_detectWithoutConf_const__InputArrayR_vectorLPointGR(instance: *mut c_void, img: *const c_void, found_locations: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_HOG_detectMultiScale_const__InputArrayR_vectorLRectGR_vectorLdoubleGX(instance: *mut c_void, img: *const c_void, found_locations: *mut c_void, confidences: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_HOG_detectMultiScale_const__InputArrayR_vectorLRectGR(instance: *mut c_void, img: *const c_void, found_locations: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_HOG_detectMultiScale_const__InputArrayR_vectorLRectGR_vectorLdoubleGR(instance: *mut c_void, img: *const c_void, found_locations: *mut c_void, confidences: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_HOG_detectMultiScaleWithoutConf_const__InputArrayR_vectorLRectGR(instance: *mut c_void, img: *const c_void, found_locations: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_HOG_compute_const__InputArrayR_const__OutputArrayR_StreamR(instance: *mut c_void, img: *const c_void, descriptors: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_HOG_compute_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, img: *const c_void, descriptors: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_HOG_detect_const__InputArrayR_vectorLPointGR_vectorLdoubleGX(instance: *mut c_void, img: *const c_void, found_locations: *mut c_void, confidences: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_HOG_detect_const__InputArrayR_vectorLPointGR(instance: *mut c_void, img: *const c_void, found_locations: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_HOG_detect_const__InputArrayR_vectorLPointGR_vectorLdoubleGR(instance: *mut c_void, img: *const c_void, found_locations: *mut c_void, confidences: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_HOG_detectWithoutConf_const__InputArrayR_vectorLPointGR(instance: *mut c_void, img: *const c_void, found_locations: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_HOG_detectMultiScale_const__InputArrayR_vectorLRectGR_vectorLdoubleGX(instance: *mut c_void, img: *const c_void, found_locations: *mut c_void, confidences: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_HOG_detectMultiScale_const__InputArrayR_vectorLRectGR(instance: *mut c_void, img: *const c_void, found_locations: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_HOG_detectMultiScale_const__InputArrayR_vectorLRectGR_vectorLdoubleGR(instance: *mut c_void, img: *const c_void, found_locations: *mut c_void, confidences: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_HOG_detectMultiScaleWithoutConf_const__InputArrayR_vectorLRectGR(instance: *mut c_void, img: *const c_void, found_locations: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_HOG_compute_const__InputArrayR_const__OutputArrayR_StreamR(instance: *mut c_void, img: *const c_void, descriptors: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_HOG_compute_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, img: *const c_void, descriptors: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_cuda_HOG_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_HOG_delete(instance: *mut c_void); pub fn cv_PtrLcv_cuda_CascadeClassifierG_getInnerPtr_const(instance: *const c_void) -> *mut c_void; @@ -4868,33 +4955,31 @@ mod cudaobjdetect_sys { pub fn cv_PtrLcv_cuda_HOGG_to_PtrOfAlgorithm(instance: *mut c_void) -> *mut c_void; } } -#[cfg(ocvrs_has_module_cudaobjdetect)] pub use cudaobjdetect_sys::*; -#[cfg(ocvrs_has_module_cudaoptflow)] mod cudaoptflow_sys { use super::*; extern "C" { pub fn cv_cuda_BroxOpticalFlow_getFlowSmoothness_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_BroxOpticalFlow_setFlowSmoothness_double(instance: *mut c_void, alpha: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_BroxOpticalFlow_setFlowSmoothness_double(instance: *mut c_void, alpha: f64, ocvrs_return: *mut Result<()>); pub fn cv_cuda_BroxOpticalFlow_getGradientConstancyImportance_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_BroxOpticalFlow_setGradientConstancyImportance_double(instance: *mut c_void, gamma: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_BroxOpticalFlow_setGradientConstancyImportance_double(instance: *mut c_void, gamma: f64, ocvrs_return: *mut Result<()>); pub fn cv_cuda_BroxOpticalFlow_getPyramidScaleFactor_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_BroxOpticalFlow_setPyramidScaleFactor_double(instance: *mut c_void, scale_factor: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_BroxOpticalFlow_setPyramidScaleFactor_double(instance: *mut c_void, scale_factor: f64, ocvrs_return: *mut Result<()>); pub fn cv_cuda_BroxOpticalFlow_getInnerIterations_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_BroxOpticalFlow_setInnerIterations_int(instance: *mut c_void, inner_iterations: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_BroxOpticalFlow_setInnerIterations_int(instance: *mut c_void, inner_iterations: i32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_BroxOpticalFlow_getOuterIterations_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_BroxOpticalFlow_setOuterIterations_int(instance: *mut c_void, outer_iterations: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_BroxOpticalFlow_setOuterIterations_int(instance: *mut c_void, outer_iterations: i32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_BroxOpticalFlow_getSolverIterations_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_BroxOpticalFlow_setSolverIterations_int(instance: *mut c_void, solver_iterations: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_BroxOpticalFlow_setSolverIterations_int(instance: *mut c_void, solver_iterations: i32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_BroxOpticalFlow_create_double_double_double_int_int_int(alpha: f64, gamma: f64, scale_factor: f64, inner_iterations: i32, outer_iterations: i32, solver_iterations: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_BroxOpticalFlow_create(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_BroxOpticalFlow_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_BroxOpticalFlow_to_CUDA_DenseOpticalFlow(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_BroxOpticalFlow_delete(instance: *mut c_void); - pub fn cv_cuda_DenseOpticalFlow_calc_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_StreamR(instance: *mut c_void, i0: *const c_void, i1: *const c_void, flow: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_DenseOpticalFlow_calc_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR(instance: *mut c_void, i0: *const c_void, i1: *const c_void, flow: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_DenseOpticalFlow_calc_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_StreamR(instance: *mut c_void, i0: *const c_void, i1: *const c_void, flow: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_DenseOpticalFlow_calc_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR(instance: *mut c_void, i0: *const c_void, i1: *const c_void, flow: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_cuda_DenseOpticalFlow_to_CUDA_BroxOpticalFlow(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_DenseOpticalFlow_to_CUDA_DensePyrLKOpticalFlow(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_DenseOpticalFlow_to_CUDA_FarnebackOpticalFlow(instance: *mut c_void) -> *mut c_void; @@ -4902,54 +4987,54 @@ mod cudaoptflow_sys { pub fn cv_cuda_DenseOpticalFlow_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_DenseOpticalFlow_delete(instance: *mut c_void); pub fn cv_cuda_DensePyrLKOpticalFlow_getWinSize_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_DensePyrLKOpticalFlow_setWinSize_Size(instance: *mut c_void, win_size: *const core::Size, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_DensePyrLKOpticalFlow_setWinSize_Size(instance: *mut c_void, win_size: *const core::Size, ocvrs_return: *mut Result<()>); pub fn cv_cuda_DensePyrLKOpticalFlow_getMaxLevel_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_DensePyrLKOpticalFlow_setMaxLevel_int(instance: *mut c_void, max_level: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_DensePyrLKOpticalFlow_setMaxLevel_int(instance: *mut c_void, max_level: i32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_DensePyrLKOpticalFlow_getNumIters_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_DensePyrLKOpticalFlow_setNumIters_int(instance: *mut c_void, iters: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_DensePyrLKOpticalFlow_setNumIters_int(instance: *mut c_void, iters: i32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_DensePyrLKOpticalFlow_getUseInitialFlow_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_DensePyrLKOpticalFlow_setUseInitialFlow_bool(instance: *mut c_void, use_initial_flow: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_DensePyrLKOpticalFlow_setUseInitialFlow_bool(instance: *mut c_void, use_initial_flow: bool, ocvrs_return: *mut Result<()>); pub fn cv_cuda_DensePyrLKOpticalFlow_create_Size_int_int_bool(win_size: *const core::Size, max_level: i32, iters: i32, use_initial_flow: bool, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_DensePyrLKOpticalFlow_create(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_DensePyrLKOpticalFlow_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_DensePyrLKOpticalFlow_to_CUDA_DenseOpticalFlow(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_DensePyrLKOpticalFlow_delete(instance: *mut c_void); pub fn cv_cuda_FarnebackOpticalFlow_getNumLevels_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_FarnebackOpticalFlow_setNumLevels_int(instance: *mut c_void, num_levels: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_FarnebackOpticalFlow_setNumLevels_int(instance: *mut c_void, num_levels: i32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_FarnebackOpticalFlow_getPyrScale_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_FarnebackOpticalFlow_setPyrScale_double(instance: *mut c_void, pyr_scale: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_FarnebackOpticalFlow_setPyrScale_double(instance: *mut c_void, pyr_scale: f64, ocvrs_return: *mut Result<()>); pub fn cv_cuda_FarnebackOpticalFlow_getFastPyramids_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_FarnebackOpticalFlow_setFastPyramids_bool(instance: *mut c_void, fast_pyramids: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_FarnebackOpticalFlow_setFastPyramids_bool(instance: *mut c_void, fast_pyramids: bool, ocvrs_return: *mut Result<()>); pub fn cv_cuda_FarnebackOpticalFlow_getWinSize_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_FarnebackOpticalFlow_setWinSize_int(instance: *mut c_void, win_size: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_FarnebackOpticalFlow_setWinSize_int(instance: *mut c_void, win_size: i32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_FarnebackOpticalFlow_getNumIters_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_FarnebackOpticalFlow_setNumIters_int(instance: *mut c_void, num_iters: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_FarnebackOpticalFlow_setNumIters_int(instance: *mut c_void, num_iters: i32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_FarnebackOpticalFlow_getPolyN_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_FarnebackOpticalFlow_setPolyN_int(instance: *mut c_void, poly_n: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_FarnebackOpticalFlow_setPolyN_int(instance: *mut c_void, poly_n: i32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_FarnebackOpticalFlow_getPolySigma_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_FarnebackOpticalFlow_setPolySigma_double(instance: *mut c_void, poly_sigma: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_FarnebackOpticalFlow_setPolySigma_double(instance: *mut c_void, poly_sigma: f64, ocvrs_return: *mut Result<()>); pub fn cv_cuda_FarnebackOpticalFlow_getFlags_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_FarnebackOpticalFlow_setFlags_int(instance: *mut c_void, flags: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_FarnebackOpticalFlow_setFlags_int(instance: *mut c_void, flags: i32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_FarnebackOpticalFlow_create_int_double_bool_int_int_int_double_int(num_levels: i32, pyr_scale: f64, fast_pyramids: bool, win_size: i32, num_iters: i32, poly_n: i32, poly_sigma: f64, flags: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_FarnebackOpticalFlow_create(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_FarnebackOpticalFlow_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_FarnebackOpticalFlow_to_CUDA_DenseOpticalFlow(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_FarnebackOpticalFlow_delete(instance: *mut c_void); - pub fn cv_cuda_NvidiaHWOpticalFlow_calc_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_StreamR_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, input_image: *const c_void, reference_image: *const c_void, flow: *const c_void, stream: *mut c_void, hint: *const c_void, cost: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_NvidiaHWOpticalFlow_calc_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR(instance: *mut c_void, input_image: *const c_void, reference_image: *const c_void, flow: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_NvidiaHWOpticalFlow_collectGarbage(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_NvidiaHWOpticalFlow_calc_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_StreamR_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, input_image: *const c_void, reference_image: *const c_void, flow: *const c_void, stream: *mut c_void, hint: *const c_void, cost: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_NvidiaHWOpticalFlow_calc_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR(instance: *mut c_void, input_image: *const c_void, reference_image: *const c_void, flow: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_NvidiaHWOpticalFlow_collectGarbage(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_cuda_NvidiaHWOpticalFlow_getGridSize_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_cuda_NvidiaHWOpticalFlow_to_CUDA_NvidiaOpticalFlow_1_0(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_NvidiaHWOpticalFlow_to_CUDA_NvidiaOpticalFlow_2_0(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_NvidiaHWOpticalFlow_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_NvidiaHWOpticalFlow_delete(instance: *mut c_void); - pub fn cv_cuda_NvidiaOpticalFlow_1_0_upSampler_const__InputArrayR_Size_int_const__InputOutputArrayR(instance: *mut c_void, flow: *const c_void, image_size: *const core::Size, grid_size: i32, upsampled_flow: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_NvidiaOpticalFlow_1_0_upSampler_const__InputArrayR_Size_int_const__InputOutputArrayR(instance: *mut c_void, flow: *const c_void, image_size: *const core::Size, grid_size: i32, upsampled_flow: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_cuda_NvidiaOpticalFlow_1_0_create_Size_NVIDIA_OF_PERF_LEVEL_bool_bool_bool_int_StreamR_StreamR(image_size: *const core::Size, perf_preset: crate::cudaoptflow::CUDA_NvidiaOpticalFlow_1_0_NVIDIA_OF_PERF_LEVEL, enable_temporal_hints: bool, enable_external_hints: bool, enable_cost_buffer: bool, gpu_id: i32, input_stream: *mut c_void, output_stream: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_NvidiaOpticalFlow_1_0_create_Size(image_size: *const core::Size, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_NvidiaOpticalFlow_1_0_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_NvidiaOpticalFlow_1_0_to_CUDA_NvidiaHWOpticalFlow(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_NvidiaOpticalFlow_1_0_delete(instance: *mut c_void); - pub fn cv_cuda_NvidiaOpticalFlow_2_0_convertToFloat_const__InputArrayR_const__InputOutputArrayR(instance: *mut c_void, flow: *const c_void, float_flow: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_NvidiaOpticalFlow_2_0_convertToFloat_const__InputArrayR_const__InputOutputArrayR(instance: *mut c_void, flow: *const c_void, float_flow: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_cuda_NvidiaOpticalFlow_2_0_create_Size_NVIDIA_OF_PERF_LEVEL_NVIDIA_OF_OUTPUT_VECTOR_GRID_SIZE_NVIDIA_OF_HINT_VECTOR_GRID_SIZE_bool_bool_bool_int_StreamR_StreamR(image_size: *const core::Size, perf_preset: crate::cudaoptflow::CUDA_NvidiaOpticalFlow_2_0_NVIDIA_OF_PERF_LEVEL, output_grid_size: crate::cudaoptflow::CUDA_NvidiaOpticalFlow_2_0_NVIDIA_OF_OUTPUT_VECTOR_GRID_SIZE, hint_grid_size: crate::cudaoptflow::CUDA_NvidiaOpticalFlow_2_0_NVIDIA_OF_HINT_VECTOR_GRID_SIZE, enable_temporal_hints: bool, enable_external_hints: bool, enable_cost_buffer: bool, gpu_id: i32, input_stream: *mut c_void, output_stream: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_NvidiaOpticalFlow_2_0_create_Size(image_size: *const core::Size, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_NvidiaOpticalFlow_2_0_create_Size_vectorLRectG_NVIDIA_OF_PERF_LEVEL_NVIDIA_OF_OUTPUT_VECTOR_GRID_SIZE_NVIDIA_OF_HINT_VECTOR_GRID_SIZE_bool_bool_bool_int_StreamR_StreamR(image_size: *const core::Size, roi_data: *mut c_void, perf_preset: crate::cudaoptflow::CUDA_NvidiaOpticalFlow_2_0_NVIDIA_OF_PERF_LEVEL, output_grid_size: crate::cudaoptflow::CUDA_NvidiaOpticalFlow_2_0_NVIDIA_OF_OUTPUT_VECTOR_GRID_SIZE, hint_grid_size: crate::cudaoptflow::CUDA_NvidiaOpticalFlow_2_0_NVIDIA_OF_HINT_VECTOR_GRID_SIZE, enable_temporal_hints: bool, enable_external_hints: bool, enable_cost_buffer: bool, gpu_id: i32, input_stream: *mut c_void, output_stream: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); @@ -4958,43 +5043,43 @@ mod cudaoptflow_sys { pub fn cv_cuda_NvidiaOpticalFlow_2_0_to_CUDA_NvidiaHWOpticalFlow(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_NvidiaOpticalFlow_2_0_delete(instance: *mut c_void); pub fn cv_cuda_OpticalFlowDual_TVL1_getTau_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_OpticalFlowDual_TVL1_setTau_double(instance: *mut c_void, tau: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_OpticalFlowDual_TVL1_setTau_double(instance: *mut c_void, tau: f64, ocvrs_return: *mut Result<()>); pub fn cv_cuda_OpticalFlowDual_TVL1_getLambda_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_OpticalFlowDual_TVL1_setLambda_double(instance: *mut c_void, lambda: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_OpticalFlowDual_TVL1_setLambda_double(instance: *mut c_void, lambda: f64, ocvrs_return: *mut Result<()>); pub fn cv_cuda_OpticalFlowDual_TVL1_getGamma_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_OpticalFlowDual_TVL1_setGamma_double(instance: *mut c_void, gamma: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_OpticalFlowDual_TVL1_setGamma_double(instance: *mut c_void, gamma: f64, ocvrs_return: *mut Result<()>); pub fn cv_cuda_OpticalFlowDual_TVL1_getTheta_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_OpticalFlowDual_TVL1_setTheta_double(instance: *mut c_void, theta: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_OpticalFlowDual_TVL1_setTheta_double(instance: *mut c_void, theta: f64, ocvrs_return: *mut Result<()>); pub fn cv_cuda_OpticalFlowDual_TVL1_getNumScales_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_OpticalFlowDual_TVL1_setNumScales_int(instance: *mut c_void, nscales: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_OpticalFlowDual_TVL1_setNumScales_int(instance: *mut c_void, nscales: i32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_OpticalFlowDual_TVL1_getNumWarps_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_OpticalFlowDual_TVL1_setNumWarps_int(instance: *mut c_void, warps: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_OpticalFlowDual_TVL1_setNumWarps_int(instance: *mut c_void, warps: i32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_OpticalFlowDual_TVL1_getEpsilon_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_OpticalFlowDual_TVL1_setEpsilon_double(instance: *mut c_void, epsilon: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_OpticalFlowDual_TVL1_setEpsilon_double(instance: *mut c_void, epsilon: f64, ocvrs_return: *mut Result<()>); pub fn cv_cuda_OpticalFlowDual_TVL1_getNumIterations_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_OpticalFlowDual_TVL1_setNumIterations_int(instance: *mut c_void, iterations: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_OpticalFlowDual_TVL1_setNumIterations_int(instance: *mut c_void, iterations: i32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_OpticalFlowDual_TVL1_getScaleStep_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_OpticalFlowDual_TVL1_setScaleStep_double(instance: *mut c_void, scale_step: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_OpticalFlowDual_TVL1_setScaleStep_double(instance: *mut c_void, scale_step: f64, ocvrs_return: *mut Result<()>); pub fn cv_cuda_OpticalFlowDual_TVL1_getUseInitialFlow_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_OpticalFlowDual_TVL1_setUseInitialFlow_bool(instance: *mut c_void, use_initial_flow: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_OpticalFlowDual_TVL1_setUseInitialFlow_bool(instance: *mut c_void, use_initial_flow: bool, ocvrs_return: *mut Result<()>); pub fn cv_cuda_OpticalFlowDual_TVL1_create_double_double_double_int_int_double_int_double_double_bool(tau: f64, lambda: f64, theta: f64, nscales: i32, warps: i32, epsilon: f64, iterations: i32, scale_step: f64, gamma: f64, use_initial_flow: bool, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_OpticalFlowDual_TVL1_create(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_OpticalFlowDual_TVL1_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_OpticalFlowDual_TVL1_to_CUDA_DenseOpticalFlow(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_OpticalFlowDual_TVL1_delete(instance: *mut c_void); - pub fn cv_cuda_SparseOpticalFlow_calc_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__OutputArrayR_const__OutputArrayR_StreamR(instance: *mut c_void, prev_img: *const c_void, next_img: *const c_void, prev_pts: *const c_void, next_pts: *const c_void, status: *const c_void, err: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_SparseOpticalFlow_calc_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__OutputArrayR(instance: *mut c_void, prev_img: *const c_void, next_img: *const c_void, prev_pts: *const c_void, next_pts: *const c_void, status: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_SparseOpticalFlow_calc_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__OutputArrayR_const__OutputArrayR_StreamR(instance: *mut c_void, prev_img: *const c_void, next_img: *const c_void, prev_pts: *const c_void, next_pts: *const c_void, status: *const c_void, err: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_SparseOpticalFlow_calc_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__OutputArrayR(instance: *mut c_void, prev_img: *const c_void, next_img: *const c_void, prev_pts: *const c_void, next_pts: *const c_void, status: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_cuda_SparseOpticalFlow_to_CUDA_SparsePyrLKOpticalFlow(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_SparseOpticalFlow_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_SparseOpticalFlow_delete(instance: *mut c_void); pub fn cv_cuda_SparsePyrLKOpticalFlow_getWinSize_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_SparsePyrLKOpticalFlow_setWinSize_Size(instance: *mut c_void, win_size: *const core::Size, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_SparsePyrLKOpticalFlow_setWinSize_Size(instance: *mut c_void, win_size: *const core::Size, ocvrs_return: *mut Result<()>); pub fn cv_cuda_SparsePyrLKOpticalFlow_getMaxLevel_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_SparsePyrLKOpticalFlow_setMaxLevel_int(instance: *mut c_void, max_level: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_SparsePyrLKOpticalFlow_setMaxLevel_int(instance: *mut c_void, max_level: i32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_SparsePyrLKOpticalFlow_getNumIters_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_SparsePyrLKOpticalFlow_setNumIters_int(instance: *mut c_void, iters: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_SparsePyrLKOpticalFlow_setNumIters_int(instance: *mut c_void, iters: i32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_SparsePyrLKOpticalFlow_getUseInitialFlow_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_SparsePyrLKOpticalFlow_setUseInitialFlow_bool(instance: *mut c_void, use_initial_flow: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_SparsePyrLKOpticalFlow_setUseInitialFlow_bool(instance: *mut c_void, use_initial_flow: bool, ocvrs_return: *mut Result<()>); pub fn cv_cuda_SparsePyrLKOpticalFlow_create_Size_int_int_bool(win_size: *const core::Size, max_level: i32, iters: i32, use_initial_flow: bool, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_SparsePyrLKOpticalFlow_create(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_SparsePyrLKOpticalFlow_to_Algorithm(instance: *mut c_void) -> *mut c_void; @@ -5059,10 +5144,8 @@ mod cudaoptflow_sys { pub fn cv_PtrLcv_cuda_SparsePyrLKOpticalFlowG_to_PtrOfCUDA_SparseOpticalFlow(instance: *mut c_void) -> *mut c_void; } } -#[cfg(ocvrs_has_module_cudaoptflow)] pub use cudaoptflow_sys::*; -#[cfg(ocvrs_has_module_cudastereo)] mod cudastereo_sys { use super::*; @@ -5077,66 +5160,66 @@ mod cudastereo_sys { pub fn cv_cuda_createStereoConstantSpaceBP_int_int_int_int_int(ndisp: i32, iters: i32, levels: i32, nr_plane: i32, msg_type: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_createStereoSGM(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_createStereoSGM_int_int_int_int_int_int(min_disparity: i32, num_disparities: i32, p1: i32, p2: i32, uniqueness_ratio: i32, mode: i32, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_cuda_drawColorDisp_const__InputArrayR_const__OutputArrayR_int(src_disp: *const c_void, dst_disp: *const c_void, ndisp: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_drawColorDisp_const__InputArrayR_const__OutputArrayR_int_StreamR(src_disp: *const c_void, dst_disp: *const c_void, ndisp: i32, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_reprojectImageTo3D_GpuMat_GpuMatR_Mat(disp: *mut c_void, xyzw: *mut c_void, q: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_reprojectImageTo3D_GpuMat_GpuMatR_Mat_int_StreamR(disp: *mut c_void, xyzw: *mut c_void, q: *mut c_void, dst_cn: i32, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_reprojectImageTo3D_const__InputArrayR_const__OutputArrayR_const__InputArrayR(disp: *const c_void, xyzw: *const c_void, q: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_reprojectImageTo3D_const__InputArrayR_const__OutputArrayR_const__InputArrayR_int_StreamR(disp: *const c_void, xyzw: *const c_void, q: *const c_void, dst_cn: i32, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_DisparityBilateralFilter_apply_const__InputArrayR_const__InputArrayR_const__OutputArrayR_StreamR(instance: *mut c_void, disparity: *const c_void, image: *const c_void, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_DisparityBilateralFilter_apply_const__InputArrayR_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, disparity: *const c_void, image: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_drawColorDisp_const__InputArrayR_const__OutputArrayR_int(src_disp: *const c_void, dst_disp: *const c_void, ndisp: i32, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_drawColorDisp_const__InputArrayR_const__OutputArrayR_int_StreamR(src_disp: *const c_void, dst_disp: *const c_void, ndisp: i32, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_reprojectImageTo3D_GpuMat_GpuMatR_Mat(disp: *mut c_void, xyzw: *mut c_void, q: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_reprojectImageTo3D_GpuMat_GpuMatR_Mat_int_StreamR(disp: *mut c_void, xyzw: *mut c_void, q: *mut c_void, dst_cn: i32, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_reprojectImageTo3D_const__InputArrayR_const__OutputArrayR_const__InputArrayR(disp: *const c_void, xyzw: *const c_void, q: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_reprojectImageTo3D_const__InputArrayR_const__OutputArrayR_const__InputArrayR_int_StreamR(disp: *const c_void, xyzw: *const c_void, q: *const c_void, dst_cn: i32, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_DisparityBilateralFilter_apply_const__InputArrayR_const__InputArrayR_const__OutputArrayR_StreamR(instance: *mut c_void, disparity: *const c_void, image: *const c_void, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_DisparityBilateralFilter_apply_const__InputArrayR_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, disparity: *const c_void, image: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_cuda_DisparityBilateralFilter_getNumDisparities_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_DisparityBilateralFilter_setNumDisparities_int(instance: *mut c_void, num_disparities: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_DisparityBilateralFilter_setNumDisparities_int(instance: *mut c_void, num_disparities: i32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_DisparityBilateralFilter_getRadius_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_DisparityBilateralFilter_setRadius_int(instance: *mut c_void, radius: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_DisparityBilateralFilter_setRadius_int(instance: *mut c_void, radius: i32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_DisparityBilateralFilter_getNumIters_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_DisparityBilateralFilter_setNumIters_int(instance: *mut c_void, iters: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_DisparityBilateralFilter_setNumIters_int(instance: *mut c_void, iters: i32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_DisparityBilateralFilter_getEdgeThreshold_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_DisparityBilateralFilter_setEdgeThreshold_double(instance: *mut c_void, edge_threshold: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_DisparityBilateralFilter_setEdgeThreshold_double(instance: *mut c_void, edge_threshold: f64, ocvrs_return: *mut Result<()>); pub fn cv_cuda_DisparityBilateralFilter_getMaxDiscThreshold_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_DisparityBilateralFilter_setMaxDiscThreshold_double(instance: *mut c_void, max_disc_threshold: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_DisparityBilateralFilter_setMaxDiscThreshold_double(instance: *mut c_void, max_disc_threshold: f64, ocvrs_return: *mut Result<()>); pub fn cv_cuda_DisparityBilateralFilter_getSigmaRange_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_DisparityBilateralFilter_setSigmaRange_double(instance: *mut c_void, sigma_range: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_DisparityBilateralFilter_setSigmaRange_double(instance: *mut c_void, sigma_range: f64, ocvrs_return: *mut Result<()>); pub fn cv_cuda_DisparityBilateralFilter_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_DisparityBilateralFilter_delete(instance: *mut c_void); - pub fn cv_cuda_StereoBM_compute_const__InputArrayR_const__InputArrayR_const__OutputArrayR_StreamR(instance: *mut c_void, left: *const c_void, right: *const c_void, disparity: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_StereoBM_compute_const__InputArrayR_const__InputArrayR_const__OutputArrayR_StreamR(instance: *mut c_void, left: *const c_void, right: *const c_void, disparity: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_cuda_StereoBM_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_StereoBM_to_StereoBM(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_StereoBM_to_StereoMatcher(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_StereoBM_delete(instance: *mut c_void); - pub fn cv_cuda_StereoBeliefPropagation_compute_const__InputArrayR_const__InputArrayR_const__OutputArrayR_StreamR(instance: *mut c_void, left: *const c_void, right: *const c_void, disparity: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_StereoBeliefPropagation_compute_const__InputArrayR_const__OutputArrayR_StreamR(instance: *mut c_void, data: *const c_void, disparity: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_StereoBeliefPropagation_compute_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, data: *const c_void, disparity: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_StereoBeliefPropagation_compute_const__InputArrayR_const__InputArrayR_const__OutputArrayR_StreamR(instance: *mut c_void, left: *const c_void, right: *const c_void, disparity: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_StereoBeliefPropagation_compute_const__InputArrayR_const__OutputArrayR_StreamR(instance: *mut c_void, data: *const c_void, disparity: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_StereoBeliefPropagation_compute_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, data: *const c_void, disparity: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_cuda_StereoBeliefPropagation_getNumIters_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_StereoBeliefPropagation_setNumIters_int(instance: *mut c_void, iters: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_StereoBeliefPropagation_setNumIters_int(instance: *mut c_void, iters: i32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_StereoBeliefPropagation_getNumLevels_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_StereoBeliefPropagation_setNumLevels_int(instance: *mut c_void, levels: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_StereoBeliefPropagation_setNumLevels_int(instance: *mut c_void, levels: i32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_StereoBeliefPropagation_getMaxDataTerm_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_StereoBeliefPropagation_setMaxDataTerm_double(instance: *mut c_void, max_data_term: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_StereoBeliefPropagation_setMaxDataTerm_double(instance: *mut c_void, max_data_term: f64, ocvrs_return: *mut Result<()>); pub fn cv_cuda_StereoBeliefPropagation_getDataWeight_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_StereoBeliefPropagation_setDataWeight_double(instance: *mut c_void, data_weight: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_StereoBeliefPropagation_setDataWeight_double(instance: *mut c_void, data_weight: f64, ocvrs_return: *mut Result<()>); pub fn cv_cuda_StereoBeliefPropagation_getMaxDiscTerm_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_StereoBeliefPropagation_setMaxDiscTerm_double(instance: *mut c_void, max_disc_term: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_StereoBeliefPropagation_setMaxDiscTerm_double(instance: *mut c_void, max_disc_term: f64, ocvrs_return: *mut Result<()>); pub fn cv_cuda_StereoBeliefPropagation_getDiscSingleJump_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_StereoBeliefPropagation_setDiscSingleJump_double(instance: *mut c_void, disc_single_jump: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_StereoBeliefPropagation_setDiscSingleJump_double(instance: *mut c_void, disc_single_jump: f64, ocvrs_return: *mut Result<()>); pub fn cv_cuda_StereoBeliefPropagation_getMsgType_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_StereoBeliefPropagation_setMsgType_int(instance: *mut c_void, msg_type: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_StereoBeliefPropagation_estimateRecommendedParams_int_int_intR_intR_intR(width: i32, height: i32, ndisp: *mut i32, iters: *mut i32, levels: *mut i32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_StereoBeliefPropagation_setMsgType_int(instance: *mut c_void, msg_type: i32, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_StereoBeliefPropagation_estimateRecommendedParams_int_int_intR_intR_intR(width: i32, height: i32, ndisp: *mut i32, iters: *mut i32, levels: *mut i32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_StereoBeliefPropagation_to_CUDA_StereoConstantSpaceBP(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_StereoBeliefPropagation_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_StereoBeliefPropagation_to_StereoMatcher(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_StereoBeliefPropagation_delete(instance: *mut c_void); pub fn cv_cuda_StereoConstantSpaceBP_getNrPlane_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_StereoConstantSpaceBP_setNrPlane_int(instance: *mut c_void, nr_plane: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_StereoConstantSpaceBP_setNrPlane_int(instance: *mut c_void, nr_plane: i32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_StereoConstantSpaceBP_getUseLocalInitDataCost_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_StereoConstantSpaceBP_setUseLocalInitDataCost_bool(instance: *mut c_void, use_local_init_data_cost: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_StereoConstantSpaceBP_estimateRecommendedParams_int_int_intR_intR_intR_intR(width: i32, height: i32, ndisp: *mut i32, iters: *mut i32, levels: *mut i32, nr_plane: *mut i32, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_StereoConstantSpaceBP_setUseLocalInitDataCost_bool(instance: *mut c_void, use_local_init_data_cost: bool, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_StereoConstantSpaceBP_estimateRecommendedParams_int_int_intR_intR_intR_intR(width: i32, height: i32, ndisp: *mut i32, iters: *mut i32, levels: *mut i32, nr_plane: *mut i32, ocvrs_return: *mut Result<()>); pub fn cv_cuda_StereoConstantSpaceBP_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_StereoConstantSpaceBP_to_CUDA_StereoBeliefPropagation(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_StereoConstantSpaceBP_to_StereoMatcher(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_StereoConstantSpaceBP_delete(instance: *mut c_void); - pub fn cv_cuda_StereoSGM_compute_const__InputArrayR_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, left: *const c_void, right: *const c_void, disparity: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_StereoSGM_compute_const__InputArrayR_const__InputArrayR_const__OutputArrayR_StreamR(instance: *mut c_void, left: *const c_void, right: *const c_void, disparity: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_StereoSGM_compute_const__InputArrayR_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, left: *const c_void, right: *const c_void, disparity: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_StereoSGM_compute_const__InputArrayR_const__InputArrayR_const__OutputArrayR_StreamR(instance: *mut c_void, left: *const c_void, right: *const c_void, disparity: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_cuda_StereoSGM_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_StereoSGM_to_StereoMatcher(instance: *mut c_void) -> *mut c_void; pub fn cv_cuda_StereoSGM_to_StereoSGBM(instance: *mut c_void) -> *mut c_void; @@ -5175,62 +5258,58 @@ mod cudastereo_sys { pub fn cv_PtrLcv_cuda_StereoSGMG_to_PtrOfStereoSGBM(instance: *mut c_void) -> *mut c_void; } } -#[cfg(ocvrs_has_module_cudastereo)] pub use cudastereo_sys::*; -#[cfg(ocvrs_has_module_cudawarping)] mod cudawarping_sys { use super::*; extern "C" { - pub fn cv_cuda_buildWarpAffineMaps_Mat_bool_Size_GpuMatR_GpuMatR(m: *mut c_void, inverse: bool, dsize: *const core::Size, xmap: *mut c_void, ymap: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_buildWarpAffineMaps_Mat_bool_Size_GpuMatR_GpuMatR_StreamR(m: *mut c_void, inverse: bool, dsize: *const core::Size, xmap: *mut c_void, ymap: *mut c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_buildWarpAffineMaps_UMat_bool_Size_GpuMatR_GpuMatR(m: *mut c_void, inverse: bool, dsize: *const core::Size, xmap: *mut c_void, ymap: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_buildWarpAffineMaps_UMat_bool_Size_GpuMatR_GpuMatR_StreamR(m: *mut c_void, inverse: bool, dsize: *const core::Size, xmap: *mut c_void, ymap: *mut c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_buildWarpAffineMaps_const__InputArrayR_bool_Size_const__OutputArrayR_const__OutputArrayR(m: *const c_void, inverse: bool, dsize: *const core::Size, xmap: *const c_void, ymap: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_buildWarpAffineMaps_const__InputArrayR_bool_Size_const__OutputArrayR_const__OutputArrayR_StreamR(m: *const c_void, inverse: bool, dsize: *const core::Size, xmap: *const c_void, ymap: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_buildWarpPerspectiveMaps_Mat_bool_Size_GpuMatR_GpuMatR(m: *mut c_void, inverse: bool, dsize: *const core::Size, xmap: *mut c_void, ymap: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_buildWarpPerspectiveMaps_Mat_bool_Size_GpuMatR_GpuMatR_StreamR(m: *mut c_void, inverse: bool, dsize: *const core::Size, xmap: *mut c_void, ymap: *mut c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_buildWarpPerspectiveMaps_UMat_bool_Size_GpuMatR_GpuMatR(m: *mut c_void, inverse: bool, dsize: *const core::Size, xmap: *mut c_void, ymap: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_buildWarpPerspectiveMaps_UMat_bool_Size_GpuMatR_GpuMatR_StreamR(m: *mut c_void, inverse: bool, dsize: *const core::Size, xmap: *mut c_void, ymap: *mut c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_buildWarpPerspectiveMaps_const__InputArrayR_bool_Size_const__OutputArrayR_const__OutputArrayR(m: *const c_void, inverse: bool, dsize: *const core::Size, xmap: *const c_void, ymap: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_buildWarpPerspectiveMaps_const__InputArrayR_bool_Size_const__OutputArrayR_const__OutputArrayR_StreamR(m: *const c_void, inverse: bool, dsize: *const core::Size, xmap: *const c_void, ymap: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_pyrDown_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_pyrDown_const__InputArrayR_const__OutputArrayR_StreamR(src: *const c_void, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_pyrUp_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_pyrUp_const__InputArrayR_const__OutputArrayR_StreamR(src: *const c_void, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_remap_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR_int(src: *const c_void, dst: *const c_void, xmap: *const c_void, ymap: *const c_void, interpolation: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_remap_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR_int_int_Scalar_StreamR(src: *const c_void, dst: *const c_void, xmap: *const c_void, ymap: *const c_void, interpolation: i32, border_mode: i32, border_value: *const core::Scalar, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_resize_const__InputArrayR_const__OutputArrayR_Size(src: *const c_void, dst: *const c_void, dsize: *const core::Size, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_resize_const__InputArrayR_const__OutputArrayR_Size_double_double_int_StreamR(src: *const c_void, dst: *const c_void, dsize: *const core::Size, fx: f64, fy: f64, interpolation: i32, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_rotate_const__InputArrayR_const__OutputArrayR_Size_double(src: *const c_void, dst: *const c_void, dsize: *const core::Size, angle: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_rotate_const__InputArrayR_const__OutputArrayR_Size_double_double_double_int_StreamR(src: *const c_void, dst: *const c_void, dsize: *const core::Size, angle: f64, x_shift: f64, y_shift: f64, interpolation: i32, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_warpAffine_const__InputArrayR_const__OutputArrayR_Mat_Size(src: *const c_void, dst: *const c_void, m: *mut c_void, dsize: *const core::Size, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_warpAffine_const__InputArrayR_const__OutputArrayR_Mat_Size_int_int_Scalar_StreamR(src: *const c_void, dst: *const c_void, m: *mut c_void, dsize: *const core::Size, flags: i32, border_mode: i32, border_value: *const core::Scalar, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_warpAffine_const__InputArrayR_const__OutputArrayR_UMat_Size(src: *const c_void, dst: *const c_void, m: *mut c_void, dsize: *const core::Size, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_warpAffine_const__InputArrayR_const__OutputArrayR_UMat_Size_int_int_Scalar_StreamR(src: *const c_void, dst: *const c_void, m: *mut c_void, dsize: *const core::Size, flags: i32, border_mode: i32, border_value: *const core::Scalar, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_warpAffine_const__InputArrayR_const__OutputArrayR_const__InputArrayR_Size(src: *const c_void, dst: *const c_void, m: *const c_void, dsize: *const core::Size, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_warpAffine_const__InputArrayR_const__OutputArrayR_const__InputArrayR_Size_int_int_Scalar_StreamR(src: *const c_void, dst: *const c_void, m: *const c_void, dsize: *const core::Size, flags: i32, border_mode: i32, border_value: *const core::Scalar, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_warpPerspective_const__InputArrayR_const__OutputArrayR_Mat_Size(src: *const c_void, dst: *const c_void, m: *mut c_void, dsize: *const core::Size, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_warpPerspective_const__InputArrayR_const__OutputArrayR_Mat_Size_int_int_Scalar_StreamR(src: *const c_void, dst: *const c_void, m: *mut c_void, dsize: *const core::Size, flags: i32, border_mode: i32, border_value: *const core::Scalar, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_warpPerspective_const__InputArrayR_const__OutputArrayR_UMat_Size(src: *const c_void, dst: *const c_void, m: *mut c_void, dsize: *const core::Size, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_warpPerspective_const__InputArrayR_const__OutputArrayR_UMat_Size_int_int_Scalar_StreamR(src: *const c_void, dst: *const c_void, m: *mut c_void, dsize: *const core::Size, flags: i32, border_mode: i32, border_value: *const core::Scalar, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_warpPerspective_const__InputArrayR_const__OutputArrayR_const__InputArrayR_Size(src: *const c_void, dst: *const c_void, m: *const c_void, dsize: *const core::Size, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_warpPerspective_const__InputArrayR_const__OutputArrayR_const__InputArrayR_Size_int_int_Scalar_StreamR(src: *const c_void, dst: *const c_void, m: *const c_void, dsize: *const core::Size, flags: i32, border_mode: i32, border_value: *const core::Scalar, stream: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_buildWarpAffineMaps_Mat_bool_Size_GpuMatR_GpuMatR(m: *mut c_void, inverse: bool, dsize: *const core::Size, xmap: *mut c_void, ymap: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_buildWarpAffineMaps_Mat_bool_Size_GpuMatR_GpuMatR_StreamR(m: *mut c_void, inverse: bool, dsize: *const core::Size, xmap: *mut c_void, ymap: *mut c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_buildWarpAffineMaps_UMat_bool_Size_GpuMatR_GpuMatR(m: *mut c_void, inverse: bool, dsize: *const core::Size, xmap: *mut c_void, ymap: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_buildWarpAffineMaps_UMat_bool_Size_GpuMatR_GpuMatR_StreamR(m: *mut c_void, inverse: bool, dsize: *const core::Size, xmap: *mut c_void, ymap: *mut c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_buildWarpAffineMaps_const__InputArrayR_bool_Size_const__OutputArrayR_const__OutputArrayR(m: *const c_void, inverse: bool, dsize: *const core::Size, xmap: *const c_void, ymap: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_buildWarpAffineMaps_const__InputArrayR_bool_Size_const__OutputArrayR_const__OutputArrayR_StreamR(m: *const c_void, inverse: bool, dsize: *const core::Size, xmap: *const c_void, ymap: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_buildWarpPerspectiveMaps_Mat_bool_Size_GpuMatR_GpuMatR(m: *mut c_void, inverse: bool, dsize: *const core::Size, xmap: *mut c_void, ymap: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_buildWarpPerspectiveMaps_Mat_bool_Size_GpuMatR_GpuMatR_StreamR(m: *mut c_void, inverse: bool, dsize: *const core::Size, xmap: *mut c_void, ymap: *mut c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_buildWarpPerspectiveMaps_UMat_bool_Size_GpuMatR_GpuMatR(m: *mut c_void, inverse: bool, dsize: *const core::Size, xmap: *mut c_void, ymap: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_buildWarpPerspectiveMaps_UMat_bool_Size_GpuMatR_GpuMatR_StreamR(m: *mut c_void, inverse: bool, dsize: *const core::Size, xmap: *mut c_void, ymap: *mut c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_buildWarpPerspectiveMaps_const__InputArrayR_bool_Size_const__OutputArrayR_const__OutputArrayR(m: *const c_void, inverse: bool, dsize: *const core::Size, xmap: *const c_void, ymap: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_buildWarpPerspectiveMaps_const__InputArrayR_bool_Size_const__OutputArrayR_const__OutputArrayR_StreamR(m: *const c_void, inverse: bool, dsize: *const core::Size, xmap: *const c_void, ymap: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_pyrDown_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_pyrDown_const__InputArrayR_const__OutputArrayR_StreamR(src: *const c_void, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_pyrUp_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_pyrUp_const__InputArrayR_const__OutputArrayR_StreamR(src: *const c_void, dst: *const c_void, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_remap_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR_int(src: *const c_void, dst: *const c_void, xmap: *const c_void, ymap: *const c_void, interpolation: i32, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_remap_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR_int_int_Scalar_StreamR(src: *const c_void, dst: *const c_void, xmap: *const c_void, ymap: *const c_void, interpolation: i32, border_mode: i32, border_value: *const core::Scalar, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_resize_const__InputArrayR_const__OutputArrayR_Size(src: *const c_void, dst: *const c_void, dsize: *const core::Size, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_resize_const__InputArrayR_const__OutputArrayR_Size_double_double_int_StreamR(src: *const c_void, dst: *const c_void, dsize: *const core::Size, fx: f64, fy: f64, interpolation: i32, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_rotate_const__InputArrayR_const__OutputArrayR_Size_double(src: *const c_void, dst: *const c_void, dsize: *const core::Size, angle: f64, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_rotate_const__InputArrayR_const__OutputArrayR_Size_double_double_double_int_StreamR(src: *const c_void, dst: *const c_void, dsize: *const core::Size, angle: f64, x_shift: f64, y_shift: f64, interpolation: i32, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_warpAffine_const__InputArrayR_const__OutputArrayR_Mat_Size(src: *const c_void, dst: *const c_void, m: *mut c_void, dsize: *const core::Size, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_warpAffine_const__InputArrayR_const__OutputArrayR_Mat_Size_int_int_Scalar_StreamR(src: *const c_void, dst: *const c_void, m: *mut c_void, dsize: *const core::Size, flags: i32, border_mode: i32, border_value: *const core::Scalar, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_warpAffine_const__InputArrayR_const__OutputArrayR_UMat_Size(src: *const c_void, dst: *const c_void, m: *mut c_void, dsize: *const core::Size, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_warpAffine_const__InputArrayR_const__OutputArrayR_UMat_Size_int_int_Scalar_StreamR(src: *const c_void, dst: *const c_void, m: *mut c_void, dsize: *const core::Size, flags: i32, border_mode: i32, border_value: *const core::Scalar, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_warpAffine_const__InputArrayR_const__OutputArrayR_const__InputArrayR_Size(src: *const c_void, dst: *const c_void, m: *const c_void, dsize: *const core::Size, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_warpAffine_const__InputArrayR_const__OutputArrayR_const__InputArrayR_Size_int_int_Scalar_StreamR(src: *const c_void, dst: *const c_void, m: *const c_void, dsize: *const core::Size, flags: i32, border_mode: i32, border_value: *const core::Scalar, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_warpPerspective_const__InputArrayR_const__OutputArrayR_Mat_Size(src: *const c_void, dst: *const c_void, m: *mut c_void, dsize: *const core::Size, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_warpPerspective_const__InputArrayR_const__OutputArrayR_Mat_Size_int_int_Scalar_StreamR(src: *const c_void, dst: *const c_void, m: *mut c_void, dsize: *const core::Size, flags: i32, border_mode: i32, border_value: *const core::Scalar, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_warpPerspective_const__InputArrayR_const__OutputArrayR_UMat_Size(src: *const c_void, dst: *const c_void, m: *mut c_void, dsize: *const core::Size, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_warpPerspective_const__InputArrayR_const__OutputArrayR_UMat_Size_int_int_Scalar_StreamR(src: *const c_void, dst: *const c_void, m: *mut c_void, dsize: *const core::Size, flags: i32, border_mode: i32, border_value: *const core::Scalar, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_warpPerspective_const__InputArrayR_const__OutputArrayR_const__InputArrayR_Size(src: *const c_void, dst: *const c_void, m: *const c_void, dsize: *const core::Size, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_warpPerspective_const__InputArrayR_const__OutputArrayR_const__InputArrayR_Size_int_int_Scalar_StreamR(src: *const c_void, dst: *const c_void, m: *const c_void, dsize: *const core::Size, flags: i32, border_mode: i32, border_value: *const core::Scalar, stream: *mut c_void, ocvrs_return: *mut Result<()>); } } -#[cfg(ocvrs_has_module_cudawarping)] pub use cudawarping_sys::*; -#[cfg(ocvrs_has_module_cvv)] mod cvv_sys { use super::*; extern "C" { - pub fn cvv_impl_debugDMatch_const__InputArrayR_vectorLKeyPointG_const__InputArrayR_vectorLKeyPointG_vectorLDMatchG_const_CallMetaDataR_const_charX_const_charX_bool(img1: *const c_void, keypoints1: *mut c_void, img2: *const c_void, keypoints2: *mut c_void, matches: *mut c_void, data: *const c_void, description: *const c_char, view: *const c_char, use_train_descriptor: bool, ocvrs_return: *mut ResultVoid); - pub fn cvv_impl_debugFilter_const__InputArrayR_const__InputArrayR_const_CallMetaDataR_const_charX_const_charX(original: *const c_void, result: *const c_void, data: *const c_void, description: *const c_char, view: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cvv_impl_finalShow(ocvrs_return: *mut ResultVoid); - pub fn cvv_impl_showImage_const__InputArrayR_const_CallMetaDataR_const_charX_const_charX(img: *const c_void, data: *const c_void, description: *const c_char, view: *const c_char, ocvrs_return: *mut ResultVoid); + pub fn cvv_impl_debugDMatch_const__InputArrayR_vectorLKeyPointG_const__InputArrayR_vectorLKeyPointG_vectorLDMatchG_const_CallMetaDataR_const_charX_const_charX_bool(img1: *const c_void, keypoints1: *mut c_void, img2: *const c_void, keypoints2: *mut c_void, matches: *mut c_void, data: *const c_void, description: *const c_char, view: *const c_char, use_train_descriptor: bool, ocvrs_return: *mut Result<()>); + pub fn cvv_impl_debugFilter_const__InputArrayR_const__InputArrayR_const_CallMetaDataR_const_charX_const_charX(original: *const c_void, result: *const c_void, data: *const c_void, description: *const c_char, view: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cvv_impl_finalShow(ocvrs_return: *mut Result<()>); + pub fn cvv_impl_showImage_const__InputArrayR_const_CallMetaDataR_const_charX_const_charX(img: *const c_void, data: *const c_void, description: *const c_char, view: *const c_char, ocvrs_return: *mut Result<()>); pub fn cvv_impl_CallMetaData_CallMetaData(ocvrs_return: *mut Result<*mut c_void>); pub fn cvv_impl_CallMetaData_CallMetaData_const_charX_size_t_const_charX(file: *const c_char, line: size_t, function: *const c_char, ocvrs_return: *mut Result<*mut c_void>); pub fn cvv_impl_CallMetaData_operator_bool(instance: *mut c_void, ocvrs_return: *mut Result); @@ -5242,49 +5321,47 @@ mod cvv_sys { pub fn cvv_impl_CallMetaData_delete(instance: *mut c_void); } } -#[cfg(ocvrs_has_module_cvv)] pub use cvv_sys::*; -#[cfg(ocvrs_has_module_dnn)] mod dnn_sys { use super::*; extern "C" { - pub fn cv_dnn_NMSBoxesBatched_const_vectorLRect2dGR_const_vectorLfloatGR_const_vectorLintGR_const_float_const_float_vectorLintGR(bboxes: *const c_void, scores: *const c_void, class_ids: *const c_void, score_threshold: f32, nms_threshold: f32, indices: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_NMSBoxesBatched_const_vectorLRect2dGR_const_vectorLfloatGR_const_vectorLintGR_const_float_const_float_vectorLintGR_const_float_const_int(bboxes: *const c_void, scores: *const c_void, class_ids: *const c_void, score_threshold: f32, nms_threshold: f32, indices: *mut c_void, eta: f32, top_k: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_NMSBoxesBatched_const_vectorLRectGR_const_vectorLfloatGR_const_vectorLintGR_const_float_const_float_vectorLintGR(bboxes: *const c_void, scores: *const c_void, class_ids: *const c_void, score_threshold: f32, nms_threshold: f32, indices: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_NMSBoxesBatched_const_vectorLRectGR_const_vectorLfloatGR_const_vectorLintGR_const_float_const_float_vectorLintGR_const_float_const_int(bboxes: *const c_void, scores: *const c_void, class_ids: *const c_void, score_threshold: f32, nms_threshold: f32, indices: *mut c_void, eta: f32, top_k: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_NMSBoxes_const_vectorLRect2dGR_const_vectorLfloatGR_const_float_const_float_vectorLintGR(bboxes: *const c_void, scores: *const c_void, score_threshold: f32, nms_threshold: f32, indices: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_NMSBoxes_const_vectorLRect2dGR_const_vectorLfloatGR_const_float_const_float_vectorLintGR_const_float_const_int(bboxes: *const c_void, scores: *const c_void, score_threshold: f32, nms_threshold: f32, indices: *mut c_void, eta: f32, top_k: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_NMSBoxes_const_vectorLRectGR_const_vectorLfloatGR_const_float_const_float_vectorLintGR(bboxes: *const c_void, scores: *const c_void, score_threshold: f32, nms_threshold: f32, indices: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_NMSBoxes_const_vectorLRectGR_const_vectorLfloatGR_const_float_const_float_vectorLintGR_const_float_const_int(bboxes: *const c_void, scores: *const c_void, score_threshold: f32, nms_threshold: f32, indices: *mut c_void, eta: f32, top_k: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_NMSBoxes_const_vectorLRotatedRectGR_const_vectorLfloatGR_const_float_const_float_vectorLintGR(bboxes: *const c_void, scores: *const c_void, score_threshold: f32, nms_threshold: f32, indices: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_NMSBoxes_const_vectorLRotatedRectGR_const_vectorLfloatGR_const_float_const_float_vectorLintGR_const_float_const_int(bboxes: *const c_void, scores: *const c_void, score_threshold: f32, nms_threshold: f32, indices: *mut c_void, eta: f32, top_k: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_dnn_NMSBoxesBatched_const_vectorLRect2dGR_const_vectorLfloatGR_const_vectorLintGR_const_float_const_float_vectorLintGR(bboxes: *const c_void, scores: *const c_void, class_ids: *const c_void, score_threshold: f32, nms_threshold: f32, indices: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_NMSBoxesBatched_const_vectorLRect2dGR_const_vectorLfloatGR_const_vectorLintGR_const_float_const_float_vectorLintGR_const_float_const_int(bboxes: *const c_void, scores: *const c_void, class_ids: *const c_void, score_threshold: f32, nms_threshold: f32, indices: *mut c_void, eta: f32, top_k: i32, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_NMSBoxesBatched_const_vectorLRectGR_const_vectorLfloatGR_const_vectorLintGR_const_float_const_float_vectorLintGR(bboxes: *const c_void, scores: *const c_void, class_ids: *const c_void, score_threshold: f32, nms_threshold: f32, indices: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_NMSBoxesBatched_const_vectorLRectGR_const_vectorLfloatGR_const_vectorLintGR_const_float_const_float_vectorLintGR_const_float_const_int(bboxes: *const c_void, scores: *const c_void, class_ids: *const c_void, score_threshold: f32, nms_threshold: f32, indices: *mut c_void, eta: f32, top_k: i32, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_NMSBoxes_const_vectorLRect2dGR_const_vectorLfloatGR_const_float_const_float_vectorLintGR(bboxes: *const c_void, scores: *const c_void, score_threshold: f32, nms_threshold: f32, indices: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_NMSBoxes_const_vectorLRect2dGR_const_vectorLfloatGR_const_float_const_float_vectorLintGR_const_float_const_int(bboxes: *const c_void, scores: *const c_void, score_threshold: f32, nms_threshold: f32, indices: *mut c_void, eta: f32, top_k: i32, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_NMSBoxes_const_vectorLRectGR_const_vectorLfloatGR_const_float_const_float_vectorLintGR(bboxes: *const c_void, scores: *const c_void, score_threshold: f32, nms_threshold: f32, indices: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_NMSBoxes_const_vectorLRectGR_const_vectorLfloatGR_const_float_const_float_vectorLintGR_const_float_const_int(bboxes: *const c_void, scores: *const c_void, score_threshold: f32, nms_threshold: f32, indices: *mut c_void, eta: f32, top_k: i32, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_NMSBoxes_const_vectorLRotatedRectGR_const_vectorLfloatGR_const_float_const_float_vectorLintGR(bboxes: *const c_void, scores: *const c_void, score_threshold: f32, nms_threshold: f32, indices: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_NMSBoxes_const_vectorLRotatedRectGR_const_vectorLfloatGR_const_float_const_float_vectorLintGR_const_float_const_int(bboxes: *const c_void, scores: *const c_void, score_threshold: f32, nms_threshold: f32, indices: *mut c_void, eta: f32, top_k: i32, ocvrs_return: *mut Result<()>); pub fn cv_dnn_blobFromImageWithParams_const__InputArrayR(image: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dnn_blobFromImageWithParams_const__InputArrayR_const_Image2BlobParamsR(image: *const c_void, param: *const crate::dnn::Image2BlobParams, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_dnn_blobFromImageWithParams_const__InputArrayR_const__OutputArrayR(image: *const c_void, blob: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_blobFromImageWithParams_const__InputArrayR_const__OutputArrayR_const_Image2BlobParamsR(image: *const c_void, blob: *const c_void, param: *const crate::dnn::Image2BlobParams, ocvrs_return: *mut ResultVoid); + pub fn cv_dnn_blobFromImageWithParams_const__InputArrayR_const__OutputArrayR(image: *const c_void, blob: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_blobFromImageWithParams_const__InputArrayR_const__OutputArrayR_const_Image2BlobParamsR(image: *const c_void, blob: *const c_void, param: *const crate::dnn::Image2BlobParams, ocvrs_return: *mut Result<()>); pub fn cv_dnn_blobFromImage_const__InputArrayR(image: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_dnn_blobFromImage_const__InputArrayR_const__OutputArrayR(image: *const c_void, blob: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_blobFromImage_const__InputArrayR_const__OutputArrayR_double_const_SizeR_const_ScalarR_bool_bool_int(image: *const c_void, blob: *const c_void, scalefactor: f64, size: *const core::Size, mean: *const core::Scalar, swap_rb: bool, crop: bool, ddepth: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_dnn_blobFromImage_const__InputArrayR_const__OutputArrayR(image: *const c_void, blob: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_blobFromImage_const__InputArrayR_const__OutputArrayR_double_const_SizeR_const_ScalarR_bool_bool_int(image: *const c_void, blob: *const c_void, scalefactor: f64, size: *const core::Size, mean: *const core::Scalar, swap_rb: bool, crop: bool, ddepth: i32, ocvrs_return: *mut Result<()>); pub fn cv_dnn_blobFromImage_const__InputArrayR_double_const_SizeR_const_ScalarR_bool_bool_int(image: *const c_void, scalefactor: f64, size: *const core::Size, mean: *const core::Scalar, swap_rb: bool, crop: bool, ddepth: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dnn_blobFromImagesWithParams_const__InputArrayR(images: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dnn_blobFromImagesWithParams_const__InputArrayR_const_Image2BlobParamsR(images: *const c_void, param: *const crate::dnn::Image2BlobParams, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_dnn_blobFromImagesWithParams_const__InputArrayR_const__OutputArrayR(images: *const c_void, blob: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_blobFromImagesWithParams_const__InputArrayR_const__OutputArrayR_const_Image2BlobParamsR(images: *const c_void, blob: *const c_void, param: *const crate::dnn::Image2BlobParams, ocvrs_return: *mut ResultVoid); + pub fn cv_dnn_blobFromImagesWithParams_const__InputArrayR_const__OutputArrayR(images: *const c_void, blob: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_blobFromImagesWithParams_const__InputArrayR_const__OutputArrayR_const_Image2BlobParamsR(images: *const c_void, blob: *const c_void, param: *const crate::dnn::Image2BlobParams, ocvrs_return: *mut Result<()>); pub fn cv_dnn_blobFromImages_const__InputArrayR(images: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_dnn_blobFromImages_const__InputArrayR_const__OutputArrayR(images: *const c_void, blob: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_blobFromImages_const__InputArrayR_const__OutputArrayR_double_Size_const_ScalarR_bool_bool_int(images: *const c_void, blob: *const c_void, scalefactor: f64, size: *const core::Size, mean: *const core::Scalar, swap_rb: bool, crop: bool, ddepth: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_dnn_blobFromImages_const__InputArrayR_const__OutputArrayR(images: *const c_void, blob: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_blobFromImages_const__InputArrayR_const__OutputArrayR_double_Size_const_ScalarR_bool_bool_int(images: *const c_void, blob: *const c_void, scalefactor: f64, size: *const core::Size, mean: *const core::Scalar, swap_rb: bool, crop: bool, ddepth: i32, ocvrs_return: *mut Result<()>); pub fn cv_dnn_blobFromImages_const__InputArrayR_double_Size_const_ScalarR_bool_bool_int(images: *const c_void, scalefactor: f64, size: *const core::Size, mean: *const core::Scalar, swap_rb: bool, crop: bool, ddepth: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dnn_concat_const_MatShapeR_const_MatShapeR(a: *const c_void, b: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_dnn_enableModelDiagnostics_bool(is_diagnostics_mode: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_dnn_enableModelDiagnostics_bool(is_diagnostics_mode: bool, ocvrs_return: *mut Result<()>); pub fn cv_dnn_getAvailableBackends(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dnn_getAvailableTargets_Backend(be: crate::dnn::Backend, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dnn_getInferenceEngineBackendType(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dnn_getInferenceEngineCPUType(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dnn_getInferenceEngineVPUType(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dnn_getPlane_const_MatR_int_int(m: *const c_void, n: i32, cn: i32, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_dnn_imagesFromBlob_const_MatR_const__OutputArrayR(blob_: *const c_void, images_: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_dnn_imagesFromBlob_const_MatR_const__OutputArrayR(blob_: *const c_void, images_: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_dnn_readNetFromCaffe_const_StringR(prototxt: *const c_char, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dnn_readNetFromCaffe_const_StringR_const_StringR(prototxt: *const c_char, caffe_model: *const c_char, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dnn_readNetFromCaffe_const_charX_size_t(buffer_proto: *const c_char, len_proto: size_t, ocvrs_return: *mut Result<*mut c_void>); @@ -5322,8 +5399,8 @@ mod dnn_sys { pub fn cv_dnn_readTensorFromONNX_const_StringR(path: *const c_char, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dnn_readTorchBlob_const_StringR(filename: *const c_char, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dnn_readTorchBlob_const_StringR_bool(filename: *const c_char, is_binary: bool, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_dnn_releaseHDDLPlugin(ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_resetMyriadDevice(ocvrs_return: *mut ResultVoid); + pub fn cv_dnn_releaseHDDLPlugin(ocvrs_return: *mut Result<()>); + pub fn cv_dnn_resetMyriadDevice(ocvrs_return: *mut Result<()>); pub fn cv_dnn_setInferenceEngineBackendType_const_StringR(new_backend_type: *const c_char, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dnn_shape_const_MatR(mat: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dnn_shape_const_MatSizeR(sz: *const c_void, ocvrs_return: *mut Result<*mut c_void>); @@ -5331,19 +5408,19 @@ mod dnn_sys { pub fn cv_dnn_shape_const_intX_const_int(dims: *const i32, n: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dnn_shape_int(a0: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dnn_shape_int_int_int_int(a0: i32, a1: i32, a2: i32, a3: i32, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_dnn_shrinkCaffeModel_const_StringR_const_StringR(src: *const c_char, dst: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_shrinkCaffeModel_const_StringR_const_StringR_const_vectorLStringGR(src: *const c_char, dst: *const c_char, layers_types: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_dnn_shrinkCaffeModel_const_StringR_const_StringR(src: *const c_char, dst: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_shrinkCaffeModel_const_StringR_const_StringR_const_vectorLStringGR(src: *const c_char, dst: *const c_char, layers_types: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_dnn_slice_const_MatR_const__RangeR(m: *const c_void, r0: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dnn_slice_const_MatR_const__RangeR_const__RangeR(m: *const c_void, r0: *const c_void, r1: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dnn_slice_const_MatR_const__RangeR_const__RangeR_const__RangeR(m: *const c_void, r0: *const c_void, r1: *const c_void, r2: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dnn_slice_const_MatR_const__RangeR_const__RangeR_const__RangeR_const__RangeR(m: *const c_void, r0: *const c_void, r1: *const c_void, r2: *const c_void, r3: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_dnn_softNMSBoxes_const_vectorLRectGR_const_vectorLfloatGR_vectorLfloatGR_const_float_const_float_vectorLintGR(bboxes: *const c_void, scores: *const c_void, updated_scores: *mut c_void, score_threshold: f32, nms_threshold: f32, indices: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_softNMSBoxes_const_vectorLRectGR_const_vectorLfloatGR_vectorLfloatGR_const_float_const_float_vectorLintGR_size_t_const_float_SoftNMSMethod(bboxes: *const c_void, scores: *const c_void, updated_scores: *mut c_void, score_threshold: f32, nms_threshold: f32, indices: *mut c_void, top_k: size_t, sigma: f32, method: crate::dnn::SoftNMSMethod, ocvrs_return: *mut ResultVoid); + pub fn cv_dnn_softNMSBoxes_const_vectorLRectGR_const_vectorLfloatGR_vectorLfloatGR_const_float_const_float_vectorLintGR(bboxes: *const c_void, scores: *const c_void, updated_scores: *mut c_void, score_threshold: f32, nms_threshold: f32, indices: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_softNMSBoxes_const_vectorLRectGR_const_vectorLfloatGR_vectorLfloatGR_const_float_const_float_vectorLintGR_size_t_const_float_SoftNMSMethod(bboxes: *const c_void, scores: *const c_void, updated_scores: *mut c_void, score_threshold: f32, nms_threshold: f32, indices: *mut c_void, top_k: size_t, sigma: f32, method: crate::dnn::SoftNMSMethod, ocvrs_return: *mut Result<()>); pub fn cv_dnn_total_const_MatR(mat: *const c_void, ocvrs_return: *mut Result); pub fn cv_dnn_total_const_MatR_int_int(mat: *const c_void, start: i32, end: i32, ocvrs_return: *mut Result); pub fn cv_dnn_total_const_MatShapeR(shape: *const c_void, ocvrs_return: *mut Result); pub fn cv_dnn_total_const_MatShapeR_int_int(shape: *const c_void, start: i32, end: i32, ocvrs_return: *mut Result); - pub fn cv_dnn_writeTextGraph_const_StringR_const_StringR(model: *const c_char, output: *const c_char, ocvrs_return: *mut ResultVoid); + pub fn cv_dnn_writeTextGraph_const_StringR_const_StringR(model: *const c_char, output: *const c_char, ocvrs_return: *mut Result<()>); pub fn cv_dnn_AbsLayer_create_const_LayerParamsR(params: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dnn_AbsLayer_defaultNew_const() -> *mut c_void; pub fn cv_dnn_AbsLayer_to_ActivationLayer(instance: *mut c_void) -> *mut c_void; @@ -5367,8 +5444,8 @@ mod dnn_sys { pub fn cv_dnn_AcoshLayer_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_dnn_AcoshLayer_to_Layer(instance: *mut c_void) -> *mut c_void; pub fn cv_dnn_AcoshLayer_delete(instance: *mut c_void); - pub fn cv_dnn_ActivationLayer_forwardSlice_const_const_floatX_floatX_int_size_t_int_int(instance: *const c_void, src: *const f32, dst: *mut f32, len: i32, out_plane_size: size_t, cn0: i32, cn1: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_ActivationLayer_forwardSlice_const_const_intX_const_intX_intX_int_size_t_int_int(instance: *const c_void, src: *const i32, lut: *const i32, dst: *mut i32, len: i32, out_plane_size: size_t, cn0: i32, cn1: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_dnn_ActivationLayer_forwardSlice_const_const_floatX_floatX_int_size_t_int_int(instance: *const c_void, src: *const f32, dst: *mut f32, len: i32, out_plane_size: size_t, cn0: i32, cn1: i32, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_ActivationLayer_forwardSlice_const_const_intX_const_intX_intX_int_size_t_int_int(instance: *const c_void, src: *const i32, lut: *const i32, dst: *mut i32, len: i32, out_plane_size: size_t, cn0: i32, cn1: i32, ocvrs_return: *mut Result<()>); pub fn cv_dnn_ActivationLayer_defaultNew_const() -> *mut c_void; pub fn cv_dnn_ActivationLayer_to_AbsLayer(instance: *mut c_void) -> *mut c_void; pub fn cv_dnn_ActivationLayer_to_AcosLayer(instance: *mut c_void) -> *mut c_void; @@ -5467,8 +5544,8 @@ mod dnn_sys { pub fn cv_dnn_BackendNode_propBackendId_const(instance: *const c_void) -> i32; pub fn cv_dnn_BackendNode_propBackendId_const_int(instance: *mut c_void, val: i32); pub fn cv_dnn_BackendNode_delete(instance: *mut c_void); - pub fn cv_dnn_BackendWrapper_copyToHost(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_BackendWrapper_setHostDirty(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_dnn_BackendWrapper_copyToHost(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_BackendWrapper_setHostDirty(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_dnn_BackendWrapper_propBackendId_const(instance: *const c_void) -> i32; pub fn cv_dnn_BackendWrapper_propBackendId_const_int(instance: *mut c_void, val: i32); pub fn cv_dnn_BackendWrapper_propTargetId_const(instance: *const c_void) -> i32; @@ -5563,7 +5640,7 @@ mod dnn_sys { pub fn cv_dnn_ClassificationModel_setEnableSoftmaxPostProcessing_bool(instance: *mut c_void, enable: bool, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dnn_ClassificationModel_getEnableSoftmaxPostProcessing_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_dnn_ClassificationModel_classify_const__InputArrayR(instance: *mut c_void, frame: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_dnn_ClassificationModel_classify_const__InputArrayR_intR_floatR(instance: *mut c_void, frame: *const c_void, class_id: *mut i32, conf: *mut f32, ocvrs_return: *mut ResultVoid); + pub fn cv_dnn_ClassificationModel_classify_const__InputArrayR_intR_floatR(instance: *mut c_void, frame: *const c_void, class_id: *mut i32, conf: *mut f32, ocvrs_return: *mut Result<()>); pub fn cv_dnn_ClassificationModel_implicitClone_const(instance: *const c_void) -> *mut c_void; pub fn cv_dnn_ClassificationModel_to_Model(instance: *mut c_void) -> *mut c_void; pub fn cv_dnn_ClassificationModel_delete(instance: *mut c_void); @@ -5685,8 +5762,8 @@ mod dnn_sys { pub fn cv_dnn_DetectionModel_DetectionModel(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dnn_DetectionModel_setNmsAcrossClasses_bool(instance: *mut c_void, value: bool, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dnn_DetectionModel_getNmsAcrossClasses(instance: *mut c_void, ocvrs_return: *mut Result); - pub fn cv_dnn_DetectionModel_detect_const__InputArrayR_vectorLintGR_vectorLfloatGR_vectorLRectGR_float_float(instance: *mut c_void, frame: *const c_void, class_ids: *mut c_void, confidences: *mut c_void, boxes: *mut c_void, conf_threshold: f32, nms_threshold: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_DetectionModel_detect_const__InputArrayR_vectorLintGR_vectorLfloatGR_vectorLRectGR(instance: *mut c_void, frame: *const c_void, class_ids: *mut c_void, confidences: *mut c_void, boxes: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_dnn_DetectionModel_detect_const__InputArrayR_vectorLintGR_vectorLfloatGR_vectorLRectGR_float_float(instance: *mut c_void, frame: *const c_void, class_ids: *mut c_void, confidences: *mut c_void, boxes: *mut c_void, conf_threshold: f32, nms_threshold: f32, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_DetectionModel_detect_const__InputArrayR_vectorLintGR_vectorLfloatGR_vectorLRectGR(instance: *mut c_void, frame: *const c_void, class_ids: *mut c_void, confidences: *mut c_void, boxes: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_dnn_DetectionModel_implicitClone_const(instance: *const c_void) -> *mut c_void; pub fn cv_dnn_DetectionModel_to_Model(instance: *mut c_void) -> *mut c_void; pub fn cv_dnn_DetectionModel_delete(instance: *mut c_void); @@ -5703,7 +5780,7 @@ mod dnn_sys { pub fn cv_dnn_Dict_set_const_cv_dnn_DictValue_const_StringR_const_DictValueR(instance: *mut c_void, key: *const c_char, value: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dnn_Dict_set_const_double_const_StringR_const_doubleR(instance: *mut c_void, key: *const c_char, value: *const f64, ocvrs_return: *mut Result); pub fn cv_dnn_Dict_set_const_int64_t_const_StringR_const_int64_tR(instance: *mut c_void, key: *const c_char, value: *const i64, ocvrs_return: *mut Result); - pub fn cv_dnn_Dict_erase_const_StringR(instance: *mut c_void, key: *const c_char, ocvrs_return: *mut ResultVoid); + pub fn cv_dnn_Dict_erase_const_StringR(instance: *mut c_void, key: *const c_char, ocvrs_return: *mut Result<()>); pub fn cv_dnn_Dict_defaultNew_const() -> *mut c_void; pub fn cv_dnn_Dict_delete(instance: *mut c_void); pub fn cv_dnn_DictValue_DictValue_const_DictValueR(r: *const c_void, ocvrs_return: *mut Result<*mut c_void>); @@ -5732,7 +5809,7 @@ mod dnn_sys { pub fn cv_dnn_DictValue_getRealValue_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_dnn_DictValue_getStringValue_const_int(instance: *const c_void, idx: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dnn_DictValue_getStringValue_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_dnn_DictValue_operatorST_const_DictValueR(instance: *mut c_void, r: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_dnn_DictValue_operatorST_const_DictValueR(instance: *mut c_void, r: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_dnn_DictValue_delete(instance: *mut c_void); pub fn cv_dnn_ELULayer_create_const_LayerParamsR(params: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dnn_ELULayer_defaultNew_const() -> *mut c_void; @@ -5861,7 +5938,7 @@ mod dnn_sys { pub fn cv_dnn_Image2BlobParams_Image2BlobParams_const_ScalarR_const_SizeR_const_ScalarR_bool_int_DataLayout_ImagePaddingMode_Scalar(scalefactor: *const core::Scalar, size: *const core::Size, mean: *const core::Scalar, swap_rb: bool, ddepth: i32, datalayout: crate::dnn::DataLayout, mode: crate::dnn::ImagePaddingMode, border_value: *const core::Scalar, ocvrs_return: *mut Result); pub fn cv_dnn_Image2BlobParams_Image2BlobParams_const_ScalarR(scalefactor: *const core::Scalar, ocvrs_return: *mut Result); pub fn cv_dnn_Image2BlobParams_blobRectToImageRect_const_RectR_const_SizeR(instance: *const crate::dnn::Image2BlobParams, r_blob: *const core::Rect, size: *const core::Size, ocvrs_return: *mut Result); - pub fn cv_dnn_Image2BlobParams_blobRectsToImageRects_const_vectorLRectGR_vectorLRectGR_const_SizeR(instance: *const crate::dnn::Image2BlobParams, r_blob: *const c_void, r_img: *mut c_void, size: *const core::Size, ocvrs_return: *mut ResultVoid); + pub fn cv_dnn_Image2BlobParams_blobRectsToImageRects_const_vectorLRectGR_vectorLRectGR_const_SizeR(instance: *const crate::dnn::Image2BlobParams, r_blob: *const c_void, r_img: *mut c_void, size: *const core::Size, ocvrs_return: *mut Result<()>); pub fn cv_dnn_InnerProductLayer_create_const_LayerParamsR(params: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dnn_InnerProductLayer_defaultNew_const() -> *mut c_void; pub fn cv_dnn_InnerProductLayer_propAxis_const(instance: *const c_void) -> i32; @@ -5923,26 +6000,26 @@ mod dnn_sys { pub fn cv_dnn_LRNLayer_to_Layer(instance: *mut c_void) -> *mut c_void; pub fn cv_dnn_LRNLayer_delete(instance: *mut c_void); pub fn cv_dnn_LSTMLayer_create_const_LayerParamsR(params: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_dnn_LSTMLayer_setWeights_const_MatR_const_MatR_const_MatR(instance: *mut c_void, wh: *const c_void, wx: *const c_void, b: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_LSTMLayer_setOutShape_const_MatShapeR(instance: *mut c_void, out_tail_shape: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_LSTMLayer_setOutShape(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_LSTMLayer_setUseTimstampsDim_bool(instance: *mut c_void, use_: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_LSTMLayer_setUseTimstampsDim(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_LSTMLayer_setProduceCellOutput_bool(instance: *mut c_void, produce: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_LSTMLayer_setProduceCellOutput(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_dnn_LSTMLayer_setWeights_const_MatR_const_MatR_const_MatR(instance: *mut c_void, wh: *const c_void, wx: *const c_void, b: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_LSTMLayer_setOutShape_const_MatShapeR(instance: *mut c_void, out_tail_shape: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_LSTMLayer_setOutShape(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_LSTMLayer_setUseTimstampsDim_bool(instance: *mut c_void, use_: bool, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_LSTMLayer_setUseTimstampsDim(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_LSTMLayer_setProduceCellOutput_bool(instance: *mut c_void, produce: bool, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_LSTMLayer_setProduceCellOutput(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_dnn_LSTMLayer_inputNameToIndex_String(instance: *mut c_void, input_name: *const c_char, ocvrs_return: *mut Result); pub fn cv_dnn_LSTMLayer_outputNameToIndex_const_StringR(instance: *mut c_void, output_name: *const c_char, ocvrs_return: *mut Result); pub fn cv_dnn_LSTMLayer_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_dnn_LSTMLayer_to_Layer(instance: *mut c_void) -> *mut c_void; pub fn cv_dnn_LSTMLayer_delete(instance: *mut c_void); - pub fn cv_dnn_Layer_finalize_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, inputs: *const c_void, outputs: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_Layer_forward_vectorLMatXGR_vectorLMatGR_vectorLMatGR(instance: *mut c_void, input: *mut c_void, output: *mut c_void, internals: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_Layer_forward_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *mut c_void, inputs: *const c_void, outputs: *const c_void, internals: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_dnn_Layer_finalize_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, inputs: *const c_void, outputs: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_Layer_forward_vectorLMatXGR_vectorLMatGR_vectorLMatGR(instance: *mut c_void, input: *mut c_void, output: *mut c_void, internals: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_Layer_forward_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *mut c_void, inputs: *const c_void, outputs: *const c_void, internals: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_dnn_Layer_tryQuantize_const_vectorLvectorLfloatGGR_const_vectorLvectorLintGGR_LayerParamsR(instance: *mut c_void, scales: *const c_void, zeropoints: *const c_void, params: *mut c_void, ocvrs_return: *mut Result); - pub fn cv_dnn_Layer_forward_fallback_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *mut c_void, inputs: *const c_void, outputs: *const c_void, internals: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_Layer_finalize_const_vectorLMatGR_vectorLMatGR(instance: *mut c_void, inputs: *const c_void, outputs: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_dnn_Layer_forward_fallback_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *mut c_void, inputs: *const c_void, outputs: *const c_void, internals: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_Layer_finalize_const_vectorLMatGR_vectorLMatGR(instance: *mut c_void, inputs: *const c_void, outputs: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_dnn_Layer_finalize_const_vectorLMatGR(instance: *mut c_void, inputs: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_dnn_Layer_run_const_vectorLMatGR_vectorLMatGR_vectorLMatGR(instance: *mut c_void, inputs: *const c_void, outputs: *mut c_void, internals: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_dnn_Layer_run_const_vectorLMatGR_vectorLMatGR_vectorLMatGR(instance: *mut c_void, inputs: *const c_void, outputs: *mut c_void, internals: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_dnn_Layer_inputNameToIndex_String(instance: *mut c_void, input_name: *const c_char, ocvrs_return: *mut Result); pub fn cv_dnn_Layer_outputNameToIndex_const_StringR(instance: *mut c_void, output_name: *const c_char, ocvrs_return: *mut Result); pub fn cv_dnn_Layer_supportBackend_int(instance: *mut c_void, backend_id: i32, ocvrs_return: *mut Result); @@ -5953,19 +6030,19 @@ mod dnn_sys { pub fn cv_dnn_Layer_initCUDA_voidX_const_vectorLPtrLBackendWrapperGGR_const_vectorLPtrLBackendWrapperGGR(instance: *mut c_void, context: *mut c_void, inputs: *const c_void, outputs: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dnn_Layer_initTimVX_voidX_const_vectorLPtrLBackendWrapperGGR_const_vectorLPtrLBackendWrapperGGR_bool(instance: *mut c_void, tim_vx_info: *mut c_void, inputs_wrapper: *const c_void, outputs_wrapper: *const c_void, is_last: bool, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dnn_Layer_initCann_const_vectorLPtrLBackendWrapperGGR_const_vectorLPtrLBackendWrapperGGR_const_vectorLPtrLBackendNodeGGR(instance: *mut c_void, inputs: *const c_void, outputs: *const c_void, nodes: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_dnn_Layer_applyHalideScheduler_const_PtrLBackendNodeGR_const_vectorLMatXGR_const_vectorLMatGR_int(instance: *const c_void, node: *mut c_void, inputs: *const c_void, outputs: *const c_void, target_id: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_dnn_Layer_applyHalideScheduler_const_PtrLBackendNodeGR_const_vectorLMatXGR_const_vectorLMatGR_int(instance: *const c_void, node: *mut c_void, inputs: *const c_void, outputs: *const c_void, target_id: i32, ocvrs_return: *mut Result<()>); pub fn cv_dnn_Layer_tryAttach_const_PtrLBackendNodeGR(instance: *mut c_void, node: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dnn_Layer_setActivation_const_PtrLActivationLayerGR(instance: *mut c_void, layer: *const c_void, ocvrs_return: *mut Result); pub fn cv_dnn_Layer_tryFuse_PtrLLayerGR(instance: *mut c_void, top: *mut c_void, ocvrs_return: *mut Result); - pub fn cv_dnn_Layer_getScaleShift_const_MatR_MatR(instance: *const c_void, scale: *mut c_void, shift: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_Layer_getScaleZeropoint_const_floatR_intR(instance: *const c_void, scale: *mut f32, zeropoint: *mut i32, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_Layer_unsetAttached(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_dnn_Layer_getScaleShift_const_MatR_MatR(instance: *const c_void, scale: *mut c_void, shift: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_Layer_getScaleZeropoint_const_floatR_intR(instance: *const c_void, scale: *mut f32, zeropoint: *mut i32, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_Layer_unsetAttached(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_dnn_Layer_getMemoryShapes_const_const_vectorLMatShapeGR_const_int_vectorLMatShapeGR_vectorLMatShapeGR(instance: *const c_void, inputs: *const c_void, required_outputs: i32, outputs: *mut c_void, internals: *mut c_void, ocvrs_return: *mut Result); pub fn cv_dnn_Layer_getFLOPS_const_const_vectorLMatShapeGR_const_vectorLMatShapeGR(instance: *const c_void, inputs: *const c_void, outputs: *const c_void, ocvrs_return: *mut Result); pub fn cv_dnn_Layer_updateMemoryShapes_const_vectorLMatShapeGR(instance: *mut c_void, inputs: *const c_void, ocvrs_return: *mut Result); pub fn cv_dnn_Layer_Layer(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dnn_Layer_Layer_const_LayerParamsR(params: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_dnn_Layer_setParamsFrom_const_LayerParamsR(instance: *mut c_void, params: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_dnn_Layer_setParamsFrom_const_LayerParamsR(instance: *mut c_void, params: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_dnn_Layer_propBlobs_const(instance: *const c_void) -> *mut c_void; pub fn cv_dnn_Layer_propBlobs_const_vectorLMatG(instance: *mut c_void, val: *const c_void); pub fn cv_dnn_Layer_propName_const(instance: *const c_void) -> *mut c_void; @@ -6092,8 +6169,8 @@ mod dnn_sys { pub fn cv_dnn_Layer_to_TopKLayer(instance: *mut c_void) -> *mut c_void; pub fn cv_dnn_Layer_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_dnn_Layer_delete(instance: *mut c_void); - pub fn cv_dnn_LayerFactory_registerLayer_const_StringR_Constructor(typ: *const c_char, constructor: Option *mut c_void>, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_LayerFactory_unregisterLayer_const_StringR(typ: *const c_char, ocvrs_return: *mut ResultVoid); + pub fn cv_dnn_LayerFactory_registerLayer_const_StringR_Constructor(typ: *const c_char, constructor: Option *mut c_void>, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_LayerFactory_unregisterLayer_const_StringR(typ: *const c_char, ocvrs_return: *mut Result<()>); pub fn cv_dnn_LayerFactory_isLayerRegistered_const_stringR(typ: *const c_char, ocvrs_return: *mut Result); pub fn cv_dnn_LayerFactory_createLayerInstance_const_StringR_LayerParamsR(typ: *const c_char, params: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dnn_LayerFactory_delete(instance: *mut c_void); @@ -6171,9 +6248,9 @@ mod dnn_sys { pub fn cv_dnn_Model_setInputCrop_bool(instance: *mut c_void, crop: bool, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dnn_Model_setInputSwapRB_bool(instance: *mut c_void, swap_rb: bool, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dnn_Model_setOutputNames_const_vectorLStringGR(instance: *mut c_void, out_names: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_dnn_Model_setInputParams_double_const_SizeR_const_ScalarR_bool_bool(instance: *mut c_void, scale: f64, size: *const core::Size, mean: *const core::Scalar, swap_rb: bool, crop: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_Model_setInputParams(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_Model_predict_const_const__InputArrayR_const__OutputArrayR(instance: *const c_void, frame: *const c_void, outs: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_dnn_Model_setInputParams_double_const_SizeR_const_ScalarR_bool_bool(instance: *mut c_void, scale: f64, size: *const core::Size, mean: *const core::Scalar, swap_rb: bool, crop: bool, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_Model_setInputParams(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_Model_predict_const_const__InputArrayR_const__OutputArrayR(instance: *const c_void, frame: *const c_void, outs: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_dnn_Model_setPreferableBackend_Backend(instance: *mut c_void, backend_id: crate::dnn::Backend, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dnn_Model_setPreferableTarget_Target(instance: *mut c_void, target_id: crate::dnn::Target, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dnn_Model_enableWinograd_bool(instance: *mut c_void, use_winograd: bool, ocvrs_return: *mut Result<*mut c_void>); @@ -6192,8 +6269,8 @@ mod dnn_sys { pub fn cv_dnn_Net_readFromModelOptimizer_const_unsigned_charX_size_t_const_unsigned_charX_size_t(buffer_model_config_ptr: *const u8, buffer_model_config_size: size_t, buffer_weights_ptr: *const u8, buffer_weights_size: size_t, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dnn_Net_empty_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_dnn_Net_dump(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_dnn_Net_dumpToFile_const_StringR(instance: *mut c_void, path: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_Net_dumpToPbtxt_const_StringR(instance: *mut c_void, path: *const c_char, ocvrs_return: *mut ResultVoid); + pub fn cv_dnn_Net_dumpToFile_const_StringR(instance: *mut c_void, path: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_Net_dumpToPbtxt_const_StringR(instance: *mut c_void, path: *const c_char, ocvrs_return: *mut Result<()>); pub fn cv_dnn_Net_addLayer_const_StringR_const_StringR_const_intR_LayerParamsR(instance: *mut c_void, name: *const c_char, typ: *const c_char, dtype: *const i32, params: *mut c_void, ocvrs_return: *mut Result); pub fn cv_dnn_Net_addLayer_const_StringR_const_StringR_LayerParamsR(instance: *mut c_void, name: *const c_char, typ: *const c_char, params: *mut c_void, ocvrs_return: *mut Result); pub fn cv_dnn_Net_addLayerToPrev_const_StringR_const_StringR_const_intR_LayerParamsR(instance: *mut c_void, name: *const c_char, typ: *const c_char, dtype: *const i32, params: *mut c_void, ocvrs_return: *mut Result); @@ -6204,54 +6281,54 @@ mod dnn_sys { pub fn cv_dnn_Net_getLayer_const_const_StringR(instance: *const c_void, layer_name: *const c_char, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dnn_Net_getLayer_const_const_LayerIdR(instance: *const c_void, layer_id: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dnn_Net_getLayerInputs_const_int(instance: *const c_void, layer_id: i32, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_dnn_Net_connect_String_String(instance: *mut c_void, out_pin: *const c_char, inp_pin: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_Net_connect_int_int_int_int(instance: *mut c_void, out_layer_id: i32, out_num: i32, inp_layer_id: i32, inp_num: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_dnn_Net_connect_String_String(instance: *mut c_void, out_pin: *const c_char, inp_pin: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_Net_connect_int_int_int_int(instance: *mut c_void, out_layer_id: i32, out_num: i32, inp_layer_id: i32, inp_num: i32, ocvrs_return: *mut Result<()>); pub fn cv_dnn_Net_registerOutput_const_stringR_int_int(instance: *mut c_void, output_name: *const c_char, layer_id: i32, output_port: i32, ocvrs_return: *mut Result); - pub fn cv_dnn_Net_setInputsNames_const_vectorLStringGR(instance: *mut c_void, input_blob_names: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_Net_setInputShape_const_StringR_const_MatShapeR(instance: *mut c_void, input_name: *const c_char, shape: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_dnn_Net_setInputsNames_const_vectorLStringGR(instance: *mut c_void, input_blob_names: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_Net_setInputShape_const_StringR_const_MatShapeR(instance: *mut c_void, input_name: *const c_char, shape: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_dnn_Net_forward_const_StringR(instance: *mut c_void, output_name: *const c_char, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dnn_Net_forward(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dnn_Net_forwardAsync_const_StringR(instance: *mut c_void, output_name: *const c_char, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dnn_Net_forwardAsync(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_dnn_Net_forward_const__OutputArrayR_const_StringR(instance: *mut c_void, output_blobs: *const c_void, output_name: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_Net_forward_const__OutputArrayR(instance: *mut c_void, output_blobs: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_Net_forward_const__OutputArrayR_const_vectorLStringGR(instance: *mut c_void, output_blobs: *const c_void, out_blob_names: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_Net_forward_vectorLvectorLMatGGR_const_vectorLStringGR(instance: *mut c_void, output_blobs: *mut c_void, out_blob_names: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_dnn_Net_forward_const__OutputArrayR_const_StringR(instance: *mut c_void, output_blobs: *const c_void, output_name: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_Net_forward_const__OutputArrayR(instance: *mut c_void, output_blobs: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_Net_forward_const__OutputArrayR_const_vectorLStringGR(instance: *mut c_void, output_blobs: *const c_void, out_blob_names: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_Net_forward_vectorLvectorLMatGGR_const_vectorLStringGR(instance: *mut c_void, output_blobs: *mut c_void, out_blob_names: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_dnn_Net_quantize_const__InputArrayR_int_int_bool(instance: *mut c_void, calib_data: *const c_void, inputs_dtype: i32, outputs_dtype: i32, per_channel: bool, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dnn_Net_quantize_const__InputArrayR_int_int(instance: *mut c_void, calib_data: *const c_void, inputs_dtype: i32, outputs_dtype: i32, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_dnn_Net_getInputDetails_const_vectorLfloatGR_vectorLintGR(instance: *const c_void, scales: *mut c_void, zeropoints: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_Net_getOutputDetails_const_vectorLfloatGR_vectorLintGR(instance: *const c_void, scales: *mut c_void, zeropoints: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_Net_setHalideScheduler_const_StringR(instance: *mut c_void, scheduler: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_Net_setPreferableBackend_int(instance: *mut c_void, backend_id: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_Net_setPreferableTarget_int(instance: *mut c_void, target_id: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_Net_setInput_const__InputArrayR_const_StringR_double_const_ScalarR(instance: *mut c_void, blob: *const c_void, name: *const c_char, scalefactor: f64, mean: *const core::Scalar, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_Net_setInput_const__InputArrayR(instance: *mut c_void, blob: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_Net_setParam_int_int_const_MatR(instance: *mut c_void, layer: i32, num_param: i32, blob: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_Net_setParam_const_StringR_int_const_MatR(instance: *mut c_void, layer_name: *const c_char, num_param: i32, blob: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_dnn_Net_getInputDetails_const_vectorLfloatGR_vectorLintGR(instance: *const c_void, scales: *mut c_void, zeropoints: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_Net_getOutputDetails_const_vectorLfloatGR_vectorLintGR(instance: *const c_void, scales: *mut c_void, zeropoints: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_Net_setHalideScheduler_const_StringR(instance: *mut c_void, scheduler: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_Net_setPreferableBackend_int(instance: *mut c_void, backend_id: i32, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_Net_setPreferableTarget_int(instance: *mut c_void, target_id: i32, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_Net_setInput_const__InputArrayR_const_StringR_double_const_ScalarR(instance: *mut c_void, blob: *const c_void, name: *const c_char, scalefactor: f64, mean: *const core::Scalar, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_Net_setInput_const__InputArrayR(instance: *mut c_void, blob: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_Net_setParam_int_int_const_MatR(instance: *mut c_void, layer: i32, num_param: i32, blob: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_Net_setParam_const_StringR_int_const_MatR(instance: *mut c_void, layer_name: *const c_char, num_param: i32, blob: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_dnn_Net_getParam_const_int_int(instance: *const c_void, layer: i32, num_param: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dnn_Net_getParam_const_int(instance: *const c_void, layer: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dnn_Net_getParam_const_const_StringR_int(instance: *const c_void, layer_name: *const c_char, num_param: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dnn_Net_getParam_const_const_StringR(instance: *const c_void, layer_name: *const c_char, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dnn_Net_getUnconnectedOutLayers_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dnn_Net_getUnconnectedOutLayersNames_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_dnn_Net_getLayersShapes_const_const_vectorLMatShapeGR_vectorLintGR_vectorLvectorLMatShapeGGR_vectorLvectorLMatShapeGGR(instance: *const c_void, net_input_shapes: *const c_void, layers_ids: *mut c_void, in_layers_shapes: *mut c_void, out_layers_shapes: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_Net_getLayersShapes_const_const_MatShapeR_vectorLintGR_vectorLvectorLMatShapeGGR_vectorLvectorLMatShapeGGR(instance: *const c_void, net_input_shape: *const c_void, layers_ids: *mut c_void, in_layers_shapes: *mut c_void, out_layers_shapes: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_Net_getLayerShapes_const_const_MatShapeR_const_int_vectorLMatShapeGR_vectorLMatShapeGR(instance: *const c_void, net_input_shape: *const c_void, layer_id: i32, in_layer_shapes: *mut c_void, out_layer_shapes: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_Net_getLayerShapes_const_const_vectorLMatShapeGR_const_int_vectorLMatShapeGR_vectorLMatShapeGR(instance: *const c_void, net_input_shapes: *const c_void, layer_id: i32, in_layer_shapes: *mut c_void, out_layer_shapes: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_dnn_Net_getLayersShapes_const_const_vectorLMatShapeGR_vectorLintGR_vectorLvectorLMatShapeGGR_vectorLvectorLMatShapeGGR(instance: *const c_void, net_input_shapes: *const c_void, layers_ids: *mut c_void, in_layers_shapes: *mut c_void, out_layers_shapes: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_Net_getLayersShapes_const_const_MatShapeR_vectorLintGR_vectorLvectorLMatShapeGGR_vectorLvectorLMatShapeGGR(instance: *const c_void, net_input_shape: *const c_void, layers_ids: *mut c_void, in_layers_shapes: *mut c_void, out_layers_shapes: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_Net_getLayerShapes_const_const_MatShapeR_const_int_vectorLMatShapeGR_vectorLMatShapeGR(instance: *const c_void, net_input_shape: *const c_void, layer_id: i32, in_layer_shapes: *mut c_void, out_layer_shapes: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_Net_getLayerShapes_const_const_vectorLMatShapeGR_const_int_vectorLMatShapeGR_vectorLMatShapeGR(instance: *const c_void, net_input_shapes: *const c_void, layer_id: i32, in_layer_shapes: *mut c_void, out_layer_shapes: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_dnn_Net_getFLOPS_const_const_vectorLMatShapeGR(instance: *const c_void, net_input_shapes: *const c_void, ocvrs_return: *mut Result); pub fn cv_dnn_Net_getFLOPS_const_const_MatShapeR(instance: *const c_void, net_input_shape: *const c_void, ocvrs_return: *mut Result); pub fn cv_dnn_Net_getFLOPS_const_const_int_const_vectorLMatShapeGR(instance: *const c_void, layer_id: i32, net_input_shapes: *const c_void, ocvrs_return: *mut Result); pub fn cv_dnn_Net_getFLOPS_const_const_int_const_MatShapeR(instance: *const c_void, layer_id: i32, net_input_shape: *const c_void, ocvrs_return: *mut Result); - pub fn cv_dnn_Net_getLayerTypes_const_vectorLStringGR(instance: *const c_void, layers_types: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_dnn_Net_getLayerTypes_const_vectorLStringGR(instance: *const c_void, layers_types: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_dnn_Net_getLayersCount_const_const_StringR(instance: *const c_void, layer_type: *const c_char, ocvrs_return: *mut Result); - pub fn cv_dnn_Net_getMemoryConsumption_const_const_vectorLMatShapeGR_size_tR_size_tR(instance: *const c_void, net_input_shapes: *const c_void, weights: *mut size_t, blobs: *mut size_t, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_Net_getMemoryConsumption_const_const_MatShapeR_size_tR_size_tR(instance: *const c_void, net_input_shape: *const c_void, weights: *mut size_t, blobs: *mut size_t, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_Net_getMemoryConsumption_const_const_int_const_vectorLMatShapeGR_size_tR_size_tR(instance: *const c_void, layer_id: i32, net_input_shapes: *const c_void, weights: *mut size_t, blobs: *mut size_t, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_Net_getMemoryConsumption_const_const_int_const_MatShapeR_size_tR_size_tR(instance: *const c_void, layer_id: i32, net_input_shape: *const c_void, weights: *mut size_t, blobs: *mut size_t, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_Net_getMemoryConsumption_const_const_vectorLMatShapeGR_vectorLintGR_vectorLsize_tGR_vectorLsize_tGR(instance: *const c_void, net_input_shapes: *const c_void, layer_ids: *mut c_void, weights: *mut c_void, blobs: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_Net_getMemoryConsumption_const_const_MatShapeR_vectorLintGR_vectorLsize_tGR_vectorLsize_tGR(instance: *const c_void, net_input_shape: *const c_void, layer_ids: *mut c_void, weights: *mut c_void, blobs: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_Net_enableFusion_bool(instance: *mut c_void, fusion: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_Net_enableWinograd_bool(instance: *mut c_void, use_winograd: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_dnn_Net_getMemoryConsumption_const_const_vectorLMatShapeGR_size_tR_size_tR(instance: *const c_void, net_input_shapes: *const c_void, weights: *mut size_t, blobs: *mut size_t, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_Net_getMemoryConsumption_const_const_MatShapeR_size_tR_size_tR(instance: *const c_void, net_input_shape: *const c_void, weights: *mut size_t, blobs: *mut size_t, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_Net_getMemoryConsumption_const_const_int_const_vectorLMatShapeGR_size_tR_size_tR(instance: *const c_void, layer_id: i32, net_input_shapes: *const c_void, weights: *mut size_t, blobs: *mut size_t, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_Net_getMemoryConsumption_const_const_int_const_MatShapeR_size_tR_size_tR(instance: *const c_void, layer_id: i32, net_input_shape: *const c_void, weights: *mut size_t, blobs: *mut size_t, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_Net_getMemoryConsumption_const_const_vectorLMatShapeGR_vectorLintGR_vectorLsize_tGR_vectorLsize_tGR(instance: *const c_void, net_input_shapes: *const c_void, layer_ids: *mut c_void, weights: *mut c_void, blobs: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_Net_getMemoryConsumption_const_const_MatShapeR_vectorLintGR_vectorLsize_tGR_vectorLsize_tGR(instance: *const c_void, net_input_shape: *const c_void, layer_ids: *mut c_void, weights: *mut c_void, blobs: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_Net_enableFusion_bool(instance: *mut c_void, fusion: bool, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_Net_enableWinograd_bool(instance: *mut c_void, use_winograd: bool, ocvrs_return: *mut Result<()>); pub fn cv_dnn_Net_getPerfProfile_vectorLdoubleGR(instance: *mut c_void, timings: *mut c_void, ocvrs_return: *mut Result); pub fn cv_dnn_Net_implicitClone_const(instance: *const c_void) -> *mut c_void; pub fn cv_dnn_Net_delete(instance: *mut c_void); @@ -6361,9 +6438,9 @@ mod dnn_sys { pub fn cv_dnn_QuantizeLayer_to_Layer(instance: *mut c_void) -> *mut c_void; pub fn cv_dnn_QuantizeLayer_delete(instance: *mut c_void); pub fn cv_dnn_RNNLayer_create_const_LayerParamsR(params: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_dnn_RNNLayer_setWeights_const_MatR_const_MatR_const_MatR_const_MatR_const_MatR(instance: *mut c_void, wxh: *const c_void, bh: *const c_void, whh: *const c_void, who: *const c_void, bo: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_RNNLayer_setProduceHiddenOutput_bool(instance: *mut c_void, produce: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_RNNLayer_setProduceHiddenOutput(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_dnn_RNNLayer_setWeights_const_MatR_const_MatR_const_MatR_const_MatR_const_MatR(instance: *mut c_void, wxh: *const c_void, bh: *const c_void, whh: *const c_void, who: *const c_void, bo: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_RNNLayer_setProduceHiddenOutput_bool(instance: *mut c_void, produce: bool, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_RNNLayer_setProduceHiddenOutput(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_dnn_RNNLayer_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_dnn_RNNLayer_to_Layer(instance: *mut c_void) -> *mut c_void; pub fn cv_dnn_RNNLayer_delete(instance: *mut c_void); @@ -6471,7 +6548,7 @@ mod dnn_sys { pub fn cv_dnn_SegmentationModel_SegmentationModel_const_StringR_const_StringR(model: *const c_char, config: *const c_char, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dnn_SegmentationModel_SegmentationModel_const_StringR(model: *const c_char, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dnn_SegmentationModel_SegmentationModel_const_NetR(network: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_dnn_SegmentationModel_segment_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, frame: *const c_void, mask: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_dnn_SegmentationModel_segment_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, frame: *const c_void, mask: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_dnn_SegmentationModel_implicitClone_const(instance: *const c_void) -> *mut c_void; pub fn cv_dnn_SegmentationModel_to_Model(instance: *mut c_void) -> *mut c_void; pub fn cv_dnn_SegmentationModel_delete(instance: *mut c_void); @@ -6614,10 +6691,10 @@ mod dnn_sys { pub fn cv_dnn_TanLayer_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_dnn_TanLayer_to_Layer(instance: *mut c_void) -> *mut c_void; pub fn cv_dnn_TanLayer_delete(instance: *mut c_void); - pub fn cv_dnn_TextDetectionModel_detect_const_const__InputArrayR_vectorLvectorLPointGGR_vectorLfloatGR(instance: *const c_void, frame: *const c_void, detections: *mut c_void, confidences: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_TextDetectionModel_detect_const_const__InputArrayR_vectorLvectorLPointGGR(instance: *const c_void, frame: *const c_void, detections: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_TextDetectionModel_detectTextRectangles_const_const__InputArrayR_vectorLRotatedRectGR_vectorLfloatGR(instance: *const c_void, frame: *const c_void, detections: *mut c_void, confidences: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_TextDetectionModel_detectTextRectangles_const_const__InputArrayR_vectorLRotatedRectGR(instance: *const c_void, frame: *const c_void, detections: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_dnn_TextDetectionModel_detect_const_const__InputArrayR_vectorLvectorLPointGGR_vectorLfloatGR(instance: *const c_void, frame: *const c_void, detections: *mut c_void, confidences: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_TextDetectionModel_detect_const_const__InputArrayR_vectorLvectorLPointGGR(instance: *const c_void, frame: *const c_void, detections: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_TextDetectionModel_detectTextRectangles_const_const__InputArrayR_vectorLRotatedRectGR_vectorLfloatGR(instance: *const c_void, frame: *const c_void, detections: *mut c_void, confidences: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_TextDetectionModel_detectTextRectangles_const_const__InputArrayR_vectorLRotatedRectGR(instance: *const c_void, frame: *const c_void, detections: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_dnn_TextDetectionModel_to_Model(instance: *mut c_void) -> *mut c_void; pub fn cv_dnn_TextDetectionModel_delete(instance: *mut c_void); pub fn cv_dnn_TextDetectionModel_DB_TextDetectionModel_DB(ocvrs_return: *mut Result<*mut c_void>); @@ -6659,7 +6736,7 @@ mod dnn_sys { pub fn cv_dnn_TextRecognitionModel_setVocabulary_const_vectorLstringGR(instance: *mut c_void, vocabulary: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dnn_TextRecognitionModel_getVocabulary_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dnn_TextRecognitionModel_recognize_const_const__InputArrayR(instance: *const c_void, frame: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_dnn_TextRecognitionModel_recognize_const_const__InputArrayR_const__InputArrayR_vectorLstringGR(instance: *const c_void, frame: *const c_void, roi_rects: *const c_void, results: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_dnn_TextRecognitionModel_recognize_const_const__InputArrayR_const__InputArrayR_vectorLstringGR(instance: *const c_void, frame: *const c_void, roi_rects: *const c_void, results: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_dnn_TextRecognitionModel_implicitClone_const(instance: *const c_void) -> *mut c_void; pub fn cv_dnn_TextRecognitionModel_to_Model(instance: *mut c_void) -> *mut c_void; pub fn cv_dnn_TextRecognitionModel_delete(instance: *mut c_void); @@ -7675,10 +7752,8 @@ mod dnn_sys { pub fn std_vectorLstd_vectorLcv_dnn_MatShapeGG_set_size_t_const_vectorLMatShapeG(instance: *mut c_void, index: size_t, val: *const c_void); } } -#[cfg(ocvrs_has_module_dnn)] pub use dnn_sys::*; -#[cfg(ocvrs_has_module_dnn_superres)] mod dnn_superres_sys { use super::*; @@ -7686,13 +7761,13 @@ mod dnn_superres_sys { pub fn cv_dnn_superres_DnnSuperResImpl_create(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dnn_superres_DnnSuperResImpl_DnnSuperResImpl(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dnn_superres_DnnSuperResImpl_DnnSuperResImpl_const_StringR_int(algo: *const c_char, scale: i32, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_dnn_superres_DnnSuperResImpl_readModel_const_StringR(instance: *mut c_void, path: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_superres_DnnSuperResImpl_readModel_const_StringR_const_StringR(instance: *mut c_void, weights: *const c_char, definition: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_superres_DnnSuperResImpl_setModel_const_StringR_int(instance: *mut c_void, algo: *const c_char, scale: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_superres_DnnSuperResImpl_setPreferableBackend_int(instance: *mut c_void, backend_id: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_superres_DnnSuperResImpl_setPreferableTarget_int(instance: *mut c_void, target_id: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_superres_DnnSuperResImpl_upsample_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, img: *const c_void, result: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_dnn_superres_DnnSuperResImpl_upsampleMultioutput_const__InputArrayR_vectorLMatGR_const_vectorLintGR_const_vectorLStringGR(instance: *mut c_void, img: *const c_void, imgs_new: *mut c_void, scale_factors: *const c_void, node_names: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_dnn_superres_DnnSuperResImpl_readModel_const_StringR(instance: *mut c_void, path: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_superres_DnnSuperResImpl_readModel_const_StringR_const_StringR(instance: *mut c_void, weights: *const c_char, definition: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_superres_DnnSuperResImpl_setModel_const_StringR_int(instance: *mut c_void, algo: *const c_char, scale: i32, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_superres_DnnSuperResImpl_setPreferableBackend_int(instance: *mut c_void, backend_id: i32, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_superres_DnnSuperResImpl_setPreferableTarget_int(instance: *mut c_void, target_id: i32, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_superres_DnnSuperResImpl_upsample_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, img: *const c_void, result: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_dnn_superres_DnnSuperResImpl_upsampleMultioutput_const__InputArrayR_vectorLMatGR_const_vectorLintGR_const_vectorLStringGR(instance: *mut c_void, img: *const c_void, imgs_new: *mut c_void, scale_factors: *const c_void, node_names: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_dnn_superres_DnnSuperResImpl_getScale(instance: *mut c_void, ocvrs_return: *mut Result); pub fn cv_dnn_superres_DnnSuperResImpl_getAlgorithm(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dnn_superres_DnnSuperResImpl_delete(instance: *mut c_void); @@ -7703,16 +7778,14 @@ mod dnn_superres_sys { pub fn cv_PtrLcv_dnn_superres_DnnSuperResImplG_new_const_DnnSuperResImpl(val: *mut c_void) -> *mut c_void; } } -#[cfg(ocvrs_has_module_dnn_superres)] pub use dnn_superres_sys::*; -#[cfg(ocvrs_has_module_dpm)] mod dpm_sys { use super::*; extern "C" { pub fn cv_dpm_DPMDetector_isEmpty_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_dpm_DPMDetector_detect_MatR_vectorLObjectDetectionGR(instance: *mut c_void, image: *mut c_void, objects: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_dpm_DPMDetector_detect_MatR_vectorLObjectDetectionGR(instance: *mut c_void, image: *mut c_void, objects: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_dpm_DPMDetector_getClassNames_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dpm_DPMDetector_getClassCount_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_dpm_DPMDetector_create_const_vectorLstringGR_const_vectorLstringGR(filenames: *const c_void, class_names: *const c_void, ocvrs_return: *mut Result<*mut c_void>); @@ -7748,10 +7821,8 @@ mod dpm_sys { pub fn std_vectorLcv_dpm_DPMDetector_ObjectDetectionG_set_size_t_const_ObjectDetection(instance: *mut c_void, index: size_t, val: *const c_void); } } -#[cfg(ocvrs_has_module_dpm)] pub use dpm_sys::*; -#[cfg(ocvrs_has_module_face)] mod face_sys { use super::*; @@ -7759,8 +7830,8 @@ mod face_sys { pub fn cv_face_createFacemarkAAM(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_face_createFacemarkKazemi(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_face_createFacemarkLBF(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_face_drawFacemarks_const__InputOutputArrayR_const__InputArrayR(image: *const c_void, points: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_face_drawFacemarks_const__InputOutputArrayR_const__InputArrayR_Scalar(image: *const c_void, points: *const c_void, color: *const core::Scalar, ocvrs_return: *mut ResultVoid); + pub fn cv_face_drawFacemarks_const__InputOutputArrayR_const__InputArrayR(image: *const c_void, points: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_face_drawFacemarks_const__InputOutputArrayR_const__InputArrayR_Scalar(image: *const c_void, points: *const c_void, color: *const core::Scalar, ocvrs_return: *mut Result<()>); pub fn cv_face_getFacesHAAR_const__InputArrayR_const__OutputArrayR_const_StringR(image: *const c_void, faces: *const c_void, face_cascade_name: *const c_char, ocvrs_return: *mut Result); pub fn cv_face_getFaces_const__InputArrayR_const__OutputArrayR_CParamsX(image: *const c_void, faces: *const c_void, params: *mut c_void, ocvrs_return: *mut Result); pub fn cv_face_loadDatasetList_String_String_vectorLStringGR_vectorLStringGR(image_list: *const c_char, annotation_list: *const c_char, images: *mut c_void, annotations: *mut c_void, ocvrs_return: *mut Result); @@ -7773,22 +7844,22 @@ mod face_sys { pub fn cv_face_loadTrainingData_vectorLStringG_vectorLvectorLPoint2fGGR_vectorLStringGR(filename: *mut c_void, trainlandmarks: *mut c_void, trainimages: *mut c_void, ocvrs_return: *mut Result); pub fn cv_face_BIF_getNumBands_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_face_BIF_getNumRotations_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_face_BIF_compute_const_const__InputArrayR_const__OutputArrayR(instance: *const c_void, image: *const c_void, features: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_face_BIF_compute_const_const__InputArrayR_const__OutputArrayR(instance: *const c_void, image: *const c_void, features: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_face_BIF_create_int_int(num_bands: i32, num_rotations: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_face_BIF_create(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_face_BIF_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_face_BIF_delete(instance: *mut c_void); pub fn cv_face_BasicFaceRecognizer_getNumComponents_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_face_BasicFaceRecognizer_setNumComponents_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_face_BasicFaceRecognizer_setNumComponents_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_face_BasicFaceRecognizer_getThreshold_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_face_BasicFaceRecognizer_setThreshold_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_face_BasicFaceRecognizer_setThreshold_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_face_BasicFaceRecognizer_getProjections_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_face_BasicFaceRecognizer_getLabels_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_face_BasicFaceRecognizer_getEigenValues_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_face_BasicFaceRecognizer_getEigenVectors_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_face_BasicFaceRecognizer_getMean_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_face_BasicFaceRecognizer_read_const_FileNodeR(instance: *mut c_void, fn_: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_face_BasicFaceRecognizer_write_const_FileStorageR(instance: *const c_void, fs: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_face_BasicFaceRecognizer_read_const_FileNodeR(instance: *mut c_void, fn_: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_face_BasicFaceRecognizer_write_const_FileStorageR(instance: *const c_void, fs: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_face_BasicFaceRecognizer_empty_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_face_BasicFaceRecognizer_to_EigenFaceRecognizer(instance: *mut c_void) -> *mut c_void; pub fn cv_face_BasicFaceRecognizer_to_FisherFaceRecognizer(instance: *mut c_void) -> *mut c_void; @@ -7816,28 +7887,28 @@ mod face_sys { pub fn cv_face_EigenFaceRecognizer_to_BasicFaceRecognizer(instance: *mut c_void) -> *mut c_void; pub fn cv_face_EigenFaceRecognizer_to_FaceRecognizer(instance: *mut c_void) -> *mut c_void; pub fn cv_face_EigenFaceRecognizer_delete(instance: *mut c_void); - pub fn cv_face_FaceRecognizer_train_const__InputArrayR_const__InputArrayR(instance: *mut c_void, src: *const c_void, labels: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_face_FaceRecognizer_update_const__InputArrayR_const__InputArrayR(instance: *mut c_void, src: *const c_void, labels: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_face_FaceRecognizer_train_const__InputArrayR_const__InputArrayR(instance: *mut c_void, src: *const c_void, labels: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_face_FaceRecognizer_update_const__InputArrayR_const__InputArrayR(instance: *mut c_void, src: *const c_void, labels: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_face_FaceRecognizer_predict_const_const__InputArrayR(instance: *const c_void, src: *const c_void, ocvrs_return: *mut Result); - pub fn cv_face_FaceRecognizer_predict_const_const__InputArrayR_intR_doubleR(instance: *const c_void, src: *const c_void, label: *mut i32, confidence: *mut f64, ocvrs_return: *mut ResultVoid); - pub fn cv_face_FaceRecognizer_predict_const_const__InputArrayR_PtrLPredictCollectorG(instance: *const c_void, src: *const c_void, collector: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_face_FaceRecognizer_write_const_const_StringR(instance: *const c_void, filename: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_face_FaceRecognizer_read_const_StringR(instance: *mut c_void, filename: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_face_FaceRecognizer_write_const_FileStorageR(instance: *const c_void, fs: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_face_FaceRecognizer_read_const_FileNodeR(instance: *mut c_void, fn_: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_face_FaceRecognizer_predict_const_const__InputArrayR_intR_doubleR(instance: *const c_void, src: *const c_void, label: *mut i32, confidence: *mut f64, ocvrs_return: *mut Result<()>); + pub fn cv_face_FaceRecognizer_predict_const_const__InputArrayR_PtrLPredictCollectorG(instance: *const c_void, src: *const c_void, collector: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_face_FaceRecognizer_write_const_const_StringR(instance: *const c_void, filename: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_face_FaceRecognizer_read_const_StringR(instance: *mut c_void, filename: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_face_FaceRecognizer_write_const_FileStorageR(instance: *const c_void, fs: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_face_FaceRecognizer_read_const_FileNodeR(instance: *mut c_void, fn_: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_face_FaceRecognizer_empty_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_face_FaceRecognizer_setLabelInfo_int_const_StringR(instance: *mut c_void, label: i32, str_info: *const c_char, ocvrs_return: *mut ResultVoid); + pub fn cv_face_FaceRecognizer_setLabelInfo_int_const_StringR(instance: *mut c_void, label: i32, str_info: *const c_char, ocvrs_return: *mut Result<()>); pub fn cv_face_FaceRecognizer_getLabelInfo_const_int(instance: *const c_void, label: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_face_FaceRecognizer_getLabelsByString_const_const_StringR(instance: *const c_void, str: *const c_char, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_face_FaceRecognizer_getThreshold_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_face_FaceRecognizer_setThreshold_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_face_FaceRecognizer_setThreshold_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_face_FaceRecognizer_to_BasicFaceRecognizer(instance: *mut c_void) -> *mut c_void; pub fn cv_face_FaceRecognizer_to_EigenFaceRecognizer(instance: *mut c_void) -> *mut c_void; pub fn cv_face_FaceRecognizer_to_FisherFaceRecognizer(instance: *mut c_void) -> *mut c_void; pub fn cv_face_FaceRecognizer_to_LBPHFaceRecognizer(instance: *mut c_void) -> *mut c_void; pub fn cv_face_FaceRecognizer_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_face_FaceRecognizer_delete(instance: *mut c_void); - pub fn cv_face_Facemark_loadModel_String(instance: *mut c_void, model: *const c_char, ocvrs_return: *mut ResultVoid); + pub fn cv_face_Facemark_loadModel_String(instance: *mut c_void, model: *const c_char, ocvrs_return: *mut Result<()>); pub fn cv_face_Facemark_fit_const__InputArrayR_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, faces: *const c_void, landmarks: *const c_void, ocvrs_return: *mut Result); pub fn cv_face_Facemark_to_FacemarkAAM(instance: *mut c_void) -> *mut c_void; pub fn cv_face_Facemark_to_FacemarkKazemi(instance: *mut c_void) -> *mut c_void; @@ -7904,8 +7975,8 @@ mod face_sys { pub fn cv_face_FacemarkAAM_Model_Texture_propInd2_const_vectorLintG(instance: *mut c_void, val: *const c_void); pub fn cv_face_FacemarkAAM_Model_Texture_delete(instance: *mut c_void); pub fn cv_face_FacemarkAAM_Params_Params(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_face_FacemarkAAM_Params_read_const_FileNodeR(instance: *mut c_void, unnamed: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_face_FacemarkAAM_Params_write_const_FileStorageR(instance: *const c_void, unnamed: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_face_FacemarkAAM_Params_read_const_FileNodeR(instance: *mut c_void, unnamed: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_face_FacemarkAAM_Params_write_const_FileStorageR(instance: *const c_void, unnamed: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_face_FacemarkAAM_Params_propModel_filename_const(instance: *const c_void) -> *mut c_void; pub fn cv_face_FacemarkAAM_Params_propModel_filename_const_string(instance: *mut c_void, val: *const c_char); pub fn cv_face_FacemarkAAM_Params_propM_const(instance: *const c_void) -> i32; @@ -7963,8 +8034,8 @@ mod face_sys { pub fn cv_face_FacemarkLBF_to_FacemarkTrain(instance: *mut c_void) -> *mut c_void; pub fn cv_face_FacemarkLBF_delete(instance: *mut c_void); pub fn cv_face_FacemarkLBF_Params_Params(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_face_FacemarkLBF_Params_read_const_FileNodeR(instance: *mut c_void, unnamed: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_face_FacemarkLBF_Params_write_const_FileStorageR(instance: *const c_void, unnamed: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_face_FacemarkLBF_Params_read_const_FileNodeR(instance: *mut c_void, unnamed: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_face_FacemarkLBF_Params_write_const_FileStorageR(instance: *const c_void, unnamed: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_face_FacemarkLBF_Params_propShape_offset_const(instance: *const c_void) -> f64; pub fn cv_face_FacemarkLBF_Params_propShape_offset_const_double(instance: *mut c_void, val: f64); pub fn cv_face_FacemarkLBF_Params_propCascade_face_const(instance: *const c_void) -> *mut c_void; @@ -7997,8 +8068,8 @@ mod face_sys { pub fn cv_face_FacemarkLBF_Params_propDetectROI_const_Rect(instance: *mut c_void, val: *const core::Rect); pub fn cv_face_FacemarkLBF_Params_delete(instance: *mut c_void); pub fn cv_face_FacemarkTrain_addTrainingSample_const__InputArrayR_const__InputArrayR(instance: *mut c_void, image: *const c_void, landmarks: *const c_void, ocvrs_return: *mut Result); - pub fn cv_face_FacemarkTrain_training_voidX(instance: *mut c_void, parameters: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_face_FacemarkTrain_training(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_face_FacemarkTrain_training_voidX(instance: *mut c_void, parameters: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_face_FacemarkTrain_training(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_face_FacemarkTrain_setFaceDetector_FN_FaceDetector_voidX(instance: *mut c_void, detector: Option bool>, user_data: *mut c_void, ocvrs_return: *mut Result); pub fn cv_face_FacemarkTrain_getFaces_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, faces: *const c_void, ocvrs_return: *mut Result); pub fn cv_face_FacemarkTrain_getData_voidX(instance: *mut c_void, items: *mut c_void, ocvrs_return: *mut Result); @@ -8015,15 +8086,15 @@ mod face_sys { pub fn cv_face_FisherFaceRecognizer_to_FaceRecognizer(instance: *mut c_void) -> *mut c_void; pub fn cv_face_FisherFaceRecognizer_delete(instance: *mut c_void); pub fn cv_face_LBPHFaceRecognizer_getGridX_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_face_LBPHFaceRecognizer_setGridX_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_face_LBPHFaceRecognizer_setGridX_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_face_LBPHFaceRecognizer_getGridY_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_face_LBPHFaceRecognizer_setGridY_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_face_LBPHFaceRecognizer_setGridY_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_face_LBPHFaceRecognizer_getRadius_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_face_LBPHFaceRecognizer_setRadius_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_face_LBPHFaceRecognizer_setRadius_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_face_LBPHFaceRecognizer_getNeighbors_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_face_LBPHFaceRecognizer_setNeighbors_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_face_LBPHFaceRecognizer_setNeighbors_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_face_LBPHFaceRecognizer_getThreshold_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_face_LBPHFaceRecognizer_setThreshold_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_face_LBPHFaceRecognizer_setThreshold_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_face_LBPHFaceRecognizer_getHistograms_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_face_LBPHFaceRecognizer_getLabels_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_face_LBPHFaceRecognizer_create_int_int_int_int_double(radius: i32, neighbors: i32, grid_x: i32, grid_y: i32, threshold: f64, ocvrs_return: *mut Result<*mut c_void>); @@ -8031,8 +8102,8 @@ mod face_sys { pub fn cv_face_LBPHFaceRecognizer_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_face_LBPHFaceRecognizer_to_FaceRecognizer(instance: *mut c_void) -> *mut c_void; pub fn cv_face_LBPHFaceRecognizer_delete(instance: *mut c_void); - pub fn cv_face_MACE_salt_const_StringR(instance: *mut c_void, passphrase: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_face_MACE_train_const__InputArrayR(instance: *mut c_void, images: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_face_MACE_salt_const_StringR(instance: *mut c_void, passphrase: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_face_MACE_train_const__InputArrayR(instance: *mut c_void, images: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_face_MACE_same_const_const__InputArrayR(instance: *const c_void, query: *const c_void, ocvrs_return: *mut Result); pub fn cv_face_MACE_load_const_StringR_const_StringR(filename: *const c_char, objname: *const c_char, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_face_MACE_load_const_StringR(filename: *const c_char, ocvrs_return: *mut Result<*mut c_void>); @@ -8040,13 +8111,13 @@ mod face_sys { pub fn cv_face_MACE_create(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_face_MACE_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_face_MACE_delete(instance: *mut c_void); - pub fn cv_face_PredictCollector_init_size_t(instance: *mut c_void, size: size_t, ocvrs_return: *mut ResultVoid); + pub fn cv_face_PredictCollector_init_size_t(instance: *mut c_void, size: size_t, ocvrs_return: *mut Result<()>); pub fn cv_face_PredictCollector_collect_int_double(instance: *mut c_void, label: i32, dist: f64, ocvrs_return: *mut Result); pub fn cv_face_PredictCollector_to_StandardCollector(instance: *mut c_void) -> *mut c_void; pub fn cv_face_PredictCollector_delete(instance: *mut c_void); pub fn cv_face_StandardCollector_StandardCollector_double(threshold_: f64, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_face_StandardCollector_StandardCollector(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_face_StandardCollector_init_size_t(instance: *mut c_void, size: size_t, ocvrs_return: *mut ResultVoid); + pub fn cv_face_StandardCollector_init_size_t(instance: *mut c_void, size: size_t, ocvrs_return: *mut Result<()>); pub fn cv_face_StandardCollector_collect_int_double(instance: *mut c_void, label: i32, dist: f64, ocvrs_return: *mut Result); pub fn cv_face_StandardCollector_getMinLabel_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_face_StandardCollector_getMinDist_const(instance: *const c_void, ocvrs_return: *mut Result); @@ -8170,70 +8241,68 @@ mod face_sys { pub fn std_vectorLcv_face_FacemarkAAM_Model_TextureG_set_size_t_const_Texture(instance: *mut c_void, index: size_t, val: *const c_void); } } -#[cfg(ocvrs_has_module_face)] pub use face_sys::*; -#[cfg(ocvrs_has_module_features2d)] mod features2d_sys { use super::*; extern "C" { - pub fn cv_AGAST_const__InputArrayR_vectorLKeyPointGR_int(image: *const c_void, keypoints: *mut c_void, threshold: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_AGAST_const__InputArrayR_vectorLKeyPointGR_int_bool(image: *const c_void, keypoints: *mut c_void, threshold: i32, nonmax_suppression: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_AGAST_const__InputArrayR_vectorLKeyPointGR_int_bool_DetectorType(image: *const c_void, keypoints: *mut c_void, threshold: i32, nonmax_suppression: bool, typ: crate::features2d::AgastFeatureDetector_DetectorType, ocvrs_return: *mut ResultVoid); - pub fn cv_FAST_const__InputArrayR_vectorLKeyPointGR_int(image: *const c_void, keypoints: *mut c_void, threshold: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_FAST_const__InputArrayR_vectorLKeyPointGR_int_bool(image: *const c_void, keypoints: *mut c_void, threshold: i32, nonmax_suppression: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_FAST_const__InputArrayR_vectorLKeyPointGR_int_bool_DetectorType(image: *const c_void, keypoints: *mut c_void, threshold: i32, nonmax_suppression: bool, typ: crate::features2d::FastFeatureDetector_DetectorType, ocvrs_return: *mut ResultVoid); - pub fn cv_computeRecallPrecisionCurve_const_vectorLvectorLDMatchGGR_const_vectorLvectorLunsigned_charGGR_vectorLPoint2fGR(matches1to2: *const c_void, correct_matches1to2_mask: *const c_void, recall_precision_curve: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_drawKeypoints_const__InputArrayR_const_vectorLKeyPointGR_const__InputOutputArrayR(image: *const c_void, keypoints: *const c_void, out_image: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_drawKeypoints_const__InputArrayR_const_vectorLKeyPointGR_const__InputOutputArrayR_const_ScalarR_DrawMatchesFlags(image: *const c_void, keypoints: *const c_void, out_image: *const c_void, color: *const core::Scalar, flags: crate::features2d::DrawMatchesFlags, ocvrs_return: *mut ResultVoid); - pub fn cv_drawMatches_const__InputArrayR_const_vectorLKeyPointGR_const__InputArrayR_const_vectorLKeyPointGR_const_vectorLDMatchGR_const__InputOutputArrayR(img1: *const c_void, keypoints1: *const c_void, img2: *const c_void, keypoints2: *const c_void, matches1to2: *const c_void, out_img: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_drawMatches_const__InputArrayR_const_vectorLKeyPointGR_const__InputArrayR_const_vectorLKeyPointGR_const_vectorLDMatchGR_const__InputOutputArrayR_const_ScalarR_const_ScalarR_const_vectorLcharGR_DrawMatchesFlags(img1: *const c_void, keypoints1: *const c_void, img2: *const c_void, keypoints2: *const c_void, matches1to2: *const c_void, out_img: *const c_void, match_color: *const core::Scalar, single_point_color: *const core::Scalar, matches_mask: *const c_void, flags: crate::features2d::DrawMatchesFlags, ocvrs_return: *mut ResultVoid); - pub fn cv_drawMatches_const__InputArrayR_const_vectorLKeyPointGR_const__InputArrayR_const_vectorLKeyPointGR_const_vectorLDMatchGR_const__InputOutputArrayR_const_int(img1: *const c_void, keypoints1: *const c_void, img2: *const c_void, keypoints2: *const c_void, matches1to2: *const c_void, out_img: *const c_void, matches_thickness: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_drawMatches_const__InputArrayR_const_vectorLKeyPointGR_const__InputArrayR_const_vectorLKeyPointGR_const_vectorLDMatchGR_const__InputOutputArrayR_const_int_const_ScalarR_const_ScalarR_const_vectorLcharGR_DrawMatchesFlags(img1: *const c_void, keypoints1: *const c_void, img2: *const c_void, keypoints2: *const c_void, matches1to2: *const c_void, out_img: *const c_void, matches_thickness: i32, match_color: *const core::Scalar, single_point_color: *const core::Scalar, matches_mask: *const c_void, flags: crate::features2d::DrawMatchesFlags, ocvrs_return: *mut ResultVoid); - pub fn cv_drawMatches_const__InputArrayR_const_vectorLKeyPointGR_const__InputArrayR_const_vectorLKeyPointGR_const_vectorLvectorLDMatchGGR_const__InputOutputArrayR(img1: *const c_void, keypoints1: *const c_void, img2: *const c_void, keypoints2: *const c_void, matches1to2: *const c_void, out_img: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_drawMatches_const__InputArrayR_const_vectorLKeyPointGR_const__InputArrayR_const_vectorLKeyPointGR_const_vectorLvectorLDMatchGGR_const__InputOutputArrayR_const_ScalarR_const_ScalarR_const_vectorLvectorLcharGGR_DrawMatchesFlags(img1: *const c_void, keypoints1: *const c_void, img2: *const c_void, keypoints2: *const c_void, matches1to2: *const c_void, out_img: *const c_void, match_color: *const core::Scalar, single_point_color: *const core::Scalar, matches_mask: *const c_void, flags: crate::features2d::DrawMatchesFlags, ocvrs_return: *mut ResultVoid); - pub fn cv_evaluateFeatureDetector_const_MatR_const_MatR_const_MatR_vectorLKeyPointGX_vectorLKeyPointGX_floatR_intR(img1: *const c_void, img2: *const c_void, h1to2: *const c_void, keypoints1: *mut c_void, keypoints2: *mut c_void, repeatability: *mut f32, corresp_count: *mut i32, ocvrs_return: *mut ResultVoid); - pub fn cv_evaluateFeatureDetector_const_MatR_const_MatR_const_MatR_vectorLKeyPointGX_vectorLKeyPointGX_floatR_intR_const_PtrLFeature2DGR(img1: *const c_void, img2: *const c_void, h1to2: *const c_void, keypoints1: *mut c_void, keypoints2: *mut c_void, repeatability: *mut f32, corresp_count: *mut i32, fdetector: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_AGAST_const__InputArrayR_vectorLKeyPointGR_int(image: *const c_void, keypoints: *mut c_void, threshold: i32, ocvrs_return: *mut Result<()>); + pub fn cv_AGAST_const__InputArrayR_vectorLKeyPointGR_int_bool(image: *const c_void, keypoints: *mut c_void, threshold: i32, nonmax_suppression: bool, ocvrs_return: *mut Result<()>); + pub fn cv_AGAST_const__InputArrayR_vectorLKeyPointGR_int_bool_DetectorType(image: *const c_void, keypoints: *mut c_void, threshold: i32, nonmax_suppression: bool, typ: crate::features2d::AgastFeatureDetector_DetectorType, ocvrs_return: *mut Result<()>); + pub fn cv_FAST_const__InputArrayR_vectorLKeyPointGR_int(image: *const c_void, keypoints: *mut c_void, threshold: i32, ocvrs_return: *mut Result<()>); + pub fn cv_FAST_const__InputArrayR_vectorLKeyPointGR_int_bool(image: *const c_void, keypoints: *mut c_void, threshold: i32, nonmax_suppression: bool, ocvrs_return: *mut Result<()>); + pub fn cv_FAST_const__InputArrayR_vectorLKeyPointGR_int_bool_DetectorType(image: *const c_void, keypoints: *mut c_void, threshold: i32, nonmax_suppression: bool, typ: crate::features2d::FastFeatureDetector_DetectorType, ocvrs_return: *mut Result<()>); + pub fn cv_computeRecallPrecisionCurve_const_vectorLvectorLDMatchGGR_const_vectorLvectorLunsigned_charGGR_vectorLPoint2fGR(matches1to2: *const c_void, correct_matches1to2_mask: *const c_void, recall_precision_curve: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_drawKeypoints_const__InputArrayR_const_vectorLKeyPointGR_const__InputOutputArrayR(image: *const c_void, keypoints: *const c_void, out_image: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_drawKeypoints_const__InputArrayR_const_vectorLKeyPointGR_const__InputOutputArrayR_const_ScalarR_DrawMatchesFlags(image: *const c_void, keypoints: *const c_void, out_image: *const c_void, color: *const core::Scalar, flags: crate::features2d::DrawMatchesFlags, ocvrs_return: *mut Result<()>); + pub fn cv_drawMatches_const__InputArrayR_const_vectorLKeyPointGR_const__InputArrayR_const_vectorLKeyPointGR_const_vectorLDMatchGR_const__InputOutputArrayR(img1: *const c_void, keypoints1: *const c_void, img2: *const c_void, keypoints2: *const c_void, matches1to2: *const c_void, out_img: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_drawMatches_const__InputArrayR_const_vectorLKeyPointGR_const__InputArrayR_const_vectorLKeyPointGR_const_vectorLDMatchGR_const__InputOutputArrayR_const_ScalarR_const_ScalarR_const_vectorLcharGR_DrawMatchesFlags(img1: *const c_void, keypoints1: *const c_void, img2: *const c_void, keypoints2: *const c_void, matches1to2: *const c_void, out_img: *const c_void, match_color: *const core::Scalar, single_point_color: *const core::Scalar, matches_mask: *const c_void, flags: crate::features2d::DrawMatchesFlags, ocvrs_return: *mut Result<()>); + pub fn cv_drawMatches_const__InputArrayR_const_vectorLKeyPointGR_const__InputArrayR_const_vectorLKeyPointGR_const_vectorLDMatchGR_const__InputOutputArrayR_const_int(img1: *const c_void, keypoints1: *const c_void, img2: *const c_void, keypoints2: *const c_void, matches1to2: *const c_void, out_img: *const c_void, matches_thickness: i32, ocvrs_return: *mut Result<()>); + pub fn cv_drawMatches_const__InputArrayR_const_vectorLKeyPointGR_const__InputArrayR_const_vectorLKeyPointGR_const_vectorLDMatchGR_const__InputOutputArrayR_const_int_const_ScalarR_const_ScalarR_const_vectorLcharGR_DrawMatchesFlags(img1: *const c_void, keypoints1: *const c_void, img2: *const c_void, keypoints2: *const c_void, matches1to2: *const c_void, out_img: *const c_void, matches_thickness: i32, match_color: *const core::Scalar, single_point_color: *const core::Scalar, matches_mask: *const c_void, flags: crate::features2d::DrawMatchesFlags, ocvrs_return: *mut Result<()>); + pub fn cv_drawMatches_const__InputArrayR_const_vectorLKeyPointGR_const__InputArrayR_const_vectorLKeyPointGR_const_vectorLvectorLDMatchGGR_const__InputOutputArrayR(img1: *const c_void, keypoints1: *const c_void, img2: *const c_void, keypoints2: *const c_void, matches1to2: *const c_void, out_img: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_drawMatches_const__InputArrayR_const_vectorLKeyPointGR_const__InputArrayR_const_vectorLKeyPointGR_const_vectorLvectorLDMatchGGR_const__InputOutputArrayR_const_ScalarR_const_ScalarR_const_vectorLvectorLcharGGR_DrawMatchesFlags(img1: *const c_void, keypoints1: *const c_void, img2: *const c_void, keypoints2: *const c_void, matches1to2: *const c_void, out_img: *const c_void, match_color: *const core::Scalar, single_point_color: *const core::Scalar, matches_mask: *const c_void, flags: crate::features2d::DrawMatchesFlags, ocvrs_return: *mut Result<()>); + pub fn cv_evaluateFeatureDetector_const_MatR_const_MatR_const_MatR_vectorLKeyPointGX_vectorLKeyPointGX_floatR_intR(img1: *const c_void, img2: *const c_void, h1to2: *const c_void, keypoints1: *mut c_void, keypoints2: *mut c_void, repeatability: *mut f32, corresp_count: *mut i32, ocvrs_return: *mut Result<()>); + pub fn cv_evaluateFeatureDetector_const_MatR_const_MatR_const_MatR_vectorLKeyPointGX_vectorLKeyPointGX_floatR_intR_const_PtrLFeature2DGR(img1: *const c_void, img2: *const c_void, h1to2: *const c_void, keypoints1: *mut c_void, keypoints2: *mut c_void, repeatability: *mut f32, corresp_count: *mut i32, fdetector: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_getNearestPoint_const_vectorLPoint2fGR_float(recall_precision_curve: *const c_void, l_precision: f32, ocvrs_return: *mut Result); pub fn cv_getRecall_const_vectorLPoint2fGR_float(recall_precision_curve: *const c_void, l_precision: f32, ocvrs_return: *mut Result); pub fn cv_AKAZE_create_DescriptorType_int_int_float_int_int_DiffusivityType_int(descriptor_type: crate::features2d::AKAZE_DescriptorType, descriptor_size: i32, descriptor_channels: i32, threshold: f32, n_octaves: i32, n_octave_layers: i32, diffusivity: crate::features2d::KAZE_DiffusivityType, max_points: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_AKAZE_create(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_AKAZE_setDescriptorType_DescriptorType(instance: *mut c_void, dtype: crate::features2d::AKAZE_DescriptorType, ocvrs_return: *mut ResultVoid); + pub fn cv_AKAZE_setDescriptorType_DescriptorType(instance: *mut c_void, dtype: crate::features2d::AKAZE_DescriptorType, ocvrs_return: *mut Result<()>); pub fn cv_AKAZE_getDescriptorType_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_AKAZE_setDescriptorSize_int(instance: *mut c_void, dsize: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_AKAZE_setDescriptorSize_int(instance: *mut c_void, dsize: i32, ocvrs_return: *mut Result<()>); pub fn cv_AKAZE_getDescriptorSize_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_AKAZE_setDescriptorChannels_int(instance: *mut c_void, dch: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_AKAZE_setDescriptorChannels_int(instance: *mut c_void, dch: i32, ocvrs_return: *mut Result<()>); pub fn cv_AKAZE_getDescriptorChannels_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_AKAZE_setThreshold_double(instance: *mut c_void, threshold: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_AKAZE_setThreshold_double(instance: *mut c_void, threshold: f64, ocvrs_return: *mut Result<()>); pub fn cv_AKAZE_getThreshold_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_AKAZE_setNOctaves_int(instance: *mut c_void, octaves: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_AKAZE_setNOctaves_int(instance: *mut c_void, octaves: i32, ocvrs_return: *mut Result<()>); pub fn cv_AKAZE_getNOctaves_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_AKAZE_setNOctaveLayers_int(instance: *mut c_void, octave_layers: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_AKAZE_setNOctaveLayers_int(instance: *mut c_void, octave_layers: i32, ocvrs_return: *mut Result<()>); pub fn cv_AKAZE_getNOctaveLayers_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_AKAZE_setDiffusivity_DiffusivityType(instance: *mut c_void, diff: crate::features2d::KAZE_DiffusivityType, ocvrs_return: *mut ResultVoid); + pub fn cv_AKAZE_setDiffusivity_DiffusivityType(instance: *mut c_void, diff: crate::features2d::KAZE_DiffusivityType, ocvrs_return: *mut Result<()>); pub fn cv_AKAZE_getDiffusivity_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_AKAZE_getDefaultName_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_AKAZE_setMaxPoints_int(instance: *mut c_void, max_points: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_AKAZE_setMaxPoints_int(instance: *mut c_void, max_points: i32, ocvrs_return: *mut Result<()>); pub fn cv_AKAZE_getMaxPoints_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_AKAZE_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_AKAZE_to_Feature2D(instance: *mut c_void) -> *mut c_void; pub fn cv_AKAZE_delete(instance: *mut c_void); pub fn cv_AffineFeature_create_const_PtrLFeature2DGR_int_int_float_float(backend: *const c_void, max_tilt: i32, min_tilt: i32, tilt_step: f32, rotate_step_base: f32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_AffineFeature_create_const_PtrLFeature2DGR(backend: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_AffineFeature_setViewParams_const_vectorLfloatGR_const_vectorLfloatGR(instance: *mut c_void, tilts: *const c_void, rolls: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_AffineFeature_getViewParams_const_vectorLfloatGR_vectorLfloatGR(instance: *const c_void, tilts: *mut c_void, rolls: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_AffineFeature_setViewParams_const_vectorLfloatGR_const_vectorLfloatGR(instance: *mut c_void, tilts: *const c_void, rolls: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_AffineFeature_getViewParams_const_vectorLfloatGR_vectorLfloatGR(instance: *const c_void, tilts: *mut c_void, rolls: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_AffineFeature_getDefaultName_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_AffineFeature_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_AffineFeature_to_Feature2D(instance: *mut c_void) -> *mut c_void; pub fn cv_AffineFeature_delete(instance: *mut c_void); pub fn cv_AgastFeatureDetector_create_int_bool_DetectorType(threshold: i32, nonmax_suppression: bool, typ: crate::features2d::AgastFeatureDetector_DetectorType, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_AgastFeatureDetector_create(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_AgastFeatureDetector_setThreshold_int(instance: *mut c_void, threshold: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_AgastFeatureDetector_setThreshold_int(instance: *mut c_void, threshold: i32, ocvrs_return: *mut Result<()>); pub fn cv_AgastFeatureDetector_getThreshold_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_AgastFeatureDetector_setNonmaxSuppression_bool(instance: *mut c_void, f: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_AgastFeatureDetector_setNonmaxSuppression_bool(instance: *mut c_void, f: bool, ocvrs_return: *mut Result<()>); pub fn cv_AgastFeatureDetector_getNonmaxSuppression_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_AgastFeatureDetector_setType_DetectorType(instance: *mut c_void, typ: crate::features2d::AgastFeatureDetector_DetectorType, ocvrs_return: *mut ResultVoid); + pub fn cv_AgastFeatureDetector_setType_DetectorType(instance: *mut c_void, typ: crate::features2d::AgastFeatureDetector_DetectorType, ocvrs_return: *mut Result<()>); pub fn cv_AgastFeatureDetector_getType_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_AgastFeatureDetector_getDefaultName_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_AgastFeatureDetector_to_Algorithm(instance: *mut c_void) -> *mut c_void; @@ -8251,13 +8320,13 @@ mod features2d_sys { pub fn cv_BFMatcher_delete(instance: *mut c_void); pub fn cv_BOWImgDescriptorExtractor_BOWImgDescriptorExtractor_const_PtrLFeature2DGR_const_PtrLDescriptorMatcherGR(dextractor: *const c_void, dmatcher: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_BOWImgDescriptorExtractor_BOWImgDescriptorExtractor_const_PtrLDescriptorMatcherGR(dmatcher: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_BOWImgDescriptorExtractor_setVocabulary_const_MatR(instance: *mut c_void, vocabulary: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_BOWImgDescriptorExtractor_setVocabulary_const_MatR(instance: *mut c_void, vocabulary: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_BOWImgDescriptorExtractor_getVocabulary_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_BOWImgDescriptorExtractor_compute_const__InputArrayR_vectorLKeyPointGR_const__OutputArrayR_vectorLvectorLintGGX_MatX(instance: *mut c_void, image: *const c_void, keypoints: *mut c_void, img_descriptor: *const c_void, point_idxs_of_clusters: *mut c_void, descriptors: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_BOWImgDescriptorExtractor_compute_const__InputArrayR_vectorLKeyPointGR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, keypoints: *mut c_void, img_descriptor: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_BOWImgDescriptorExtractor_compute_const__InputArrayR_const__OutputArrayR_vectorLvectorLintGGX(instance: *mut c_void, keypoint_descriptors: *const c_void, img_descriptor: *const c_void, point_idxs_of_clusters: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_BOWImgDescriptorExtractor_compute_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, keypoint_descriptors: *const c_void, img_descriptor: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_BOWImgDescriptorExtractor_compute2_const_MatR_vectorLKeyPointGR_MatR(instance: *mut c_void, image: *const c_void, keypoints: *mut c_void, img_descriptor: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_BOWImgDescriptorExtractor_compute_const__InputArrayR_vectorLKeyPointGR_const__OutputArrayR_vectorLvectorLintGGX_MatX(instance: *mut c_void, image: *const c_void, keypoints: *mut c_void, img_descriptor: *const c_void, point_idxs_of_clusters: *mut c_void, descriptors: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_BOWImgDescriptorExtractor_compute_const__InputArrayR_vectorLKeyPointGR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, keypoints: *mut c_void, img_descriptor: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_BOWImgDescriptorExtractor_compute_const__InputArrayR_const__OutputArrayR_vectorLvectorLintGGX(instance: *mut c_void, keypoint_descriptors: *const c_void, img_descriptor: *const c_void, point_idxs_of_clusters: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_BOWImgDescriptorExtractor_compute_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, keypoint_descriptors: *const c_void, img_descriptor: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_BOWImgDescriptorExtractor_compute2_const_MatR_vectorLKeyPointGR_MatR(instance: *mut c_void, image: *const c_void, keypoints: *mut c_void, img_descriptor: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_BOWImgDescriptorExtractor_descriptorSize_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_BOWImgDescriptorExtractor_descriptorType_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_BOWImgDescriptorExtractor_delete(instance: *mut c_void); @@ -8267,10 +8336,10 @@ mod features2d_sys { pub fn cv_BOWKMeansTrainer_cluster_const_const_MatR(instance: *const c_void, descriptors: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_BOWKMeansTrainer_to_BOWTrainer(instance: *mut c_void) -> *mut c_void; pub fn cv_BOWKMeansTrainer_delete(instance: *mut c_void); - pub fn cv_BOWTrainer_add_const_MatR(instance: *mut c_void, descriptors: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_BOWTrainer_add_const_MatR(instance: *mut c_void, descriptors: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_BOWTrainer_getDescriptors_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_BOWTrainer_descriptorsCount_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_BOWTrainer_clear(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_BOWTrainer_clear(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_BOWTrainer_cluster_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_BOWTrainer_cluster_const_const_MatR(instance: *const c_void, descriptors: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_BOWTrainer_to_BOWKMeansTrainer(instance: *mut c_void) -> *mut c_void; @@ -8282,78 +8351,78 @@ mod features2d_sys { pub fn cv_BRISK_create_int_int_const_vectorLfloatGR_const_vectorLintGR_float_float_const_vectorLintGR(thresh: i32, octaves: i32, radius_list: *const c_void, number_list: *const c_void, d_max: f32, d_min: f32, index_change: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_BRISK_create_int_int_const_vectorLfloatGR_const_vectorLintGR(thresh: i32, octaves: i32, radius_list: *const c_void, number_list: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_BRISK_getDefaultName_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_BRISK_setThreshold_int(instance: *mut c_void, threshold: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_BRISK_setThreshold_int(instance: *mut c_void, threshold: i32, ocvrs_return: *mut Result<()>); pub fn cv_BRISK_getThreshold_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_BRISK_setOctaves_int(instance: *mut c_void, octaves: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_BRISK_setOctaves_int(instance: *mut c_void, octaves: i32, ocvrs_return: *mut Result<()>); pub fn cv_BRISK_getOctaves_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_BRISK_setPatternScale_float(instance: *mut c_void, pattern_scale: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_BRISK_setPatternScale_float(instance: *mut c_void, pattern_scale: f32, ocvrs_return: *mut Result<()>); pub fn cv_BRISK_getPatternScale_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_BRISK_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_BRISK_to_Feature2D(instance: *mut c_void) -> *mut c_void; pub fn cv_BRISK_delete(instance: *mut c_void); - pub fn cv_DescriptorMatcher_add_const__InputArrayR(instance: *mut c_void, descriptors: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_DescriptorMatcher_add_const__InputArrayR(instance: *mut c_void, descriptors: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_DescriptorMatcher_getTrainDescriptors_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_DescriptorMatcher_clear(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_DescriptorMatcher_clear(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_DescriptorMatcher_empty_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_DescriptorMatcher_isMaskSupported_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_DescriptorMatcher_train(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_DescriptorMatcher_match_const_const__InputArrayR_const__InputArrayR_vectorLDMatchGR_const__InputArrayR(instance: *const c_void, query_descriptors: *const c_void, train_descriptors: *const c_void, matches: *mut c_void, mask: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_DescriptorMatcher_match_const_const__InputArrayR_const__InputArrayR_vectorLDMatchGR(instance: *const c_void, query_descriptors: *const c_void, train_descriptors: *const c_void, matches: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_DescriptorMatcher_knnMatch_const_const__InputArrayR_const__InputArrayR_vectorLvectorLDMatchGGR_int_const__InputArrayR_bool(instance: *const c_void, query_descriptors: *const c_void, train_descriptors: *const c_void, matches: *mut c_void, k: i32, mask: *const c_void, compact_result: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_DescriptorMatcher_knnMatch_const_const__InputArrayR_const__InputArrayR_vectorLvectorLDMatchGGR_int(instance: *const c_void, query_descriptors: *const c_void, train_descriptors: *const c_void, matches: *mut c_void, k: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_DescriptorMatcher_radiusMatch_const_const__InputArrayR_const__InputArrayR_vectorLvectorLDMatchGGR_float_const__InputArrayR_bool(instance: *const c_void, query_descriptors: *const c_void, train_descriptors: *const c_void, matches: *mut c_void, max_distance: f32, mask: *const c_void, compact_result: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_DescriptorMatcher_radiusMatch_const_const__InputArrayR_const__InputArrayR_vectorLvectorLDMatchGGR_float(instance: *const c_void, query_descriptors: *const c_void, train_descriptors: *const c_void, matches: *mut c_void, max_distance: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_DescriptorMatcher_match_const__InputArrayR_vectorLDMatchGR_const__InputArrayR(instance: *mut c_void, query_descriptors: *const c_void, matches: *mut c_void, masks: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_DescriptorMatcher_match_const__InputArrayR_vectorLDMatchGR(instance: *mut c_void, query_descriptors: *const c_void, matches: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_DescriptorMatcher_knnMatch_const__InputArrayR_vectorLvectorLDMatchGGR_int_const__InputArrayR_bool(instance: *mut c_void, query_descriptors: *const c_void, matches: *mut c_void, k: i32, masks: *const c_void, compact_result: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_DescriptorMatcher_knnMatch_const__InputArrayR_vectorLvectorLDMatchGGR_int(instance: *mut c_void, query_descriptors: *const c_void, matches: *mut c_void, k: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_DescriptorMatcher_radiusMatch_const__InputArrayR_vectorLvectorLDMatchGGR_float_const__InputArrayR_bool(instance: *mut c_void, query_descriptors: *const c_void, matches: *mut c_void, max_distance: f32, masks: *const c_void, compact_result: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_DescriptorMatcher_radiusMatch_const__InputArrayR_vectorLvectorLDMatchGGR_float(instance: *mut c_void, query_descriptors: *const c_void, matches: *mut c_void, max_distance: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_DescriptorMatcher_write_const_const_StringR(instance: *const c_void, file_name: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_DescriptorMatcher_read_const_StringR(instance: *mut c_void, file_name: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_DescriptorMatcher_read_const_FileNodeR(instance: *mut c_void, unnamed: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_DescriptorMatcher_write_const_FileStorageR(instance: *const c_void, unnamed: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_DescriptorMatcher_train(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_DescriptorMatcher_match_const_const__InputArrayR_const__InputArrayR_vectorLDMatchGR_const__InputArrayR(instance: *const c_void, query_descriptors: *const c_void, train_descriptors: *const c_void, matches: *mut c_void, mask: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_DescriptorMatcher_match_const_const__InputArrayR_const__InputArrayR_vectorLDMatchGR(instance: *const c_void, query_descriptors: *const c_void, train_descriptors: *const c_void, matches: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_DescriptorMatcher_knnMatch_const_const__InputArrayR_const__InputArrayR_vectorLvectorLDMatchGGR_int_const__InputArrayR_bool(instance: *const c_void, query_descriptors: *const c_void, train_descriptors: *const c_void, matches: *mut c_void, k: i32, mask: *const c_void, compact_result: bool, ocvrs_return: *mut Result<()>); + pub fn cv_DescriptorMatcher_knnMatch_const_const__InputArrayR_const__InputArrayR_vectorLvectorLDMatchGGR_int(instance: *const c_void, query_descriptors: *const c_void, train_descriptors: *const c_void, matches: *mut c_void, k: i32, ocvrs_return: *mut Result<()>); + pub fn cv_DescriptorMatcher_radiusMatch_const_const__InputArrayR_const__InputArrayR_vectorLvectorLDMatchGGR_float_const__InputArrayR_bool(instance: *const c_void, query_descriptors: *const c_void, train_descriptors: *const c_void, matches: *mut c_void, max_distance: f32, mask: *const c_void, compact_result: bool, ocvrs_return: *mut Result<()>); + pub fn cv_DescriptorMatcher_radiusMatch_const_const__InputArrayR_const__InputArrayR_vectorLvectorLDMatchGGR_float(instance: *const c_void, query_descriptors: *const c_void, train_descriptors: *const c_void, matches: *mut c_void, max_distance: f32, ocvrs_return: *mut Result<()>); + pub fn cv_DescriptorMatcher_match_const__InputArrayR_vectorLDMatchGR_const__InputArrayR(instance: *mut c_void, query_descriptors: *const c_void, matches: *mut c_void, masks: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_DescriptorMatcher_match_const__InputArrayR_vectorLDMatchGR(instance: *mut c_void, query_descriptors: *const c_void, matches: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_DescriptorMatcher_knnMatch_const__InputArrayR_vectorLvectorLDMatchGGR_int_const__InputArrayR_bool(instance: *mut c_void, query_descriptors: *const c_void, matches: *mut c_void, k: i32, masks: *const c_void, compact_result: bool, ocvrs_return: *mut Result<()>); + pub fn cv_DescriptorMatcher_knnMatch_const__InputArrayR_vectorLvectorLDMatchGGR_int(instance: *mut c_void, query_descriptors: *const c_void, matches: *mut c_void, k: i32, ocvrs_return: *mut Result<()>); + pub fn cv_DescriptorMatcher_radiusMatch_const__InputArrayR_vectorLvectorLDMatchGGR_float_const__InputArrayR_bool(instance: *mut c_void, query_descriptors: *const c_void, matches: *mut c_void, max_distance: f32, masks: *const c_void, compact_result: bool, ocvrs_return: *mut Result<()>); + pub fn cv_DescriptorMatcher_radiusMatch_const__InputArrayR_vectorLvectorLDMatchGGR_float(instance: *mut c_void, query_descriptors: *const c_void, matches: *mut c_void, max_distance: f32, ocvrs_return: *mut Result<()>); + pub fn cv_DescriptorMatcher_write_const_const_StringR(instance: *const c_void, file_name: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_DescriptorMatcher_read_const_StringR(instance: *mut c_void, file_name: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_DescriptorMatcher_read_const_FileNodeR(instance: *mut c_void, unnamed: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_DescriptorMatcher_write_const_FileStorageR(instance: *const c_void, unnamed: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_DescriptorMatcher_clone_const_bool(instance: *const c_void, empty_train_data: bool, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_DescriptorMatcher_clone_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_DescriptorMatcher_create_const_StringR(descriptor_matcher_type: *const c_char, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_DescriptorMatcher_create_const_MatcherTypeR(matcher_type: crate::features2d::DescriptorMatcher_MatcherType, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_DescriptorMatcher_write_const_FileStorageR_const_StringR(instance: *const c_void, fs: *mut c_void, name: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_DescriptorMatcher_write_const_const_PtrLFileStorageGR_const_StringR(instance: *const c_void, fs: *const c_void, name: *const c_char, ocvrs_return: *mut ResultVoid); + pub fn cv_DescriptorMatcher_write_const_FileStorageR_const_StringR(instance: *const c_void, fs: *mut c_void, name: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_DescriptorMatcher_write_const_const_PtrLFileStorageGR_const_StringR(instance: *const c_void, fs: *const c_void, name: *const c_char, ocvrs_return: *mut Result<()>); pub fn cv_DescriptorMatcher_to_BFMatcher(instance: *mut c_void) -> *mut c_void; pub fn cv_DescriptorMatcher_to_FlannBasedMatcher(instance: *mut c_void) -> *mut c_void; pub fn cv_DescriptorMatcher_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_DescriptorMatcher_delete(instance: *mut c_void); pub fn cv_FastFeatureDetector_create_int_bool_DetectorType(threshold: i32, nonmax_suppression: bool, typ: crate::features2d::FastFeatureDetector_DetectorType, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_FastFeatureDetector_create(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_FastFeatureDetector_setThreshold_int(instance: *mut c_void, threshold: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_FastFeatureDetector_setThreshold_int(instance: *mut c_void, threshold: i32, ocvrs_return: *mut Result<()>); pub fn cv_FastFeatureDetector_getThreshold_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_FastFeatureDetector_setNonmaxSuppression_bool(instance: *mut c_void, f: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_FastFeatureDetector_setNonmaxSuppression_bool(instance: *mut c_void, f: bool, ocvrs_return: *mut Result<()>); pub fn cv_FastFeatureDetector_getNonmaxSuppression_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_FastFeatureDetector_setType_DetectorType(instance: *mut c_void, typ: crate::features2d::FastFeatureDetector_DetectorType, ocvrs_return: *mut ResultVoid); + pub fn cv_FastFeatureDetector_setType_DetectorType(instance: *mut c_void, typ: crate::features2d::FastFeatureDetector_DetectorType, ocvrs_return: *mut Result<()>); pub fn cv_FastFeatureDetector_getType_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_FastFeatureDetector_getDefaultName_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_FastFeatureDetector_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_FastFeatureDetector_to_Feature2D(instance: *mut c_void) -> *mut c_void; pub fn cv_FastFeatureDetector_delete(instance: *mut c_void); - pub fn cv_Feature2D_detect_const__InputArrayR_vectorLKeyPointGR_const__InputArrayR(instance: *mut c_void, image: *const c_void, keypoints: *mut c_void, mask: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_Feature2D_detect_const__InputArrayR_vectorLKeyPointGR(instance: *mut c_void, image: *const c_void, keypoints: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_Feature2D_detect_const__InputArrayR_vectorLvectorLKeyPointGGR_const__InputArrayR(instance: *mut c_void, images: *const c_void, keypoints: *mut c_void, masks: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_Feature2D_detect_const__InputArrayR_vectorLvectorLKeyPointGGR(instance: *mut c_void, images: *const c_void, keypoints: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_Feature2D_compute_const__InputArrayR_vectorLKeyPointGR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, keypoints: *mut c_void, descriptors: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_Feature2D_compute_const__InputArrayR_vectorLvectorLKeyPointGGR_const__OutputArrayR(instance: *mut c_void, images: *const c_void, keypoints: *mut c_void, descriptors: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_Feature2D_detectAndCompute_const__InputArrayR_const__InputArrayR_vectorLKeyPointGR_const__OutputArrayR_bool(instance: *mut c_void, image: *const c_void, mask: *const c_void, keypoints: *mut c_void, descriptors: *const c_void, use_provided_keypoints: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_Feature2D_detectAndCompute_const__InputArrayR_const__InputArrayR_vectorLKeyPointGR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, mask: *const c_void, keypoints: *mut c_void, descriptors: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_Feature2D_detect_const__InputArrayR_vectorLKeyPointGR_const__InputArrayR(instance: *mut c_void, image: *const c_void, keypoints: *mut c_void, mask: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_Feature2D_detect_const__InputArrayR_vectorLKeyPointGR(instance: *mut c_void, image: *const c_void, keypoints: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_Feature2D_detect_const__InputArrayR_vectorLvectorLKeyPointGGR_const__InputArrayR(instance: *mut c_void, images: *const c_void, keypoints: *mut c_void, masks: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_Feature2D_detect_const__InputArrayR_vectorLvectorLKeyPointGGR(instance: *mut c_void, images: *const c_void, keypoints: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_Feature2D_compute_const__InputArrayR_vectorLKeyPointGR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, keypoints: *mut c_void, descriptors: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_Feature2D_compute_const__InputArrayR_vectorLvectorLKeyPointGGR_const__OutputArrayR(instance: *mut c_void, images: *const c_void, keypoints: *mut c_void, descriptors: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_Feature2D_detectAndCompute_const__InputArrayR_const__InputArrayR_vectorLKeyPointGR_const__OutputArrayR_bool(instance: *mut c_void, image: *const c_void, mask: *const c_void, keypoints: *mut c_void, descriptors: *const c_void, use_provided_keypoints: bool, ocvrs_return: *mut Result<()>); + pub fn cv_Feature2D_detectAndCompute_const__InputArrayR_const__InputArrayR_vectorLKeyPointGR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, mask: *const c_void, keypoints: *mut c_void, descriptors: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_Feature2D_descriptorSize_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_Feature2D_descriptorType_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_Feature2D_defaultNorm_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_Feature2D_write_const_const_StringR(instance: *const c_void, file_name: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_Feature2D_read_const_StringR(instance: *mut c_void, file_name: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_Feature2D_write_const_FileStorageR(instance: *const c_void, unnamed: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_Feature2D_read_const_FileNodeR(instance: *mut c_void, unnamed: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_Feature2D_write_const_const_StringR(instance: *const c_void, file_name: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_Feature2D_read_const_StringR(instance: *mut c_void, file_name: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_Feature2D_write_const_FileStorageR(instance: *const c_void, unnamed: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_Feature2D_read_const_FileNodeR(instance: *mut c_void, unnamed: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_Feature2D_empty_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_Feature2D_getDefaultName_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_Feature2D_write_const_FileStorageR_const_StringR(instance: *const c_void, fs: *mut c_void, name: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_Feature2D_write_const_const_PtrLFileStorageGR_const_StringR(instance: *const c_void, fs: *const c_void, name: *const c_char, ocvrs_return: *mut ResultVoid); + pub fn cv_Feature2D_write_const_FileStorageR_const_StringR(instance: *const c_void, fs: *mut c_void, name: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_Feature2D_write_const_const_PtrLFileStorageGR_const_StringR(instance: *const c_void, fs: *const c_void, name: *const c_char, ocvrs_return: *mut Result<()>); pub fn cv_Feature2D_defaultNew_const() -> *mut c_void; pub fn cv_Feature2D_to_AKAZE(instance: *mut c_void) -> *mut c_void; pub fn cv_Feature2D_to_AffineFeature(instance: *mut c_void) -> *mut c_void; @@ -8370,11 +8439,11 @@ mod features2d_sys { pub fn cv_Feature2D_delete(instance: *mut c_void); pub fn cv_FlannBasedMatcher_FlannBasedMatcher_const_PtrLIndexParamsGR_const_PtrLSearchParamsGR(index_params: *const c_void, search_params: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_FlannBasedMatcher_FlannBasedMatcher(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_FlannBasedMatcher_add_const__InputArrayR(instance: *mut c_void, descriptors: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_FlannBasedMatcher_clear(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_FlannBasedMatcher_read_const_FileNodeR(instance: *mut c_void, unnamed: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_FlannBasedMatcher_write_const_FileStorageR(instance: *const c_void, unnamed: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_FlannBasedMatcher_train(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_FlannBasedMatcher_add_const__InputArrayR(instance: *mut c_void, descriptors: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_FlannBasedMatcher_clear(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_FlannBasedMatcher_read_const_FileNodeR(instance: *mut c_void, unnamed: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_FlannBasedMatcher_write_const_FileStorageR(instance: *const c_void, unnamed: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_FlannBasedMatcher_train(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_FlannBasedMatcher_isMaskSupported_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_FlannBasedMatcher_create(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_FlannBasedMatcher_clone_const_bool(instance: *const c_void, empty_train_data: bool, ocvrs_return: *mut Result<*mut c_void>); @@ -8386,19 +8455,19 @@ mod features2d_sys { pub fn cv_GFTTDetector_create(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_GFTTDetector_create_int_double_double_int_int_bool_double(max_corners: i32, quality_level: f64, min_distance: f64, block_size: i32, gradiant_size: i32, use_harris_detector: bool, k: f64, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_GFTTDetector_create_int_double_double_int_int(max_corners: i32, quality_level: f64, min_distance: f64, block_size: i32, gradiant_size: i32, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_GFTTDetector_setMaxFeatures_int(instance: *mut c_void, max_features: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_GFTTDetector_setMaxFeatures_int(instance: *mut c_void, max_features: i32, ocvrs_return: *mut Result<()>); pub fn cv_GFTTDetector_getMaxFeatures_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_GFTTDetector_setQualityLevel_double(instance: *mut c_void, qlevel: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_GFTTDetector_setQualityLevel_double(instance: *mut c_void, qlevel: f64, ocvrs_return: *mut Result<()>); pub fn cv_GFTTDetector_getQualityLevel_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_GFTTDetector_setMinDistance_double(instance: *mut c_void, min_distance: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_GFTTDetector_setMinDistance_double(instance: *mut c_void, min_distance: f64, ocvrs_return: *mut Result<()>); pub fn cv_GFTTDetector_getMinDistance_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_GFTTDetector_setBlockSize_int(instance: *mut c_void, block_size: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_GFTTDetector_setBlockSize_int(instance: *mut c_void, block_size: i32, ocvrs_return: *mut Result<()>); pub fn cv_GFTTDetector_getBlockSize_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_GFTTDetector_setGradientSize_int(instance: *mut c_void, gradient_size_: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_GFTTDetector_setGradientSize_int(instance: *mut c_void, gradient_size_: i32, ocvrs_return: *mut Result<()>); pub fn cv_GFTTDetector_getGradientSize(instance: *mut c_void, ocvrs_return: *mut Result); - pub fn cv_GFTTDetector_setHarrisDetector_bool(instance: *mut c_void, val: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_GFTTDetector_setHarrisDetector_bool(instance: *mut c_void, val: bool, ocvrs_return: *mut Result<()>); pub fn cv_GFTTDetector_getHarrisDetector_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_GFTTDetector_setK_double(instance: *mut c_void, k: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_GFTTDetector_setK_double(instance: *mut c_void, k: f64, ocvrs_return: *mut Result<()>); pub fn cv_GFTTDetector_getK_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_GFTTDetector_getDefaultName_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_GFTTDetector_to_Algorithm(instance: *mut c_void) -> *mut c_void; @@ -8406,54 +8475,54 @@ mod features2d_sys { pub fn cv_GFTTDetector_delete(instance: *mut c_void); pub fn cv_KAZE_create_bool_bool_float_int_int_DiffusivityType(extended: bool, upright: bool, threshold: f32, n_octaves: i32, n_octave_layers: i32, diffusivity: crate::features2d::KAZE_DiffusivityType, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_KAZE_create(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_KAZE_setExtended_bool(instance: *mut c_void, extended: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_KAZE_setExtended_bool(instance: *mut c_void, extended: bool, ocvrs_return: *mut Result<()>); pub fn cv_KAZE_getExtended_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_KAZE_setUpright_bool(instance: *mut c_void, upright: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_KAZE_setUpright_bool(instance: *mut c_void, upright: bool, ocvrs_return: *mut Result<()>); pub fn cv_KAZE_getUpright_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_KAZE_setThreshold_double(instance: *mut c_void, threshold: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_KAZE_setThreshold_double(instance: *mut c_void, threshold: f64, ocvrs_return: *mut Result<()>); pub fn cv_KAZE_getThreshold_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_KAZE_setNOctaves_int(instance: *mut c_void, octaves: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_KAZE_setNOctaves_int(instance: *mut c_void, octaves: i32, ocvrs_return: *mut Result<()>); pub fn cv_KAZE_getNOctaves_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_KAZE_setNOctaveLayers_int(instance: *mut c_void, octave_layers: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_KAZE_setNOctaveLayers_int(instance: *mut c_void, octave_layers: i32, ocvrs_return: *mut Result<()>); pub fn cv_KAZE_getNOctaveLayers_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_KAZE_setDiffusivity_DiffusivityType(instance: *mut c_void, diff: crate::features2d::KAZE_DiffusivityType, ocvrs_return: *mut ResultVoid); + pub fn cv_KAZE_setDiffusivity_DiffusivityType(instance: *mut c_void, diff: crate::features2d::KAZE_DiffusivityType, ocvrs_return: *mut Result<()>); pub fn cv_KAZE_getDiffusivity_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_KAZE_getDefaultName_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_KAZE_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_KAZE_to_Feature2D(instance: *mut c_void) -> *mut c_void; pub fn cv_KAZE_delete(instance: *mut c_void); pub fn cv_KeyPointsFilter_KeyPointsFilter(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_KeyPointsFilter_runByImageBorder_vectorLKeyPointGR_Size_int(keypoints: *mut c_void, image_size: *const core::Size, border_size: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_KeyPointsFilter_runByKeypointSize_vectorLKeyPointGR_float_float(keypoints: *mut c_void, min_size: f32, max_size: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_KeyPointsFilter_runByKeypointSize_vectorLKeyPointGR_float(keypoints: *mut c_void, min_size: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_KeyPointsFilter_runByPixelsMask_vectorLKeyPointGR_const_MatR(keypoints: *mut c_void, mask: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_KeyPointsFilter_runByPixelsMask2VectorPoint_vectorLKeyPointGR_vectorLvectorLPointGGR_const_MatR(keypoints: *mut c_void, remove_from: *mut c_void, mask: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_KeyPointsFilter_removeDuplicated_vectorLKeyPointGR(keypoints: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_KeyPointsFilter_removeDuplicatedSorted_vectorLKeyPointGR(keypoints: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_KeyPointsFilter_retainBest_vectorLKeyPointGR_int(keypoints: *mut c_void, npoints: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_KeyPointsFilter_runByImageBorder_vectorLKeyPointGR_Size_int(keypoints: *mut c_void, image_size: *const core::Size, border_size: i32, ocvrs_return: *mut Result<()>); + pub fn cv_KeyPointsFilter_runByKeypointSize_vectorLKeyPointGR_float_float(keypoints: *mut c_void, min_size: f32, max_size: f32, ocvrs_return: *mut Result<()>); + pub fn cv_KeyPointsFilter_runByKeypointSize_vectorLKeyPointGR_float(keypoints: *mut c_void, min_size: f32, ocvrs_return: *mut Result<()>); + pub fn cv_KeyPointsFilter_runByPixelsMask_vectorLKeyPointGR_const_MatR(keypoints: *mut c_void, mask: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_KeyPointsFilter_runByPixelsMask2VectorPoint_vectorLKeyPointGR_vectorLvectorLPointGGR_const_MatR(keypoints: *mut c_void, remove_from: *mut c_void, mask: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_KeyPointsFilter_removeDuplicated_vectorLKeyPointGR(keypoints: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_KeyPointsFilter_removeDuplicatedSorted_vectorLKeyPointGR(keypoints: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_KeyPointsFilter_retainBest_vectorLKeyPointGR_int(keypoints: *mut c_void, npoints: i32, ocvrs_return: *mut Result<()>); pub fn cv_KeyPointsFilter_delete(instance: *mut c_void); pub fn cv_MSER_create_int_int_int_double_double_int_double_double_int(delta: i32, min_area: i32, max_area: i32, max_variation: f64, min_diversity: f64, max_evolution: i32, area_threshold: f64, min_margin: f64, edge_blur_size: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_MSER_create(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_MSER_detectRegions_const__InputArrayR_vectorLvectorLPointGGR_vectorLRectGR(instance: *mut c_void, image: *const c_void, msers: *mut c_void, bboxes: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_MSER_setDelta_int(instance: *mut c_void, delta: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_MSER_detectRegions_const__InputArrayR_vectorLvectorLPointGGR_vectorLRectGR(instance: *mut c_void, image: *const c_void, msers: *mut c_void, bboxes: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_MSER_setDelta_int(instance: *mut c_void, delta: i32, ocvrs_return: *mut Result<()>); pub fn cv_MSER_getDelta_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_MSER_setMinArea_int(instance: *mut c_void, min_area: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_MSER_setMinArea_int(instance: *mut c_void, min_area: i32, ocvrs_return: *mut Result<()>); pub fn cv_MSER_getMinArea_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_MSER_setMaxArea_int(instance: *mut c_void, max_area: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_MSER_setMaxArea_int(instance: *mut c_void, max_area: i32, ocvrs_return: *mut Result<()>); pub fn cv_MSER_getMaxArea_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_MSER_setMaxVariation_double(instance: *mut c_void, max_variation: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_MSER_setMaxVariation_double(instance: *mut c_void, max_variation: f64, ocvrs_return: *mut Result<()>); pub fn cv_MSER_getMaxVariation_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_MSER_setMinDiversity_double(instance: *mut c_void, min_diversity: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_MSER_setMinDiversity_double(instance: *mut c_void, min_diversity: f64, ocvrs_return: *mut Result<()>); pub fn cv_MSER_getMinDiversity_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_MSER_setMaxEvolution_int(instance: *mut c_void, max_evolution: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_MSER_setMaxEvolution_int(instance: *mut c_void, max_evolution: i32, ocvrs_return: *mut Result<()>); pub fn cv_MSER_getMaxEvolution_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_MSER_setAreaThreshold_double(instance: *mut c_void, area_threshold: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_MSER_setAreaThreshold_double(instance: *mut c_void, area_threshold: f64, ocvrs_return: *mut Result<()>); pub fn cv_MSER_getAreaThreshold_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_MSER_setMinMargin_double(instance: *mut c_void, min_margin: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_MSER_setMinMargin_double(instance: *mut c_void, min_margin: f64, ocvrs_return: *mut Result<()>); pub fn cv_MSER_getMinMargin_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_MSER_setEdgeBlurSize_int(instance: *mut c_void, edge_blur_size: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_MSER_setEdgeBlurSize_int(instance: *mut c_void, edge_blur_size: i32, ocvrs_return: *mut Result<()>); pub fn cv_MSER_getEdgeBlurSize_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_MSER_setPass2Only_bool(instance: *mut c_void, f: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_MSER_setPass2Only_bool(instance: *mut c_void, f: bool, ocvrs_return: *mut Result<()>); pub fn cv_MSER_getPass2Only_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_MSER_getDefaultName_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_MSER_to_Algorithm(instance: *mut c_void) -> *mut c_void; @@ -8461,23 +8530,23 @@ mod features2d_sys { pub fn cv_MSER_delete(instance: *mut c_void); pub fn cv_ORB_create_int_float_int_int_int_int_ScoreType_int_int(nfeatures: i32, scale_factor: f32, nlevels: i32, edge_threshold: i32, first_level: i32, wta_k: i32, score_type: crate::features2d::ORB_ScoreType, patch_size: i32, fast_threshold: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ORB_create(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_ORB_setMaxFeatures_int(instance: *mut c_void, max_features: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_ORB_setMaxFeatures_int(instance: *mut c_void, max_features: i32, ocvrs_return: *mut Result<()>); pub fn cv_ORB_getMaxFeatures_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ORB_setScaleFactor_double(instance: *mut c_void, scale_factor: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_ORB_setScaleFactor_double(instance: *mut c_void, scale_factor: f64, ocvrs_return: *mut Result<()>); pub fn cv_ORB_getScaleFactor_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ORB_setNLevels_int(instance: *mut c_void, nlevels: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_ORB_setNLevels_int(instance: *mut c_void, nlevels: i32, ocvrs_return: *mut Result<()>); pub fn cv_ORB_getNLevels_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ORB_setEdgeThreshold_int(instance: *mut c_void, edge_threshold: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_ORB_setEdgeThreshold_int(instance: *mut c_void, edge_threshold: i32, ocvrs_return: *mut Result<()>); pub fn cv_ORB_getEdgeThreshold_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ORB_setFirstLevel_int(instance: *mut c_void, first_level: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_ORB_setFirstLevel_int(instance: *mut c_void, first_level: i32, ocvrs_return: *mut Result<()>); pub fn cv_ORB_getFirstLevel_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ORB_setWTA_K_int(instance: *mut c_void, wta_k: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_ORB_setWTA_K_int(instance: *mut c_void, wta_k: i32, ocvrs_return: *mut Result<()>); pub fn cv_ORB_getWTA_K_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ORB_setScoreType_ScoreType(instance: *mut c_void, score_type: crate::features2d::ORB_ScoreType, ocvrs_return: *mut ResultVoid); + pub fn cv_ORB_setScoreType_ScoreType(instance: *mut c_void, score_type: crate::features2d::ORB_ScoreType, ocvrs_return: *mut Result<()>); pub fn cv_ORB_getScoreType_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ORB_setPatchSize_int(instance: *mut c_void, patch_size: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_ORB_setPatchSize_int(instance: *mut c_void, patch_size: i32, ocvrs_return: *mut Result<()>); pub fn cv_ORB_getPatchSize_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ORB_setFastThreshold_int(instance: *mut c_void, fast_threshold: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_ORB_setFastThreshold_int(instance: *mut c_void, fast_threshold: i32, ocvrs_return: *mut Result<()>); pub fn cv_ORB_getFastThreshold_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_ORB_getDefaultName_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ORB_to_Algorithm(instance: *mut c_void) -> *mut c_void; @@ -8488,22 +8557,22 @@ mod features2d_sys { pub fn cv_SIFT_create_int_int_double_double_double_int_bool(nfeatures: i32, n_octave_layers: i32, contrast_threshold: f64, edge_threshold: f64, sigma: f64, descriptor_type: i32, enable_precise_upscale: bool, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_SIFT_create_int_int_double_double_double_int(nfeatures: i32, n_octave_layers: i32, contrast_threshold: f64, edge_threshold: f64, sigma: f64, descriptor_type: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_SIFT_getDefaultName_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_SIFT_setNFeatures_int(instance: *mut c_void, max_features: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_SIFT_setNFeatures_int(instance: *mut c_void, max_features: i32, ocvrs_return: *mut Result<()>); pub fn cv_SIFT_getNFeatures_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_SIFT_setNOctaveLayers_int(instance: *mut c_void, n_octave_layers: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_SIFT_setNOctaveLayers_int(instance: *mut c_void, n_octave_layers: i32, ocvrs_return: *mut Result<()>); pub fn cv_SIFT_getNOctaveLayers_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_SIFT_setContrastThreshold_double(instance: *mut c_void, contrast_threshold: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_SIFT_setContrastThreshold_double(instance: *mut c_void, contrast_threshold: f64, ocvrs_return: *mut Result<()>); pub fn cv_SIFT_getContrastThreshold_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_SIFT_setEdgeThreshold_double(instance: *mut c_void, edge_threshold: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_SIFT_setEdgeThreshold_double(instance: *mut c_void, edge_threshold: f64, ocvrs_return: *mut Result<()>); pub fn cv_SIFT_getEdgeThreshold_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_SIFT_setSigma_double(instance: *mut c_void, sigma: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_SIFT_setSigma_double(instance: *mut c_void, sigma: f64, ocvrs_return: *mut Result<()>); pub fn cv_SIFT_getSigma_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_SIFT_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_SIFT_to_Feature2D(instance: *mut c_void) -> *mut c_void; pub fn cv_SIFT_delete(instance: *mut c_void); pub fn cv_SimpleBlobDetector_create_const_ParamsR(parameters: *const crate::features2d::SimpleBlobDetector_Params, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_SimpleBlobDetector_create(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_SimpleBlobDetector_setParams_const_ParamsR(instance: *mut c_void, params: *const crate::features2d::SimpleBlobDetector_Params, ocvrs_return: *mut ResultVoid); + pub fn cv_SimpleBlobDetector_setParams_const_ParamsR(instance: *mut c_void, params: *const crate::features2d::SimpleBlobDetector_Params, ocvrs_return: *mut Result<()>); pub fn cv_SimpleBlobDetector_getParams_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_SimpleBlobDetector_getDefaultName_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_SimpleBlobDetector_getBlobContours_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); @@ -8511,8 +8580,8 @@ mod features2d_sys { pub fn cv_SimpleBlobDetector_to_Feature2D(instance: *mut c_void) -> *mut c_void; pub fn cv_SimpleBlobDetector_delete(instance: *mut c_void); pub fn cv_SimpleBlobDetector_Params_Params(ocvrs_return: *mut Result); - pub fn cv_SimpleBlobDetector_Params_read_const_FileNodeR(instance: *const crate::features2d::SimpleBlobDetector_Params, fn_: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_SimpleBlobDetector_Params_write_const_FileStorageR(instance: *const crate::features2d::SimpleBlobDetector_Params, fs: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_SimpleBlobDetector_Params_read_const_FileNodeR(instance: *const crate::features2d::SimpleBlobDetector_Params, fn_: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_SimpleBlobDetector_Params_write_const_FileStorageR(instance: *const crate::features2d::SimpleBlobDetector_Params, fs: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_PtrLcv_AKAZEG_getInnerPtr_const(instance: *const c_void) -> *mut c_void; pub fn cv_PtrLcv_AKAZEG_getInnerPtrMut(instance: *mut c_void) -> *mut c_void; pub fn cv_PtrLcv_AKAZEG_new_null_const() -> *mut c_void; @@ -8606,16 +8675,14 @@ mod features2d_sys { pub fn cv_PtrLcv_SimpleBlobDetectorG_to_PtrOfFeature2D(instance: *mut c_void) -> *mut c_void; } } -#[cfg(ocvrs_has_module_features2d)] pub use features2d_sys::*; -#[cfg(ocvrs_has_module_flann)] mod flann_sys { use super::*; extern "C" { pub fn cvflann_flann_distance_type(ocvrs_return: *mut Result); - pub fn cvflann_set_distance_type_flann_distance_t_int(distance_type: crate::flann::flann_distance_t, order: i32, ocvrs_return: *mut ResultVoid); + pub fn cvflann_set_distance_type_flann_distance_t_int(distance_type: crate::flann::flann_distance_t, order: i32, ocvrs_return: *mut Result<()>); pub fn cv_flann_AutotunedIndexParams_AutotunedIndexParams_float_float_float_float(target_precision: f32, build_weight: f32, memory_weight: f32, sample_fraction: f32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_flann_AutotunedIndexParams_AutotunedIndexParams(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_flann_AutotunedIndexParams_to_IndexParams(instance: *mut c_void) -> *mut c_void; @@ -8631,15 +8698,15 @@ mod flann_sys { pub fn cv_flann_Index_Index(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_flann_Index_Index_const__InputArrayR_const_IndexParamsR_flann_distance_t(features: *const c_void, params: *const c_void, dist_type: crate::flann::flann_distance_t, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_flann_Index_Index_const__InputArrayR_const_IndexParamsR(features: *const c_void, params: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_flann_Index_build_const__InputArrayR_const_IndexParamsR_flann_distance_t(instance: *mut c_void, features: *const c_void, params: *const c_void, dist_type: crate::flann::flann_distance_t, ocvrs_return: *mut ResultVoid); - pub fn cv_flann_Index_build_const__InputArrayR_const_IndexParamsR(instance: *mut c_void, features: *const c_void, params: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_flann_Index_knnSearch_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_int_const_SearchParamsR(instance: *mut c_void, query: *const c_void, indices: *const c_void, dists: *const c_void, knn: i32, params: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_flann_Index_knnSearch_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_int(instance: *mut c_void, query: *const c_void, indices: *const c_void, dists: *const c_void, knn: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_flann_Index_build_const__InputArrayR_const_IndexParamsR_flann_distance_t(instance: *mut c_void, features: *const c_void, params: *const c_void, dist_type: crate::flann::flann_distance_t, ocvrs_return: *mut Result<()>); + pub fn cv_flann_Index_build_const__InputArrayR_const_IndexParamsR(instance: *mut c_void, features: *const c_void, params: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_flann_Index_knnSearch_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_int_const_SearchParamsR(instance: *mut c_void, query: *const c_void, indices: *const c_void, dists: *const c_void, knn: i32, params: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_flann_Index_knnSearch_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_int(instance: *mut c_void, query: *const c_void, indices: *const c_void, dists: *const c_void, knn: i32, ocvrs_return: *mut Result<()>); pub fn cv_flann_Index_radiusSearch_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_double_int_const_SearchParamsR(instance: *mut c_void, query: *const c_void, indices: *const c_void, dists: *const c_void, radius: f64, max_results: i32, params: *const c_void, ocvrs_return: *mut Result); pub fn cv_flann_Index_radiusSearch_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_double_int(instance: *mut c_void, query: *const c_void, indices: *const c_void, dists: *const c_void, radius: f64, max_results: i32, ocvrs_return: *mut Result); - pub fn cv_flann_Index_save_const_const_StringR(instance: *const c_void, filename: *const c_char, ocvrs_return: *mut ResultVoid); + pub fn cv_flann_Index_save_const_const_StringR(instance: *const c_void, filename: *const c_char, ocvrs_return: *mut Result<()>); pub fn cv_flann_Index_load_const__InputArrayR_const_StringR(instance: *mut c_void, features: *const c_void, filename: *const c_char, ocvrs_return: *mut Result); - pub fn cv_flann_Index_release(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_flann_Index_release(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_flann_Index_getDistance_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_flann_Index_getAlgorithm_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_flann_Index_delete(instance: *mut c_void); @@ -8650,13 +8717,13 @@ mod flann_sys { pub fn cv_flann_IndexParams_getInt_const_const_StringR(instance: *const c_void, key: *const c_char, ocvrs_return: *mut Result); pub fn cv_flann_IndexParams_getDouble_const_const_StringR_double(instance: *const c_void, key: *const c_char, default_val: f64, ocvrs_return: *mut Result); pub fn cv_flann_IndexParams_getDouble_const_const_StringR(instance: *const c_void, key: *const c_char, ocvrs_return: *mut Result); - pub fn cv_flann_IndexParams_setString_const_StringR_const_StringR(instance: *mut c_void, key: *const c_char, value: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_flann_IndexParams_setInt_const_StringR_int(instance: *mut c_void, key: *const c_char, value: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_flann_IndexParams_setDouble_const_StringR_double(instance: *mut c_void, key: *const c_char, value: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_flann_IndexParams_setFloat_const_StringR_float(instance: *mut c_void, key: *const c_char, value: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_flann_IndexParams_setBool_const_StringR_bool(instance: *mut c_void, key: *const c_char, value: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_flann_IndexParams_setAlgorithm_int(instance: *mut c_void, value: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_flann_IndexParams_getAll_const_vectorLStringGR_vectorLFlannIndexTypeGR_vectorLStringGR_vectorLdoubleGR(instance: *const c_void, names: *mut c_void, types: *mut c_void, str_values: *mut c_void, num_values: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_flann_IndexParams_setString_const_StringR_const_StringR(instance: *mut c_void, key: *const c_char, value: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_flann_IndexParams_setInt_const_StringR_int(instance: *mut c_void, key: *const c_char, value: i32, ocvrs_return: *mut Result<()>); + pub fn cv_flann_IndexParams_setDouble_const_StringR_double(instance: *mut c_void, key: *const c_char, value: f64, ocvrs_return: *mut Result<()>); + pub fn cv_flann_IndexParams_setFloat_const_StringR_float(instance: *mut c_void, key: *const c_char, value: f32, ocvrs_return: *mut Result<()>); + pub fn cv_flann_IndexParams_setBool_const_StringR_bool(instance: *mut c_void, key: *const c_char, value: bool, ocvrs_return: *mut Result<()>); + pub fn cv_flann_IndexParams_setAlgorithm_int(instance: *mut c_void, value: i32, ocvrs_return: *mut Result<()>); + pub fn cv_flann_IndexParams_getAll_const_vectorLStringGR_vectorLFlannIndexTypeGR_vectorLStringGR_vectorLdoubleGR(instance: *const c_void, names: *mut c_void, types: *mut c_void, str_values: *mut c_void, num_values: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_flann_IndexParams_propParams(instance: *mut c_void) -> *mut c_void; pub fn cv_flann_IndexParams_propParams_voidX(instance: *mut c_void, val: *const c_void); pub fn cv_flann_IndexParams_delete(instance: *mut c_void); @@ -8779,19 +8846,17 @@ mod flann_sys { pub fn cv_fromSlice_const_const_FlannIndexTypeX_size_t(data: *const crate::flann::FlannIndexType, len: size_t) -> *mut c_void; } } -#[cfg(ocvrs_has_module_flann)] pub use flann_sys::*; -#[cfg(ocvrs_has_module_freetype)] mod freetype_sys { use super::*; extern "C" { pub fn cv_freetype_createFreeType2(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_freetype_FreeType2_loadFontData_String_int(instance: *mut c_void, font_file_name: *const c_char, idx: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_freetype_FreeType2_loadFontData_charX_size_t_int(instance: *mut c_void, p_buf: *mut c_char, buf_size: size_t, idx: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_freetype_FreeType2_setSplitNumber_int(instance: *mut c_void, num: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_freetype_FreeType2_putText_const__InputOutputArrayR_const_StringR_Point_int_Scalar_int_int_bool(instance: *mut c_void, img: *const c_void, text: *const c_char, org: *const core::Point, font_height: i32, color: *const core::Scalar, thickness: i32, line_type: i32, bottom_left_origin: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_freetype_FreeType2_loadFontData_String_int(instance: *mut c_void, font_file_name: *const c_char, idx: i32, ocvrs_return: *mut Result<()>); + pub fn cv_freetype_FreeType2_loadFontData_charX_size_t_int(instance: *mut c_void, p_buf: *mut c_char, buf_size: size_t, idx: i32, ocvrs_return: *mut Result<()>); + pub fn cv_freetype_FreeType2_setSplitNumber_int(instance: *mut c_void, num: i32, ocvrs_return: *mut Result<()>); + pub fn cv_freetype_FreeType2_putText_const__InputOutputArrayR_const_StringR_Point_int_Scalar_int_int_bool(instance: *mut c_void, img: *const c_void, text: *const c_char, org: *const core::Point, font_height: i32, color: *const core::Scalar, thickness: i32, line_type: i32, bottom_left_origin: bool, ocvrs_return: *mut Result<()>); pub fn cv_freetype_FreeType2_getTextSize_const_StringR_int_int_intX(instance: *mut c_void, text: *const c_char, font_height: i32, thickness: i32, base_line: *mut i32, ocvrs_return: *mut Result); pub fn cv_freetype_FreeType2_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_freetype_FreeType2_delete(instance: *mut c_void); @@ -8802,40 +8867,36 @@ mod freetype_sys { pub fn cv_PtrLcv_freetype_FreeType2G_to_PtrOfAlgorithm(instance: *mut c_void) -> *mut c_void; } } -#[cfg(ocvrs_has_module_freetype)] pub use freetype_sys::*; -#[cfg(ocvrs_has_module_fuzzy)] mod fuzzy_sys { use super::*; extern "C" { - pub fn cv_ft_FT02D_FL_process_const__InputArrayR_const_int_const__OutputArrayR(matrix: *const c_void, radius: i32, output: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ft_FT02D_FL_process_float_const__InputArrayR_const_int_const__OutputArrayR(matrix: *const c_void, radius: i32, output: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ft_FT02D_components_const__InputArrayR_const__InputArrayR_const__OutputArrayR(matrix: *const c_void, kernel: *const c_void, components: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ft_FT02D_components_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__InputArrayR(matrix: *const c_void, kernel: *const c_void, components: *const c_void, mask: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ft_FT02D_inverseFT_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int_int(components: *const c_void, kernel: *const c_void, output: *const c_void, width: i32, height: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_ft_FT02D_FL_process_const__InputArrayR_const_int_const__OutputArrayR(matrix: *const c_void, radius: i32, output: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ft_FT02D_FL_process_float_const__InputArrayR_const_int_const__OutputArrayR(matrix: *const c_void, radius: i32, output: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ft_FT02D_components_const__InputArrayR_const__InputArrayR_const__OutputArrayR(matrix: *const c_void, kernel: *const c_void, components: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ft_FT02D_components_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__InputArrayR(matrix: *const c_void, kernel: *const c_void, components: *const c_void, mask: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ft_FT02D_inverseFT_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int_int(components: *const c_void, kernel: *const c_void, output: *const c_void, width: i32, height: i32, ocvrs_return: *mut Result<()>); pub fn cv_ft_FT02D_iteration_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__OutputArrayR_bool(matrix: *const c_void, kernel: *const c_void, output: *const c_void, mask: *const c_void, mask_output: *const c_void, first_stop: bool, ocvrs_return: *mut Result); - pub fn cv_ft_FT02D_process_const__InputArrayR_const__InputArrayR_const__OutputArrayR(matrix: *const c_void, kernel: *const c_void, output: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ft_FT02D_process_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__InputArrayR(matrix: *const c_void, kernel: *const c_void, output: *const c_void, mask: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ft_FT12D_components_const__InputArrayR_const__InputArrayR_const__OutputArrayR(matrix: *const c_void, kernel: *const c_void, components: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ft_FT12D_createPolynomMatrixHorizontal_int_const__OutputArrayR_const_int(radius: i32, matrix: *const c_void, chn: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_ft_FT12D_createPolynomMatrixVertical_int_const__OutputArrayR_const_int(radius: i32, matrix: *const c_void, chn: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_ft_FT12D_inverseFT_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int_int(components: *const c_void, kernel: *const c_void, output: *const c_void, width: i32, height: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_ft_FT12D_polynomial_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(matrix: *const c_void, kernel: *const c_void, c00: *const c_void, c10: *const c_void, c01: *const c_void, components: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ft_FT12D_polynomial_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__InputArrayR(matrix: *const c_void, kernel: *const c_void, c00: *const c_void, c10: *const c_void, c01: *const c_void, components: *const c_void, mask: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ft_FT12D_process_const__InputArrayR_const__InputArrayR_const__OutputArrayR(matrix: *const c_void, kernel: *const c_void, output: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ft_FT12D_process_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__InputArrayR(matrix: *const c_void, kernel: *const c_void, output: *const c_void, mask: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ft_createKernel_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const_int(a: *const c_void, b: *const c_void, kernel: *const c_void, chn: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_ft_createKernel_int_int_const__OutputArrayR_const_int(function: i32, radius: i32, kernel: *const c_void, chn: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_ft_filter_const__InputArrayR_const__InputArrayR_const__OutputArrayR(image: *const c_void, kernel: *const c_void, output: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ft_inpaint_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int_int_int(image: *const c_void, mask: *const c_void, output: *const c_void, radius: i32, function: i32, algorithm: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_ft_FT02D_process_const__InputArrayR_const__InputArrayR_const__OutputArrayR(matrix: *const c_void, kernel: *const c_void, output: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ft_FT02D_process_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__InputArrayR(matrix: *const c_void, kernel: *const c_void, output: *const c_void, mask: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ft_FT12D_components_const__InputArrayR_const__InputArrayR_const__OutputArrayR(matrix: *const c_void, kernel: *const c_void, components: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ft_FT12D_createPolynomMatrixHorizontal_int_const__OutputArrayR_const_int(radius: i32, matrix: *const c_void, chn: i32, ocvrs_return: *mut Result<()>); + pub fn cv_ft_FT12D_createPolynomMatrixVertical_int_const__OutputArrayR_const_int(radius: i32, matrix: *const c_void, chn: i32, ocvrs_return: *mut Result<()>); + pub fn cv_ft_FT12D_inverseFT_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int_int(components: *const c_void, kernel: *const c_void, output: *const c_void, width: i32, height: i32, ocvrs_return: *mut Result<()>); + pub fn cv_ft_FT12D_polynomial_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(matrix: *const c_void, kernel: *const c_void, c00: *const c_void, c10: *const c_void, c01: *const c_void, components: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ft_FT12D_polynomial_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__InputArrayR(matrix: *const c_void, kernel: *const c_void, c00: *const c_void, c10: *const c_void, c01: *const c_void, components: *const c_void, mask: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ft_FT12D_process_const__InputArrayR_const__InputArrayR_const__OutputArrayR(matrix: *const c_void, kernel: *const c_void, output: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ft_FT12D_process_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__InputArrayR(matrix: *const c_void, kernel: *const c_void, output: *const c_void, mask: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ft_createKernel_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const_int(a: *const c_void, b: *const c_void, kernel: *const c_void, chn: i32, ocvrs_return: *mut Result<()>); + pub fn cv_ft_createKernel_int_int_const__OutputArrayR_const_int(function: i32, radius: i32, kernel: *const c_void, chn: i32, ocvrs_return: *mut Result<()>); + pub fn cv_ft_filter_const__InputArrayR_const__InputArrayR_const__OutputArrayR(image: *const c_void, kernel: *const c_void, output: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ft_inpaint_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int_int_int(image: *const c_void, mask: *const c_void, output: *const c_void, radius: i32, function: i32, algorithm: i32, ocvrs_return: *mut Result<()>); } } -#[cfg(ocvrs_has_module_fuzzy)] pub use fuzzy_sys::*; -#[cfg(ocvrs_has_module_gapi)] mod gapi_sys { use super::*; @@ -9049,8 +9110,8 @@ mod gapi_sys { pub fn cv_operatorX_const_GMatR_float(lhs: *const c_void, rhs: f32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_operatorX_const_GScalarR_const_GMatR(lhs: *const c_void, rhs: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_operatorX_float_const_GMatR(lhs: f32, rhs: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_validate_input_arg_const_GRunArgR(arg: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_validate_input_args_const_GRunArgsR(args: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_validate_input_arg_const_GRunArgR(arg: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_validate_input_args_const_GRunArgsR(args: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_GArg_GArg(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_GArg_propKind_const(instance: *const c_void, ocvrs_return: *mut crate::gapi::Detail_ArgKind); pub fn cv_GArg_propKind_const_ArgKind(instance: *mut c_void, val: crate::gapi::Detail_ArgKind); @@ -9072,21 +9133,21 @@ mod gapi_sys { pub fn cv_GCall_yieldFrame(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_GCall_kernel(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_GCall_params(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_GCall_setArgs_vectorLGArgGRR(instance: *mut c_void, args: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_GCall_setArgs_vectorLGArgGRR(instance: *mut c_void, args: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_GCall_delete(instance: *mut c_void); pub fn cv_GCompileArg_GCompileArg() -> *mut c_void; pub fn cv_GCompileArg_propTag_const(instance: *const c_void) -> *mut c_void; pub fn cv_GCompileArg_propTag_const_string(instance: *mut c_void, val: *const c_char); pub fn cv_GCompileArg_delete(instance: *mut c_void); pub fn cv_GCompiled_GCompiled(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_GCompiled_operator___Mat_MatR(instance: *mut c_void, in_: *mut c_void, out: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_GCompiled_operator___Mat_ScalarR(instance: *mut c_void, in_: *mut c_void, out: *mut core::Scalar, ocvrs_return: *mut ResultVoid); - pub fn cv_GCompiled_operator___Mat_Mat_MatR(instance: *mut c_void, in1: *mut c_void, in2: *mut c_void, out: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_GCompiled_operator___Mat_Mat_ScalarR(instance: *mut c_void, in1: *mut c_void, in2: *mut c_void, out: *mut core::Scalar, ocvrs_return: *mut ResultVoid); - pub fn cv_GCompiled_operator___const_vectorLMatGR_const_vectorLMatGR(instance: *mut c_void, ins: *const c_void, outs: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_GCompiled_operator___Mat_MatR(instance: *mut c_void, in_: *mut c_void, out: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_GCompiled_operator___Mat_ScalarR(instance: *mut c_void, in_: *mut c_void, out: *mut core::Scalar, ocvrs_return: *mut Result<()>); + pub fn cv_GCompiled_operator___Mat_Mat_MatR(instance: *mut c_void, in1: *mut c_void, in2: *mut c_void, out: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_GCompiled_operator___Mat_Mat_ScalarR(instance: *mut c_void, in1: *mut c_void, in2: *mut c_void, out: *mut core::Scalar, ocvrs_return: *mut Result<()>); + pub fn cv_GCompiled_operator___const_vectorLMatGR_const_vectorLMatGR(instance: *mut c_void, ins: *const c_void, outs: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_GCompiled_operator_bool_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_GCompiled_canReshape_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_GCompiled_prepareForNewStream(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_GCompiled_prepareForNewStream(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_GCompiled_delete(instance: *mut c_void); pub fn cv_GComputation_GComputation_GMat_GMat(in_: *mut c_void, out: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_GComputation_GComputation_GMat_GScalar(in_: *mut c_void, out: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); @@ -9095,18 +9156,18 @@ mod gapi_sys { pub fn cv_GComputation_GComputation_const_vectorLGMatGR_const_vectorLGMatGR(ins: *const c_void, outs: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_GComputation_apply_const_ExtractArgsCallbackR_GCompileArgsRR(instance: *mut c_void, callback: *const c_void, args: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_GComputation_apply_const_ExtractArgsCallbackR(instance: *mut c_void, callback: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_GComputation_apply_const_vectorLMatGR_const_vectorLMatGR_GCompileArgsRR(instance: *mut c_void, ins: *const c_void, outs: *const c_void, args: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_GComputation_apply_const_vectorLMatGR_const_vectorLMatGR(instance: *mut c_void, ins: *const c_void, outs: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_GComputation_apply_Mat_MatR_GCompileArgsRR(instance: *mut c_void, in_: *mut c_void, out: *mut c_void, args: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_GComputation_apply_Mat_MatR(instance: *mut c_void, in_: *mut c_void, out: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_GComputation_apply_Mat_ScalarR_GCompileArgsRR(instance: *mut c_void, in_: *mut c_void, out: *mut core::Scalar, args: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_GComputation_apply_Mat_ScalarR(instance: *mut c_void, in_: *mut c_void, out: *mut core::Scalar, ocvrs_return: *mut ResultVoid); - pub fn cv_GComputation_apply_Mat_Mat_MatR_GCompileArgsRR(instance: *mut c_void, in1: *mut c_void, in2: *mut c_void, out: *mut c_void, args: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_GComputation_apply_Mat_Mat_MatR(instance: *mut c_void, in1: *mut c_void, in2: *mut c_void, out: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_GComputation_apply_Mat_Mat_ScalarR_GCompileArgsRR(instance: *mut c_void, in1: *mut c_void, in2: *mut c_void, out: *mut core::Scalar, args: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_GComputation_apply_Mat_Mat_ScalarR(instance: *mut c_void, in1: *mut c_void, in2: *mut c_void, out: *mut core::Scalar, ocvrs_return: *mut ResultVoid); - pub fn cv_GComputation_apply_const_vectorLMatGR_vectorLMatGR_GCompileArgsRR(instance: *mut c_void, ins: *const c_void, outs: *mut c_void, args: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_GComputation_apply_const_vectorLMatGR_vectorLMatGR(instance: *mut c_void, ins: *const c_void, outs: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_GComputation_apply_const_vectorLMatGR_const_vectorLMatGR_GCompileArgsRR(instance: *mut c_void, ins: *const c_void, outs: *const c_void, args: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_GComputation_apply_const_vectorLMatGR_const_vectorLMatGR(instance: *mut c_void, ins: *const c_void, outs: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_GComputation_apply_Mat_MatR_GCompileArgsRR(instance: *mut c_void, in_: *mut c_void, out: *mut c_void, args: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_GComputation_apply_Mat_MatR(instance: *mut c_void, in_: *mut c_void, out: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_GComputation_apply_Mat_ScalarR_GCompileArgsRR(instance: *mut c_void, in_: *mut c_void, out: *mut core::Scalar, args: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_GComputation_apply_Mat_ScalarR(instance: *mut c_void, in_: *mut c_void, out: *mut core::Scalar, ocvrs_return: *mut Result<()>); + pub fn cv_GComputation_apply_Mat_Mat_MatR_GCompileArgsRR(instance: *mut c_void, in1: *mut c_void, in2: *mut c_void, out: *mut c_void, args: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_GComputation_apply_Mat_Mat_MatR(instance: *mut c_void, in1: *mut c_void, in2: *mut c_void, out: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_GComputation_apply_Mat_Mat_ScalarR_GCompileArgsRR(instance: *mut c_void, in1: *mut c_void, in2: *mut c_void, out: *mut core::Scalar, args: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_GComputation_apply_Mat_Mat_ScalarR(instance: *mut c_void, in1: *mut c_void, in2: *mut c_void, out: *mut core::Scalar, ocvrs_return: *mut Result<()>); + pub fn cv_GComputation_apply_const_vectorLMatGR_vectorLMatGR_GCompileArgsRR(instance: *mut c_void, ins: *const c_void, outs: *mut c_void, args: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_GComputation_apply_const_vectorLMatGR_vectorLMatGR(instance: *mut c_void, ins: *const c_void, outs: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_GComputation_compileStreaming_GCompileArgsRR(instance: *mut c_void, args: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_GComputation_compileStreaming(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_GComputation_compileStreaming_const_ExtractMetaCallbackR_GCompileArgsRR(instance: *mut c_void, callback: *const c_void, args: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); @@ -9138,13 +9199,13 @@ mod gapi_sys { pub fn cv_GKernelImpl_propOpaque_const(instance: *const c_void) -> *mut c_void; pub fn cv_GKernelImpl_propOpaque_const_any(instance: *mut c_void, val: *const c_void); pub fn cv_GKernelImpl_delete(instance: *mut c_void); - pub fn cv_GKernelPackage_include_const_GFunctorR(instance: *mut c_void, functor: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_GKernelPackage_include_const_GFunctorR(instance: *mut c_void, functor: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_GKernelPackage_get_transformations_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_GKernelPackage_get_kernel_ids_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_GKernelPackage_remove_const_GBackendR(instance: *mut c_void, backend: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_GKernelPackage_remove_const_GBackendR(instance: *mut c_void, backend: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_GKernelPackage_includesAPI_const_const_stringR(instance: *const c_void, id: *const c_char, ocvrs_return: *mut Result); pub fn cv_GKernelPackage_lookup_const_const_stringR(instance: *const c_void, id: *const c_char, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_GKernelPackage_include_const_GBackendR_const_stringR(instance: *mut c_void, backend: *const c_void, kernel_id: *const c_char, ocvrs_return: *mut ResultVoid); + pub fn cv_GKernelPackage_include_const_GBackendR_const_stringR(instance: *mut c_void, backend: *const c_void, kernel_id: *const c_char, ocvrs_return: *mut Result<()>); pub fn cv_GKernelPackage_backends_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_GKernelPackage_implicitClone_const(instance: *const c_void) -> *mut c_void; pub fn cv_GKernelPackage_defaultNew_const() -> *mut c_void; @@ -9193,8 +9254,8 @@ mod gapi_sys { pub fn cv_GRunArg_GRunArg(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_GRunArg_GRunArg_const_GRunArgR(arg: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_GRunArg_GRunArg_GRunArgRR(arg: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_GRunArg_operatorST_const_GRunArgR(instance: *mut c_void, arg: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_GRunArg_operatorST_GRunArgRR(instance: *mut c_void, arg: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_GRunArg_operatorST_const_GRunArgR(instance: *mut c_void, arg: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_GRunArg_operatorST_GRunArgRR(instance: *mut c_void, arg: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_GRunArg_delete(instance: *mut c_void); pub fn cv_GScalar_GScalar(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_GScalar_GScalar_const_ScalarR(s: *const core::Scalar, ocvrs_return: *mut Result<*mut c_void>); @@ -9208,10 +9269,10 @@ mod gapi_sys { pub fn cv_GScalarDesc_defaultNew_const() -> *mut c_void; pub fn cv_GScalarDesc_delete(instance: *mut c_void); pub fn cv_GStreamingCompiled_GStreamingCompiled(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_GStreamingCompiled_setSource_GRunArgsRR(instance: *mut c_void, ins: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_GStreamingCompiled_setSource_const_ExtractArgsCallbackR(instance: *mut c_void, callback: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_GStreamingCompiled_start(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_GStreamingCompiled_stop(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_GStreamingCompiled_setSource_GRunArgsRR(instance: *mut c_void, ins: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_GStreamingCompiled_setSource_const_ExtractArgsCallbackR(instance: *mut c_void, callback: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_GStreamingCompiled_start(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_GStreamingCompiled_stop(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_GStreamingCompiled_running_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_GStreamingCompiled_operator_bool_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_GStreamingCompiled_implicitClone_const(instance: *const c_void) -> *mut c_void; @@ -9242,7 +9303,7 @@ mod gapi_sys { pub fn cv_RMat_IAdapter_delete(instance: *mut c_void); pub fn cv_RMat_View_View() -> *mut c_void; pub fn cv_RMat_View_View_ViewRR(unnamed: *mut c_void) -> *mut c_void; - pub fn cv_RMat_View_operatorST_ViewRR(instance: *mut c_void, v: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_RMat_View_operatorST_ViewRR(instance: *mut c_void, v: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_RMat_View_size_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_RMat_View_dims_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_RMat_View_cols_const(instance: *const c_void, ocvrs_return: *mut Result); @@ -9355,7 +9416,7 @@ mod gapi_sys { pub fn cv_util_any_any() -> *mut c_void; pub fn cv_util_any_any_anyRR(unnamed: *mut c_void) -> *mut c_void; pub fn cv_util_any_operatorST_anyRR(instance: *mut c_void, unnamed: *mut c_void); - pub fn cv_util_any_operatorST_const_anyR(instance: *mut c_void, src: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_util_any_operatorST_const_anyR(instance: *mut c_void, src: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_util_any_delete(instance: *mut c_void); pub fn std_pairLcv_gapi_GBackend__cv_GKernelImplG_new_const_GBackend_GKernelImpl(arg: *mut c_void, arg_1: *mut c_void) -> *mut c_void; pub fn std_pairLcv_gapi_GBackend__cv_GKernelImplG_get_0_const(instance: *const c_void, ocvrs_return: *mut *mut c_void); @@ -9516,58 +9577,56 @@ mod gapi_sys { pub fn std_vectorLcv_GTypeInfoG_set_size_t_const_GTypeInfo(instance: *mut c_void, index: size_t, val: *const c_void); } } -#[cfg(ocvrs_has_module_gapi)] pub use gapi_sys::*; -#[cfg(ocvrs_has_module_hdf)] mod hdf_sys { use super::*; extern "C" { pub fn cv_hdf_open_const_StringR(hdf5_filename: *const c_char, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_hdf_HDF5_close(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_hdf_HDF5_grcreate_const_StringR(instance: *mut c_void, grlabel: *const c_char, ocvrs_return: *mut ResultVoid); + pub fn cv_hdf_HDF5_close(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_hdf_HDF5_grcreate_const_StringR(instance: *mut c_void, grlabel: *const c_char, ocvrs_return: *mut Result<()>); pub fn cv_hdf_HDF5_hlexists_const_const_StringR(instance: *const c_void, label: *const c_char, ocvrs_return: *mut Result); pub fn cv_hdf_HDF5_atexists_const_const_StringR(instance: *const c_void, atlabel: *const c_char, ocvrs_return: *mut Result); - pub fn cv_hdf_HDF5_atdelete_const_StringR(instance: *mut c_void, atlabel: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_hdf_HDF5_atwrite_const_int_const_StringR(instance: *mut c_void, value: i32, atlabel: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_hdf_HDF5_atread_intX_const_StringR(instance: *mut c_void, value: *mut i32, atlabel: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_hdf_HDF5_atwrite_const_double_const_StringR(instance: *mut c_void, value: f64, atlabel: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_hdf_HDF5_atread_doubleX_const_StringR(instance: *mut c_void, value: *mut f64, atlabel: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_hdf_HDF5_atwrite_const_StringR_const_StringR(instance: *mut c_void, value: *const c_char, atlabel: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_hdf_HDF5_atread_StringX_const_StringR(instance: *mut c_void, value: *mut *mut c_void, atlabel: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_hdf_HDF5_atwrite_const__InputArrayR_const_StringR(instance: *mut c_void, value: *const c_void, atlabel: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_hdf_HDF5_atread_const__OutputArrayR_const_StringR(instance: *mut c_void, value: *const c_void, atlabel: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_hdf_HDF5_dscreate_const_const_int_const_int_const_int_const_StringR(instance: *const c_void, rows: i32, cols: i32, typ: i32, dslabel: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_hdf_HDF5_dscreate_const_const_int_const_int_const_int_const_StringR_const_int(instance: *const c_void, rows: i32, cols: i32, typ: i32, dslabel: *const c_char, compresslevel: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_hdf_HDF5_dscreate_const_const_int_const_int_const_int_const_StringR_const_int_const_vectorLintGR(instance: *const c_void, rows: i32, cols: i32, typ: i32, dslabel: *const c_char, compresslevel: i32, dims_chunks: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_hdf_HDF5_dscreate_const_const_int_const_intX_const_int_const_StringR(instance: *const c_void, n_dims: i32, sizes: *const i32, typ: i32, dslabel: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_hdf_HDF5_dscreate_const_const_int_const_intX_const_int_const_StringR_const_int(instance: *const c_void, n_dims: i32, sizes: *const i32, typ: i32, dslabel: *const c_char, compresslevel: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_hdf_HDF5_dscreate_const_const_vectorLintGR_const_int_const_StringR_const_int_const_vectorLintGR(instance: *const c_void, sizes: *const c_void, typ: i32, dslabel: *const c_char, compresslevel: i32, dims_chunks: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_hdf_HDF5_dscreate_const_const_vectorLintGR_const_int_const_StringR(instance: *const c_void, sizes: *const c_void, typ: i32, dslabel: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_hdf_HDF5_dscreate_const_const_int_const_intX_const_int_const_StringR_const_int_const_intX(instance: *const c_void, n_dims: i32, sizes: *const i32, typ: i32, dslabel: *const c_char, compresslevel: i32, dims_chunks: *const i32, ocvrs_return: *mut ResultVoid); + pub fn cv_hdf_HDF5_atdelete_const_StringR(instance: *mut c_void, atlabel: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_hdf_HDF5_atwrite_const_int_const_StringR(instance: *mut c_void, value: i32, atlabel: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_hdf_HDF5_atread_intX_const_StringR(instance: *mut c_void, value: *mut i32, atlabel: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_hdf_HDF5_atwrite_const_double_const_StringR(instance: *mut c_void, value: f64, atlabel: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_hdf_HDF5_atread_doubleX_const_StringR(instance: *mut c_void, value: *mut f64, atlabel: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_hdf_HDF5_atwrite_const_StringR_const_StringR(instance: *mut c_void, value: *const c_char, atlabel: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_hdf_HDF5_atread_StringX_const_StringR(instance: *mut c_void, value: *mut *mut c_void, atlabel: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_hdf_HDF5_atwrite_const__InputArrayR_const_StringR(instance: *mut c_void, value: *const c_void, atlabel: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_hdf_HDF5_atread_const__OutputArrayR_const_StringR(instance: *mut c_void, value: *const c_void, atlabel: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_hdf_HDF5_dscreate_const_const_int_const_int_const_int_const_StringR(instance: *const c_void, rows: i32, cols: i32, typ: i32, dslabel: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_hdf_HDF5_dscreate_const_const_int_const_int_const_int_const_StringR_const_int(instance: *const c_void, rows: i32, cols: i32, typ: i32, dslabel: *const c_char, compresslevel: i32, ocvrs_return: *mut Result<()>); + pub fn cv_hdf_HDF5_dscreate_const_const_int_const_int_const_int_const_StringR_const_int_const_vectorLintGR(instance: *const c_void, rows: i32, cols: i32, typ: i32, dslabel: *const c_char, compresslevel: i32, dims_chunks: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_hdf_HDF5_dscreate_const_const_int_const_intX_const_int_const_StringR(instance: *const c_void, n_dims: i32, sizes: *const i32, typ: i32, dslabel: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_hdf_HDF5_dscreate_const_const_int_const_intX_const_int_const_StringR_const_int(instance: *const c_void, n_dims: i32, sizes: *const i32, typ: i32, dslabel: *const c_char, compresslevel: i32, ocvrs_return: *mut Result<()>); + pub fn cv_hdf_HDF5_dscreate_const_const_vectorLintGR_const_int_const_StringR_const_int_const_vectorLintGR(instance: *const c_void, sizes: *const c_void, typ: i32, dslabel: *const c_char, compresslevel: i32, dims_chunks: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_hdf_HDF5_dscreate_const_const_vectorLintGR_const_int_const_StringR(instance: *const c_void, sizes: *const c_void, typ: i32, dslabel: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_hdf_HDF5_dscreate_const_const_int_const_intX_const_int_const_StringR_const_int_const_intX(instance: *const c_void, n_dims: i32, sizes: *const i32, typ: i32, dslabel: *const c_char, compresslevel: i32, dims_chunks: *const i32, ocvrs_return: *mut Result<()>); pub fn cv_hdf_HDF5_dsgetsize_const_const_StringR_int(instance: *const c_void, dslabel: *const c_char, dims_flag: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_hdf_HDF5_dsgetsize_const_const_StringR(instance: *const c_void, dslabel: *const c_char, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_hdf_HDF5_dsgettype_const_const_StringR(instance: *const c_void, dslabel: *const c_char, ocvrs_return: *mut Result); - pub fn cv_hdf_HDF5_dswrite_const_const__InputArrayR_const_StringR(instance: *const c_void, array: *const c_void, dslabel: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_hdf_HDF5_dswrite_const_const__InputArrayR_const_StringR_const_vectorLintGR_const_vectorLintGR(instance: *const c_void, array: *const c_void, dslabel: *const c_char, dims_offset: *const c_void, dims_counts: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_hdf_HDF5_dswrite_const_const__InputArrayR_const_StringR_const_vectorLintGR(instance: *const c_void, array: *const c_void, dslabel: *const c_char, dims_offset: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_hdf_HDF5_dsinsert_const_const__InputArrayR_const_StringR(instance: *const c_void, array: *const c_void, dslabel: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_hdf_HDF5_dsinsert_const_const__InputArrayR_const_StringR_const_vectorLintGR_const_vectorLintGR(instance: *const c_void, array: *const c_void, dslabel: *const c_char, dims_offset: *const c_void, dims_counts: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_hdf_HDF5_dsinsert_const_const__InputArrayR_const_StringR_const_vectorLintGR(instance: *const c_void, array: *const c_void, dslabel: *const c_char, dims_offset: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_hdf_HDF5_dsread_const_const__OutputArrayR_const_StringR(instance: *const c_void, array: *const c_void, dslabel: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_hdf_HDF5_dsread_const_const__OutputArrayR_const_StringR_const_vectorLintGR_const_vectorLintGR(instance: *const c_void, array: *const c_void, dslabel: *const c_char, dims_offset: *const c_void, dims_counts: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_hdf_HDF5_dsread_const_const__OutputArrayR_const_StringR_const_vectorLintGR(instance: *const c_void, array: *const c_void, dslabel: *const c_char, dims_offset: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_hdf_HDF5_dswrite_const_const__InputArrayR_const_StringR(instance: *const c_void, array: *const c_void, dslabel: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_hdf_HDF5_dswrite_const_const__InputArrayR_const_StringR_const_vectorLintGR_const_vectorLintGR(instance: *const c_void, array: *const c_void, dslabel: *const c_char, dims_offset: *const c_void, dims_counts: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_hdf_HDF5_dswrite_const_const__InputArrayR_const_StringR_const_vectorLintGR(instance: *const c_void, array: *const c_void, dslabel: *const c_char, dims_offset: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_hdf_HDF5_dsinsert_const_const__InputArrayR_const_StringR(instance: *const c_void, array: *const c_void, dslabel: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_hdf_HDF5_dsinsert_const_const__InputArrayR_const_StringR_const_vectorLintGR_const_vectorLintGR(instance: *const c_void, array: *const c_void, dslabel: *const c_char, dims_offset: *const c_void, dims_counts: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_hdf_HDF5_dsinsert_const_const__InputArrayR_const_StringR_const_vectorLintGR(instance: *const c_void, array: *const c_void, dslabel: *const c_char, dims_offset: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_hdf_HDF5_dsread_const_const__OutputArrayR_const_StringR(instance: *const c_void, array: *const c_void, dslabel: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_hdf_HDF5_dsread_const_const__OutputArrayR_const_StringR_const_vectorLintGR_const_vectorLintGR(instance: *const c_void, array: *const c_void, dslabel: *const c_char, dims_offset: *const c_void, dims_counts: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_hdf_HDF5_dsread_const_const__OutputArrayR_const_StringR_const_vectorLintGR(instance: *const c_void, array: *const c_void, dslabel: *const c_char, dims_offset: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_hdf_HDF5_kpgetsize_const_const_StringR_int(instance: *const c_void, kplabel: *const c_char, dims_flag: i32, ocvrs_return: *mut Result); pub fn cv_hdf_HDF5_kpgetsize_const_const_StringR(instance: *const c_void, kplabel: *const c_char, ocvrs_return: *mut Result); - pub fn cv_hdf_HDF5_kpcreate_const_const_int_const_StringR_const_int_const_int(instance: *const c_void, size: i32, kplabel: *const c_char, compresslevel: i32, chunks: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_hdf_HDF5_kpcreate_const_const_int_const_StringR(instance: *const c_void, size: i32, kplabel: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_hdf_HDF5_kpwrite_const_const_vectorLKeyPointG_const_StringR_const_int_const_int(instance: *const c_void, keypoints: *const c_void, kplabel: *const c_char, offset: i32, counts: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_hdf_HDF5_kpwrite_const_const_vectorLKeyPointG_const_StringR(instance: *const c_void, keypoints: *const c_void, kplabel: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_hdf_HDF5_kpinsert_const_const_vectorLKeyPointG_const_StringR_const_int_const_int(instance: *const c_void, keypoints: *const c_void, kplabel: *const c_char, offset: i32, counts: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_hdf_HDF5_kpinsert_const_const_vectorLKeyPointG_const_StringR(instance: *const c_void, keypoints: *const c_void, kplabel: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_hdf_HDF5_kpread_const_vectorLKeyPointGR_const_StringR_const_int_const_int(instance: *const c_void, keypoints: *mut c_void, kplabel: *const c_char, offset: i32, counts: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_hdf_HDF5_kpread_const_vectorLKeyPointGR_const_StringR(instance: *const c_void, keypoints: *mut c_void, kplabel: *const c_char, ocvrs_return: *mut ResultVoid); + pub fn cv_hdf_HDF5_kpcreate_const_const_int_const_StringR_const_int_const_int(instance: *const c_void, size: i32, kplabel: *const c_char, compresslevel: i32, chunks: i32, ocvrs_return: *mut Result<()>); + pub fn cv_hdf_HDF5_kpcreate_const_const_int_const_StringR(instance: *const c_void, size: i32, kplabel: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_hdf_HDF5_kpwrite_const_const_vectorLKeyPointG_const_StringR_const_int_const_int(instance: *const c_void, keypoints: *const c_void, kplabel: *const c_char, offset: i32, counts: i32, ocvrs_return: *mut Result<()>); + pub fn cv_hdf_HDF5_kpwrite_const_const_vectorLKeyPointG_const_StringR(instance: *const c_void, keypoints: *const c_void, kplabel: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_hdf_HDF5_kpinsert_const_const_vectorLKeyPointG_const_StringR_const_int_const_int(instance: *const c_void, keypoints: *const c_void, kplabel: *const c_char, offset: i32, counts: i32, ocvrs_return: *mut Result<()>); + pub fn cv_hdf_HDF5_kpinsert_const_const_vectorLKeyPointG_const_StringR(instance: *const c_void, keypoints: *const c_void, kplabel: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_hdf_HDF5_kpread_const_vectorLKeyPointGR_const_StringR_const_int_const_int(instance: *const c_void, keypoints: *mut c_void, kplabel: *const c_char, offset: i32, counts: i32, ocvrs_return: *mut Result<()>); + pub fn cv_hdf_HDF5_kpread_const_vectorLKeyPointGR_const_StringR(instance: *const c_void, keypoints: *mut c_void, kplabel: *const c_char, ocvrs_return: *mut Result<()>); pub fn cv_hdf_HDF5_delete(instance: *mut c_void); pub fn cv_PtrLcv_hdf_HDF5G_getInnerPtr_const(instance: *const c_void) -> *mut c_void; pub fn cv_PtrLcv_hdf_HDF5G_getInnerPtrMut(instance: *mut c_void) -> *mut c_void; @@ -9575,27 +9634,25 @@ mod hdf_sys { pub fn cv_PtrLcv_hdf_HDF5G_delete(instance: *mut c_void); } } -#[cfg(ocvrs_has_module_hdf)] pub use hdf_sys::*; -#[cfg(ocvrs_has_module_hfs)] mod hfs_sys { use super::*; extern "C" { - pub fn cv_hfs_HfsSegment_setSegEgbThresholdI_float(instance: *mut c_void, c: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_hfs_HfsSegment_setSegEgbThresholdI_float(instance: *mut c_void, c: f32, ocvrs_return: *mut Result<()>); pub fn cv_hfs_HfsSegment_getSegEgbThresholdI(instance: *mut c_void, ocvrs_return: *mut Result); - pub fn cv_hfs_HfsSegment_setMinRegionSizeI_int(instance: *mut c_void, n: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_hfs_HfsSegment_setMinRegionSizeI_int(instance: *mut c_void, n: i32, ocvrs_return: *mut Result<()>); pub fn cv_hfs_HfsSegment_getMinRegionSizeI(instance: *mut c_void, ocvrs_return: *mut Result); - pub fn cv_hfs_HfsSegment_setSegEgbThresholdII_float(instance: *mut c_void, c: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_hfs_HfsSegment_setSegEgbThresholdII_float(instance: *mut c_void, c: f32, ocvrs_return: *mut Result<()>); pub fn cv_hfs_HfsSegment_getSegEgbThresholdII(instance: *mut c_void, ocvrs_return: *mut Result); - pub fn cv_hfs_HfsSegment_setMinRegionSizeII_int(instance: *mut c_void, n: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_hfs_HfsSegment_setMinRegionSizeII_int(instance: *mut c_void, n: i32, ocvrs_return: *mut Result<()>); pub fn cv_hfs_HfsSegment_getMinRegionSizeII(instance: *mut c_void, ocvrs_return: *mut Result); - pub fn cv_hfs_HfsSegment_setSpatialWeight_float(instance: *mut c_void, w: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_hfs_HfsSegment_setSpatialWeight_float(instance: *mut c_void, w: f32, ocvrs_return: *mut Result<()>); pub fn cv_hfs_HfsSegment_getSpatialWeight(instance: *mut c_void, ocvrs_return: *mut Result); - pub fn cv_hfs_HfsSegment_setSlicSpixelSize_int(instance: *mut c_void, n: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_hfs_HfsSegment_setSlicSpixelSize_int(instance: *mut c_void, n: i32, ocvrs_return: *mut Result<()>); pub fn cv_hfs_HfsSegment_getSlicSpixelSize(instance: *mut c_void, ocvrs_return: *mut Result); - pub fn cv_hfs_HfsSegment_setNumSlicIter_int(instance: *mut c_void, n: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_hfs_HfsSegment_setNumSlicIter_int(instance: *mut c_void, n: i32, ocvrs_return: *mut Result<()>); pub fn cv_hfs_HfsSegment_getNumSlicIter(instance: *mut c_void, ocvrs_return: *mut Result); pub fn cv_hfs_HfsSegment_performSegmentGpu_const__InputArrayR_bool(instance: *mut c_void, src: *const c_void, if_draw: bool, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_hfs_HfsSegment_performSegmentGpu_const__InputArrayR(instance: *mut c_void, src: *const c_void, ocvrs_return: *mut Result<*mut c_void>); @@ -9612,60 +9669,58 @@ mod hfs_sys { pub fn cv_PtrLcv_hfs_HfsSegmentG_to_PtrOfAlgorithm(instance: *mut c_void) -> *mut c_void; } } -#[cfg(ocvrs_has_module_hfs)] pub use hfs_sys::*; -#[cfg(ocvrs_has_module_highgui)] mod highgui_sys { use super::*; extern "C" { - pub fn cv_addText_const_MatR_const_StringR_Point_const_QtFontR(img: *const c_void, text: *const c_char, org: *const core::Point, font: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_addText_const_MatR_const_StringR_Point_const_StringR(img: *const c_void, text: *const c_char, org: *const core::Point, name_font: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_addText_const_MatR_const_StringR_Point_const_StringR_int_Scalar_int_int_int(img: *const c_void, text: *const c_char, org: *const core::Point, name_font: *const c_char, point_size: i32, color: *const core::Scalar, weight: i32, style: i32, spacing: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_addText_const_MatR_const_StringR_Point_const_QtFontR(img: *const c_void, text: *const c_char, org: *const core::Point, font: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_addText_const_MatR_const_StringR_Point_const_StringR(img: *const c_void, text: *const c_char, org: *const core::Point, name_font: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_addText_const_MatR_const_StringR_Point_const_StringR_int_Scalar_int_int_int(img: *const c_void, text: *const c_char, org: *const core::Point, name_font: *const c_char, point_size: i32, color: *const core::Scalar, weight: i32, style: i32, spacing: i32, ocvrs_return: *mut Result<()>); pub fn cv_createButton_const_StringR_ButtonCallback_voidX(bar_name: *const c_char, on_change: Option ()>, userdata: *mut c_void, ocvrs_return: *mut Result); pub fn cv_createButton_const_StringR_ButtonCallback_voidX_int_bool(bar_name: *const c_char, on_change: Option ()>, userdata: *mut c_void, typ: i32, initial_button_state: bool, ocvrs_return: *mut Result); pub fn cv_createTrackbar_const_StringR_const_StringR_intX_int_TrackbarCallback_voidX(trackbarname: *const c_char, winname: *const c_char, value: *mut i32, count: i32, on_change: Option ()>, userdata: *mut c_void, ocvrs_return: *mut Result); pub fn cv_currentUIFramework(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_destroyAllWindows(ocvrs_return: *mut ResultVoid); - pub fn cv_destroyWindow_const_StringR(winname: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_displayOverlay_const_StringR_const_StringR(winname: *const c_char, text: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_displayOverlay_const_StringR_const_StringR_int(winname: *const c_char, text: *const c_char, delayms: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_displayStatusBar_const_StringR_const_StringR(winname: *const c_char, text: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_displayStatusBar_const_StringR_const_StringR_int(winname: *const c_char, text: *const c_char, delayms: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_destroyAllWindows(ocvrs_return: *mut Result<()>); + pub fn cv_destroyWindow_const_StringR(winname: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_displayOverlay_const_StringR_const_StringR(winname: *const c_char, text: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_displayOverlay_const_StringR_const_StringR_int(winname: *const c_char, text: *const c_char, delayms: i32, ocvrs_return: *mut Result<()>); + pub fn cv_displayStatusBar_const_StringR_const_StringR(winname: *const c_char, text: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_displayStatusBar_const_StringR_const_StringR_int(winname: *const c_char, text: *const c_char, delayms: i32, ocvrs_return: *mut Result<()>); pub fn cv_fontQt_const_StringR(name_font: *const c_char, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_fontQt_const_StringR_int_Scalar_int_int_int(name_font: *const c_char, point_size: i32, color: *const core::Scalar, weight: i32, style: i32, spacing: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_getMouseWheelDelta_int(flags: i32, ocvrs_return: *mut Result); pub fn cv_getTrackbarPos_const_StringR_const_StringR(trackbarname: *const c_char, winname: *const c_char, ocvrs_return: *mut Result); pub fn cv_getWindowImageRect_const_StringR(winname: *const c_char, ocvrs_return: *mut Result); pub fn cv_getWindowProperty_const_StringR_int(winname: *const c_char, prop_id: i32, ocvrs_return: *mut Result); - pub fn cv_imshow_const_StringR_const__InputArrayR(winname: *const c_char, mat: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_loadWindowParameters_const_StringR(window_name: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_moveWindow_const_StringR_int_int(winname: *const c_char, x: i32, y: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_namedWindow_const_StringR(winname: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_namedWindow_const_StringR_int(winname: *const c_char, flags: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_imshow_const_StringR_const__InputArrayR(winname: *const c_char, mat: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_loadWindowParameters_const_StringR(window_name: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_moveWindow_const_StringR_int_int(winname: *const c_char, x: i32, y: i32, ocvrs_return: *mut Result<()>); + pub fn cv_namedWindow_const_StringR(winname: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_namedWindow_const_StringR_int(winname: *const c_char, flags: i32, ocvrs_return: *mut Result<()>); pub fn cv_pollKey(ocvrs_return: *mut Result); - pub fn cv_resizeWindow_const_StringR_const_SizeR(winname: *const c_char, size: *const core::Size, ocvrs_return: *mut ResultVoid); - pub fn cv_resizeWindow_const_StringR_int_int(winname: *const c_char, width: i32, height: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_saveWindowParameters_const_StringR(window_name: *const c_char, ocvrs_return: *mut ResultVoid); + pub fn cv_resizeWindow_const_StringR_const_SizeR(winname: *const c_char, size: *const core::Size, ocvrs_return: *mut Result<()>); + pub fn cv_resizeWindow_const_StringR_int_int(winname: *const c_char, width: i32, height: i32, ocvrs_return: *mut Result<()>); + pub fn cv_saveWindowParameters_const_StringR(window_name: *const c_char, ocvrs_return: *mut Result<()>); pub fn cv_selectROI_const_StringR_const__InputArrayR(window_name: *const c_char, img: *const c_void, ocvrs_return: *mut Result); pub fn cv_selectROI_const_StringR_const__InputArrayR_bool_bool_bool(window_name: *const c_char, img: *const c_void, show_crosshair: bool, from_center: bool, print_notice: bool, ocvrs_return: *mut Result); pub fn cv_selectROI_const__InputArrayR(img: *const c_void, ocvrs_return: *mut Result); pub fn cv_selectROI_const__InputArrayR_bool_bool_bool(img: *const c_void, show_crosshair: bool, from_center: bool, print_notice: bool, ocvrs_return: *mut Result); - pub fn cv_selectROIs_const_StringR_const__InputArrayR_vectorLRectGR(window_name: *const c_char, img: *const c_void, bounding_boxes: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_selectROIs_const_StringR_const__InputArrayR_vectorLRectGR_bool_bool_bool(window_name: *const c_char, img: *const c_void, bounding_boxes: *mut c_void, show_crosshair: bool, from_center: bool, print_notice: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_setMouseCallback_const_StringR_MouseCallback_voidX(winname: *const c_char, on_mouse: Option ()>, userdata: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_setOpenGlContext_const_StringR(winname: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_setOpenGlDrawCallback_const_StringR_OpenGlDrawCallback_voidX(winname: *const c_char, on_opengl_draw: Option ()>, userdata: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_setTrackbarMax_const_StringR_const_StringR_int(trackbarname: *const c_char, winname: *const c_char, maxval: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_setTrackbarMin_const_StringR_const_StringR_int(trackbarname: *const c_char, winname: *const c_char, minval: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_setTrackbarPos_const_StringR_const_StringR_int(trackbarname: *const c_char, winname: *const c_char, pos: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_setWindowProperty_const_StringR_int_double(winname: *const c_char, prop_id: i32, prop_value: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_setWindowTitle_const_StringR_const_StringR(winname: *const c_char, title: *const c_char, ocvrs_return: *mut ResultVoid); + pub fn cv_selectROIs_const_StringR_const__InputArrayR_vectorLRectGR(window_name: *const c_char, img: *const c_void, bounding_boxes: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_selectROIs_const_StringR_const__InputArrayR_vectorLRectGR_bool_bool_bool(window_name: *const c_char, img: *const c_void, bounding_boxes: *mut c_void, show_crosshair: bool, from_center: bool, print_notice: bool, ocvrs_return: *mut Result<()>); + pub fn cv_setMouseCallback_const_StringR_MouseCallback_voidX(winname: *const c_char, on_mouse: Option ()>, userdata: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_setOpenGlContext_const_StringR(winname: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_setOpenGlDrawCallback_const_StringR_OpenGlDrawCallback_voidX(winname: *const c_char, on_opengl_draw: Option ()>, userdata: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_setTrackbarMax_const_StringR_const_StringR_int(trackbarname: *const c_char, winname: *const c_char, maxval: i32, ocvrs_return: *mut Result<()>); + pub fn cv_setTrackbarMin_const_StringR_const_StringR_int(trackbarname: *const c_char, winname: *const c_char, minval: i32, ocvrs_return: *mut Result<()>); + pub fn cv_setTrackbarPos_const_StringR_const_StringR_int(trackbarname: *const c_char, winname: *const c_char, pos: i32, ocvrs_return: *mut Result<()>); + pub fn cv_setWindowProperty_const_StringR_int_double(winname: *const c_char, prop_id: i32, prop_value: f64, ocvrs_return: *mut Result<()>); + pub fn cv_setWindowTitle_const_StringR_const_StringR(winname: *const c_char, title: *const c_char, ocvrs_return: *mut Result<()>); pub fn cv_startLoop_int__X__int__charXX__int_charXX(pt2_func: Option i32>, argc: i32, argv: *mut *mut c_char, ocvrs_return: *mut Result); pub fn cv_startWindowThread(ocvrs_return: *mut Result); - pub fn cv_stopLoop(ocvrs_return: *mut ResultVoid); - pub fn cv_updateWindow_const_StringR(winname: *const c_char, ocvrs_return: *mut ResultVoid); + pub fn cv_stopLoop(ocvrs_return: *mut Result<()>); + pub fn cv_updateWindow_const_StringR(winname: *const c_char, ocvrs_return: *mut Result<()>); pub fn cv_waitKey(ocvrs_return: *mut Result); pub fn cv_waitKeyEx(ocvrs_return: *mut Result); pub fn cv_waitKeyEx_int(delay: i32, ocvrs_return: *mut Result); @@ -9694,28 +9749,26 @@ mod highgui_sys { pub fn cv_QtFont_delete(instance: *mut c_void); } } -#[cfg(ocvrs_has_module_highgui)] pub use highgui_sys::*; -#[cfg(ocvrs_has_module_img_hash)] mod img_hash_sys { use super::*; extern "C" { - pub fn cv_img_hash_averageHash_const__InputArrayR_const__OutputArrayR(input_arr: *const c_void, output_arr: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_img_hash_blockMeanHash_const__InputArrayR_const__OutputArrayR(input_arr: *const c_void, output_arr: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_img_hash_blockMeanHash_const__InputArrayR_const__OutputArrayR_int(input_arr: *const c_void, output_arr: *const c_void, mode: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_img_hash_colorMomentHash_const__InputArrayR_const__OutputArrayR(input_arr: *const c_void, output_arr: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_img_hash_marrHildrethHash_const__InputArrayR_const__OutputArrayR(input_arr: *const c_void, output_arr: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_img_hash_marrHildrethHash_const__InputArrayR_const__OutputArrayR_float_float(input_arr: *const c_void, output_arr: *const c_void, alpha: f32, scale: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_img_hash_pHash_const__InputArrayR_const__OutputArrayR(input_arr: *const c_void, output_arr: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_img_hash_radialVarianceHash_const__InputArrayR_const__OutputArrayR(input_arr: *const c_void, output_arr: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_img_hash_radialVarianceHash_const__InputArrayR_const__OutputArrayR_double_int(input_arr: *const c_void, output_arr: *const c_void, sigma: f64, num_of_angle_line: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_img_hash_averageHash_const__InputArrayR_const__OutputArrayR(input_arr: *const c_void, output_arr: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_img_hash_blockMeanHash_const__InputArrayR_const__OutputArrayR(input_arr: *const c_void, output_arr: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_img_hash_blockMeanHash_const__InputArrayR_const__OutputArrayR_int(input_arr: *const c_void, output_arr: *const c_void, mode: i32, ocvrs_return: *mut Result<()>); + pub fn cv_img_hash_colorMomentHash_const__InputArrayR_const__OutputArrayR(input_arr: *const c_void, output_arr: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_img_hash_marrHildrethHash_const__InputArrayR_const__OutputArrayR(input_arr: *const c_void, output_arr: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_img_hash_marrHildrethHash_const__InputArrayR_const__OutputArrayR_float_float(input_arr: *const c_void, output_arr: *const c_void, alpha: f32, scale: f32, ocvrs_return: *mut Result<()>); + pub fn cv_img_hash_pHash_const__InputArrayR_const__OutputArrayR(input_arr: *const c_void, output_arr: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_img_hash_radialVarianceHash_const__InputArrayR_const__OutputArrayR(input_arr: *const c_void, output_arr: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_img_hash_radialVarianceHash_const__InputArrayR_const__OutputArrayR_double_int(input_arr: *const c_void, output_arr: *const c_void, sigma: f64, num_of_angle_line: i32, ocvrs_return: *mut Result<()>); pub fn cv_img_hash_AverageHash_create(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_img_hash_AverageHash_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_img_hash_AverageHash_to_ImgHashBase(instance: *mut c_void) -> *mut c_void; pub fn cv_img_hash_AverageHash_delete(instance: *mut c_void); - pub fn cv_img_hash_BlockMeanHash_setMode_int(instance: *mut c_void, mode: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_img_hash_BlockMeanHash_setMode_int(instance: *mut c_void, mode: i32, ocvrs_return: *mut Result<()>); pub fn cv_img_hash_BlockMeanHash_getMean_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_img_hash_BlockMeanHash_create_int(mode: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_img_hash_BlockMeanHash_create(ocvrs_return: *mut Result<*mut c_void>); @@ -9726,13 +9779,13 @@ mod img_hash_sys { pub fn cv_img_hash_ColorMomentHash_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_img_hash_ColorMomentHash_to_ImgHashBase(instance: *mut c_void) -> *mut c_void; pub fn cv_img_hash_ColorMomentHash_delete(instance: *mut c_void); - pub fn cv_img_hash_ImgHashBase_compute_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, input_arr: *const c_void, output_arr: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_img_hash_ImgHashBase_compute_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, input_arr: *const c_void, output_arr: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_img_hash_ImgHashBase_compare_const_const__InputArrayR_const__InputArrayR(instance: *const c_void, hash_one: *const c_void, hash_two: *const c_void, ocvrs_return: *mut Result); pub fn cv_img_hash_ImgHashBase_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_img_hash_ImgHashBase_delete(instance: *mut c_void); pub fn cv_img_hash_MarrHildrethHash_getAlpha_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_img_hash_MarrHildrethHash_getScale_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_img_hash_MarrHildrethHash_setKernelParam_float_float(instance: *mut c_void, alpha: f32, scale: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_img_hash_MarrHildrethHash_setKernelParam_float_float(instance: *mut c_void, alpha: f32, scale: f32, ocvrs_return: *mut Result<()>); pub fn cv_img_hash_MarrHildrethHash_create_float_float(alpha: f32, scale: f32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_img_hash_MarrHildrethHash_create(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_img_hash_MarrHildrethHash_to_Algorithm(instance: *mut c_void) -> *mut c_void; @@ -9746,8 +9799,8 @@ mod img_hash_sys { pub fn cv_img_hash_RadialVarianceHash_create(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_img_hash_RadialVarianceHash_getNumOfAngleLine_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_img_hash_RadialVarianceHash_getSigma_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_img_hash_RadialVarianceHash_setNumOfAngleLine_int(instance: *mut c_void, value: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_img_hash_RadialVarianceHash_setSigma_double(instance: *mut c_void, value: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_img_hash_RadialVarianceHash_setNumOfAngleLine_int(instance: *mut c_void, value: i32, ocvrs_return: *mut Result<()>); + pub fn cv_img_hash_RadialVarianceHash_setSigma_double(instance: *mut c_void, value: f64, ocvrs_return: *mut Result<()>); pub fn cv_img_hash_RadialVarianceHash_getFeatures(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_img_hash_RadialVarianceHash_getHash(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_img_hash_RadialVarianceHash_getPixPerLine_const_MatR(instance: *mut c_void, input: *const c_void, ocvrs_return: *mut Result<*mut c_void>); @@ -9805,10 +9858,8 @@ mod img_hash_sys { pub fn cv_PtrLcv_img_hash_RadialVarianceHashG_new_const_RadialVarianceHash(val: *mut c_void) -> *mut c_void; } } -#[cfg(ocvrs_has_module_img_hash)] pub use img_hash_sys::*; -#[cfg(ocvrs_has_module_imgcodecs)] mod imgcodecs_sys { use super::*; @@ -9826,8 +9877,8 @@ mod imgcodecs_sys { pub fn cv_imencodemulti_const_StringR_const__InputArrayR_vectorLunsigned_charGR(ext: *const c_char, imgs: *const c_void, buf: *mut c_void, ocvrs_return: *mut Result); pub fn cv_imencodemulti_const_StringR_const__InputArrayR_vectorLunsigned_charGR_const_vectorLintGR(ext: *const c_char, imgs: *const c_void, buf: *mut c_void, params: *const c_void, ocvrs_return: *mut Result); pub fn cv_imread_const_StringR(filename: *const c_char, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_imread_const_StringR_const__OutputArrayR(filename: *const c_char, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_imread_const_StringR_const__OutputArrayR_int(filename: *const c_char, dst: *const c_void, flags: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_imread_const_StringR_const__OutputArrayR(filename: *const c_char, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_imread_const_StringR_const__OutputArrayR_int(filename: *const c_char, dst: *const c_void, flags: i32, ocvrs_return: *mut Result<()>); pub fn cv_imread_const_StringR_int(filename: *const c_char, flags: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_imreadanimation_const_StringR_AnimationR(filename: *const c_char, animation: *mut c_void, ocvrs_return: *mut Result); pub fn cv_imreadanimation_const_StringR_AnimationR_int_int(filename: *const c_char, animation: *mut c_void, start: i32, count: i32, ocvrs_return: *mut Result); @@ -9855,11 +9906,11 @@ mod imgcodecs_sys { pub fn cv_Animation_delete(instance: *mut c_void); pub fn cv_ImageCollection_ImageCollection(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ImageCollection_ImageCollection_const_StringR_int(filename: *const c_char, flags: i32, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_ImageCollection_init_const_StringR_int(instance: *mut c_void, img: *const c_char, flags: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_ImageCollection_init_const_StringR_int(instance: *mut c_void, img: *const c_char, flags: i32, ocvrs_return: *mut Result<()>); pub fn cv_ImageCollection_size_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_ImageCollection_at_int(instance: *mut c_void, index: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ImageCollection_operator___int(instance: *mut c_void, index: i32, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_ImageCollection_releaseCache_int(instance: *mut c_void, index: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_ImageCollection_releaseCache_int(instance: *mut c_void, index: i32, ocvrs_return: *mut Result<()>); pub fn cv_ImageCollection_begin(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ImageCollection_end(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ImageCollection_delete(instance: *mut c_void); @@ -9870,70 +9921,68 @@ mod imgcodecs_sys { pub fn cv_ImageCollection_iterator_delete(instance: *mut c_void); } } -#[cfg(ocvrs_has_module_imgcodecs)] pub use imgcodecs_sys::*; -#[cfg(ocvrs_has_module_imgproc)] mod imgproc_sys { use super::*; extern "C" { - pub fn cv_Canny_const__InputArrayR_const__InputArrayR_const__OutputArrayR_double_double(dx: *const c_void, dy: *const c_void, edges: *const c_void, threshold1: f64, threshold2: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_Canny_const__InputArrayR_const__InputArrayR_const__OutputArrayR_double_double_bool(dx: *const c_void, dy: *const c_void, edges: *const c_void, threshold1: f64, threshold2: f64, l2gradient: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_Canny_const__InputArrayR_const__OutputArrayR_double_double(image: *const c_void, edges: *const c_void, threshold1: f64, threshold2: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_Canny_const__InputArrayR_const__OutputArrayR_double_double_int_bool(image: *const c_void, edges: *const c_void, threshold1: f64, threshold2: f64, aperture_size: i32, l2gradient: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_Canny_const__InputArrayR_const__InputArrayR_const__OutputArrayR_double_double(dx: *const c_void, dy: *const c_void, edges: *const c_void, threshold1: f64, threshold2: f64, ocvrs_return: *mut Result<()>); + pub fn cv_Canny_const__InputArrayR_const__InputArrayR_const__OutputArrayR_double_double_bool(dx: *const c_void, dy: *const c_void, edges: *const c_void, threshold1: f64, threshold2: f64, l2gradient: bool, ocvrs_return: *mut Result<()>); + pub fn cv_Canny_const__InputArrayR_const__OutputArrayR_double_double(image: *const c_void, edges: *const c_void, threshold1: f64, threshold2: f64, ocvrs_return: *mut Result<()>); + pub fn cv_Canny_const__InputArrayR_const__OutputArrayR_double_double_int_bool(image: *const c_void, edges: *const c_void, threshold1: f64, threshold2: f64, aperture_size: i32, l2gradient: bool, ocvrs_return: *mut Result<()>); pub fn cv_EMD_const__InputArrayR_const__InputArrayR_int(signature1: *const c_void, signature2: *const c_void, dist_type: i32, ocvrs_return: *mut Result); pub fn cv_EMD_const__InputArrayR_const__InputArrayR_int_const__InputArrayR_floatX_const__OutputArrayR(signature1: *const c_void, signature2: *const c_void, dist_type: i32, cost: *const c_void, lower_bound: *mut f32, flow: *const c_void, ocvrs_return: *mut Result); - pub fn cv_GaussianBlur_const__InputArrayR_const__OutputArrayR_Size_double(src: *const c_void, dst: *const c_void, ksize: *const core::Size, sigma_x: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_GaussianBlur_const__InputArrayR_const__OutputArrayR_Size_double_double_int_AlgorithmHint(src: *const c_void, dst: *const c_void, ksize: *const core::Size, sigma_x: f64, sigma_y: f64, border_type: i32, hint: core::AlgorithmHint, ocvrs_return: *mut ResultVoid); - pub fn cv_HoughCircles_const__InputArrayR_const__OutputArrayR_int_double_double(image: *const c_void, circles: *const c_void, method: i32, dp: f64, min_dist: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_HoughCircles_const__InputArrayR_const__OutputArrayR_int_double_double_double_double_int_int(image: *const c_void, circles: *const c_void, method: i32, dp: f64, min_dist: f64, param1: f64, param2: f64, min_radius: i32, max_radius: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_HoughLinesP_const__InputArrayR_const__OutputArrayR_double_double_int(image: *const c_void, lines: *const c_void, rho: f64, theta: f64, threshold: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_HoughLinesP_const__InputArrayR_const__OutputArrayR_double_double_int_double_double(image: *const c_void, lines: *const c_void, rho: f64, theta: f64, threshold: i32, min_line_length: f64, max_line_gap: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_HoughLinesPointSet_const__InputArrayR_const__OutputArrayR_int_int_double_double_double_double_double_double(point: *const c_void, lines: *const c_void, lines_max: i32, threshold: i32, min_rho: f64, max_rho: f64, rho_step: f64, min_theta: f64, max_theta: f64, theta_step: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_HoughLines_const__InputArrayR_const__OutputArrayR_double_double_int(image: *const c_void, lines: *const c_void, rho: f64, theta: f64, threshold: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_HoughLines_const__InputArrayR_const__OutputArrayR_double_double_int_double_double_double_double_bool(image: *const c_void, lines: *const c_void, rho: f64, theta: f64, threshold: i32, srn: f64, stn: f64, min_theta: f64, max_theta: f64, use_edgeval: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_HuMoments_const_MomentsR_const__OutputArrayR(m: *const core::Moments, hu: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_HuMoments_const_MomentsR_doubleXX(moments: *const core::Moments, hu: *mut [f64; 7], ocvrs_return: *mut ResultVoid); - pub fn cv_Laplacian_const__InputArrayR_const__OutputArrayR_int(src: *const c_void, dst: *const c_void, ddepth: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_Laplacian_const__InputArrayR_const__OutputArrayR_int_int_double_double_int(src: *const c_void, dst: *const c_void, ddepth: i32, ksize: i32, scale: f64, delta: f64, border_type: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_Scharr_const__InputArrayR_const__OutputArrayR_int_int_int(src: *const c_void, dst: *const c_void, ddepth: i32, dx: i32, dy: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_Scharr_const__InputArrayR_const__OutputArrayR_int_int_int_double_double_int(src: *const c_void, dst: *const c_void, ddepth: i32, dx: i32, dy: i32, scale: f64, delta: f64, border_type: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_Sobel_const__InputArrayR_const__OutputArrayR_int_int_int(src: *const c_void, dst: *const c_void, ddepth: i32, dx: i32, dy: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_Sobel_const__InputArrayR_const__OutputArrayR_int_int_int_int_double_double_int(src: *const c_void, dst: *const c_void, ddepth: i32, dx: i32, dy: i32, ksize: i32, scale: f64, delta: f64, border_type: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_accumulateProduct_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_accumulateProduct_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__InputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, mask: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_accumulateSquare_const__InputArrayR_const__InputOutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_accumulateSquare_const__InputArrayR_const__InputOutputArrayR_const__InputArrayR(src: *const c_void, dst: *const c_void, mask: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_accumulateWeighted_const__InputArrayR_const__InputOutputArrayR_double(src: *const c_void, dst: *const c_void, alpha: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_accumulateWeighted_const__InputArrayR_const__InputOutputArrayR_double_const__InputArrayR(src: *const c_void, dst: *const c_void, alpha: f64, mask: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_accumulate_const__InputArrayR_const__InputOutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_accumulate_const__InputArrayR_const__InputOutputArrayR_const__InputArrayR(src: *const c_void, dst: *const c_void, mask: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_adaptiveThreshold_const__InputArrayR_const__OutputArrayR_double_int_int_int_double(src: *const c_void, dst: *const c_void, max_value: f64, adaptive_method: i32, threshold_type: i32, block_size: i32, c: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_applyColorMap_const__InputArrayR_const__OutputArrayR_const__InputArrayR(src: *const c_void, dst: *const c_void, user_color: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_applyColorMap_const__InputArrayR_const__OutputArrayR_int(src: *const c_void, dst: *const c_void, colormap: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_approxPolyDP_const__InputArrayR_const__OutputArrayR_double_bool(curve: *const c_void, approx_curve: *const c_void, epsilon: f64, closed: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_approxPolyN_const__InputArrayR_const__OutputArrayR_int(curve: *const c_void, approx_curve: *const c_void, nsides: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_approxPolyN_const__InputArrayR_const__OutputArrayR_int_float_bool(curve: *const c_void, approx_curve: *const c_void, nsides: i32, epsilon_percentage: f32, ensure_convex: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_GaussianBlur_const__InputArrayR_const__OutputArrayR_Size_double(src: *const c_void, dst: *const c_void, ksize: *const core::Size, sigma_x: f64, ocvrs_return: *mut Result<()>); + pub fn cv_GaussianBlur_const__InputArrayR_const__OutputArrayR_Size_double_double_int_AlgorithmHint(src: *const c_void, dst: *const c_void, ksize: *const core::Size, sigma_x: f64, sigma_y: f64, border_type: i32, hint: core::AlgorithmHint, ocvrs_return: *mut Result<()>); + pub fn cv_HoughCircles_const__InputArrayR_const__OutputArrayR_int_double_double(image: *const c_void, circles: *const c_void, method: i32, dp: f64, min_dist: f64, ocvrs_return: *mut Result<()>); + pub fn cv_HoughCircles_const__InputArrayR_const__OutputArrayR_int_double_double_double_double_int_int(image: *const c_void, circles: *const c_void, method: i32, dp: f64, min_dist: f64, param1: f64, param2: f64, min_radius: i32, max_radius: i32, ocvrs_return: *mut Result<()>); + pub fn cv_HoughLinesP_const__InputArrayR_const__OutputArrayR_double_double_int(image: *const c_void, lines: *const c_void, rho: f64, theta: f64, threshold: i32, ocvrs_return: *mut Result<()>); + pub fn cv_HoughLinesP_const__InputArrayR_const__OutputArrayR_double_double_int_double_double(image: *const c_void, lines: *const c_void, rho: f64, theta: f64, threshold: i32, min_line_length: f64, max_line_gap: f64, ocvrs_return: *mut Result<()>); + pub fn cv_HoughLinesPointSet_const__InputArrayR_const__OutputArrayR_int_int_double_double_double_double_double_double(point: *const c_void, lines: *const c_void, lines_max: i32, threshold: i32, min_rho: f64, max_rho: f64, rho_step: f64, min_theta: f64, max_theta: f64, theta_step: f64, ocvrs_return: *mut Result<()>); + pub fn cv_HoughLines_const__InputArrayR_const__OutputArrayR_double_double_int(image: *const c_void, lines: *const c_void, rho: f64, theta: f64, threshold: i32, ocvrs_return: *mut Result<()>); + pub fn cv_HoughLines_const__InputArrayR_const__OutputArrayR_double_double_int_double_double_double_double_bool(image: *const c_void, lines: *const c_void, rho: f64, theta: f64, threshold: i32, srn: f64, stn: f64, min_theta: f64, max_theta: f64, use_edgeval: bool, ocvrs_return: *mut Result<()>); + pub fn cv_HuMoments_const_MomentsR_const__OutputArrayR(m: *const core::Moments, hu: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_HuMoments_const_MomentsR_doubleXX(moments: *const core::Moments, hu: *mut [f64; 7], ocvrs_return: *mut Result<()>); + pub fn cv_Laplacian_const__InputArrayR_const__OutputArrayR_int(src: *const c_void, dst: *const c_void, ddepth: i32, ocvrs_return: *mut Result<()>); + pub fn cv_Laplacian_const__InputArrayR_const__OutputArrayR_int_int_double_double_int(src: *const c_void, dst: *const c_void, ddepth: i32, ksize: i32, scale: f64, delta: f64, border_type: i32, ocvrs_return: *mut Result<()>); + pub fn cv_Scharr_const__InputArrayR_const__OutputArrayR_int_int_int(src: *const c_void, dst: *const c_void, ddepth: i32, dx: i32, dy: i32, ocvrs_return: *mut Result<()>); + pub fn cv_Scharr_const__InputArrayR_const__OutputArrayR_int_int_int_double_double_int(src: *const c_void, dst: *const c_void, ddepth: i32, dx: i32, dy: i32, scale: f64, delta: f64, border_type: i32, ocvrs_return: *mut Result<()>); + pub fn cv_Sobel_const__InputArrayR_const__OutputArrayR_int_int_int(src: *const c_void, dst: *const c_void, ddepth: i32, dx: i32, dy: i32, ocvrs_return: *mut Result<()>); + pub fn cv_Sobel_const__InputArrayR_const__OutputArrayR_int_int_int_int_double_double_int(src: *const c_void, dst: *const c_void, ddepth: i32, dx: i32, dy: i32, ksize: i32, scale: f64, delta: f64, border_type: i32, ocvrs_return: *mut Result<()>); + pub fn cv_accumulateProduct_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_accumulateProduct_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__InputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, mask: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_accumulateSquare_const__InputArrayR_const__InputOutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_accumulateSquare_const__InputArrayR_const__InputOutputArrayR_const__InputArrayR(src: *const c_void, dst: *const c_void, mask: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_accumulateWeighted_const__InputArrayR_const__InputOutputArrayR_double(src: *const c_void, dst: *const c_void, alpha: f64, ocvrs_return: *mut Result<()>); + pub fn cv_accumulateWeighted_const__InputArrayR_const__InputOutputArrayR_double_const__InputArrayR(src: *const c_void, dst: *const c_void, alpha: f64, mask: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_accumulate_const__InputArrayR_const__InputOutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_accumulate_const__InputArrayR_const__InputOutputArrayR_const__InputArrayR(src: *const c_void, dst: *const c_void, mask: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_adaptiveThreshold_const__InputArrayR_const__OutputArrayR_double_int_int_int_double(src: *const c_void, dst: *const c_void, max_value: f64, adaptive_method: i32, threshold_type: i32, block_size: i32, c: f64, ocvrs_return: *mut Result<()>); + pub fn cv_applyColorMap_const__InputArrayR_const__OutputArrayR_const__InputArrayR(src: *const c_void, dst: *const c_void, user_color: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_applyColorMap_const__InputArrayR_const__OutputArrayR_int(src: *const c_void, dst: *const c_void, colormap: i32, ocvrs_return: *mut Result<()>); + pub fn cv_approxPolyDP_const__InputArrayR_const__OutputArrayR_double_bool(curve: *const c_void, approx_curve: *const c_void, epsilon: f64, closed: bool, ocvrs_return: *mut Result<()>); + pub fn cv_approxPolyN_const__InputArrayR_const__OutputArrayR_int(curve: *const c_void, approx_curve: *const c_void, nsides: i32, ocvrs_return: *mut Result<()>); + pub fn cv_approxPolyN_const__InputArrayR_const__OutputArrayR_int_float_bool(curve: *const c_void, approx_curve: *const c_void, nsides: i32, epsilon_percentage: f32, ensure_convex: bool, ocvrs_return: *mut Result<()>); pub fn cv_arcLength_const__InputArrayR_bool(curve: *const c_void, closed: bool, ocvrs_return: *mut Result); - pub fn cv_arrowedLine_const__InputOutputArrayR_Point_Point_const_ScalarR(img: *const c_void, pt1: *const core::Point, pt2: *const core::Point, color: *const core::Scalar, ocvrs_return: *mut ResultVoid); - pub fn cv_arrowedLine_const__InputOutputArrayR_Point_Point_const_ScalarR_int_int_int_double(img: *const c_void, pt1: *const core::Point, pt2: *const core::Point, color: *const core::Scalar, thickness: i32, line_type: i32, shift: i32, tip_length: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_bilateralFilter_const__InputArrayR_const__OutputArrayR_int_double_double(src: *const c_void, dst: *const c_void, d: i32, sigma_color: f64, sigma_space: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_bilateralFilter_const__InputArrayR_const__OutputArrayR_int_double_double_int(src: *const c_void, dst: *const c_void, d: i32, sigma_color: f64, sigma_space: f64, border_type: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_blendLinear_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src1: *const c_void, src2: *const c_void, weights1: *const c_void, weights2: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_blur_const__InputArrayR_const__OutputArrayR_Size(src: *const c_void, dst: *const c_void, ksize: *const core::Size, ocvrs_return: *mut ResultVoid); - pub fn cv_blur_const__InputArrayR_const__OutputArrayR_Size_Point_int(src: *const c_void, dst: *const c_void, ksize: *const core::Size, anchor: *const core::Point, border_type: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_arrowedLine_const__InputOutputArrayR_Point_Point_const_ScalarR(img: *const c_void, pt1: *const core::Point, pt2: *const core::Point, color: *const core::Scalar, ocvrs_return: *mut Result<()>); + pub fn cv_arrowedLine_const__InputOutputArrayR_Point_Point_const_ScalarR_int_int_int_double(img: *const c_void, pt1: *const core::Point, pt2: *const core::Point, color: *const core::Scalar, thickness: i32, line_type: i32, shift: i32, tip_length: f64, ocvrs_return: *mut Result<()>); + pub fn cv_bilateralFilter_const__InputArrayR_const__OutputArrayR_int_double_double(src: *const c_void, dst: *const c_void, d: i32, sigma_color: f64, sigma_space: f64, ocvrs_return: *mut Result<()>); + pub fn cv_bilateralFilter_const__InputArrayR_const__OutputArrayR_int_double_double_int(src: *const c_void, dst: *const c_void, d: i32, sigma_color: f64, sigma_space: f64, border_type: i32, ocvrs_return: *mut Result<()>); + pub fn cv_blendLinear_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src1: *const c_void, src2: *const c_void, weights1: *const c_void, weights2: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_blur_const__InputArrayR_const__OutputArrayR_Size(src: *const c_void, dst: *const c_void, ksize: *const core::Size, ocvrs_return: *mut Result<()>); + pub fn cv_blur_const__InputArrayR_const__OutputArrayR_Size_Point_int(src: *const c_void, dst: *const c_void, ksize: *const core::Size, anchor: *const core::Point, border_type: i32, ocvrs_return: *mut Result<()>); pub fn cv_boundingRect_const__InputArrayR(array: *const c_void, ocvrs_return: *mut Result); - pub fn cv_boxFilter_const__InputArrayR_const__OutputArrayR_int_Size(src: *const c_void, dst: *const c_void, ddepth: i32, ksize: *const core::Size, ocvrs_return: *mut ResultVoid); - pub fn cv_boxFilter_const__InputArrayR_const__OutputArrayR_int_Size_Point_bool_int(src: *const c_void, dst: *const c_void, ddepth: i32, ksize: *const core::Size, anchor: *const core::Point, normalize: bool, border_type: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_boxPoints_RotatedRect_const__OutputArrayR(box_: *const core::RotatedRect, points: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_buildPyramid_const__InputArrayR_const__OutputArrayR_int(src: *const c_void, dst: *const c_void, maxlevel: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_buildPyramid_const__InputArrayR_const__OutputArrayR_int_int(src: *const c_void, dst: *const c_void, maxlevel: i32, border_type: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_calcBackProject_const__InputArrayR_const_vectorLintGR_const__InputArrayR_const__OutputArrayR_const_vectorLfloatGR_double(images: *const c_void, channels: *const c_void, hist: *const c_void, dst: *const c_void, ranges: *const c_void, scale: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_calcHist_const__InputArrayR_const_vectorLintGR_const__InputArrayR_const__OutputArrayR_const_vectorLintGR_const_vectorLfloatGR(images: *const c_void, channels: *const c_void, mask: *const c_void, hist: *const c_void, hist_size: *const c_void, ranges: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_calcHist_const__InputArrayR_const_vectorLintGR_const__InputArrayR_const__OutputArrayR_const_vectorLintGR_const_vectorLfloatGR_bool(images: *const c_void, channels: *const c_void, mask: *const c_void, hist: *const c_void, hist_size: *const c_void, ranges: *const c_void, accumulate: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_circle_const__InputOutputArrayR_Point_int_const_ScalarR(img: *const c_void, center: *const core::Point, radius: i32, color: *const core::Scalar, ocvrs_return: *mut ResultVoid); - pub fn cv_circle_const__InputOutputArrayR_Point_int_const_ScalarR_int_int_int(img: *const c_void, center: *const core::Point, radius: i32, color: *const core::Scalar, thickness: i32, line_type: i32, shift: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_boxFilter_const__InputArrayR_const__OutputArrayR_int_Size(src: *const c_void, dst: *const c_void, ddepth: i32, ksize: *const core::Size, ocvrs_return: *mut Result<()>); + pub fn cv_boxFilter_const__InputArrayR_const__OutputArrayR_int_Size_Point_bool_int(src: *const c_void, dst: *const c_void, ddepth: i32, ksize: *const core::Size, anchor: *const core::Point, normalize: bool, border_type: i32, ocvrs_return: *mut Result<()>); + pub fn cv_boxPoints_RotatedRect_const__OutputArrayR(box_: *const core::RotatedRect, points: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_buildPyramid_const__InputArrayR_const__OutputArrayR_int(src: *const c_void, dst: *const c_void, maxlevel: i32, ocvrs_return: *mut Result<()>); + pub fn cv_buildPyramid_const__InputArrayR_const__OutputArrayR_int_int(src: *const c_void, dst: *const c_void, maxlevel: i32, border_type: i32, ocvrs_return: *mut Result<()>); + pub fn cv_calcBackProject_const__InputArrayR_const_vectorLintGR_const__InputArrayR_const__OutputArrayR_const_vectorLfloatGR_double(images: *const c_void, channels: *const c_void, hist: *const c_void, dst: *const c_void, ranges: *const c_void, scale: f64, ocvrs_return: *mut Result<()>); + pub fn cv_calcHist_const__InputArrayR_const_vectorLintGR_const__InputArrayR_const__OutputArrayR_const_vectorLintGR_const_vectorLfloatGR(images: *const c_void, channels: *const c_void, mask: *const c_void, hist: *const c_void, hist_size: *const c_void, ranges: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_calcHist_const__InputArrayR_const_vectorLintGR_const__InputArrayR_const__OutputArrayR_const_vectorLintGR_const_vectorLfloatGR_bool(images: *const c_void, channels: *const c_void, mask: *const c_void, hist: *const c_void, hist_size: *const c_void, ranges: *const c_void, accumulate: bool, ocvrs_return: *mut Result<()>); + pub fn cv_circle_const__InputOutputArrayR_Point_int_const_ScalarR(img: *const c_void, center: *const core::Point, radius: i32, color: *const core::Scalar, ocvrs_return: *mut Result<()>); + pub fn cv_circle_const__InputOutputArrayR_Point_int_const_ScalarR_int_int_int(img: *const c_void, center: *const core::Point, radius: i32, color: *const core::Scalar, thickness: i32, line_type: i32, shift: i32, ocvrs_return: *mut Result<()>); pub fn cv_clipLine_Rect_PointR_PointR(img_rect: *const core::Rect, pt1: *mut core::Point, pt2: *mut core::Point, ocvrs_return: *mut Result); pub fn cv_clipLine_Size2l_Point2lR_Point2lR(img_size: *const core::Size2l, pt1: *mut core::Point2l, pt2: *mut core::Point2l, ocvrs_return: *mut Result); pub fn cv_clipLine_Size_PointR_PointR(img_size: *const core::Size, pt1: *mut core::Point, pt2: *mut core::Point, ocvrs_return: *mut Result); @@ -9947,76 +9996,76 @@ mod imgproc_sys { pub fn cv_connectedComponents_const__InputArrayR_const__OutputArrayR_int_int_int(image: *const c_void, labels: *const c_void, connectivity: i32, ltype: i32, ccltype: i32, ocvrs_return: *mut Result); pub fn cv_contourArea_const__InputArrayR(contour: *const c_void, ocvrs_return: *mut Result); pub fn cv_contourArea_const__InputArrayR_bool(contour: *const c_void, oriented: bool, ocvrs_return: *mut Result); - pub fn cv_convertMaps_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_int(map1: *const c_void, map2: *const c_void, dstmap1: *const c_void, dstmap2: *const c_void, dstmap1type: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_convertMaps_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_int_bool(map1: *const c_void, map2: *const c_void, dstmap1: *const c_void, dstmap2: *const c_void, dstmap1type: i32, nninterpolation: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_convexHull_const__InputArrayR_const__OutputArrayR(points: *const c_void, hull: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_convexHull_const__InputArrayR_const__OutputArrayR_bool_bool(points: *const c_void, hull: *const c_void, clockwise: bool, return_points: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_convexityDefects_const__InputArrayR_const__InputArrayR_const__OutputArrayR(contour: *const c_void, convexhull: *const c_void, convexity_defects: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cornerEigenValsAndVecs_const__InputArrayR_const__OutputArrayR_int_int(src: *const c_void, dst: *const c_void, block_size: i32, ksize: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_cornerEigenValsAndVecs_const__InputArrayR_const__OutputArrayR_int_int_int(src: *const c_void, dst: *const c_void, block_size: i32, ksize: i32, border_type: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_cornerHarris_const__InputArrayR_const__OutputArrayR_int_int_double(src: *const c_void, dst: *const c_void, block_size: i32, ksize: i32, k: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_cornerHarris_const__InputArrayR_const__OutputArrayR_int_int_double_int(src: *const c_void, dst: *const c_void, block_size: i32, ksize: i32, k: f64, border_type: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_cornerMinEigenVal_const__InputArrayR_const__OutputArrayR_int(src: *const c_void, dst: *const c_void, block_size: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_cornerMinEigenVal_const__InputArrayR_const__OutputArrayR_int_int_int(src: *const c_void, dst: *const c_void, block_size: i32, ksize: i32, border_type: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_cornerSubPix_const__InputArrayR_const__InputOutputArrayR_Size_Size_TermCriteria(image: *const c_void, corners: *const c_void, win_size: *const core::Size, zero_zone: *const core::Size, criteria: *const core::TermCriteria, ocvrs_return: *mut ResultVoid); + pub fn cv_convertMaps_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_int(map1: *const c_void, map2: *const c_void, dstmap1: *const c_void, dstmap2: *const c_void, dstmap1type: i32, ocvrs_return: *mut Result<()>); + pub fn cv_convertMaps_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_int_bool(map1: *const c_void, map2: *const c_void, dstmap1: *const c_void, dstmap2: *const c_void, dstmap1type: i32, nninterpolation: bool, ocvrs_return: *mut Result<()>); + pub fn cv_convexHull_const__InputArrayR_const__OutputArrayR(points: *const c_void, hull: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_convexHull_const__InputArrayR_const__OutputArrayR_bool_bool(points: *const c_void, hull: *const c_void, clockwise: bool, return_points: bool, ocvrs_return: *mut Result<()>); + pub fn cv_convexityDefects_const__InputArrayR_const__InputArrayR_const__OutputArrayR(contour: *const c_void, convexhull: *const c_void, convexity_defects: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cornerEigenValsAndVecs_const__InputArrayR_const__OutputArrayR_int_int(src: *const c_void, dst: *const c_void, block_size: i32, ksize: i32, ocvrs_return: *mut Result<()>); + pub fn cv_cornerEigenValsAndVecs_const__InputArrayR_const__OutputArrayR_int_int_int(src: *const c_void, dst: *const c_void, block_size: i32, ksize: i32, border_type: i32, ocvrs_return: *mut Result<()>); + pub fn cv_cornerHarris_const__InputArrayR_const__OutputArrayR_int_int_double(src: *const c_void, dst: *const c_void, block_size: i32, ksize: i32, k: f64, ocvrs_return: *mut Result<()>); + pub fn cv_cornerHarris_const__InputArrayR_const__OutputArrayR_int_int_double_int(src: *const c_void, dst: *const c_void, block_size: i32, ksize: i32, k: f64, border_type: i32, ocvrs_return: *mut Result<()>); + pub fn cv_cornerMinEigenVal_const__InputArrayR_const__OutputArrayR_int(src: *const c_void, dst: *const c_void, block_size: i32, ocvrs_return: *mut Result<()>); + pub fn cv_cornerMinEigenVal_const__InputArrayR_const__OutputArrayR_int_int_int(src: *const c_void, dst: *const c_void, block_size: i32, ksize: i32, border_type: i32, ocvrs_return: *mut Result<()>); + pub fn cv_cornerSubPix_const__InputArrayR_const__InputOutputArrayR_Size_Size_TermCriteria(image: *const c_void, corners: *const c_void, win_size: *const core::Size, zero_zone: *const core::Size, criteria: *const core::TermCriteria, ocvrs_return: *mut Result<()>); pub fn cv_createCLAHE(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_createCLAHE_double_Size(clip_limit: f64, tile_grid_size: *const core::Size, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_createGeneralizedHoughBallard(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_createGeneralizedHoughGuil(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_createHanningWindow_const__OutputArrayR_Size_int(dst: *const c_void, win_size: *const core::Size, typ: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_createHanningWindow_const__OutputArrayR_Size_int(dst: *const c_void, win_size: *const core::Size, typ: i32, ocvrs_return: *mut Result<()>); pub fn cv_createLineSegmentDetector(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_createLineSegmentDetector_int_double_double_double_double_double_double_int(refine: i32, scale: f64, sigma_scale: f64, quant: f64, ang_th: f64, log_eps: f64, density_th: f64, n_bins: i32, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_cvtColorTwoPlane_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int(src1: *const c_void, src2: *const c_void, dst: *const c_void, code: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_cvtColorTwoPlane_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int_AlgorithmHint(src1: *const c_void, src2: *const c_void, dst: *const c_void, code: i32, hint: core::AlgorithmHint, ocvrs_return: *mut ResultVoid); - pub fn cv_cvtColor_const__InputArrayR_const__OutputArrayR_int(src: *const c_void, dst: *const c_void, code: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_cvtColor_const__InputArrayR_const__OutputArrayR_int_int_AlgorithmHint(src: *const c_void, dst: *const c_void, code: i32, dst_cn: i32, hint: core::AlgorithmHint, ocvrs_return: *mut ResultVoid); - pub fn cv_demosaicing_const__InputArrayR_const__OutputArrayR_int(src: *const c_void, dst: *const c_void, code: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_demosaicing_const__InputArrayR_const__OutputArrayR_int_int(src: *const c_void, dst: *const c_void, code: i32, dst_cn: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_dilate_const__InputArrayR_const__OutputArrayR_const__InputArrayR(src: *const c_void, dst: *const c_void, kernel: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_dilate_const__InputArrayR_const__OutputArrayR_const__InputArrayR_Point_int_int_const_ScalarR(src: *const c_void, dst: *const c_void, kernel: *const c_void, anchor: *const core::Point, iterations: i32, border_type: i32, border_value: *const core::Scalar, ocvrs_return: *mut ResultVoid); - pub fn cv_distanceTransform_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_int_int(src: *const c_void, dst: *const c_void, labels: *const c_void, distance_type: i32, mask_size: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_distanceTransform_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_int_int_int(src: *const c_void, dst: *const c_void, labels: *const c_void, distance_type: i32, mask_size: i32, label_type: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_distanceTransform_const__InputArrayR_const__OutputArrayR_int_int(src: *const c_void, dst: *const c_void, distance_type: i32, mask_size: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_distanceTransform_const__InputArrayR_const__OutputArrayR_int_int_int(src: *const c_void, dst: *const c_void, distance_type: i32, mask_size: i32, dst_type: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_divSpectrums_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int(a: *const c_void, b: *const c_void, c: *const c_void, flags: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_divSpectrums_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int_bool(a: *const c_void, b: *const c_void, c: *const c_void, flags: i32, conj_b: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_drawContours_const__InputOutputArrayR_const__InputArrayR_int_const_ScalarR(image: *const c_void, contours: *const c_void, contour_idx: i32, color: *const core::Scalar, ocvrs_return: *mut ResultVoid); - pub fn cv_drawContours_const__InputOutputArrayR_const__InputArrayR_int_const_ScalarR_int_int_const__InputArrayR_int_Point(image: *const c_void, contours: *const c_void, contour_idx: i32, color: *const core::Scalar, thickness: i32, line_type: i32, hierarchy: *const c_void, max_level: i32, offset: *const core::Point, ocvrs_return: *mut ResultVoid); - pub fn cv_drawMarker_const__InputOutputArrayR_Point_const_ScalarR(img: *const c_void, position: *const core::Point, color: *const core::Scalar, ocvrs_return: *mut ResultVoid); - pub fn cv_drawMarker_const__InputOutputArrayR_Point_const_ScalarR_int_int_int_int(img: *const c_void, position: *const core::Point, color: *const core::Scalar, marker_type: i32, marker_size: i32, thickness: i32, line_type: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_ellipse2Poly_Point2d_Size2d_int_int_int_int_vectorLPoint2dGR(center: *const core::Point2d, axes: *const core::Size2d, angle: i32, arc_start: i32, arc_end: i32, delta: i32, pts: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ellipse2Poly_Point_Size_int_int_int_int_vectorLPointGR(center: *const core::Point, axes: *const core::Size, angle: i32, arc_start: i32, arc_end: i32, delta: i32, pts: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ellipse_const__InputOutputArrayR_Point_Size_double_double_double_const_ScalarR(img: *const c_void, center: *const core::Point, axes: *const core::Size, angle: f64, start_angle: f64, end_angle: f64, color: *const core::Scalar, ocvrs_return: *mut ResultVoid); - pub fn cv_ellipse_const__InputOutputArrayR_Point_Size_double_double_double_const_ScalarR_int_int_int(img: *const c_void, center: *const core::Point, axes: *const core::Size, angle: f64, start_angle: f64, end_angle: f64, color: *const core::Scalar, thickness: i32, line_type: i32, shift: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_ellipse_const__InputOutputArrayR_const_RotatedRectR_const_ScalarR(img: *const c_void, box_: *const core::RotatedRect, color: *const core::Scalar, ocvrs_return: *mut ResultVoid); - pub fn cv_ellipse_const__InputOutputArrayR_const_RotatedRectR_const_ScalarR_int_int(img: *const c_void, box_: *const core::RotatedRect, color: *const core::Scalar, thickness: i32, line_type: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_equalizeHist_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_erode_const__InputArrayR_const__OutputArrayR_const__InputArrayR(src: *const c_void, dst: *const c_void, kernel: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_erode_const__InputArrayR_const__OutputArrayR_const__InputArrayR_Point_int_int_const_ScalarR(src: *const c_void, dst: *const c_void, kernel: *const c_void, anchor: *const core::Point, iterations: i32, border_type: i32, border_value: *const core::Scalar, ocvrs_return: *mut ResultVoid); - pub fn cv_fillConvexPoly_const__InputOutputArrayR_const__InputArrayR_const_ScalarR(img: *const c_void, points: *const c_void, color: *const core::Scalar, ocvrs_return: *mut ResultVoid); - pub fn cv_fillConvexPoly_const__InputOutputArrayR_const__InputArrayR_const_ScalarR_int_int(img: *const c_void, points: *const c_void, color: *const core::Scalar, line_type: i32, shift: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_fillPoly_const__InputOutputArrayR_const__InputArrayR_const_ScalarR(img: *const c_void, pts: *const c_void, color: *const core::Scalar, ocvrs_return: *mut ResultVoid); - pub fn cv_fillPoly_const__InputOutputArrayR_const__InputArrayR_const_ScalarR_int_int_Point(img: *const c_void, pts: *const c_void, color: *const core::Scalar, line_type: i32, shift: i32, offset: *const core::Point, ocvrs_return: *mut ResultVoid); - pub fn cv_filter2D_const__InputArrayR_const__OutputArrayR_int_const__InputArrayR(src: *const c_void, dst: *const c_void, ddepth: i32, kernel: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_filter2D_const__InputArrayR_const__OutputArrayR_int_const__InputArrayR_Point_double_int(src: *const c_void, dst: *const c_void, ddepth: i32, kernel: *const c_void, anchor: *const core::Point, delta: f64, border_type: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_findContoursLinkRuns_const__InputArrayR_const__OutputArrayR(image: *const c_void, contours: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_findContoursLinkRuns_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(image: *const c_void, contours: *const c_void, hierarchy: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_findContours_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_int_int(image: *const c_void, contours: *const c_void, hierarchy: *const c_void, mode: i32, method: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_findContours_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_int_int_Point(image: *const c_void, contours: *const c_void, hierarchy: *const c_void, mode: i32, method: i32, offset: *const core::Point, ocvrs_return: *mut ResultVoid); - pub fn cv_findContours_const__InputArrayR_const__OutputArrayR_int_int(image: *const c_void, contours: *const c_void, mode: i32, method: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_findContours_const__InputArrayR_const__OutputArrayR_int_int_Point(image: *const c_void, contours: *const c_void, mode: i32, method: i32, offset: *const core::Point, ocvrs_return: *mut ResultVoid); + pub fn cv_cvtColorTwoPlane_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int(src1: *const c_void, src2: *const c_void, dst: *const c_void, code: i32, ocvrs_return: *mut Result<()>); + pub fn cv_cvtColorTwoPlane_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int_AlgorithmHint(src1: *const c_void, src2: *const c_void, dst: *const c_void, code: i32, hint: core::AlgorithmHint, ocvrs_return: *mut Result<()>); + pub fn cv_cvtColor_const__InputArrayR_const__OutputArrayR_int(src: *const c_void, dst: *const c_void, code: i32, ocvrs_return: *mut Result<()>); + pub fn cv_cvtColor_const__InputArrayR_const__OutputArrayR_int_int_AlgorithmHint(src: *const c_void, dst: *const c_void, code: i32, dst_cn: i32, hint: core::AlgorithmHint, ocvrs_return: *mut Result<()>); + pub fn cv_demosaicing_const__InputArrayR_const__OutputArrayR_int(src: *const c_void, dst: *const c_void, code: i32, ocvrs_return: *mut Result<()>); + pub fn cv_demosaicing_const__InputArrayR_const__OutputArrayR_int_int(src: *const c_void, dst: *const c_void, code: i32, dst_cn: i32, ocvrs_return: *mut Result<()>); + pub fn cv_dilate_const__InputArrayR_const__OutputArrayR_const__InputArrayR(src: *const c_void, dst: *const c_void, kernel: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_dilate_const__InputArrayR_const__OutputArrayR_const__InputArrayR_Point_int_int_const_ScalarR(src: *const c_void, dst: *const c_void, kernel: *const c_void, anchor: *const core::Point, iterations: i32, border_type: i32, border_value: *const core::Scalar, ocvrs_return: *mut Result<()>); + pub fn cv_distanceTransform_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_int_int(src: *const c_void, dst: *const c_void, labels: *const c_void, distance_type: i32, mask_size: i32, ocvrs_return: *mut Result<()>); + pub fn cv_distanceTransform_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_int_int_int(src: *const c_void, dst: *const c_void, labels: *const c_void, distance_type: i32, mask_size: i32, label_type: i32, ocvrs_return: *mut Result<()>); + pub fn cv_distanceTransform_const__InputArrayR_const__OutputArrayR_int_int(src: *const c_void, dst: *const c_void, distance_type: i32, mask_size: i32, ocvrs_return: *mut Result<()>); + pub fn cv_distanceTransform_const__InputArrayR_const__OutputArrayR_int_int_int(src: *const c_void, dst: *const c_void, distance_type: i32, mask_size: i32, dst_type: i32, ocvrs_return: *mut Result<()>); + pub fn cv_divSpectrums_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int(a: *const c_void, b: *const c_void, c: *const c_void, flags: i32, ocvrs_return: *mut Result<()>); + pub fn cv_divSpectrums_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int_bool(a: *const c_void, b: *const c_void, c: *const c_void, flags: i32, conj_b: bool, ocvrs_return: *mut Result<()>); + pub fn cv_drawContours_const__InputOutputArrayR_const__InputArrayR_int_const_ScalarR(image: *const c_void, contours: *const c_void, contour_idx: i32, color: *const core::Scalar, ocvrs_return: *mut Result<()>); + pub fn cv_drawContours_const__InputOutputArrayR_const__InputArrayR_int_const_ScalarR_int_int_const__InputArrayR_int_Point(image: *const c_void, contours: *const c_void, contour_idx: i32, color: *const core::Scalar, thickness: i32, line_type: i32, hierarchy: *const c_void, max_level: i32, offset: *const core::Point, ocvrs_return: *mut Result<()>); + pub fn cv_drawMarker_const__InputOutputArrayR_Point_const_ScalarR(img: *const c_void, position: *const core::Point, color: *const core::Scalar, ocvrs_return: *mut Result<()>); + pub fn cv_drawMarker_const__InputOutputArrayR_Point_const_ScalarR_int_int_int_int(img: *const c_void, position: *const core::Point, color: *const core::Scalar, marker_type: i32, marker_size: i32, thickness: i32, line_type: i32, ocvrs_return: *mut Result<()>); + pub fn cv_ellipse2Poly_Point2d_Size2d_int_int_int_int_vectorLPoint2dGR(center: *const core::Point2d, axes: *const core::Size2d, angle: i32, arc_start: i32, arc_end: i32, delta: i32, pts: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ellipse2Poly_Point_Size_int_int_int_int_vectorLPointGR(center: *const core::Point, axes: *const core::Size, angle: i32, arc_start: i32, arc_end: i32, delta: i32, pts: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ellipse_const__InputOutputArrayR_Point_Size_double_double_double_const_ScalarR(img: *const c_void, center: *const core::Point, axes: *const core::Size, angle: f64, start_angle: f64, end_angle: f64, color: *const core::Scalar, ocvrs_return: *mut Result<()>); + pub fn cv_ellipse_const__InputOutputArrayR_Point_Size_double_double_double_const_ScalarR_int_int_int(img: *const c_void, center: *const core::Point, axes: *const core::Size, angle: f64, start_angle: f64, end_angle: f64, color: *const core::Scalar, thickness: i32, line_type: i32, shift: i32, ocvrs_return: *mut Result<()>); + pub fn cv_ellipse_const__InputOutputArrayR_const_RotatedRectR_const_ScalarR(img: *const c_void, box_: *const core::RotatedRect, color: *const core::Scalar, ocvrs_return: *mut Result<()>); + pub fn cv_ellipse_const__InputOutputArrayR_const_RotatedRectR_const_ScalarR_int_int(img: *const c_void, box_: *const core::RotatedRect, color: *const core::Scalar, thickness: i32, line_type: i32, ocvrs_return: *mut Result<()>); + pub fn cv_equalizeHist_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_erode_const__InputArrayR_const__OutputArrayR_const__InputArrayR(src: *const c_void, dst: *const c_void, kernel: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_erode_const__InputArrayR_const__OutputArrayR_const__InputArrayR_Point_int_int_const_ScalarR(src: *const c_void, dst: *const c_void, kernel: *const c_void, anchor: *const core::Point, iterations: i32, border_type: i32, border_value: *const core::Scalar, ocvrs_return: *mut Result<()>); + pub fn cv_fillConvexPoly_const__InputOutputArrayR_const__InputArrayR_const_ScalarR(img: *const c_void, points: *const c_void, color: *const core::Scalar, ocvrs_return: *mut Result<()>); + pub fn cv_fillConvexPoly_const__InputOutputArrayR_const__InputArrayR_const_ScalarR_int_int(img: *const c_void, points: *const c_void, color: *const core::Scalar, line_type: i32, shift: i32, ocvrs_return: *mut Result<()>); + pub fn cv_fillPoly_const__InputOutputArrayR_const__InputArrayR_const_ScalarR(img: *const c_void, pts: *const c_void, color: *const core::Scalar, ocvrs_return: *mut Result<()>); + pub fn cv_fillPoly_const__InputOutputArrayR_const__InputArrayR_const_ScalarR_int_int_Point(img: *const c_void, pts: *const c_void, color: *const core::Scalar, line_type: i32, shift: i32, offset: *const core::Point, ocvrs_return: *mut Result<()>); + pub fn cv_filter2D_const__InputArrayR_const__OutputArrayR_int_const__InputArrayR(src: *const c_void, dst: *const c_void, ddepth: i32, kernel: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_filter2D_const__InputArrayR_const__OutputArrayR_int_const__InputArrayR_Point_double_int(src: *const c_void, dst: *const c_void, ddepth: i32, kernel: *const c_void, anchor: *const core::Point, delta: f64, border_type: i32, ocvrs_return: *mut Result<()>); + pub fn cv_findContoursLinkRuns_const__InputArrayR_const__OutputArrayR(image: *const c_void, contours: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_findContoursLinkRuns_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(image: *const c_void, contours: *const c_void, hierarchy: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_findContours_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_int_int(image: *const c_void, contours: *const c_void, hierarchy: *const c_void, mode: i32, method: i32, ocvrs_return: *mut Result<()>); + pub fn cv_findContours_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_int_int_Point(image: *const c_void, contours: *const c_void, hierarchy: *const c_void, mode: i32, method: i32, offset: *const core::Point, ocvrs_return: *mut Result<()>); + pub fn cv_findContours_const__InputArrayR_const__OutputArrayR_int_int(image: *const c_void, contours: *const c_void, mode: i32, method: i32, ocvrs_return: *mut Result<()>); + pub fn cv_findContours_const__InputArrayR_const__OutputArrayR_int_int_Point(image: *const c_void, contours: *const c_void, mode: i32, method: i32, offset: *const core::Point, ocvrs_return: *mut Result<()>); pub fn cv_fitEllipseAMS_const__InputArrayR(points: *const c_void, ocvrs_return: *mut Result); pub fn cv_fitEllipseDirect_const__InputArrayR(points: *const c_void, ocvrs_return: *mut Result); pub fn cv_fitEllipse_const__InputArrayR(points: *const c_void, ocvrs_return: *mut Result); - pub fn cv_fitLine_const__InputArrayR_const__OutputArrayR_int_double_double_double(points: *const c_void, line: *const c_void, dist_type: i32, param: f64, reps: f64, aeps: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_fitLine_const__InputArrayR_const__OutputArrayR_int_double_double_double(points: *const c_void, line: *const c_void, dist_type: i32, param: f64, reps: f64, aeps: f64, ocvrs_return: *mut Result<()>); pub fn cv_floodFill_const__InputOutputArrayR_Point_Scalar(image: *const c_void, seed_point: *const core::Point, new_val: *const core::Scalar, ocvrs_return: *mut Result); pub fn cv_floodFill_const__InputOutputArrayR_Point_Scalar_RectX_Scalar_Scalar_int(image: *const c_void, seed_point: *const core::Point, new_val: *const core::Scalar, rect: *mut core::Rect, lo_diff: *const core::Scalar, up_diff: *const core::Scalar, flags: i32, ocvrs_return: *mut Result); pub fn cv_floodFill_const__InputOutputArrayR_const__InputOutputArrayR_Point_Scalar(image: *const c_void, mask: *const c_void, seed_point: *const core::Point, new_val: *const core::Scalar, ocvrs_return: *mut Result); pub fn cv_floodFill_const__InputOutputArrayR_const__InputOutputArrayR_Point_Scalar_RectX_Scalar_Scalar_int(image: *const c_void, mask: *const c_void, seed_point: *const core::Point, new_val: *const core::Scalar, rect: *mut core::Rect, lo_diff: *const core::Scalar, up_diff: *const core::Scalar, flags: i32, ocvrs_return: *mut Result); pub fn cv_getAffineTransform_const_Point2fXX_const_Point2fXX(src: *const [core::Point2f; 3], dst: *const [core::Point2f; 3], ocvrs_return: *mut Result<*mut c_void>); pub fn cv_getAffineTransform_const__InputArrayR_const__InputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_getDerivKernels_const__OutputArrayR_const__OutputArrayR_int_int_int(kx: *const c_void, ky: *const c_void, dx: i32, dy: i32, ksize: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_getDerivKernels_const__OutputArrayR_const__OutputArrayR_int_int_int_bool_int(kx: *const c_void, ky: *const c_void, dx: i32, dy: i32, ksize: i32, normalize: bool, ktype: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_getDerivKernels_const__OutputArrayR_const__OutputArrayR_int_int_int(kx: *const c_void, ky: *const c_void, dx: i32, dy: i32, ksize: i32, ocvrs_return: *mut Result<()>); + pub fn cv_getDerivKernels_const__OutputArrayR_const__OutputArrayR_int_int_int_bool_int(kx: *const c_void, ky: *const c_void, dx: i32, dy: i32, ksize: i32, normalize: bool, ktype: i32, ocvrs_return: *mut Result<()>); pub fn cv_getFontScaleFromHeight_const_int_const_int(font_face: i32, pixel_height: i32, ocvrs_return: *mut Result); pub fn cv_getFontScaleFromHeight_const_int_const_int_const_int(font_face: i32, pixel_height: i32, thickness: i32, ocvrs_return: *mut Result); pub fn cv_getGaborKernel_Size_double_double_double_double(ksize: *const core::Size, sigma: f64, theta: f64, lambd: f64, gamma: f64, ocvrs_return: *mut Result<*mut c_void>); @@ -10027,148 +10076,148 @@ mod imgproc_sys { pub fn cv_getPerspectiveTransform_const_Point2fXX_const_Point2fXX_int(src: *const [core::Point2f; 4], dst: *const [core::Point2f; 4], solve_method: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_getPerspectiveTransform_const__InputArrayR_const__InputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_getPerspectiveTransform_const__InputArrayR_const__InputArrayR_int(src: *const c_void, dst: *const c_void, solve_method: i32, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_getRectSubPix_const__InputArrayR_Size_Point2f_const__OutputArrayR(image: *const c_void, patch_size: *const core::Size, center: *const core::Point2f, patch: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_getRectSubPix_const__InputArrayR_Size_Point2f_const__OutputArrayR_int(image: *const c_void, patch_size: *const core::Size, center: *const core::Point2f, patch: *const c_void, patch_type: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_getRectSubPix_const__InputArrayR_Size_Point2f_const__OutputArrayR(image: *const c_void, patch_size: *const core::Size, center: *const core::Point2f, patch: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_getRectSubPix_const__InputArrayR_Size_Point2f_const__OutputArrayR_int(image: *const c_void, patch_size: *const core::Size, center: *const core::Point2f, patch: *const c_void, patch_type: i32, ocvrs_return: *mut Result<()>); pub fn cv_getRotationMatrix2D_Point2f_double_double(center: *const core::Point2f, angle: f64, scale: f64, ocvrs_return: *mut Result<*mut c_void>); #[cfg(not(target_os = "windows"))] pub fn cv_getRotationMatrix2D__Point2f_double_double(center: *const core::Point2f, angle: f64, scale: f64, ocvrs_return: *mut Result); pub fn cv_getStructuringElement_int_Size(shape: i32, ksize: *const core::Size, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_getStructuringElement_int_Size_Point(shape: i32, ksize: *const core::Size, anchor: *const core::Point, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_getTextSize_const_StringR_int_double_int_intX(text: *const c_char, font_face: i32, font_scale: f64, thickness: i32, base_line: *mut i32, ocvrs_return: *mut Result); - pub fn cv_goodFeaturesToTrack_const__InputArrayR_const__OutputArrayR_int_double_double(image: *const c_void, corners: *const c_void, max_corners: i32, quality_level: f64, min_distance: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_goodFeaturesToTrack_const__InputArrayR_const__OutputArrayR_int_double_double_const__InputArrayR_const__OutputArrayR(image: *const c_void, corners: *const c_void, max_corners: i32, quality_level: f64, min_distance: f64, mask: *const c_void, corners_quality: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_goodFeaturesToTrack_const__InputArrayR_const__OutputArrayR_int_double_double_const__InputArrayR_const__OutputArrayR_int_int_bool_double(image: *const c_void, corners: *const c_void, max_corners: i32, quality_level: f64, min_distance: f64, mask: *const c_void, corners_quality: *const c_void, block_size: i32, gradient_size: i32, use_harris_detector: bool, k: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_goodFeaturesToTrack_const__InputArrayR_const__OutputArrayR_int_double_double_const__InputArrayR_int_bool_double(image: *const c_void, corners: *const c_void, max_corners: i32, quality_level: f64, min_distance: f64, mask: *const c_void, block_size: i32, use_harris_detector: bool, k: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_goodFeaturesToTrack_const__InputArrayR_const__OutputArrayR_int_double_double_const__InputArrayR_int_int(image: *const c_void, corners: *const c_void, max_corners: i32, quality_level: f64, min_distance: f64, mask: *const c_void, block_size: i32, gradient_size: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_goodFeaturesToTrack_const__InputArrayR_const__OutputArrayR_int_double_double_const__InputArrayR_int_int_bool_double(image: *const c_void, corners: *const c_void, max_corners: i32, quality_level: f64, min_distance: f64, mask: *const c_void, block_size: i32, gradient_size: i32, use_harris_detector: bool, k: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_grabCut_const__InputArrayR_const__InputOutputArrayR_Rect_const__InputOutputArrayR_const__InputOutputArrayR_int(img: *const c_void, mask: *const c_void, rect: *const core::Rect, bgd_model: *const c_void, fgd_model: *const c_void, iter_count: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_grabCut_const__InputArrayR_const__InputOutputArrayR_Rect_const__InputOutputArrayR_const__InputOutputArrayR_int_int(img: *const c_void, mask: *const c_void, rect: *const core::Rect, bgd_model: *const c_void, fgd_model: *const c_void, iter_count: i32, mode: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_integral_const__InputArrayR_const__OutputArrayR(src: *const c_void, sum: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_integral_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(src: *const c_void, sum: *const c_void, sqsum: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_integral_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(src: *const c_void, sum: *const c_void, sqsum: *const c_void, tilted: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_integral_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_int_int(src: *const c_void, sum: *const c_void, sqsum: *const c_void, tilted: *const c_void, sdepth: i32, sqdepth: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_integral_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_int_int(src: *const c_void, sum: *const c_void, sqsum: *const c_void, sdepth: i32, sqdepth: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_integral_const__InputArrayR_const__OutputArrayR_int(src: *const c_void, sum: *const c_void, sdepth: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_goodFeaturesToTrack_const__InputArrayR_const__OutputArrayR_int_double_double(image: *const c_void, corners: *const c_void, max_corners: i32, quality_level: f64, min_distance: f64, ocvrs_return: *mut Result<()>); + pub fn cv_goodFeaturesToTrack_const__InputArrayR_const__OutputArrayR_int_double_double_const__InputArrayR_const__OutputArrayR(image: *const c_void, corners: *const c_void, max_corners: i32, quality_level: f64, min_distance: f64, mask: *const c_void, corners_quality: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_goodFeaturesToTrack_const__InputArrayR_const__OutputArrayR_int_double_double_const__InputArrayR_const__OutputArrayR_int_int_bool_double(image: *const c_void, corners: *const c_void, max_corners: i32, quality_level: f64, min_distance: f64, mask: *const c_void, corners_quality: *const c_void, block_size: i32, gradient_size: i32, use_harris_detector: bool, k: f64, ocvrs_return: *mut Result<()>); + pub fn cv_goodFeaturesToTrack_const__InputArrayR_const__OutputArrayR_int_double_double_const__InputArrayR_int_bool_double(image: *const c_void, corners: *const c_void, max_corners: i32, quality_level: f64, min_distance: f64, mask: *const c_void, block_size: i32, use_harris_detector: bool, k: f64, ocvrs_return: *mut Result<()>); + pub fn cv_goodFeaturesToTrack_const__InputArrayR_const__OutputArrayR_int_double_double_const__InputArrayR_int_int(image: *const c_void, corners: *const c_void, max_corners: i32, quality_level: f64, min_distance: f64, mask: *const c_void, block_size: i32, gradient_size: i32, ocvrs_return: *mut Result<()>); + pub fn cv_goodFeaturesToTrack_const__InputArrayR_const__OutputArrayR_int_double_double_const__InputArrayR_int_int_bool_double(image: *const c_void, corners: *const c_void, max_corners: i32, quality_level: f64, min_distance: f64, mask: *const c_void, block_size: i32, gradient_size: i32, use_harris_detector: bool, k: f64, ocvrs_return: *mut Result<()>); + pub fn cv_grabCut_const__InputArrayR_const__InputOutputArrayR_Rect_const__InputOutputArrayR_const__InputOutputArrayR_int(img: *const c_void, mask: *const c_void, rect: *const core::Rect, bgd_model: *const c_void, fgd_model: *const c_void, iter_count: i32, ocvrs_return: *mut Result<()>); + pub fn cv_grabCut_const__InputArrayR_const__InputOutputArrayR_Rect_const__InputOutputArrayR_const__InputOutputArrayR_int_int(img: *const c_void, mask: *const c_void, rect: *const core::Rect, bgd_model: *const c_void, fgd_model: *const c_void, iter_count: i32, mode: i32, ocvrs_return: *mut Result<()>); + pub fn cv_integral_const__InputArrayR_const__OutputArrayR(src: *const c_void, sum: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_integral_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(src: *const c_void, sum: *const c_void, sqsum: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_integral_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(src: *const c_void, sum: *const c_void, sqsum: *const c_void, tilted: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_integral_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_int_int(src: *const c_void, sum: *const c_void, sqsum: *const c_void, tilted: *const c_void, sdepth: i32, sqdepth: i32, ocvrs_return: *mut Result<()>); + pub fn cv_integral_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_int_int(src: *const c_void, sum: *const c_void, sqsum: *const c_void, sdepth: i32, sqdepth: i32, ocvrs_return: *mut Result<()>); + pub fn cv_integral_const__InputArrayR_const__OutputArrayR_int(src: *const c_void, sum: *const c_void, sdepth: i32, ocvrs_return: *mut Result<()>); pub fn cv_intersectConvexConvex_const__InputArrayR_const__InputArrayR_const__OutputArrayR(p1: *const c_void, p2: *const c_void, p12: *const c_void, ocvrs_return: *mut Result); pub fn cv_intersectConvexConvex_const__InputArrayR_const__InputArrayR_const__OutputArrayR_bool(p1: *const c_void, p2: *const c_void, p12: *const c_void, handle_nested: bool, ocvrs_return: *mut Result); - pub fn cv_invertAffineTransform_const__InputArrayR_const__OutputArrayR(m: *const c_void, i_m: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_invertAffineTransform_const__InputArrayR_const__OutputArrayR(m: *const c_void, i_m: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_isContourConvex_const__InputArrayR(contour: *const c_void, ocvrs_return: *mut Result); - pub fn cv_line_const__InputOutputArrayR_Point_Point_const_ScalarR(img: *const c_void, pt1: *const core::Point, pt2: *const core::Point, color: *const core::Scalar, ocvrs_return: *mut ResultVoid); - pub fn cv_line_const__InputOutputArrayR_Point_Point_const_ScalarR_int_int_int(img: *const c_void, pt1: *const core::Point, pt2: *const core::Point, color: *const core::Scalar, thickness: i32, line_type: i32, shift: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_linearPolar_const__InputArrayR_const__OutputArrayR_Point2f_double_int(src: *const c_void, dst: *const c_void, center: *const core::Point2f, max_radius: f64, flags: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_logPolar_const__InputArrayR_const__OutputArrayR_Point2f_double_int(src: *const c_void, dst: *const c_void, center: *const core::Point2f, m: f64, flags: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_line_const__InputOutputArrayR_Point_Point_const_ScalarR(img: *const c_void, pt1: *const core::Point, pt2: *const core::Point, color: *const core::Scalar, ocvrs_return: *mut Result<()>); + pub fn cv_line_const__InputOutputArrayR_Point_Point_const_ScalarR_int_int_int(img: *const c_void, pt1: *const core::Point, pt2: *const core::Point, color: *const core::Scalar, thickness: i32, line_type: i32, shift: i32, ocvrs_return: *mut Result<()>); + pub fn cv_linearPolar_const__InputArrayR_const__OutputArrayR_Point2f_double_int(src: *const c_void, dst: *const c_void, center: *const core::Point2f, max_radius: f64, flags: i32, ocvrs_return: *mut Result<()>); + pub fn cv_logPolar_const__InputArrayR_const__OutputArrayR_Point2f_double_int(src: *const c_void, dst: *const c_void, center: *const core::Point2f, m: f64, flags: i32, ocvrs_return: *mut Result<()>); pub fn cv_matchShapes_const__InputArrayR_const__InputArrayR_int_double(contour1: *const c_void, contour2: *const c_void, method: i32, parameter: f64, ocvrs_return: *mut Result); - pub fn cv_matchTemplate_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int(image: *const c_void, templ: *const c_void, result: *const c_void, method: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_matchTemplate_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int_const__InputArrayR(image: *const c_void, templ: *const c_void, result: *const c_void, method: i32, mask: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_medianBlur_const__InputArrayR_const__OutputArrayR_int(src: *const c_void, dst: *const c_void, ksize: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_matchTemplate_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int(image: *const c_void, templ: *const c_void, result: *const c_void, method: i32, ocvrs_return: *mut Result<()>); + pub fn cv_matchTemplate_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int_const__InputArrayR(image: *const c_void, templ: *const c_void, result: *const c_void, method: i32, mask: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_medianBlur_const__InputArrayR_const__OutputArrayR_int(src: *const c_void, dst: *const c_void, ksize: i32, ocvrs_return: *mut Result<()>); pub fn cv_minAreaRect_const__InputArrayR(points: *const c_void, ocvrs_return: *mut Result); - pub fn cv_minEnclosingCircle_const__InputArrayR_Point2fR_floatR(points: *const c_void, center: *mut core::Point2f, radius: *mut f32, ocvrs_return: *mut ResultVoid); + pub fn cv_minEnclosingCircle_const__InputArrayR_Point2fR_floatR(points: *const c_void, center: *mut core::Point2f, radius: *mut f32, ocvrs_return: *mut Result<()>); pub fn cv_minEnclosingTriangle_const__InputArrayR_const__OutputArrayR(points: *const c_void, triangle: *const c_void, ocvrs_return: *mut Result); pub fn cv_moments_const__InputArrayR(array: *const c_void, ocvrs_return: *mut Result); pub fn cv_moments_const__InputArrayR_bool(array: *const c_void, binary_image: bool, ocvrs_return: *mut Result); pub fn cv_morphologyDefaultBorderValue(ocvrs_return: *mut Result); - pub fn cv_morphologyEx_const__InputArrayR_const__OutputArrayR_int_const__InputArrayR(src: *const c_void, dst: *const c_void, op: i32, kernel: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_morphologyEx_const__InputArrayR_const__OutputArrayR_int_const__InputArrayR_Point_int_int_const_ScalarR(src: *const c_void, dst: *const c_void, op: i32, kernel: *const c_void, anchor: *const core::Point, iterations: i32, border_type: i32, border_value: *const core::Scalar, ocvrs_return: *mut ResultVoid); + pub fn cv_morphologyEx_const__InputArrayR_const__OutputArrayR_int_const__InputArrayR(src: *const c_void, dst: *const c_void, op: i32, kernel: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_morphologyEx_const__InputArrayR_const__OutputArrayR_int_const__InputArrayR_Point_int_int_const_ScalarR(src: *const c_void, dst: *const c_void, op: i32, kernel: *const c_void, anchor: *const core::Point, iterations: i32, border_type: i32, border_value: *const core::Scalar, ocvrs_return: *mut Result<()>); pub fn cv_phaseCorrelate_const__InputArrayR_const__InputArrayR(src1: *const c_void, src2: *const c_void, ocvrs_return: *mut Result); pub fn cv_phaseCorrelate_const__InputArrayR_const__InputArrayR_const__InputArrayR_doubleX(src1: *const c_void, src2: *const c_void, window: *const c_void, response: *mut f64, ocvrs_return: *mut Result); pub fn cv_pointPolygonTest_const__InputArrayR_Point2f_bool(contour: *const c_void, pt: *const core::Point2f, measure_dist: bool, ocvrs_return: *mut Result); - pub fn cv_polylines_const__InputOutputArrayR_const__InputArrayR_bool_const_ScalarR(img: *const c_void, pts: *const c_void, is_closed: bool, color: *const core::Scalar, ocvrs_return: *mut ResultVoid); - pub fn cv_polylines_const__InputOutputArrayR_const__InputArrayR_bool_const_ScalarR_int_int_int(img: *const c_void, pts: *const c_void, is_closed: bool, color: *const core::Scalar, thickness: i32, line_type: i32, shift: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_preCornerDetect_const__InputArrayR_const__OutputArrayR_int(src: *const c_void, dst: *const c_void, ksize: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_preCornerDetect_const__InputArrayR_const__OutputArrayR_int_int(src: *const c_void, dst: *const c_void, ksize: i32, border_type: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_putText_const__InputOutputArrayR_const_StringR_Point_int_double_Scalar(img: *const c_void, text: *const c_char, org: *const core::Point, font_face: i32, font_scale: f64, color: *const core::Scalar, ocvrs_return: *mut ResultVoid); - pub fn cv_putText_const__InputOutputArrayR_const_StringR_Point_int_double_Scalar_int_int_bool(img: *const c_void, text: *const c_char, org: *const core::Point, font_face: i32, font_scale: f64, color: *const core::Scalar, thickness: i32, line_type: i32, bottom_left_origin: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_pyrDown_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_pyrDown_const__InputArrayR_const__OutputArrayR_const_SizeR_int(src: *const c_void, dst: *const c_void, dstsize: *const core::Size, border_type: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_pyrMeanShiftFiltering_const__InputArrayR_const__OutputArrayR_double_double(src: *const c_void, dst: *const c_void, sp: f64, sr: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_pyrMeanShiftFiltering_const__InputArrayR_const__OutputArrayR_double_double_int_TermCriteria(src: *const c_void, dst: *const c_void, sp: f64, sr: f64, max_level: i32, termcrit: *const core::TermCriteria, ocvrs_return: *mut ResultVoid); - pub fn cv_pyrUp_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_pyrUp_const__InputArrayR_const__OutputArrayR_const_SizeR_int(src: *const c_void, dst: *const c_void, dstsize: *const core::Size, border_type: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_rectangle_const__InputOutputArrayR_Point_Point_const_ScalarR(img: *const c_void, pt1: *const core::Point, pt2: *const core::Point, color: *const core::Scalar, ocvrs_return: *mut ResultVoid); - pub fn cv_rectangle_const__InputOutputArrayR_Point_Point_const_ScalarR_int_int_int(img: *const c_void, pt1: *const core::Point, pt2: *const core::Point, color: *const core::Scalar, thickness: i32, line_type: i32, shift: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_rectangle_const__InputOutputArrayR_Rect_const_ScalarR(img: *const c_void, rec: *const core::Rect, color: *const core::Scalar, ocvrs_return: *mut ResultVoid); - pub fn cv_rectangle_const__InputOutputArrayR_Rect_const_ScalarR_int_int_int(img: *const c_void, rec: *const core::Rect, color: *const core::Scalar, thickness: i32, line_type: i32, shift: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_remap_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR_int(src: *const c_void, dst: *const c_void, map1: *const c_void, map2: *const c_void, interpolation: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_remap_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR_int_int_const_ScalarR(src: *const c_void, dst: *const c_void, map1: *const c_void, map2: *const c_void, interpolation: i32, border_mode: i32, border_value: *const core::Scalar, ocvrs_return: *mut ResultVoid); - pub fn cv_resize_const__InputArrayR_const__OutputArrayR_Size(src: *const c_void, dst: *const c_void, dsize: *const core::Size, ocvrs_return: *mut ResultVoid); - pub fn cv_resize_const__InputArrayR_const__OutputArrayR_Size_double_double_int(src: *const c_void, dst: *const c_void, dsize: *const core::Size, fx: f64, fy: f64, interpolation: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_polylines_const__InputOutputArrayR_const__InputArrayR_bool_const_ScalarR(img: *const c_void, pts: *const c_void, is_closed: bool, color: *const core::Scalar, ocvrs_return: *mut Result<()>); + pub fn cv_polylines_const__InputOutputArrayR_const__InputArrayR_bool_const_ScalarR_int_int_int(img: *const c_void, pts: *const c_void, is_closed: bool, color: *const core::Scalar, thickness: i32, line_type: i32, shift: i32, ocvrs_return: *mut Result<()>); + pub fn cv_preCornerDetect_const__InputArrayR_const__OutputArrayR_int(src: *const c_void, dst: *const c_void, ksize: i32, ocvrs_return: *mut Result<()>); + pub fn cv_preCornerDetect_const__InputArrayR_const__OutputArrayR_int_int(src: *const c_void, dst: *const c_void, ksize: i32, border_type: i32, ocvrs_return: *mut Result<()>); + pub fn cv_putText_const__InputOutputArrayR_const_StringR_Point_int_double_Scalar(img: *const c_void, text: *const c_char, org: *const core::Point, font_face: i32, font_scale: f64, color: *const core::Scalar, ocvrs_return: *mut Result<()>); + pub fn cv_putText_const__InputOutputArrayR_const_StringR_Point_int_double_Scalar_int_int_bool(img: *const c_void, text: *const c_char, org: *const core::Point, font_face: i32, font_scale: f64, color: *const core::Scalar, thickness: i32, line_type: i32, bottom_left_origin: bool, ocvrs_return: *mut Result<()>); + pub fn cv_pyrDown_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_pyrDown_const__InputArrayR_const__OutputArrayR_const_SizeR_int(src: *const c_void, dst: *const c_void, dstsize: *const core::Size, border_type: i32, ocvrs_return: *mut Result<()>); + pub fn cv_pyrMeanShiftFiltering_const__InputArrayR_const__OutputArrayR_double_double(src: *const c_void, dst: *const c_void, sp: f64, sr: f64, ocvrs_return: *mut Result<()>); + pub fn cv_pyrMeanShiftFiltering_const__InputArrayR_const__OutputArrayR_double_double_int_TermCriteria(src: *const c_void, dst: *const c_void, sp: f64, sr: f64, max_level: i32, termcrit: *const core::TermCriteria, ocvrs_return: *mut Result<()>); + pub fn cv_pyrUp_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_pyrUp_const__InputArrayR_const__OutputArrayR_const_SizeR_int(src: *const c_void, dst: *const c_void, dstsize: *const core::Size, border_type: i32, ocvrs_return: *mut Result<()>); + pub fn cv_rectangle_const__InputOutputArrayR_Point_Point_const_ScalarR(img: *const c_void, pt1: *const core::Point, pt2: *const core::Point, color: *const core::Scalar, ocvrs_return: *mut Result<()>); + pub fn cv_rectangle_const__InputOutputArrayR_Point_Point_const_ScalarR_int_int_int(img: *const c_void, pt1: *const core::Point, pt2: *const core::Point, color: *const core::Scalar, thickness: i32, line_type: i32, shift: i32, ocvrs_return: *mut Result<()>); + pub fn cv_rectangle_const__InputOutputArrayR_Rect_const_ScalarR(img: *const c_void, rec: *const core::Rect, color: *const core::Scalar, ocvrs_return: *mut Result<()>); + pub fn cv_rectangle_const__InputOutputArrayR_Rect_const_ScalarR_int_int_int(img: *const c_void, rec: *const core::Rect, color: *const core::Scalar, thickness: i32, line_type: i32, shift: i32, ocvrs_return: *mut Result<()>); + pub fn cv_remap_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR_int(src: *const c_void, dst: *const c_void, map1: *const c_void, map2: *const c_void, interpolation: i32, ocvrs_return: *mut Result<()>); + pub fn cv_remap_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR_int_int_const_ScalarR(src: *const c_void, dst: *const c_void, map1: *const c_void, map2: *const c_void, interpolation: i32, border_mode: i32, border_value: *const core::Scalar, ocvrs_return: *mut Result<()>); + pub fn cv_resize_const__InputArrayR_const__OutputArrayR_Size(src: *const c_void, dst: *const c_void, dsize: *const core::Size, ocvrs_return: *mut Result<()>); + pub fn cv_resize_const__InputArrayR_const__OutputArrayR_Size_double_double_int(src: *const c_void, dst: *const c_void, dsize: *const core::Size, fx: f64, fy: f64, interpolation: i32, ocvrs_return: *mut Result<()>); pub fn cv_rotatedRectangleIntersection_const_RotatedRectR_const_RotatedRectR_const__OutputArrayR(rect1: *const core::RotatedRect, rect2: *const core::RotatedRect, intersecting_region: *const c_void, ocvrs_return: *mut Result); - pub fn cv_sepFilter2D_const__InputArrayR_const__OutputArrayR_int_const__InputArrayR_const__InputArrayR(src: *const c_void, dst: *const c_void, ddepth: i32, kernel_x: *const c_void, kernel_y: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_sepFilter2D_const__InputArrayR_const__OutputArrayR_int_const__InputArrayR_const__InputArrayR_Point_double_int(src: *const c_void, dst: *const c_void, ddepth: i32, kernel_x: *const c_void, kernel_y: *const c_void, anchor: *const core::Point, delta: f64, border_type: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_spatialGradient_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(src: *const c_void, dx: *const c_void, dy: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_spatialGradient_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_int_int(src: *const c_void, dx: *const c_void, dy: *const c_void, ksize: i32, border_type: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_sqrBoxFilter_const__InputArrayR_const__OutputArrayR_int_Size(src: *const c_void, dst: *const c_void, ddepth: i32, ksize: *const core::Size, ocvrs_return: *mut ResultVoid); - pub fn cv_sqrBoxFilter_const__InputArrayR_const__OutputArrayR_int_Size_Point_bool_int(src: *const c_void, dst: *const c_void, ddepth: i32, ksize: *const core::Size, anchor: *const core::Point, normalize: bool, border_type: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_stackBlur_const__InputArrayR_const__OutputArrayR_Size(src: *const c_void, dst: *const c_void, ksize: *const core::Size, ocvrs_return: *mut ResultVoid); + pub fn cv_sepFilter2D_const__InputArrayR_const__OutputArrayR_int_const__InputArrayR_const__InputArrayR(src: *const c_void, dst: *const c_void, ddepth: i32, kernel_x: *const c_void, kernel_y: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_sepFilter2D_const__InputArrayR_const__OutputArrayR_int_const__InputArrayR_const__InputArrayR_Point_double_int(src: *const c_void, dst: *const c_void, ddepth: i32, kernel_x: *const c_void, kernel_y: *const c_void, anchor: *const core::Point, delta: f64, border_type: i32, ocvrs_return: *mut Result<()>); + pub fn cv_spatialGradient_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(src: *const c_void, dx: *const c_void, dy: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_spatialGradient_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_int_int(src: *const c_void, dx: *const c_void, dy: *const c_void, ksize: i32, border_type: i32, ocvrs_return: *mut Result<()>); + pub fn cv_sqrBoxFilter_const__InputArrayR_const__OutputArrayR_int_Size(src: *const c_void, dst: *const c_void, ddepth: i32, ksize: *const core::Size, ocvrs_return: *mut Result<()>); + pub fn cv_sqrBoxFilter_const__InputArrayR_const__OutputArrayR_int_Size_Point_bool_int(src: *const c_void, dst: *const c_void, ddepth: i32, ksize: *const core::Size, anchor: *const core::Point, normalize: bool, border_type: i32, ocvrs_return: *mut Result<()>); + pub fn cv_stackBlur_const__InputArrayR_const__OutputArrayR_Size(src: *const c_void, dst: *const c_void, ksize: *const core::Size, ocvrs_return: *mut Result<()>); pub fn cv_threshold_const__InputArrayR_const__OutputArrayR_double_double_int(src: *const c_void, dst: *const c_void, thresh: f64, maxval: f64, typ: i32, ocvrs_return: *mut Result); - pub fn cv_warpAffine_const__InputArrayR_const__OutputArrayR_const__InputArrayR_Size(src: *const c_void, dst: *const c_void, m: *const c_void, dsize: *const core::Size, ocvrs_return: *mut ResultVoid); - pub fn cv_warpAffine_const__InputArrayR_const__OutputArrayR_const__InputArrayR_Size_int_int_const_ScalarR(src: *const c_void, dst: *const c_void, m: *const c_void, dsize: *const core::Size, flags: i32, border_mode: i32, border_value: *const core::Scalar, ocvrs_return: *mut ResultVoid); - pub fn cv_warpPerspective_const__InputArrayR_const__OutputArrayR_const__InputArrayR_Size(src: *const c_void, dst: *const c_void, m: *const c_void, dsize: *const core::Size, ocvrs_return: *mut ResultVoid); - pub fn cv_warpPerspective_const__InputArrayR_const__OutputArrayR_const__InputArrayR_Size_int_int_const_ScalarR(src: *const c_void, dst: *const c_void, m: *const c_void, dsize: *const core::Size, flags: i32, border_mode: i32, border_value: *const core::Scalar, ocvrs_return: *mut ResultVoid); - pub fn cv_warpPolar_const__InputArrayR_const__OutputArrayR_Size_Point2f_double_int(src: *const c_void, dst: *const c_void, dsize: *const core::Size, center: *const core::Point2f, max_radius: f64, flags: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_watershed_const__InputArrayR_const__InputOutputArrayR(image: *const c_void, markers: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_warpAffine_const__InputArrayR_const__OutputArrayR_const__InputArrayR_Size(src: *const c_void, dst: *const c_void, m: *const c_void, dsize: *const core::Size, ocvrs_return: *mut Result<()>); + pub fn cv_warpAffine_const__InputArrayR_const__OutputArrayR_const__InputArrayR_Size_int_int_const_ScalarR(src: *const c_void, dst: *const c_void, m: *const c_void, dsize: *const core::Size, flags: i32, border_mode: i32, border_value: *const core::Scalar, ocvrs_return: *mut Result<()>); + pub fn cv_warpPerspective_const__InputArrayR_const__OutputArrayR_const__InputArrayR_Size(src: *const c_void, dst: *const c_void, m: *const c_void, dsize: *const core::Size, ocvrs_return: *mut Result<()>); + pub fn cv_warpPerspective_const__InputArrayR_const__OutputArrayR_const__InputArrayR_Size_int_int_const_ScalarR(src: *const c_void, dst: *const c_void, m: *const c_void, dsize: *const core::Size, flags: i32, border_mode: i32, border_value: *const core::Scalar, ocvrs_return: *mut Result<()>); + pub fn cv_warpPolar_const__InputArrayR_const__OutputArrayR_Size_Point2f_double_int(src: *const c_void, dst: *const c_void, dsize: *const core::Size, center: *const core::Point2f, max_radius: f64, flags: i32, ocvrs_return: *mut Result<()>); + pub fn cv_watershed_const__InputArrayR_const__InputOutputArrayR(image: *const c_void, markers: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_wrapperEMD_const__InputArrayR_const__InputArrayR_int(signature1: *const c_void, signature2: *const c_void, dist_type: i32, ocvrs_return: *mut Result); pub fn cv_wrapperEMD_const__InputArrayR_const__InputArrayR_int_const__InputArrayR_PtrLfloatG_const__OutputArrayR(signature1: *const c_void, signature2: *const c_void, dist_type: i32, cost: *const c_void, lower_bound: *mut c_void, flow: *const c_void, ocvrs_return: *mut Result); - pub fn cv_CLAHE_apply_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_CLAHE_setClipLimit_double(instance: *mut c_void, clip_limit: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_CLAHE_apply_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_CLAHE_setClipLimit_double(instance: *mut c_void, clip_limit: f64, ocvrs_return: *mut Result<()>); pub fn cv_CLAHE_getClipLimit_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_CLAHE_setTilesGridSize_Size(instance: *mut c_void, tile_grid_size: *const core::Size, ocvrs_return: *mut ResultVoid); + pub fn cv_CLAHE_setTilesGridSize_Size(instance: *mut c_void, tile_grid_size: *const core::Size, ocvrs_return: *mut Result<()>); pub fn cv_CLAHE_getTilesGridSize_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_CLAHE_collectGarbage(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_CLAHE_collectGarbage(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_CLAHE_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_CLAHE_delete(instance: *mut c_void); - pub fn cv_GeneralizedHough_setTemplate_const__InputArrayR_Point(instance: *mut c_void, templ: *const c_void, templ_center: *const core::Point, ocvrs_return: *mut ResultVoid); - pub fn cv_GeneralizedHough_setTemplate_const__InputArrayR(instance: *mut c_void, templ: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_GeneralizedHough_setTemplate_const__InputArrayR_const__InputArrayR_const__InputArrayR_Point(instance: *mut c_void, edges: *const c_void, dx: *const c_void, dy: *const c_void, templ_center: *const core::Point, ocvrs_return: *mut ResultVoid); - pub fn cv_GeneralizedHough_setTemplate_const__InputArrayR_const__InputArrayR_const__InputArrayR(instance: *mut c_void, edges: *const c_void, dx: *const c_void, dy: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_GeneralizedHough_detect_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, positions: *const c_void, votes: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_GeneralizedHough_detect_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, positions: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_GeneralizedHough_detect_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *mut c_void, edges: *const c_void, dx: *const c_void, dy: *const c_void, positions: *const c_void, votes: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_GeneralizedHough_detect_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, edges: *const c_void, dx: *const c_void, dy: *const c_void, positions: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_GeneralizedHough_setCannyLowThresh_int(instance: *mut c_void, canny_low_thresh: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_GeneralizedHough_setTemplate_const__InputArrayR_Point(instance: *mut c_void, templ: *const c_void, templ_center: *const core::Point, ocvrs_return: *mut Result<()>); + pub fn cv_GeneralizedHough_setTemplate_const__InputArrayR(instance: *mut c_void, templ: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_GeneralizedHough_setTemplate_const__InputArrayR_const__InputArrayR_const__InputArrayR_Point(instance: *mut c_void, edges: *const c_void, dx: *const c_void, dy: *const c_void, templ_center: *const core::Point, ocvrs_return: *mut Result<()>); + pub fn cv_GeneralizedHough_setTemplate_const__InputArrayR_const__InputArrayR_const__InputArrayR(instance: *mut c_void, edges: *const c_void, dx: *const c_void, dy: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_GeneralizedHough_detect_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, positions: *const c_void, votes: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_GeneralizedHough_detect_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, positions: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_GeneralizedHough_detect_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *mut c_void, edges: *const c_void, dx: *const c_void, dy: *const c_void, positions: *const c_void, votes: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_GeneralizedHough_detect_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, edges: *const c_void, dx: *const c_void, dy: *const c_void, positions: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_GeneralizedHough_setCannyLowThresh_int(instance: *mut c_void, canny_low_thresh: i32, ocvrs_return: *mut Result<()>); pub fn cv_GeneralizedHough_getCannyLowThresh_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_GeneralizedHough_setCannyHighThresh_int(instance: *mut c_void, canny_high_thresh: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_GeneralizedHough_setCannyHighThresh_int(instance: *mut c_void, canny_high_thresh: i32, ocvrs_return: *mut Result<()>); pub fn cv_GeneralizedHough_getCannyHighThresh_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_GeneralizedHough_setMinDist_double(instance: *mut c_void, min_dist: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_GeneralizedHough_setMinDist_double(instance: *mut c_void, min_dist: f64, ocvrs_return: *mut Result<()>); pub fn cv_GeneralizedHough_getMinDist_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_GeneralizedHough_setDp_double(instance: *mut c_void, dp: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_GeneralizedHough_setDp_double(instance: *mut c_void, dp: f64, ocvrs_return: *mut Result<()>); pub fn cv_GeneralizedHough_getDp_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_GeneralizedHough_setMaxBufferSize_int(instance: *mut c_void, max_buffer_size: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_GeneralizedHough_setMaxBufferSize_int(instance: *mut c_void, max_buffer_size: i32, ocvrs_return: *mut Result<()>); pub fn cv_GeneralizedHough_getMaxBufferSize_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_GeneralizedHough_to_GeneralizedHoughBallard(instance: *mut c_void) -> *mut c_void; pub fn cv_GeneralizedHough_to_GeneralizedHoughGuil(instance: *mut c_void) -> *mut c_void; pub fn cv_GeneralizedHough_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_GeneralizedHough_delete(instance: *mut c_void); - pub fn cv_GeneralizedHoughBallard_setLevels_int(instance: *mut c_void, levels: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_GeneralizedHoughBallard_setLevels_int(instance: *mut c_void, levels: i32, ocvrs_return: *mut Result<()>); pub fn cv_GeneralizedHoughBallard_getLevels_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_GeneralizedHoughBallard_setVotesThreshold_int(instance: *mut c_void, votes_threshold: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_GeneralizedHoughBallard_setVotesThreshold_int(instance: *mut c_void, votes_threshold: i32, ocvrs_return: *mut Result<()>); pub fn cv_GeneralizedHoughBallard_getVotesThreshold_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_GeneralizedHoughBallard_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_GeneralizedHoughBallard_to_GeneralizedHough(instance: *mut c_void) -> *mut c_void; pub fn cv_GeneralizedHoughBallard_delete(instance: *mut c_void); - pub fn cv_GeneralizedHoughGuil_setXi_double(instance: *mut c_void, xi: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_GeneralizedHoughGuil_setXi_double(instance: *mut c_void, xi: f64, ocvrs_return: *mut Result<()>); pub fn cv_GeneralizedHoughGuil_getXi_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_GeneralizedHoughGuil_setLevels_int(instance: *mut c_void, levels: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_GeneralizedHoughGuil_setLevels_int(instance: *mut c_void, levels: i32, ocvrs_return: *mut Result<()>); pub fn cv_GeneralizedHoughGuil_getLevels_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_GeneralizedHoughGuil_setAngleEpsilon_double(instance: *mut c_void, angle_epsilon: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_GeneralizedHoughGuil_setAngleEpsilon_double(instance: *mut c_void, angle_epsilon: f64, ocvrs_return: *mut Result<()>); pub fn cv_GeneralizedHoughGuil_getAngleEpsilon_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_GeneralizedHoughGuil_setMinAngle_double(instance: *mut c_void, min_angle: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_GeneralizedHoughGuil_setMinAngle_double(instance: *mut c_void, min_angle: f64, ocvrs_return: *mut Result<()>); pub fn cv_GeneralizedHoughGuil_getMinAngle_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_GeneralizedHoughGuil_setMaxAngle_double(instance: *mut c_void, max_angle: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_GeneralizedHoughGuil_setMaxAngle_double(instance: *mut c_void, max_angle: f64, ocvrs_return: *mut Result<()>); pub fn cv_GeneralizedHoughGuil_getMaxAngle_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_GeneralizedHoughGuil_setAngleStep_double(instance: *mut c_void, angle_step: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_GeneralizedHoughGuil_setAngleStep_double(instance: *mut c_void, angle_step: f64, ocvrs_return: *mut Result<()>); pub fn cv_GeneralizedHoughGuil_getAngleStep_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_GeneralizedHoughGuil_setAngleThresh_int(instance: *mut c_void, angle_thresh: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_GeneralizedHoughGuil_setAngleThresh_int(instance: *mut c_void, angle_thresh: i32, ocvrs_return: *mut Result<()>); pub fn cv_GeneralizedHoughGuil_getAngleThresh_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_GeneralizedHoughGuil_setMinScale_double(instance: *mut c_void, min_scale: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_GeneralizedHoughGuil_setMinScale_double(instance: *mut c_void, min_scale: f64, ocvrs_return: *mut Result<()>); pub fn cv_GeneralizedHoughGuil_getMinScale_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_GeneralizedHoughGuil_setMaxScale_double(instance: *mut c_void, max_scale: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_GeneralizedHoughGuil_setMaxScale_double(instance: *mut c_void, max_scale: f64, ocvrs_return: *mut Result<()>); pub fn cv_GeneralizedHoughGuil_getMaxScale_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_GeneralizedHoughGuil_setScaleStep_double(instance: *mut c_void, scale_step: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_GeneralizedHoughGuil_setScaleStep_double(instance: *mut c_void, scale_step: f64, ocvrs_return: *mut Result<()>); pub fn cv_GeneralizedHoughGuil_getScaleStep_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_GeneralizedHoughGuil_setScaleThresh_int(instance: *mut c_void, scale_thresh: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_GeneralizedHoughGuil_setScaleThresh_int(instance: *mut c_void, scale_thresh: i32, ocvrs_return: *mut Result<()>); pub fn cv_GeneralizedHoughGuil_getScaleThresh_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_GeneralizedHoughGuil_setPosThresh_int(instance: *mut c_void, pos_thresh: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_GeneralizedHoughGuil_setPosThresh_int(instance: *mut c_void, pos_thresh: i32, ocvrs_return: *mut Result<()>); pub fn cv_GeneralizedHoughGuil_getPosThresh_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_GeneralizedHoughGuil_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_GeneralizedHoughGuil_to_GeneralizedHough(instance: *mut c_void) -> *mut c_void; @@ -10181,7 +10230,7 @@ mod imgproc_sys { pub fn cv_LineIterator_LineIterator_Size_Point_Point(bounding_area_size: *const core::Size, pt1: *const core::Point, pt2: *const core::Point, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_LineIterator_LineIterator_Rect_Point_Point_int_bool(bounding_area_rect: *const core::Rect, pt1: *const core::Point, pt2: *const core::Point, connectivity: i32, left_to_right: bool, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_LineIterator_LineIterator_Rect_Point_Point(bounding_area_rect: *const core::Rect, pt1: *const core::Point, pt2: *const core::Point, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_LineIterator_init_const_MatX_Rect_Point_Point_int_bool(instance: *mut c_void, img: *const c_void, bounding_area_rect: *const core::Rect, pt1: *const core::Point, pt2: *const core::Point, connectivity: i32, left_to_right: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_LineIterator_init_const_MatX_Rect_Point_Point_int_bool(instance: *mut c_void, img: *const c_void, bounding_area_rect: *const core::Rect, pt1: *const core::Point, pt2: *const core::Point, connectivity: i32, left_to_right: bool, ocvrs_return: *mut Result<()>); pub fn cv_LineIterator_operatorX(instance: *mut c_void, ocvrs_return: *mut Result<*mut u8>); pub fn cv_LineIterator_operatorAA(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_LineIterator_pos_const(instance: *const c_void, ocvrs_return: *mut Result); @@ -10214,25 +10263,25 @@ mod imgproc_sys { pub fn cv_LineIterator_propPtmode_const(instance: *const c_void) -> bool; pub fn cv_LineIterator_propPtmode_const_bool(instance: *mut c_void, val: bool); pub fn cv_LineIterator_delete(instance: *mut c_void); - pub fn cv_LineSegmentDetector_detect_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, lines: *const c_void, width: *const c_void, prec: *const c_void, nfa: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_LineSegmentDetector_detect_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, lines: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_LineSegmentDetector_drawSegments_const__InputOutputArrayR_const__InputArrayR(instance: *mut c_void, image: *const c_void, lines: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_LineSegmentDetector_detect_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, lines: *const c_void, width: *const c_void, prec: *const c_void, nfa: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_LineSegmentDetector_detect_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, lines: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_LineSegmentDetector_drawSegments_const__InputOutputArrayR_const__InputArrayR(instance: *mut c_void, image: *const c_void, lines: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_LineSegmentDetector_compareSegments_const_SizeR_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR(instance: *mut c_void, size: *const core::Size, lines1: *const c_void, lines2: *const c_void, image: *const c_void, ocvrs_return: *mut Result); pub fn cv_LineSegmentDetector_compareSegments_const_SizeR_const__InputArrayR_const__InputArrayR(instance: *mut c_void, size: *const core::Size, lines1: *const c_void, lines2: *const c_void, ocvrs_return: *mut Result); pub fn cv_LineSegmentDetector_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_LineSegmentDetector_delete(instance: *mut c_void); pub fn cv_Subdiv2D_Subdiv2D(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_Subdiv2D_Subdiv2D_Rect(rect: *const core::Rect, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_Subdiv2D_initDelaunay_Rect(instance: *mut c_void, rect: *const core::Rect, ocvrs_return: *mut ResultVoid); + pub fn cv_Subdiv2D_initDelaunay_Rect(instance: *mut c_void, rect: *const core::Rect, ocvrs_return: *mut Result<()>); pub fn cv_Subdiv2D_insert_Point2f(instance: *mut c_void, pt: *const core::Point2f, ocvrs_return: *mut Result); - pub fn cv_Subdiv2D_insert_const_vectorLPoint2fGR(instance: *mut c_void, ptvec: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_Subdiv2D_insert_const_vectorLPoint2fGR(instance: *mut c_void, ptvec: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_Subdiv2D_locate_Point2f_intR_intR(instance: *mut c_void, pt: *const core::Point2f, edge: *mut i32, vertex: *mut i32, ocvrs_return: *mut Result); pub fn cv_Subdiv2D_findNearest_Point2f_Point2fX(instance: *mut c_void, pt: *const core::Point2f, nearest_pt: *mut core::Point2f, ocvrs_return: *mut Result); pub fn cv_Subdiv2D_findNearest_Point2f(instance: *mut c_void, pt: *const core::Point2f, ocvrs_return: *mut Result); - pub fn cv_Subdiv2D_getEdgeList_const_vectorLVec4fGR(instance: *const c_void, edge_list: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_Subdiv2D_getLeadingEdgeList_const_vectorLintGR(instance: *const c_void, leading_edge_list: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_Subdiv2D_getTriangleList_const_vectorLVec6fGR(instance: *const c_void, triangle_list: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_Subdiv2D_getVoronoiFacetList_const_vectorLintGR_vectorLvectorLPoint2fGGR_vectorLPoint2fGR(instance: *mut c_void, idx: *const c_void, facet_list: *mut c_void, facet_centers: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_Subdiv2D_getEdgeList_const_vectorLVec4fGR(instance: *const c_void, edge_list: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_Subdiv2D_getLeadingEdgeList_const_vectorLintGR(instance: *const c_void, leading_edge_list: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_Subdiv2D_getTriangleList_const_vectorLVec6fGR(instance: *const c_void, triangle_list: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_Subdiv2D_getVoronoiFacetList_const_vectorLintGR_vectorLvectorLPoint2fGGR_vectorLPoint2fGR(instance: *mut c_void, idx: *const c_void, facet_list: *mut c_void, facet_centers: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_Subdiv2D_getVertex_const_int_intX(instance: *const c_void, vertex: i32, first_edge: *mut i32, ocvrs_return: *mut Result); pub fn cv_Subdiv2D_getVertex_const_int(instance: *const c_void, vertex: i32, ocvrs_return: *mut Result); pub fn cv_Subdiv2D_getEdge_const_int_int(instance: *const c_void, edge: i32, next_edge_type: i32, ocvrs_return: *mut Result); @@ -10255,9 +10304,9 @@ mod imgproc_sys { pub fn cv_segmentation_IntelligentScissorsMB_applyImage_const__InputArrayR(instance: *mut c_void, image: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_segmentation_IntelligentScissorsMB_applyImageFeatures_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR(instance: *mut c_void, non_edge: *const c_void, gradient_direction: *const c_void, gradient_magnitude: *const c_void, image: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_segmentation_IntelligentScissorsMB_applyImageFeatures_const__InputArrayR_const__InputArrayR_const__InputArrayR(instance: *mut c_void, non_edge: *const c_void, gradient_direction: *const c_void, gradient_magnitude: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_segmentation_IntelligentScissorsMB_buildMap_const_PointR(instance: *mut c_void, source_pt: *const core::Point, ocvrs_return: *mut ResultVoid); - pub fn cv_segmentation_IntelligentScissorsMB_getContour_const_const_PointR_const__OutputArrayR_bool(instance: *const c_void, target_pt: *const core::Point, contour: *const c_void, backward: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_segmentation_IntelligentScissorsMB_getContour_const_const_PointR_const__OutputArrayR(instance: *const c_void, target_pt: *const core::Point, contour: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_segmentation_IntelligentScissorsMB_buildMap_const_PointR(instance: *mut c_void, source_pt: *const core::Point, ocvrs_return: *mut Result<()>); + pub fn cv_segmentation_IntelligentScissorsMB_getContour_const_const_PointR_const__OutputArrayR_bool(instance: *const c_void, target_pt: *const core::Point, contour: *const c_void, backward: bool, ocvrs_return: *mut Result<()>); + pub fn cv_segmentation_IntelligentScissorsMB_getContour_const_const_PointR_const__OutputArrayR(instance: *const c_void, target_pt: *const core::Point, contour: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_segmentation_IntelligentScissorsMB_implicitClone_const(instance: *const c_void) -> *mut c_void; pub fn cv_segmentation_IntelligentScissorsMB_delete(instance: *mut c_void); pub fn cv_PtrLcv_CLAHEG_getInnerPtr_const(instance: *const c_void) -> *mut c_void; @@ -10289,65 +10338,61 @@ mod imgproc_sys { pub fn cv_PtrLcv_LineSegmentDetectorG_to_PtrOfAlgorithm(instance: *mut c_void) -> *mut c_void; } } -#[cfg(ocvrs_has_module_imgproc)] pub use imgproc_sys::*; -#[cfg(ocvrs_has_module_intensity_transform)] mod intensity_transform_sys { use super::*; extern "C" { - pub fn cv_intensity_transform_BIMEF_const__InputArrayR_const__OutputArrayR(input: *const c_void, output: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_intensity_transform_BIMEF_const__InputArrayR_const__OutputArrayR_float_float_float(input: *const c_void, output: *const c_void, mu: f32, a: f32, b: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_intensity_transform_BIMEF_const__InputArrayR_const__OutputArrayR_float_float_float_float(input: *const c_void, output: *const c_void, k: f32, mu: f32, a: f32, b: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_intensity_transform_autoscaling_const_Mat_MatR(input: *const c_void, output: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_intensity_transform_contrastStretching_const_Mat_MatR_const_int_const_int_const_int_const_int(input: *const c_void, output: *mut c_void, r1: i32, s1: i32, r2: i32, s2: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_intensity_transform_gammaCorrection_const_Mat_MatR_const_float(input: *const c_void, output: *mut c_void, gamma: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_intensity_transform_logTransform_const_Mat_MatR(input: *const c_void, output: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_intensity_transform_BIMEF_const__InputArrayR_const__OutputArrayR(input: *const c_void, output: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_intensity_transform_BIMEF_const__InputArrayR_const__OutputArrayR_float_float_float(input: *const c_void, output: *const c_void, mu: f32, a: f32, b: f32, ocvrs_return: *mut Result<()>); + pub fn cv_intensity_transform_BIMEF_const__InputArrayR_const__OutputArrayR_float_float_float_float(input: *const c_void, output: *const c_void, k: f32, mu: f32, a: f32, b: f32, ocvrs_return: *mut Result<()>); + pub fn cv_intensity_transform_autoscaling_const_Mat_MatR(input: *const c_void, output: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_intensity_transform_contrastStretching_const_Mat_MatR_const_int_const_int_const_int_const_int(input: *const c_void, output: *mut c_void, r1: i32, s1: i32, r2: i32, s2: i32, ocvrs_return: *mut Result<()>); + pub fn cv_intensity_transform_gammaCorrection_const_Mat_MatR_const_float(input: *const c_void, output: *mut c_void, gamma: f32, ocvrs_return: *mut Result<()>); + pub fn cv_intensity_transform_logTransform_const_Mat_MatR(input: *const c_void, output: *mut c_void, ocvrs_return: *mut Result<()>); } } -#[cfg(ocvrs_has_module_intensity_transform)] pub use intensity_transform_sys::*; -#[cfg(ocvrs_has_module_line_descriptor)] mod line_descriptor_sys { use super::*; extern "C" { - pub fn cv_line_descriptor_drawKeylines_const_MatR_const_vectorLKeyLineGR_MatR(image: *const c_void, keylines: *const c_void, out_image: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_line_descriptor_drawKeylines_const_MatR_const_vectorLKeyLineGR_MatR_const_ScalarR_int(image: *const c_void, keylines: *const c_void, out_image: *mut c_void, color: *const core::Scalar, flags: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_line_descriptor_drawLineMatches_const_MatR_const_vectorLKeyLineGR_const_MatR_const_vectorLKeyLineGR_const_vectorLDMatchGR_MatR(img1: *const c_void, keylines1: *const c_void, img2: *const c_void, keylines2: *const c_void, matches1to2: *const c_void, out_img: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_line_descriptor_drawLineMatches_const_MatR_const_vectorLKeyLineGR_const_MatR_const_vectorLKeyLineGR_const_vectorLDMatchGR_MatR_const_ScalarR_const_ScalarR_const_vectorLcharGR_int(img1: *const c_void, keylines1: *const c_void, img2: *const c_void, keylines2: *const c_void, matches1to2: *const c_void, out_img: *mut c_void, match_color: *const core::Scalar, single_line_color: *const core::Scalar, matches_mask: *const c_void, flags: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_line_descriptor_drawKeylines_const_MatR_const_vectorLKeyLineGR_MatR(image: *const c_void, keylines: *const c_void, out_image: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_line_descriptor_drawKeylines_const_MatR_const_vectorLKeyLineGR_MatR_const_ScalarR_int(image: *const c_void, keylines: *const c_void, out_image: *mut c_void, color: *const core::Scalar, flags: i32, ocvrs_return: *mut Result<()>); + pub fn cv_line_descriptor_drawLineMatches_const_MatR_const_vectorLKeyLineGR_const_MatR_const_vectorLKeyLineGR_const_vectorLDMatchGR_MatR(img1: *const c_void, keylines1: *const c_void, img2: *const c_void, keylines2: *const c_void, matches1to2: *const c_void, out_img: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_line_descriptor_drawLineMatches_const_MatR_const_vectorLKeyLineGR_const_MatR_const_vectorLKeyLineGR_const_vectorLDMatchGR_MatR_const_ScalarR_const_ScalarR_const_vectorLcharGR_int(img1: *const c_void, keylines1: *const c_void, img2: *const c_void, keylines2: *const c_void, matches1to2: *const c_void, out_img: *mut c_void, match_color: *const core::Scalar, single_line_color: *const core::Scalar, matches_mask: *const c_void, flags: i32, ocvrs_return: *mut Result<()>); pub fn cv_line_descriptor_BinaryDescriptor_BinaryDescriptor_const_ParamsR(parameters: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_line_descriptor_BinaryDescriptor_BinaryDescriptor(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_line_descriptor_BinaryDescriptor_createBinaryDescriptor(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_line_descriptor_BinaryDescriptor_createBinaryDescriptor_Params(parameters: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_line_descriptor_BinaryDescriptor_getNumOfOctaves(instance: *mut c_void, ocvrs_return: *mut Result); - pub fn cv_line_descriptor_BinaryDescriptor_setNumOfOctaves_int(instance: *mut c_void, octaves: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_line_descriptor_BinaryDescriptor_setNumOfOctaves_int(instance: *mut c_void, octaves: i32, ocvrs_return: *mut Result<()>); pub fn cv_line_descriptor_BinaryDescriptor_getWidthOfBand(instance: *mut c_void, ocvrs_return: *mut Result); - pub fn cv_line_descriptor_BinaryDescriptor_setWidthOfBand_int(instance: *mut c_void, width: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_line_descriptor_BinaryDescriptor_setWidthOfBand_int(instance: *mut c_void, width: i32, ocvrs_return: *mut Result<()>); pub fn cv_line_descriptor_BinaryDescriptor_getReductionRatio(instance: *mut c_void, ocvrs_return: *mut Result); - pub fn cv_line_descriptor_BinaryDescriptor_setReductionRatio_int(instance: *mut c_void, r_ratio: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_line_descriptor_BinaryDescriptor_read_const_FileNodeR(instance: *mut c_void, fn_: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_line_descriptor_BinaryDescriptor_write_const_FileStorageR(instance: *const c_void, fs: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_line_descriptor_BinaryDescriptor_detect_const_MatR_vectorLKeyLineGR_const_MatR(instance: *mut c_void, image: *const c_void, keypoints: *mut c_void, mask: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_line_descriptor_BinaryDescriptor_detect_const_MatR_vectorLKeyLineGR(instance: *mut c_void, image: *const c_void, keypoints: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_line_descriptor_BinaryDescriptor_detect_const_const_vectorLMatGR_vectorLvectorLKeyLineGGR_const_vectorLMatGR(instance: *const c_void, images: *const c_void, keylines: *mut c_void, masks: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_line_descriptor_BinaryDescriptor_detect_const_const_vectorLMatGR_vectorLvectorLKeyLineGGR(instance: *const c_void, images: *const c_void, keylines: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_line_descriptor_BinaryDescriptor_compute_const_const_MatR_vectorLKeyLineGR_MatR_bool(instance: *const c_void, image: *const c_void, keylines: *mut c_void, descriptors: *mut c_void, return_float_descr: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_line_descriptor_BinaryDescriptor_compute_const_const_MatR_vectorLKeyLineGR_MatR(instance: *const c_void, image: *const c_void, keylines: *mut c_void, descriptors: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_line_descriptor_BinaryDescriptor_compute_const_const_vectorLMatGR_vectorLvectorLKeyLineGGR_vectorLMatGR_bool(instance: *const c_void, images: *const c_void, keylines: *mut c_void, descriptors: *mut c_void, return_float_descr: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_line_descriptor_BinaryDescriptor_compute_const_const_vectorLMatGR_vectorLvectorLKeyLineGGR_vectorLMatGR(instance: *const c_void, images: *const c_void, keylines: *mut c_void, descriptors: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_line_descriptor_BinaryDescriptor_setReductionRatio_int(instance: *mut c_void, r_ratio: i32, ocvrs_return: *mut Result<()>); + pub fn cv_line_descriptor_BinaryDescriptor_read_const_FileNodeR(instance: *mut c_void, fn_: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_line_descriptor_BinaryDescriptor_write_const_FileStorageR(instance: *const c_void, fs: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_line_descriptor_BinaryDescriptor_detect_const_MatR_vectorLKeyLineGR_const_MatR(instance: *mut c_void, image: *const c_void, keypoints: *mut c_void, mask: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_line_descriptor_BinaryDescriptor_detect_const_MatR_vectorLKeyLineGR(instance: *mut c_void, image: *const c_void, keypoints: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_line_descriptor_BinaryDescriptor_detect_const_const_vectorLMatGR_vectorLvectorLKeyLineGGR_const_vectorLMatGR(instance: *const c_void, images: *const c_void, keylines: *mut c_void, masks: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_line_descriptor_BinaryDescriptor_detect_const_const_vectorLMatGR_vectorLvectorLKeyLineGGR(instance: *const c_void, images: *const c_void, keylines: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_line_descriptor_BinaryDescriptor_compute_const_const_MatR_vectorLKeyLineGR_MatR_bool(instance: *const c_void, image: *const c_void, keylines: *mut c_void, descriptors: *mut c_void, return_float_descr: bool, ocvrs_return: *mut Result<()>); + pub fn cv_line_descriptor_BinaryDescriptor_compute_const_const_MatR_vectorLKeyLineGR_MatR(instance: *const c_void, image: *const c_void, keylines: *mut c_void, descriptors: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_line_descriptor_BinaryDescriptor_compute_const_const_vectorLMatGR_vectorLvectorLKeyLineGGR_vectorLMatGR_bool(instance: *const c_void, images: *const c_void, keylines: *mut c_void, descriptors: *mut c_void, return_float_descr: bool, ocvrs_return: *mut Result<()>); + pub fn cv_line_descriptor_BinaryDescriptor_compute_const_const_vectorLMatGR_vectorLvectorLKeyLineGGR_vectorLMatGR(instance: *const c_void, images: *const c_void, keylines: *mut c_void, descriptors: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_line_descriptor_BinaryDescriptor_descriptorSize_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_line_descriptor_BinaryDescriptor_descriptorType_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_line_descriptor_BinaryDescriptor_defaultNorm_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_line_descriptor_BinaryDescriptor_operator___const_const__InputArrayR_const__InputArrayR_vectorLKeyLineGR_const__OutputArrayR_bool_bool(instance: *const c_void, image: *const c_void, mask: *const c_void, keylines: *mut c_void, descriptors: *const c_void, use_provided_key_lines: bool, return_float_descr: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_line_descriptor_BinaryDescriptor_operator___const_const__InputArrayR_const__InputArrayR_vectorLKeyLineGR_const__OutputArrayR(instance: *const c_void, image: *const c_void, mask: *const c_void, keylines: *mut c_void, descriptors: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_line_descriptor_BinaryDescriptor_operator___const_const__InputArrayR_const__InputArrayR_vectorLKeyLineGR_const__OutputArrayR_bool_bool(instance: *const c_void, image: *const c_void, mask: *const c_void, keylines: *mut c_void, descriptors: *const c_void, use_provided_key_lines: bool, return_float_descr: bool, ocvrs_return: *mut Result<()>); + pub fn cv_line_descriptor_BinaryDescriptor_operator___const_const__InputArrayR_const__InputArrayR_vectorLKeyLineGR_const__OutputArrayR(instance: *const c_void, image: *const c_void, mask: *const c_void, keylines: *mut c_void, descriptors: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_line_descriptor_BinaryDescriptor_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_line_descriptor_BinaryDescriptor_delete(instance: *mut c_void); pub fn cv_line_descriptor_BinaryDescriptor_Params_Params(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_line_descriptor_BinaryDescriptor_Params_read_const_FileNodeR(instance: *mut c_void, fn_: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_line_descriptor_BinaryDescriptor_Params_write_const_FileStorageR(instance: *const c_void, fs: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_line_descriptor_BinaryDescriptor_Params_read_const_FileNodeR(instance: *mut c_void, fn_: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_line_descriptor_BinaryDescriptor_Params_write_const_FileStorageR(instance: *const c_void, fs: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_line_descriptor_BinaryDescriptor_Params_propNumOfOctave__const(instance: *const c_void) -> i32; pub fn cv_line_descriptor_BinaryDescriptor_Params_propNumOfOctave__const_int(instance: *mut c_void, val: i32); pub fn cv_line_descriptor_BinaryDescriptor_Params_propWidthOfBand__const(instance: *const c_void) -> i32; @@ -10357,22 +10402,22 @@ mod line_descriptor_sys { pub fn cv_line_descriptor_BinaryDescriptor_Params_propKsize__const(instance: *const c_void) -> i32; pub fn cv_line_descriptor_BinaryDescriptor_Params_propKsize__const_int(instance: *mut c_void, val: i32); pub fn cv_line_descriptor_BinaryDescriptor_Params_delete(instance: *mut c_void); - pub fn cv_line_descriptor_BinaryDescriptorMatcher_match_const_const_MatR_const_MatR_vectorLDMatchGR_const_MatR(instance: *const c_void, query_descriptors: *const c_void, train_descriptors: *const c_void, matches: *mut c_void, mask: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_line_descriptor_BinaryDescriptorMatcher_match_const_const_MatR_const_MatR_vectorLDMatchGR(instance: *const c_void, query_descriptors: *const c_void, train_descriptors: *const c_void, matches: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_line_descriptor_BinaryDescriptorMatcher_match_const_MatR_vectorLDMatchGR_const_vectorLMatGR(instance: *mut c_void, query_descriptors: *const c_void, matches: *mut c_void, masks: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_line_descriptor_BinaryDescriptorMatcher_match_const_MatR_vectorLDMatchGR(instance: *mut c_void, query_descriptors: *const c_void, matches: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_line_descriptor_BinaryDescriptorMatcher_knnMatch_const_const_MatR_const_MatR_vectorLvectorLDMatchGGR_int_const_MatR_bool(instance: *const c_void, query_descriptors: *const c_void, train_descriptors: *const c_void, matches: *mut c_void, k: i32, mask: *const c_void, compact_result: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_line_descriptor_BinaryDescriptorMatcher_knnMatch_const_const_MatR_const_MatR_vectorLvectorLDMatchGGR_int(instance: *const c_void, query_descriptors: *const c_void, train_descriptors: *const c_void, matches: *mut c_void, k: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_line_descriptor_BinaryDescriptorMatcher_knnMatch_const_MatR_vectorLvectorLDMatchGGR_int_const_vectorLMatGR_bool(instance: *mut c_void, query_descriptors: *const c_void, matches: *mut c_void, k: i32, masks: *const c_void, compact_result: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_line_descriptor_BinaryDescriptorMatcher_knnMatch_const_MatR_vectorLvectorLDMatchGGR_int(instance: *mut c_void, query_descriptors: *const c_void, matches: *mut c_void, k: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_line_descriptor_BinaryDescriptorMatcher_radiusMatch_const_const_MatR_const_MatR_vectorLvectorLDMatchGGR_float_const_MatR_bool(instance: *const c_void, query_descriptors: *const c_void, train_descriptors: *const c_void, matches: *mut c_void, max_distance: f32, mask: *const c_void, compact_result: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_line_descriptor_BinaryDescriptorMatcher_radiusMatch_const_const_MatR_const_MatR_vectorLvectorLDMatchGGR_float(instance: *const c_void, query_descriptors: *const c_void, train_descriptors: *const c_void, matches: *mut c_void, max_distance: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_line_descriptor_BinaryDescriptorMatcher_radiusMatch_const_MatR_vectorLvectorLDMatchGGR_float_const_vectorLMatGR_bool(instance: *mut c_void, query_descriptors: *const c_void, matches: *mut c_void, max_distance: f32, masks: *const c_void, compact_result: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_line_descriptor_BinaryDescriptorMatcher_radiusMatch_const_MatR_vectorLvectorLDMatchGGR_float(instance: *mut c_void, query_descriptors: *const c_void, matches: *mut c_void, max_distance: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_line_descriptor_BinaryDescriptorMatcher_add_const_vectorLMatGR(instance: *mut c_void, descriptors: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_line_descriptor_BinaryDescriptorMatcher_train(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_line_descriptor_BinaryDescriptorMatcher_match_const_const_MatR_const_MatR_vectorLDMatchGR_const_MatR(instance: *const c_void, query_descriptors: *const c_void, train_descriptors: *const c_void, matches: *mut c_void, mask: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_line_descriptor_BinaryDescriptorMatcher_match_const_const_MatR_const_MatR_vectorLDMatchGR(instance: *const c_void, query_descriptors: *const c_void, train_descriptors: *const c_void, matches: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_line_descriptor_BinaryDescriptorMatcher_match_const_MatR_vectorLDMatchGR_const_vectorLMatGR(instance: *mut c_void, query_descriptors: *const c_void, matches: *mut c_void, masks: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_line_descriptor_BinaryDescriptorMatcher_match_const_MatR_vectorLDMatchGR(instance: *mut c_void, query_descriptors: *const c_void, matches: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_line_descriptor_BinaryDescriptorMatcher_knnMatch_const_const_MatR_const_MatR_vectorLvectorLDMatchGGR_int_const_MatR_bool(instance: *const c_void, query_descriptors: *const c_void, train_descriptors: *const c_void, matches: *mut c_void, k: i32, mask: *const c_void, compact_result: bool, ocvrs_return: *mut Result<()>); + pub fn cv_line_descriptor_BinaryDescriptorMatcher_knnMatch_const_const_MatR_const_MatR_vectorLvectorLDMatchGGR_int(instance: *const c_void, query_descriptors: *const c_void, train_descriptors: *const c_void, matches: *mut c_void, k: i32, ocvrs_return: *mut Result<()>); + pub fn cv_line_descriptor_BinaryDescriptorMatcher_knnMatch_const_MatR_vectorLvectorLDMatchGGR_int_const_vectorLMatGR_bool(instance: *mut c_void, query_descriptors: *const c_void, matches: *mut c_void, k: i32, masks: *const c_void, compact_result: bool, ocvrs_return: *mut Result<()>); + pub fn cv_line_descriptor_BinaryDescriptorMatcher_knnMatch_const_MatR_vectorLvectorLDMatchGGR_int(instance: *mut c_void, query_descriptors: *const c_void, matches: *mut c_void, k: i32, ocvrs_return: *mut Result<()>); + pub fn cv_line_descriptor_BinaryDescriptorMatcher_radiusMatch_const_const_MatR_const_MatR_vectorLvectorLDMatchGGR_float_const_MatR_bool(instance: *const c_void, query_descriptors: *const c_void, train_descriptors: *const c_void, matches: *mut c_void, max_distance: f32, mask: *const c_void, compact_result: bool, ocvrs_return: *mut Result<()>); + pub fn cv_line_descriptor_BinaryDescriptorMatcher_radiusMatch_const_const_MatR_const_MatR_vectorLvectorLDMatchGGR_float(instance: *const c_void, query_descriptors: *const c_void, train_descriptors: *const c_void, matches: *mut c_void, max_distance: f32, ocvrs_return: *mut Result<()>); + pub fn cv_line_descriptor_BinaryDescriptorMatcher_radiusMatch_const_MatR_vectorLvectorLDMatchGGR_float_const_vectorLMatGR_bool(instance: *mut c_void, query_descriptors: *const c_void, matches: *mut c_void, max_distance: f32, masks: *const c_void, compact_result: bool, ocvrs_return: *mut Result<()>); + pub fn cv_line_descriptor_BinaryDescriptorMatcher_radiusMatch_const_MatR_vectorLvectorLDMatchGGR_float(instance: *mut c_void, query_descriptors: *const c_void, matches: *mut c_void, max_distance: f32, ocvrs_return: *mut Result<()>); + pub fn cv_line_descriptor_BinaryDescriptorMatcher_add_const_vectorLMatGR(instance: *mut c_void, descriptors: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_line_descriptor_BinaryDescriptorMatcher_train(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_line_descriptor_BinaryDescriptorMatcher_createBinaryDescriptorMatcher(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_line_descriptor_BinaryDescriptorMatcher_clear(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_line_descriptor_BinaryDescriptorMatcher_clear(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_line_descriptor_BinaryDescriptorMatcher_BinaryDescriptorMatcher(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_line_descriptor_BinaryDescriptorMatcher_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_line_descriptor_BinaryDescriptorMatcher_delete(instance: *mut c_void); @@ -10385,10 +10430,10 @@ mod line_descriptor_sys { pub fn cv_line_descriptor_LSDDetector_LSDDetector_LSDParam(_params: *const crate::line_descriptor::LSDParam, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_line_descriptor_LSDDetector_createLSDDetector(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_line_descriptor_LSDDetector_createLSDDetector_LSDParam(params: *const crate::line_descriptor::LSDParam, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_line_descriptor_LSDDetector_detect_const_MatR_vectorLKeyLineGR_int_int_const_MatR(instance: *mut c_void, image: *const c_void, keypoints: *mut c_void, scale: i32, num_octaves: i32, mask: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_line_descriptor_LSDDetector_detect_const_MatR_vectorLKeyLineGR_int_int(instance: *mut c_void, image: *const c_void, keypoints: *mut c_void, scale: i32, num_octaves: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_line_descriptor_LSDDetector_detect_const_const_vectorLMatGR_vectorLvectorLKeyLineGGR_int_int_const_vectorLMatGR(instance: *const c_void, images: *const c_void, keylines: *mut c_void, scale: i32, num_octaves: i32, masks: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_line_descriptor_LSDDetector_detect_const_const_vectorLMatGR_vectorLvectorLKeyLineGGR_int_int(instance: *const c_void, images: *const c_void, keylines: *mut c_void, scale: i32, num_octaves: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_line_descriptor_LSDDetector_detect_const_MatR_vectorLKeyLineGR_int_int_const_MatR(instance: *mut c_void, image: *const c_void, keypoints: *mut c_void, scale: i32, num_octaves: i32, mask: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_line_descriptor_LSDDetector_detect_const_MatR_vectorLKeyLineGR_int_int(instance: *mut c_void, image: *const c_void, keypoints: *mut c_void, scale: i32, num_octaves: i32, ocvrs_return: *mut Result<()>); + pub fn cv_line_descriptor_LSDDetector_detect_const_const_vectorLMatGR_vectorLvectorLKeyLineGGR_int_int_const_vectorLMatGR(instance: *const c_void, images: *const c_void, keylines: *mut c_void, scale: i32, num_octaves: i32, masks: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_line_descriptor_LSDDetector_detect_const_const_vectorLMatGR_vectorLvectorLKeyLineGGR_int_int(instance: *const c_void, images: *const c_void, keylines: *mut c_void, scale: i32, num_octaves: i32, ocvrs_return: *mut Result<()>); pub fn cv_line_descriptor_LSDDetector_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_line_descriptor_LSDDetector_delete(instance: *mut c_void); pub fn cv_line_descriptor_LSDParam_LSDParam(ocvrs_return: *mut Result); @@ -10444,10 +10489,8 @@ mod line_descriptor_sys { pub fn std_vectorLstd_vectorLcv_line_descriptor_KeyLineGG_set_size_t_const_vectorLKeyLineG(instance: *mut c_void, index: size_t, val: *const c_void); } } -#[cfg(ocvrs_has_module_line_descriptor)] pub use line_descriptor_sys::*; -#[cfg(ocvrs_has_module_mcc)] mod mcc_sys { use super::*; @@ -10455,19 +10498,19 @@ mod mcc_sys { pub fn cv_ccm_ColorCorrectionModel_ColorCorrectionModel_const_MatR_CONST_COLOR(src: *const c_void, constcolor: crate::mcc::CONST_COLOR, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ccm_ColorCorrectionModel_ColorCorrectionModel_const_MatR_Mat_COLOR_SPACE(src: *const c_void, colors: *mut c_void, ref_cs: crate::mcc::COLOR_SPACE, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ccm_ColorCorrectionModel_ColorCorrectionModel_const_MatR_Mat_COLOR_SPACE_Mat(src: *const c_void, colors: *mut c_void, ref_cs: crate::mcc::COLOR_SPACE, colored: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_ccm_ColorCorrectionModel_setColorSpace_COLOR_SPACE(instance: *mut c_void, cs: crate::mcc::COLOR_SPACE, ocvrs_return: *mut ResultVoid); - pub fn cv_ccm_ColorCorrectionModel_setCCM_TYPE_CCM_TYPE(instance: *mut c_void, ccm_type: crate::mcc::CCM_TYPE, ocvrs_return: *mut ResultVoid); - pub fn cv_ccm_ColorCorrectionModel_setDistance_DISTANCE_TYPE(instance: *mut c_void, distance: crate::mcc::DISTANCE_TYPE, ocvrs_return: *mut ResultVoid); - pub fn cv_ccm_ColorCorrectionModel_setLinear_LINEAR_TYPE(instance: *mut c_void, linear_type: crate::mcc::LINEAR_TYPE, ocvrs_return: *mut ResultVoid); - pub fn cv_ccm_ColorCorrectionModel_setLinearGamma_const_doubleR(instance: *mut c_void, gamma: *const f64, ocvrs_return: *mut ResultVoid); - pub fn cv_ccm_ColorCorrectionModel_setLinearDegree_const_intR(instance: *mut c_void, deg: *const i32, ocvrs_return: *mut ResultVoid); - pub fn cv_ccm_ColorCorrectionModel_setSaturatedThreshold_const_doubleR_const_doubleR(instance: *mut c_void, lower: *const f64, upper: *const f64, ocvrs_return: *mut ResultVoid); - pub fn cv_ccm_ColorCorrectionModel_setWeightsList_const_MatR(instance: *mut c_void, weights_list: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ccm_ColorCorrectionModel_setWeightCoeff_const_doubleR(instance: *mut c_void, weights_coeff: *const f64, ocvrs_return: *mut ResultVoid); - pub fn cv_ccm_ColorCorrectionModel_setInitialMethod_INITIAL_METHOD_TYPE(instance: *mut c_void, initial_method_type: crate::mcc::INITIAL_METHOD_TYPE, ocvrs_return: *mut ResultVoid); - pub fn cv_ccm_ColorCorrectionModel_setMaxCount_const_intR(instance: *mut c_void, max_count: *const i32, ocvrs_return: *mut ResultVoid); - pub fn cv_ccm_ColorCorrectionModel_setEpsilon_const_doubleR(instance: *mut c_void, epsilon: *const f64, ocvrs_return: *mut ResultVoid); - pub fn cv_ccm_ColorCorrectionModel_run(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ccm_ColorCorrectionModel_setColorSpace_COLOR_SPACE(instance: *mut c_void, cs: crate::mcc::COLOR_SPACE, ocvrs_return: *mut Result<()>); + pub fn cv_ccm_ColorCorrectionModel_setCCM_TYPE_CCM_TYPE(instance: *mut c_void, ccm_type: crate::mcc::CCM_TYPE, ocvrs_return: *mut Result<()>); + pub fn cv_ccm_ColorCorrectionModel_setDistance_DISTANCE_TYPE(instance: *mut c_void, distance: crate::mcc::DISTANCE_TYPE, ocvrs_return: *mut Result<()>); + pub fn cv_ccm_ColorCorrectionModel_setLinear_LINEAR_TYPE(instance: *mut c_void, linear_type: crate::mcc::LINEAR_TYPE, ocvrs_return: *mut Result<()>); + pub fn cv_ccm_ColorCorrectionModel_setLinearGamma_const_doubleR(instance: *mut c_void, gamma: *const f64, ocvrs_return: *mut Result<()>); + pub fn cv_ccm_ColorCorrectionModel_setLinearDegree_const_intR(instance: *mut c_void, deg: *const i32, ocvrs_return: *mut Result<()>); + pub fn cv_ccm_ColorCorrectionModel_setSaturatedThreshold_const_doubleR_const_doubleR(instance: *mut c_void, lower: *const f64, upper: *const f64, ocvrs_return: *mut Result<()>); + pub fn cv_ccm_ColorCorrectionModel_setWeightsList_const_MatR(instance: *mut c_void, weights_list: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ccm_ColorCorrectionModel_setWeightCoeff_const_doubleR(instance: *mut c_void, weights_coeff: *const f64, ocvrs_return: *mut Result<()>); + pub fn cv_ccm_ColorCorrectionModel_setInitialMethod_INITIAL_METHOD_TYPE(instance: *mut c_void, initial_method_type: crate::mcc::INITIAL_METHOD_TYPE, ocvrs_return: *mut Result<()>); + pub fn cv_ccm_ColorCorrectionModel_setMaxCount_const_intR(instance: *mut c_void, max_count: *const i32, ocvrs_return: *mut Result<()>); + pub fn cv_ccm_ColorCorrectionModel_setEpsilon_const_doubleR(instance: *mut c_void, epsilon: *const f64, ocvrs_return: *mut Result<()>); + pub fn cv_ccm_ColorCorrectionModel_run(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_ccm_ColorCorrectionModel_getCCM_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ccm_ColorCorrectionModel_getLoss_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_ccm_ColorCorrectionModel_get_src_rgbl_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); @@ -10478,12 +10521,12 @@ mod mcc_sys { pub fn cv_ccm_ColorCorrectionModel_infer_const_MatR(instance: *mut c_void, img: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ccm_ColorCorrectionModel_delete(instance: *mut c_void); pub fn cv_mcc_CChecker_create(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_mcc_CChecker_setTarget_TYPECHART(instance: *mut c_void, _target: crate::mcc::MCC_TYPECHART, ocvrs_return: *mut ResultVoid); - pub fn cv_mcc_CChecker_setBox_vectorLPoint2fG(instance: *mut c_void, _box: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_mcc_CChecker_setChartsRGB_Mat(instance: *mut c_void, _charts_rgb: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_mcc_CChecker_setChartsYCbCr_Mat(instance: *mut c_void, _charts_y_cb_cr: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_mcc_CChecker_setCost_float(instance: *mut c_void, _cost: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_mcc_CChecker_setCenter_Point2f(instance: *mut c_void, _center: *const core::Point2f, ocvrs_return: *mut ResultVoid); + pub fn cv_mcc_CChecker_setTarget_TYPECHART(instance: *mut c_void, _target: crate::mcc::MCC_TYPECHART, ocvrs_return: *mut Result<()>); + pub fn cv_mcc_CChecker_setBox_vectorLPoint2fG(instance: *mut c_void, _box: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_mcc_CChecker_setChartsRGB_Mat(instance: *mut c_void, _charts_rgb: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_mcc_CChecker_setChartsYCbCr_Mat(instance: *mut c_void, _charts_y_cb_cr: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_mcc_CChecker_setCost_float(instance: *mut c_void, _cost: f32, ocvrs_return: *mut Result<()>); + pub fn cv_mcc_CChecker_setCenter_Point2f(instance: *mut c_void, _center: *const core::Point2f, ocvrs_return: *mut Result<()>); pub fn cv_mcc_CChecker_getTarget(instance: *mut c_void, ocvrs_return: *mut Result); pub fn cv_mcc_CChecker_getBox(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_mcc_CChecker_getColorCharts(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); @@ -10502,7 +10545,7 @@ mod mcc_sys { pub fn cv_mcc_CCheckerDetector_create(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_mcc_CCheckerDetector_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_mcc_CCheckerDetector_delete(instance: *mut c_void); - pub fn cv_mcc_CCheckerDraw_draw_const__InputOutputArrayR(instance: *mut c_void, img: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_mcc_CCheckerDraw_draw_const__InputOutputArrayR(instance: *mut c_void, img: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_mcc_CCheckerDraw_create_PtrLCCheckerG_Scalar_int(p_checker: *mut c_void, color: *const core::Scalar, thickness: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_mcc_CCheckerDraw_create_PtrLCCheckerG(p_checker: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_mcc_CCheckerDraw_delete(instance: *mut c_void); @@ -10579,48 +10622,46 @@ mod mcc_sys { pub fn std_vectorLcv_PtrLcv_mcc_CCheckerGG_set_size_t_const_PtrLCCheckerG(instance: *mut c_void, index: size_t, val: *const c_void); } } -#[cfg(ocvrs_has_module_mcc)] pub use mcc_sys::*; -#[cfg(ocvrs_has_module_ml)] mod ml_sys { use super::*; extern "C" { - pub fn cv_ml_createConcentricSpheresTestSet_int_int_int_const__OutputArrayR_const__OutputArrayR(nsamples: i32, nfeatures: i32, nclasses: i32, samples: *const c_void, responses: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ml_randMVNormal_const__InputArrayR_const__InputArrayR_int_const__OutputArrayR(mean: *const c_void, cov: *const c_void, nsamples: i32, samples: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ml_ANN_MLP_setTrainMethod_int_double_double(instance: *mut c_void, method: i32, param1: f64, param2: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_ml_ANN_MLP_setTrainMethod_int(instance: *mut c_void, method: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_createConcentricSpheresTestSet_int_int_int_const__OutputArrayR_const__OutputArrayR(nsamples: i32, nfeatures: i32, nclasses: i32, samples: *const c_void, responses: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ml_randMVNormal_const__InputArrayR_const__InputArrayR_int_const__OutputArrayR(mean: *const c_void, cov: *const c_void, nsamples: i32, samples: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ml_ANN_MLP_setTrainMethod_int_double_double(instance: *mut c_void, method: i32, param1: f64, param2: f64, ocvrs_return: *mut Result<()>); + pub fn cv_ml_ANN_MLP_setTrainMethod_int(instance: *mut c_void, method: i32, ocvrs_return: *mut Result<()>); pub fn cv_ml_ANN_MLP_getTrainMethod_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_ANN_MLP_setActivationFunction_int_double_double(instance: *mut c_void, typ: i32, param1: f64, param2: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_ml_ANN_MLP_setActivationFunction_int(instance: *mut c_void, typ: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_ml_ANN_MLP_setLayerSizes_const__InputArrayR(instance: *mut c_void, _layer_sizes: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_ANN_MLP_setActivationFunction_int_double_double(instance: *mut c_void, typ: i32, param1: f64, param2: f64, ocvrs_return: *mut Result<()>); + pub fn cv_ml_ANN_MLP_setActivationFunction_int(instance: *mut c_void, typ: i32, ocvrs_return: *mut Result<()>); + pub fn cv_ml_ANN_MLP_setLayerSizes_const__InputArrayR(instance: *mut c_void, _layer_sizes: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_ml_ANN_MLP_getLayerSizes_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ml_ANN_MLP_getTermCriteria_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_ANN_MLP_setTermCriteria_TermCriteria(instance: *mut c_void, val: *const core::TermCriteria, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_ANN_MLP_setTermCriteria_TermCriteria(instance: *mut c_void, val: *const core::TermCriteria, ocvrs_return: *mut Result<()>); pub fn cv_ml_ANN_MLP_getBackpropWeightScale_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_ANN_MLP_setBackpropWeightScale_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_ANN_MLP_setBackpropWeightScale_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_ml_ANN_MLP_getBackpropMomentumScale_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_ANN_MLP_setBackpropMomentumScale_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_ANN_MLP_setBackpropMomentumScale_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_ml_ANN_MLP_getRpropDW0_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_ANN_MLP_setRpropDW0_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_ANN_MLP_setRpropDW0_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_ml_ANN_MLP_getRpropDWPlus_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_ANN_MLP_setRpropDWPlus_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_ANN_MLP_setRpropDWPlus_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_ml_ANN_MLP_getRpropDWMinus_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_ANN_MLP_setRpropDWMinus_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_ANN_MLP_setRpropDWMinus_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_ml_ANN_MLP_getRpropDWMin_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_ANN_MLP_setRpropDWMin_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_ANN_MLP_setRpropDWMin_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_ml_ANN_MLP_getRpropDWMax_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_ANN_MLP_setRpropDWMax_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_ANN_MLP_setRpropDWMax_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_ml_ANN_MLP_getAnnealInitialT_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_ANN_MLP_setAnnealInitialT_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_ANN_MLP_setAnnealInitialT_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_ml_ANN_MLP_getAnnealFinalT_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_ANN_MLP_setAnnealFinalT_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_ANN_MLP_setAnnealFinalT_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_ml_ANN_MLP_getAnnealCoolingRatio_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_ANN_MLP_setAnnealCoolingRatio_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_ANN_MLP_setAnnealCoolingRatio_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_ml_ANN_MLP_getAnnealItePerStep_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_ANN_MLP_setAnnealItePerStep_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_ml_ANN_MLP_setAnnealEnergyRNG_const_RNGR(instance: *mut c_void, rng: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_ANN_MLP_setAnnealItePerStep_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); + pub fn cv_ml_ANN_MLP_setAnnealEnergyRNG_const_RNGR(instance: *mut c_void, rng: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_ml_ANN_MLP_getWeights_const_int(instance: *const c_void, layer_idx: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ml_ANN_MLP_create(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ml_ANN_MLP_load_const_StringR(filepath: *const c_char, ocvrs_return: *mut Result<*mut c_void>); @@ -10628,11 +10669,11 @@ mod ml_sys { pub fn cv_ml_ANN_MLP_to_StatModel(instance: *mut c_void) -> *mut c_void; pub fn cv_ml_ANN_MLP_delete(instance: *mut c_void); pub fn cv_ml_Boost_getBoostType_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_Boost_setBoostType_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_Boost_setBoostType_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_ml_Boost_getWeakCount_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_Boost_setWeakCount_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_Boost_setWeakCount_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_ml_Boost_getWeightTrimRate_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_Boost_setWeightTrimRate_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_Boost_setWeightTrimRate_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_ml_Boost_create(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ml_Boost_load_const_StringR_const_StringR(filepath: *const c_char, node_name: *const c_char, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ml_Boost_load_const_StringR(filepath: *const c_char, ocvrs_return: *mut Result<*mut c_void>); @@ -10641,23 +10682,23 @@ mod ml_sys { pub fn cv_ml_Boost_to_StatModel(instance: *mut c_void) -> *mut c_void; pub fn cv_ml_Boost_delete(instance: *mut c_void); pub fn cv_ml_DTrees_getMaxCategories_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_DTrees_setMaxCategories_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_DTrees_setMaxCategories_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_ml_DTrees_getMaxDepth_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_DTrees_setMaxDepth_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_DTrees_setMaxDepth_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_ml_DTrees_getMinSampleCount_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_DTrees_setMinSampleCount_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_DTrees_setMinSampleCount_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_ml_DTrees_getCVFolds_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_DTrees_setCVFolds_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_DTrees_setCVFolds_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_ml_DTrees_getUseSurrogates_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_DTrees_setUseSurrogates_bool(instance: *mut c_void, val: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_DTrees_setUseSurrogates_bool(instance: *mut c_void, val: bool, ocvrs_return: *mut Result<()>); pub fn cv_ml_DTrees_getUse1SERule_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_DTrees_setUse1SERule_bool(instance: *mut c_void, val: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_DTrees_setUse1SERule_bool(instance: *mut c_void, val: bool, ocvrs_return: *mut Result<()>); pub fn cv_ml_DTrees_getTruncatePrunedTree_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_DTrees_setTruncatePrunedTree_bool(instance: *mut c_void, val: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_DTrees_setTruncatePrunedTree_bool(instance: *mut c_void, val: bool, ocvrs_return: *mut Result<()>); pub fn cv_ml_DTrees_getRegressionAccuracy_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_DTrees_setRegressionAccuracy_float(instance: *mut c_void, val: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_DTrees_setRegressionAccuracy_float(instance: *mut c_void, val: f32, ocvrs_return: *mut Result<()>); pub fn cv_ml_DTrees_getPriors_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_ml_DTrees_setPriors_const_MatR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_DTrees_setPriors_const_MatR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_ml_DTrees_getRoots_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ml_DTrees_getNodes_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ml_DTrees_getSplits_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); @@ -10701,14 +10742,14 @@ mod ml_sys { pub fn cv_ml_DTrees_Split_propSubsetOfs_const_int(instance: *mut c_void, val: i32); pub fn cv_ml_DTrees_Split_delete(instance: *mut c_void); pub fn cv_ml_EM_getClustersNumber_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_EM_setClustersNumber_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_EM_setClustersNumber_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_ml_EM_getCovarianceMatrixType_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_EM_setCovarianceMatrixType_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_EM_setCovarianceMatrixType_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_ml_EM_getTermCriteria_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_EM_setTermCriteria_const_TermCriteriaR(instance: *mut c_void, val: *const core::TermCriteria, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_EM_setTermCriteria_const_TermCriteriaR(instance: *mut c_void, val: *const core::TermCriteria, ocvrs_return: *mut Result<()>); pub fn cv_ml_EM_getWeights_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ml_EM_getMeans_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_ml_EM_getCovs_const_vectorLMatGR(instance: *const c_void, covs: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_EM_getCovs_const_vectorLMatGR(instance: *const c_void, covs: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_ml_EM_predict_const_const__InputArrayR_const__OutputArrayR_int(instance: *const c_void, samples: *const c_void, results: *const c_void, flags: i32, ocvrs_return: *mut Result); pub fn cv_ml_EM_predict_const_const__InputArrayR(instance: *const c_void, samples: *const c_void, ocvrs_return: *mut Result); pub fn cv_ml_EM_predict2_const_const__InputArrayR_const__OutputArrayR(instance: *const c_void, sample: *const c_void, probs: *const c_void, ocvrs_return: *mut Result); @@ -10725,13 +10766,13 @@ mod ml_sys { pub fn cv_ml_EM_to_StatModel(instance: *mut c_void) -> *mut c_void; pub fn cv_ml_EM_delete(instance: *mut c_void); pub fn cv_ml_KNearest_getDefaultK_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_KNearest_setDefaultK_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_KNearest_setDefaultK_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_ml_KNearest_getIsClassifier_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_KNearest_setIsClassifier_bool(instance: *mut c_void, val: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_KNearest_setIsClassifier_bool(instance: *mut c_void, val: bool, ocvrs_return: *mut Result<()>); pub fn cv_ml_KNearest_getEmax_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_KNearest_setEmax_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_KNearest_setEmax_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_ml_KNearest_getAlgorithmType_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_KNearest_setAlgorithmType_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_KNearest_setAlgorithmType_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_ml_KNearest_findNearest_const_const__InputArrayR_int_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *const c_void, samples: *const c_void, k: i32, results: *const c_void, neighbor_responses: *const c_void, dist: *const c_void, ocvrs_return: *mut Result); pub fn cv_ml_KNearest_findNearest_const_const__InputArrayR_int_const__OutputArrayR(instance: *const c_void, samples: *const c_void, k: i32, results: *const c_void, ocvrs_return: *mut Result); pub fn cv_ml_KNearest_create(ocvrs_return: *mut Result<*mut c_void>); @@ -10740,17 +10781,17 @@ mod ml_sys { pub fn cv_ml_KNearest_to_StatModel(instance: *mut c_void) -> *mut c_void; pub fn cv_ml_KNearest_delete(instance: *mut c_void); pub fn cv_ml_LogisticRegression_getLearningRate_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_LogisticRegression_setLearningRate_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_LogisticRegression_setLearningRate_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_ml_LogisticRegression_getIterations_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_LogisticRegression_setIterations_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_LogisticRegression_setIterations_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_ml_LogisticRegression_getRegularization_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_LogisticRegression_setRegularization_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_LogisticRegression_setRegularization_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_ml_LogisticRegression_getTrainMethod_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_LogisticRegression_setTrainMethod_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_LogisticRegression_setTrainMethod_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_ml_LogisticRegression_getMiniBatchSize_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_LogisticRegression_setMiniBatchSize_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_LogisticRegression_setMiniBatchSize_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_ml_LogisticRegression_getTermCriteria_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_LogisticRegression_setTermCriteria_TermCriteria(instance: *mut c_void, val: *const core::TermCriteria, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_LogisticRegression_setTermCriteria_TermCriteria(instance: *mut c_void, val: *const core::TermCriteria, ocvrs_return: *mut Result<()>); pub fn cv_ml_LogisticRegression_predict_const_const__InputArrayR_const__OutputArrayR_int(instance: *const c_void, samples: *const c_void, results: *const c_void, flags: i32, ocvrs_return: *mut Result); pub fn cv_ml_LogisticRegression_predict_const_const__InputArrayR(instance: *const c_void, samples: *const c_void, ocvrs_return: *mut Result); pub fn cv_ml_LogisticRegression_get_learnt_thetas_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); @@ -10780,13 +10821,13 @@ mod ml_sys { pub fn cv_ml_ParamGrid_propLogStep_const_double(instance: *mut c_void, val: f64); pub fn cv_ml_ParamGrid_delete(instance: *mut c_void); pub fn cv_ml_RTrees_getCalculateVarImportance_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_RTrees_setCalculateVarImportance_bool(instance: *mut c_void, val: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_RTrees_setCalculateVarImportance_bool(instance: *mut c_void, val: bool, ocvrs_return: *mut Result<()>); pub fn cv_ml_RTrees_getActiveVarCount_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_RTrees_setActiveVarCount_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_RTrees_setActiveVarCount_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_ml_RTrees_getTermCriteria_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_RTrees_setTermCriteria_const_TermCriteriaR(instance: *mut c_void, val: *const core::TermCriteria, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_RTrees_setTermCriteria_const_TermCriteriaR(instance: *mut c_void, val: *const core::TermCriteria, ocvrs_return: *mut Result<()>); pub fn cv_ml_RTrees_getVarImportance_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_ml_RTrees_getVotes_const_const__InputArrayR_const__OutputArrayR_int(instance: *const c_void, samples: *const c_void, results: *const c_void, flags: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_RTrees_getVotes_const_const__InputArrayR_const__OutputArrayR_int(instance: *const c_void, samples: *const c_void, results: *const c_void, flags: i32, ocvrs_return: *mut Result<()>); pub fn cv_ml_RTrees_getOOBError_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_ml_RTrees_create(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ml_RTrees_load_const_StringR_const_StringR(filepath: *const c_char, node_name: *const c_char, ocvrs_return: *mut Result<*mut c_void>); @@ -10796,26 +10837,26 @@ mod ml_sys { pub fn cv_ml_RTrees_to_StatModel(instance: *mut c_void) -> *mut c_void; pub fn cv_ml_RTrees_delete(instance: *mut c_void); pub fn cv_ml_SVM_getType_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_SVM_setType_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_SVM_setType_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_ml_SVM_getGamma_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_SVM_setGamma_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_SVM_setGamma_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_ml_SVM_getCoef0_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_SVM_setCoef0_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_SVM_setCoef0_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_ml_SVM_getDegree_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_SVM_setDegree_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_SVM_setDegree_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_ml_SVM_getC_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_SVM_setC_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_SVM_setC_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_ml_SVM_getNu_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_SVM_setNu_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_SVM_setNu_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_ml_SVM_getP_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_SVM_setP_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_SVM_setP_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_ml_SVM_getClassWeights_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_ml_SVM_setClassWeights_const_MatR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_SVM_setClassWeights_const_MatR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_ml_SVM_getTermCriteria_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_SVM_setTermCriteria_const_TermCriteriaR(instance: *mut c_void, val: *const core::TermCriteria, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_SVM_setTermCriteria_const_TermCriteriaR(instance: *mut c_void, val: *const core::TermCriteria, ocvrs_return: *mut Result<()>); pub fn cv_ml_SVM_getKernelType_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_SVM_setKernel_int(instance: *mut c_void, kernel_type: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_ml_SVM_setCustomKernel_const_PtrLKernelGR(instance: *mut c_void, _kernel: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_SVM_setKernel_int(instance: *mut c_void, kernel_type: i32, ocvrs_return: *mut Result<()>); + pub fn cv_ml_SVM_setCustomKernel_const_PtrLKernelGR(instance: *mut c_void, _kernel: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_ml_SVM_trainAuto_const_PtrLTrainDataGR_int_ParamGrid_ParamGrid_ParamGrid_ParamGrid_ParamGrid_ParamGrid_bool(instance: *mut c_void, data: *const c_void, k_fold: i32, cgrid: *mut c_void, gamma_grid: *mut c_void, p_grid: *mut c_void, nu_grid: *mut c_void, coeff_grid: *mut c_void, degree_grid: *mut c_void, balanced: bool, ocvrs_return: *mut Result); pub fn cv_ml_SVM_trainAuto_const_PtrLTrainDataGR(instance: *mut c_void, data: *const c_void, ocvrs_return: *mut Result); pub fn cv_ml_SVM_trainAuto_const__InputArrayR_int_const__InputArrayR_int_PtrLParamGridG_PtrLParamGridG_PtrLParamGridG_PtrLParamGridG_PtrLParamGridG_PtrLParamGridG_bool(instance: *mut c_void, samples: *const c_void, layout: i32, responses: *const c_void, k_fold: i32, cgrid: *mut c_void, gamma_grid: *mut c_void, p_grid: *mut c_void, nu_grid: *mut c_void, coeff_grid: *mut c_void, degree_grid: *mut c_void, balanced: bool, ocvrs_return: *mut Result); @@ -10831,7 +10872,7 @@ mod ml_sys { pub fn cv_ml_SVM_to_StatModel(instance: *mut c_void) -> *mut c_void; pub fn cv_ml_SVM_delete(instance: *mut c_void); pub fn cv_ml_SVM_Kernel_getType_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_SVM_Kernel_calc_int_int_const_floatX_const_floatX_floatX(instance: *mut c_void, vcount: i32, n: i32, vecs: *const f32, another: *const f32, results: *mut f32, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_SVM_Kernel_calc_int_int_const_floatX_const_floatX_floatX(instance: *mut c_void, vcount: i32, n: i32, vecs: *const f32, another: *const f32, results: *mut f32, ocvrs_return: *mut Result<()>); pub fn cv_ml_SVM_Kernel_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_ml_SVM_Kernel_delete(instance: *mut c_void); pub fn cv_ml_SVMSGD_getWeights(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); @@ -10839,20 +10880,20 @@ mod ml_sys { pub fn cv_ml_SVMSGD_create(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ml_SVMSGD_load_const_StringR_const_StringR(filepath: *const c_char, node_name: *const c_char, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ml_SVMSGD_load_const_StringR(filepath: *const c_char, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_ml_SVMSGD_setOptimalParameters_int_int(instance: *mut c_void, svmsgd_type: i32, margin_type: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_ml_SVMSGD_setOptimalParameters(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_SVMSGD_setOptimalParameters_int_int(instance: *mut c_void, svmsgd_type: i32, margin_type: i32, ocvrs_return: *mut Result<()>); + pub fn cv_ml_SVMSGD_setOptimalParameters(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_ml_SVMSGD_getSvmsgdType_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_SVMSGD_setSvmsgdType_int(instance: *mut c_void, svmsgd_type: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_SVMSGD_setSvmsgdType_int(instance: *mut c_void, svmsgd_type: i32, ocvrs_return: *mut Result<()>); pub fn cv_ml_SVMSGD_getMarginType_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_SVMSGD_setMarginType_int(instance: *mut c_void, margin_type: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_SVMSGD_setMarginType_int(instance: *mut c_void, margin_type: i32, ocvrs_return: *mut Result<()>); pub fn cv_ml_SVMSGD_getMarginRegularization_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_SVMSGD_setMarginRegularization_float(instance: *mut c_void, margin_regularization: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_SVMSGD_setMarginRegularization_float(instance: *mut c_void, margin_regularization: f32, ocvrs_return: *mut Result<()>); pub fn cv_ml_SVMSGD_getInitialStepSize_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_SVMSGD_setInitialStepSize_float(instance: *mut c_void, initial_step_size: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_SVMSGD_setInitialStepSize_float(instance: *mut c_void, initial_step_size: f32, ocvrs_return: *mut Result<()>); pub fn cv_ml_SVMSGD_getStepDecreasingPower_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_SVMSGD_setStepDecreasingPower_float(instance: *mut c_void, step_decreasing_power: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_SVMSGD_setStepDecreasingPower_float(instance: *mut c_void, step_decreasing_power: f32, ocvrs_return: *mut Result<()>); pub fn cv_ml_SVMSGD_getTermCriteria_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_SVMSGD_setTermCriteria_const_TermCriteriaR(instance: *mut c_void, val: *const core::TermCriteria, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_SVMSGD_setTermCriteria_const_TermCriteriaR(instance: *mut c_void, val: *const core::TermCriteria, ocvrs_return: *mut Result<()>); pub fn cv_ml_SVMSGD_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_ml_SVMSGD_to_StatModel(instance: *mut c_void) -> *mut c_void; pub fn cv_ml_SVMSGD_delete(instance: *mut c_void); @@ -10885,7 +10926,7 @@ mod ml_sys { pub fn cv_ml_TrainData_getNSamples_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_ml_TrainData_getNVars_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_ml_TrainData_getNAllVars_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ml_TrainData_getSample_const_const__InputArrayR_int_floatX(instance: *const c_void, var_idx: *const c_void, sidx: i32, buf: *mut f32, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_TrainData_getSample_const_const__InputArrayR_int_floatX(instance: *const c_void, var_idx: *const c_void, sidx: i32, buf: *mut f32, ocvrs_return: *mut Result<()>); pub fn cv_ml_TrainData_getSamples_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ml_TrainData_getMissing_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ml_TrainData_getTrainSamples_const_int_bool_bool(instance: *const c_void, layout: i32, compress_samples: bool, compress_vars: bool, ocvrs_return: *mut Result<*mut c_void>); @@ -10905,20 +10946,20 @@ mod ml_sys { pub fn cv_ml_TrainData_getResponseType_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_ml_TrainData_getTrainSampleIdx_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ml_TrainData_getTestSampleIdx_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_ml_TrainData_getValues_const_int_const__InputArrayR_floatX(instance: *const c_void, vi: i32, sidx: *const c_void, values: *mut f32, ocvrs_return: *mut ResultVoid); - pub fn cv_ml_TrainData_getNormCatValues_const_int_const__InputArrayR_intX(instance: *const c_void, vi: i32, sidx: *const c_void, values: *mut i32, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_TrainData_getValues_const_int_const__InputArrayR_floatX(instance: *const c_void, vi: i32, sidx: *const c_void, values: *mut f32, ocvrs_return: *mut Result<()>); + pub fn cv_ml_TrainData_getNormCatValues_const_int_const__InputArrayR_intX(instance: *const c_void, vi: i32, sidx: *const c_void, values: *mut i32, ocvrs_return: *mut Result<()>); pub fn cv_ml_TrainData_getDefaultSubstValues_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ml_TrainData_getCatCount_const_int(instance: *const c_void, vi: i32, ocvrs_return: *mut Result); pub fn cv_ml_TrainData_getClassLabels_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ml_TrainData_getCatOfs_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ml_TrainData_getCatMap_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_ml_TrainData_setTrainTestSplit_int_bool(instance: *mut c_void, count: i32, shuffle: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_ml_TrainData_setTrainTestSplit_int(instance: *mut c_void, count: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_ml_TrainData_setTrainTestSplitRatio_double_bool(instance: *mut c_void, ratio: f64, shuffle: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_ml_TrainData_setTrainTestSplitRatio_double(instance: *mut c_void, ratio: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_ml_TrainData_shuffleTrainTest(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_TrainData_setTrainTestSplit_int_bool(instance: *mut c_void, count: i32, shuffle: bool, ocvrs_return: *mut Result<()>); + pub fn cv_ml_TrainData_setTrainTestSplit_int(instance: *mut c_void, count: i32, ocvrs_return: *mut Result<()>); + pub fn cv_ml_TrainData_setTrainTestSplitRatio_double_bool(instance: *mut c_void, ratio: f64, shuffle: bool, ocvrs_return: *mut Result<()>); + pub fn cv_ml_TrainData_setTrainTestSplitRatio_double(instance: *mut c_void, ratio: f64, ocvrs_return: *mut Result<()>); + pub fn cv_ml_TrainData_shuffleTrainTest(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_ml_TrainData_getTestSamples_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_ml_TrainData_getNames_const_vectorLStringGR(instance: *const c_void, names: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ml_TrainData_getNames_const_vectorLStringGR(instance: *const c_void, names: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_ml_TrainData_getSubVector_const_MatR_const_MatR(vec: *const c_void, idx: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ml_TrainData_getSubMatrix_const_MatR_const_MatR_int(matrix: *const c_void, idx: *const c_void, layout: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ml_TrainData_loadFromCSV_const_StringR_int_int_int_const_StringR_char_char(filename: *const c_char, header_line_count: i32, response_start_idx: i32, response_end_idx: i32, var_type_spec: *const c_char, delimiter: c_char, missch: c_char, ocvrs_return: *mut Result<*mut c_void>); @@ -11037,83 +11078,81 @@ mod ml_sys { pub fn std_vectorLcv_ml_DTrees_SplitG_set_size_t_const_Split(instance: *mut c_void, index: size_t, val: *const c_void); } } -#[cfg(ocvrs_has_module_ml)] pub use ml_sys::*; -#[cfg(ocvrs_has_module_objdetect)] mod objdetect_sys { use super::*; extern "C" { - pub fn cv_aruco_drawDetectedCornersCharuco_const__InputOutputArrayR_const__InputArrayR(image: *const c_void, charuco_corners: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_aruco_drawDetectedCornersCharuco_const__InputOutputArrayR_const__InputArrayR_const__InputArrayR_Scalar(image: *const c_void, charuco_corners: *const c_void, charuco_ids: *const c_void, corner_color: *const core::Scalar, ocvrs_return: *mut ResultVoid); - pub fn cv_aruco_drawDetectedDiamonds_const__InputOutputArrayR_const__InputArrayR(image: *const c_void, diamond_corners: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_aruco_drawDetectedDiamonds_const__InputOutputArrayR_const__InputArrayR_const__InputArrayR_Scalar(image: *const c_void, diamond_corners: *const c_void, diamond_ids: *const c_void, border_color: *const core::Scalar, ocvrs_return: *mut ResultVoid); - pub fn cv_aruco_drawDetectedMarkers_const__InputOutputArrayR_const__InputArrayR(image: *const c_void, corners: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_aruco_drawDetectedMarkers_const__InputOutputArrayR_const__InputArrayR_const__InputArrayR_Scalar(image: *const c_void, corners: *const c_void, ids: *const c_void, border_color: *const core::Scalar, ocvrs_return: *mut ResultVoid); + pub fn cv_aruco_drawDetectedCornersCharuco_const__InputOutputArrayR_const__InputArrayR(image: *const c_void, charuco_corners: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_aruco_drawDetectedCornersCharuco_const__InputOutputArrayR_const__InputArrayR_const__InputArrayR_Scalar(image: *const c_void, charuco_corners: *const c_void, charuco_ids: *const c_void, corner_color: *const core::Scalar, ocvrs_return: *mut Result<()>); + pub fn cv_aruco_drawDetectedDiamonds_const__InputOutputArrayR_const__InputArrayR(image: *const c_void, diamond_corners: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_aruco_drawDetectedDiamonds_const__InputOutputArrayR_const__InputArrayR_const__InputArrayR_Scalar(image: *const c_void, diamond_corners: *const c_void, diamond_ids: *const c_void, border_color: *const core::Scalar, ocvrs_return: *mut Result<()>); + pub fn cv_aruco_drawDetectedMarkers_const__InputOutputArrayR_const__InputArrayR(image: *const c_void, corners: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_aruco_drawDetectedMarkers_const__InputOutputArrayR_const__InputArrayR_const__InputArrayR_Scalar(image: *const c_void, corners: *const c_void, ids: *const c_void, border_color: *const core::Scalar, ocvrs_return: *mut Result<()>); pub fn cv_aruco_extendDictionary_int_int(n_markers: i32, marker_size: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_aruco_extendDictionary_int_int_const_DictionaryR_int(n_markers: i32, marker_size: i32, base_dictionary: *const c_void, random_seed: i32, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_aruco_generateImageMarker_const_DictionaryR_int_int_const__OutputArrayR(dictionary: *const c_void, id: i32, side_pixels: i32, img: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_aruco_generateImageMarker_const_DictionaryR_int_int_const__OutputArrayR_int(dictionary: *const c_void, id: i32, side_pixels: i32, img: *const c_void, border_bits: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_aruco_generateImageMarker_const_DictionaryR_int_int_const__OutputArrayR(dictionary: *const c_void, id: i32, side_pixels: i32, img: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_aruco_generateImageMarker_const_DictionaryR_int_int_const__OutputArrayR_int(dictionary: *const c_void, id: i32, side_pixels: i32, img: *const c_void, border_bits: i32, ocvrs_return: *mut Result<()>); pub fn cv_aruco_getPredefinedDictionary_PredefinedDictionaryType(name: crate::objdetect::PredefinedDictionaryType, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_aruco_getPredefinedDictionary_int(dict: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_createFaceDetectionMaskGenerator(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_groupRectangles_meanshift_vectorLRectGR_vectorLdoubleGR_vectorLdoubleGR(rect_list: *mut c_void, found_weights: *mut c_void, found_scales: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_groupRectangles_meanshift_vectorLRectGR_vectorLdoubleGR_vectorLdoubleGR_double_Size(rect_list: *mut c_void, found_weights: *mut c_void, found_scales: *mut c_void, detect_threshold: f64, win_det_size: *const core::Size, ocvrs_return: *mut ResultVoid); - pub fn cv_groupRectangles_vectorLRectGR_int(rect_list: *mut c_void, group_threshold: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_groupRectangles_vectorLRectGR_int_double(rect_list: *mut c_void, group_threshold: i32, eps: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_groupRectangles_vectorLRectGR_int_double_vectorLintGX_vectorLdoubleGX(rect_list: *mut c_void, group_threshold: i32, eps: f64, weights: *mut c_void, level_weights: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_groupRectangles_vectorLRectGR_vectorLintGR_int(rect_list: *mut c_void, weights: *mut c_void, group_threshold: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_groupRectangles_vectorLRectGR_vectorLintGR_int_double(rect_list: *mut c_void, weights: *mut c_void, group_threshold: i32, eps: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_groupRectangles_vectorLRectGR_vectorLintGR_vectorLdoubleGR_int(rect_list: *mut c_void, reject_levels: *mut c_void, level_weights: *mut c_void, group_threshold: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_groupRectangles_vectorLRectGR_vectorLintGR_vectorLdoubleGR_int_double(rect_list: *mut c_void, reject_levels: *mut c_void, level_weights: *mut c_void, group_threshold: i32, eps: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_groupRectangles_meanshift_vectorLRectGR_vectorLdoubleGR_vectorLdoubleGR(rect_list: *mut c_void, found_weights: *mut c_void, found_scales: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_groupRectangles_meanshift_vectorLRectGR_vectorLdoubleGR_vectorLdoubleGR_double_Size(rect_list: *mut c_void, found_weights: *mut c_void, found_scales: *mut c_void, detect_threshold: f64, win_det_size: *const core::Size, ocvrs_return: *mut Result<()>); + pub fn cv_groupRectangles_vectorLRectGR_int(rect_list: *mut c_void, group_threshold: i32, ocvrs_return: *mut Result<()>); + pub fn cv_groupRectangles_vectorLRectGR_int_double(rect_list: *mut c_void, group_threshold: i32, eps: f64, ocvrs_return: *mut Result<()>); + pub fn cv_groupRectangles_vectorLRectGR_int_double_vectorLintGX_vectorLdoubleGX(rect_list: *mut c_void, group_threshold: i32, eps: f64, weights: *mut c_void, level_weights: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_groupRectangles_vectorLRectGR_vectorLintGR_int(rect_list: *mut c_void, weights: *mut c_void, group_threshold: i32, ocvrs_return: *mut Result<()>); + pub fn cv_groupRectangles_vectorLRectGR_vectorLintGR_int_double(rect_list: *mut c_void, weights: *mut c_void, group_threshold: i32, eps: f64, ocvrs_return: *mut Result<()>); + pub fn cv_groupRectangles_vectorLRectGR_vectorLintGR_vectorLdoubleGR_int(rect_list: *mut c_void, reject_levels: *mut c_void, level_weights: *mut c_void, group_threshold: i32, ocvrs_return: *mut Result<()>); + pub fn cv_groupRectangles_vectorLRectGR_vectorLintGR_vectorLdoubleGR_int_double(rect_list: *mut c_void, reject_levels: *mut c_void, level_weights: *mut c_void, group_threshold: i32, eps: f64, ocvrs_return: *mut Result<()>); pub fn cv_BaseCascadeClassifier_empty_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_BaseCascadeClassifier_load_const_StringR(instance: *mut c_void, filename: *const c_char, ocvrs_return: *mut Result); - pub fn cv_BaseCascadeClassifier_detectMultiScale_const__InputArrayR_vectorLRectGR_double_int_int_Size_Size(instance: *mut c_void, image: *const c_void, objects: *mut c_void, scale_factor: f64, min_neighbors: i32, flags: i32, min_size: *const core::Size, max_size: *const core::Size, ocvrs_return: *mut ResultVoid); - pub fn cv_BaseCascadeClassifier_detectMultiScale_const__InputArrayR_vectorLRectGR_vectorLintGR_double_int_int_Size_Size(instance: *mut c_void, image: *const c_void, objects: *mut c_void, num_detections: *mut c_void, scale_factor: f64, min_neighbors: i32, flags: i32, min_size: *const core::Size, max_size: *const core::Size, ocvrs_return: *mut ResultVoid); - pub fn cv_BaseCascadeClassifier_detectMultiScale_const__InputArrayR_vectorLRectGR_vectorLintGR_vectorLdoubleGR_double_int_int_Size_Size_bool(instance: *mut c_void, image: *const c_void, objects: *mut c_void, reject_levels: *mut c_void, level_weights: *mut c_void, scale_factor: f64, min_neighbors: i32, flags: i32, min_size: *const core::Size, max_size: *const core::Size, output_reject_levels: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_BaseCascadeClassifier_detectMultiScale_const__InputArrayR_vectorLRectGR_double_int_int_Size_Size(instance: *mut c_void, image: *const c_void, objects: *mut c_void, scale_factor: f64, min_neighbors: i32, flags: i32, min_size: *const core::Size, max_size: *const core::Size, ocvrs_return: *mut Result<()>); + pub fn cv_BaseCascadeClassifier_detectMultiScale_const__InputArrayR_vectorLRectGR_vectorLintGR_double_int_int_Size_Size(instance: *mut c_void, image: *const c_void, objects: *mut c_void, num_detections: *mut c_void, scale_factor: f64, min_neighbors: i32, flags: i32, min_size: *const core::Size, max_size: *const core::Size, ocvrs_return: *mut Result<()>); + pub fn cv_BaseCascadeClassifier_detectMultiScale_const__InputArrayR_vectorLRectGR_vectorLintGR_vectorLdoubleGR_double_int_int_Size_Size_bool(instance: *mut c_void, image: *const c_void, objects: *mut c_void, reject_levels: *mut c_void, level_weights: *mut c_void, scale_factor: f64, min_neighbors: i32, flags: i32, min_size: *const core::Size, max_size: *const core::Size, output_reject_levels: bool, ocvrs_return: *mut Result<()>); pub fn cv_BaseCascadeClassifier_isOldFormatCascade_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_BaseCascadeClassifier_getOriginalWindowSize_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_BaseCascadeClassifier_getFeatureType_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_BaseCascadeClassifier_getOldCascade(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_BaseCascadeClassifier_setMaskGenerator_const_PtrLMaskGeneratorGR(instance: *mut c_void, mask_generator: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_BaseCascadeClassifier_setMaskGenerator_const_PtrLMaskGeneratorGR(instance: *mut c_void, mask_generator: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_BaseCascadeClassifier_getMaskGenerator(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_BaseCascadeClassifier_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_BaseCascadeClassifier_delete(instance: *mut c_void); pub fn cv_BaseCascadeClassifier_MaskGenerator_generateMask_const_MatR(instance: *mut c_void, src: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_BaseCascadeClassifier_MaskGenerator_initializeMask_const_MatR(instance: *mut c_void, unnamed: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_BaseCascadeClassifier_MaskGenerator_initializeMask_const_MatR(instance: *mut c_void, unnamed: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_BaseCascadeClassifier_MaskGenerator_delete(instance: *mut c_void); pub fn cv_CascadeClassifier_CascadeClassifier(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_CascadeClassifier_CascadeClassifier_const_StringR(filename: *const c_char, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_CascadeClassifier_empty_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_CascadeClassifier_load_const_StringR(instance: *mut c_void, filename: *const c_char, ocvrs_return: *mut Result); pub fn cv_CascadeClassifier_read_const_FileNodeR(instance: *mut c_void, node: *const c_void, ocvrs_return: *mut Result); - pub fn cv_CascadeClassifier_detectMultiScale_const__InputArrayR_vectorLRectGR_double_int_int_Size_Size(instance: *mut c_void, image: *const c_void, objects: *mut c_void, scale_factor: f64, min_neighbors: i32, flags: i32, min_size: *const core::Size, max_size: *const core::Size, ocvrs_return: *mut ResultVoid); - pub fn cv_CascadeClassifier_detectMultiScale_const__InputArrayR_vectorLRectGR(instance: *mut c_void, image: *const c_void, objects: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_CascadeClassifier_detectMultiScale_const__InputArrayR_vectorLRectGR_vectorLintGR_double_int_int_Size_Size(instance: *mut c_void, image: *const c_void, objects: *mut c_void, num_detections: *mut c_void, scale_factor: f64, min_neighbors: i32, flags: i32, min_size: *const core::Size, max_size: *const core::Size, ocvrs_return: *mut ResultVoid); - pub fn cv_CascadeClassifier_detectMultiScale_const__InputArrayR_vectorLRectGR_vectorLintGR(instance: *mut c_void, image: *const c_void, objects: *mut c_void, num_detections: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_CascadeClassifier_detectMultiScale_const__InputArrayR_vectorLRectGR_vectorLintGR_vectorLdoubleGR_double_int_int_Size_Size_bool(instance: *mut c_void, image: *const c_void, objects: *mut c_void, reject_levels: *mut c_void, level_weights: *mut c_void, scale_factor: f64, min_neighbors: i32, flags: i32, min_size: *const core::Size, max_size: *const core::Size, output_reject_levels: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_CascadeClassifier_detectMultiScale_const__InputArrayR_vectorLRectGR_vectorLintGR_vectorLdoubleGR(instance: *mut c_void, image: *const c_void, objects: *mut c_void, reject_levels: *mut c_void, level_weights: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_CascadeClassifier_detectMultiScale_const__InputArrayR_vectorLRectGR_double_int_int_Size_Size(instance: *mut c_void, image: *const c_void, objects: *mut c_void, scale_factor: f64, min_neighbors: i32, flags: i32, min_size: *const core::Size, max_size: *const core::Size, ocvrs_return: *mut Result<()>); + pub fn cv_CascadeClassifier_detectMultiScale_const__InputArrayR_vectorLRectGR(instance: *mut c_void, image: *const c_void, objects: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_CascadeClassifier_detectMultiScale_const__InputArrayR_vectorLRectGR_vectorLintGR_double_int_int_Size_Size(instance: *mut c_void, image: *const c_void, objects: *mut c_void, num_detections: *mut c_void, scale_factor: f64, min_neighbors: i32, flags: i32, min_size: *const core::Size, max_size: *const core::Size, ocvrs_return: *mut Result<()>); + pub fn cv_CascadeClassifier_detectMultiScale_const__InputArrayR_vectorLRectGR_vectorLintGR(instance: *mut c_void, image: *const c_void, objects: *mut c_void, num_detections: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_CascadeClassifier_detectMultiScale_const__InputArrayR_vectorLRectGR_vectorLintGR_vectorLdoubleGR_double_int_int_Size_Size_bool(instance: *mut c_void, image: *const c_void, objects: *mut c_void, reject_levels: *mut c_void, level_weights: *mut c_void, scale_factor: f64, min_neighbors: i32, flags: i32, min_size: *const core::Size, max_size: *const core::Size, output_reject_levels: bool, ocvrs_return: *mut Result<()>); + pub fn cv_CascadeClassifier_detectMultiScale_const__InputArrayR_vectorLRectGR_vectorLintGR_vectorLdoubleGR(instance: *mut c_void, image: *const c_void, objects: *mut c_void, reject_levels: *mut c_void, level_weights: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_CascadeClassifier_isOldFormatCascade_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_CascadeClassifier_getOriginalWindowSize_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_CascadeClassifier_getFeatureType_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_CascadeClassifier_getOldCascade(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_CascadeClassifier_convert_const_StringR_const_StringR(oldcascade: *const c_char, newcascade: *const c_char, ocvrs_return: *mut Result); - pub fn cv_CascadeClassifier_setMaskGenerator_const_PtrLMaskGeneratorGR(instance: *mut c_void, mask_generator: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_CascadeClassifier_setMaskGenerator_const_PtrLMaskGeneratorGR(instance: *mut c_void, mask_generator: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_CascadeClassifier_getMaskGenerator(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_CascadeClassifier_propCc(instance: *mut c_void) -> *mut c_void; pub fn cv_CascadeClassifier_propCc_const_PtrLBaseCascadeClassifierG(instance: *mut c_void, val: *const c_void); pub fn cv_CascadeClassifier_delete(instance: *mut c_void); pub fn cv_DetectionBasedTracker_DetectionBasedTracker_PtrLIDetectorG_PtrLIDetectorG_const_ParametersR(main_detector: *mut c_void, tracking_detector: *mut c_void, params: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_DetectionBasedTracker_run(instance: *mut c_void, ocvrs_return: *mut Result); - pub fn cv_DetectionBasedTracker_stop(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_DetectionBasedTracker_resetTracking(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_DetectionBasedTracker_process_const_MatR(instance: *mut c_void, image_gray: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_DetectionBasedTracker_stop(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_DetectionBasedTracker_resetTracking(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_DetectionBasedTracker_process_const_MatR(instance: *mut c_void, image_gray: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_DetectionBasedTracker_setParameters_const_ParametersR(instance: *mut c_void, params: *const c_void, ocvrs_return: *mut Result); pub fn cv_DetectionBasedTracker_getParameters_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_DetectionBasedTracker_getObjects_const_vectorLRectGR(instance: *const c_void, result: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_DetectionBasedTracker_getObjects_const_vectorLObjectGR(instance: *const c_void, result: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_DetectionBasedTracker_getObjects_const_vectorLExtObjectGR(instance: *const c_void, result: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_DetectionBasedTracker_getObjects_const_vectorLRectGR(instance: *const c_void, result: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_DetectionBasedTracker_getObjects_const_vectorLObjectGR(instance: *const c_void, result: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_DetectionBasedTracker_getObjects_const_vectorLExtObjectGR(instance: *const c_void, result: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_DetectionBasedTracker_addObject_const_RectR(instance: *mut c_void, location: *const core::Rect, ocvrs_return: *mut Result); pub fn cv_DetectionBasedTracker_delete(instance: *mut c_void); pub fn cv_DetectionBasedTracker_ExtObject_ExtObject_int_Rect_ObjectStatus(_id: i32, _location: *const core::Rect, _status: crate::objdetect::DetectionBasedTracker_ObjectStatus, ocvrs_return: *mut Result<*mut c_void>); @@ -11125,15 +11164,15 @@ mod objdetect_sys { pub fn cv_DetectionBasedTracker_ExtObject_propStatus_const(instance: *const c_void, ocvrs_return: *mut crate::objdetect::DetectionBasedTracker_ObjectStatus); pub fn cv_DetectionBasedTracker_ExtObject_propStatus_const_ObjectStatus(instance: *mut c_void, val: crate::objdetect::DetectionBasedTracker_ObjectStatus); pub fn cv_DetectionBasedTracker_ExtObject_delete(instance: *mut c_void); - pub fn cv_DetectionBasedTracker_IDetector_detect_const_MatR_vectorLRectGR(instance: *mut c_void, image: *const c_void, objects: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_DetectionBasedTracker_IDetector_setMinObjectSize_const_SizeR(instance: *mut c_void, min: *const core::Size, ocvrs_return: *mut ResultVoid); - pub fn cv_DetectionBasedTracker_IDetector_setMaxObjectSize_const_SizeR(instance: *mut c_void, max: *const core::Size, ocvrs_return: *mut ResultVoid); + pub fn cv_DetectionBasedTracker_IDetector_detect_const_MatR_vectorLRectGR(instance: *mut c_void, image: *const c_void, objects: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_DetectionBasedTracker_IDetector_setMinObjectSize_const_SizeR(instance: *mut c_void, min: *const core::Size, ocvrs_return: *mut Result<()>); + pub fn cv_DetectionBasedTracker_IDetector_setMaxObjectSize_const_SizeR(instance: *mut c_void, max: *const core::Size, ocvrs_return: *mut Result<()>); pub fn cv_DetectionBasedTracker_IDetector_getMinObjectSize_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_DetectionBasedTracker_IDetector_getMaxObjectSize_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_DetectionBasedTracker_IDetector_getScaleFactor(instance: *mut c_void, ocvrs_return: *mut Result); - pub fn cv_DetectionBasedTracker_IDetector_setScaleFactor_float(instance: *mut c_void, value: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_DetectionBasedTracker_IDetector_setScaleFactor_float(instance: *mut c_void, value: f32, ocvrs_return: *mut Result<()>); pub fn cv_DetectionBasedTracker_IDetector_getMinNeighbours(instance: *mut c_void, ocvrs_return: *mut Result); - pub fn cv_DetectionBasedTracker_IDetector_setMinNeighbours_int(instance: *mut c_void, value: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_DetectionBasedTracker_IDetector_setMinNeighbours_int(instance: *mut c_void, value: i32, ocvrs_return: *mut Result<()>); pub fn cv_DetectionBasedTracker_IDetector_delete(instance: *mut c_void); pub fn cv_DetectionBasedTracker_Parameters_Parameters(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_DetectionBasedTracker_Parameters_propMaxTrackLifetime_const(instance: *const c_void) -> i32; @@ -11149,13 +11188,13 @@ mod objdetect_sys { pub fn cv_DetectionROI_propConfidences_const(instance: *const c_void) -> *mut c_void; pub fn cv_DetectionROI_propConfidences_const_vectorLdoubleG(instance: *mut c_void, val: *const c_void); pub fn cv_DetectionROI_delete(instance: *mut c_void); - pub fn cv_FaceDetectorYN_setInputSize_const_SizeR(instance: *mut c_void, input_size: *const core::Size, ocvrs_return: *mut ResultVoid); + pub fn cv_FaceDetectorYN_setInputSize_const_SizeR(instance: *mut c_void, input_size: *const core::Size, ocvrs_return: *mut Result<()>); pub fn cv_FaceDetectorYN_getInputSize(instance: *mut c_void, ocvrs_return: *mut Result); - pub fn cv_FaceDetectorYN_setScoreThreshold_float(instance: *mut c_void, score_threshold: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_FaceDetectorYN_setScoreThreshold_float(instance: *mut c_void, score_threshold: f32, ocvrs_return: *mut Result<()>); pub fn cv_FaceDetectorYN_getScoreThreshold(instance: *mut c_void, ocvrs_return: *mut Result); - pub fn cv_FaceDetectorYN_setNMSThreshold_float(instance: *mut c_void, nms_threshold: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_FaceDetectorYN_setNMSThreshold_float(instance: *mut c_void, nms_threshold: f32, ocvrs_return: *mut Result<()>); pub fn cv_FaceDetectorYN_getNMSThreshold(instance: *mut c_void, ocvrs_return: *mut Result); - pub fn cv_FaceDetectorYN_setTopK_int(instance: *mut c_void, top_k: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_FaceDetectorYN_setTopK_int(instance: *mut c_void, top_k: i32, ocvrs_return: *mut Result<()>); pub fn cv_FaceDetectorYN_getTopK(instance: *mut c_void, ocvrs_return: *mut Result); pub fn cv_FaceDetectorYN_detect_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, faces: *const c_void, ocvrs_return: *mut Result); pub fn cv_FaceDetectorYN_create_const_StringR_const_StringR_const_SizeR_float_float_int_int_int(model: *const c_char, config: *const c_char, input_size: *const core::Size, score_threshold: f32, nms_threshold: f32, top_k: i32, backend_id: i32, target_id: i32, ocvrs_return: *mut Result<*mut c_void>); @@ -11163,8 +11202,8 @@ mod objdetect_sys { pub fn cv_FaceDetectorYN_create_const_StringR_const_vectorLunsigned_charGR_const_vectorLunsigned_charGR_const_SizeR_float_float_int_int_int(framework: *const c_char, buffer_model: *const c_void, buffer_config: *const c_void, input_size: *const core::Size, score_threshold: f32, nms_threshold: f32, top_k: i32, backend_id: i32, target_id: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_FaceDetectorYN_create_const_StringR_const_vectorLunsigned_charGR_const_vectorLunsigned_charGR_const_SizeR(framework: *const c_char, buffer_model: *const c_void, buffer_config: *const c_void, input_size: *const core::Size, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_FaceDetectorYN_delete(instance: *mut c_void); - pub fn cv_FaceRecognizerSF_alignCrop_const_const__InputArrayR_const__InputArrayR_const__OutputArrayR(instance: *const c_void, src_img: *const c_void, face_box: *const c_void, aligned_img: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_FaceRecognizerSF_feature_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, aligned_img: *const c_void, face_feature: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_FaceRecognizerSF_alignCrop_const_const__InputArrayR_const__InputArrayR_const__OutputArrayR(instance: *const c_void, src_img: *const c_void, face_box: *const c_void, aligned_img: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_FaceRecognizerSF_feature_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, aligned_img: *const c_void, face_feature: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_FaceRecognizerSF_match_const_const__InputArrayR_const__InputArrayR_int(instance: *const c_void, face_feature1: *const c_void, face_feature2: *const c_void, dis_type: i32, ocvrs_return: *mut Result); pub fn cv_FaceRecognizerSF_match_const_const__InputArrayR_const__InputArrayR(instance: *const c_void, face_feature1: *const c_void, face_feature2: *const c_void, ocvrs_return: *mut Result); pub fn cv_FaceRecognizerSF_create_const_StringR_const_StringR_int_int(model: *const c_char, config: *const c_char, backend_id: i32, target_id: i32, ocvrs_return: *mut Result<*mut c_void>); @@ -11197,33 +11236,33 @@ mod objdetect_sys { pub fn cv_HOGDescriptor_getDescriptorSize_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_HOGDescriptor_checkDetectorSize_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_HOGDescriptor_getWinSigma_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_HOGDescriptor_setSVMDetector_const__InputArrayR(instance: *mut c_void, svmdetector: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_HOGDescriptor_setSVMDetector_const__InputArrayR(instance: *mut c_void, svmdetector: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_HOGDescriptor_read_FileNodeR(instance: *mut c_void, fn_: *mut c_void, ocvrs_return: *mut Result); - pub fn cv_HOGDescriptor_write_const_FileStorageR_const_StringR(instance: *const c_void, fs: *mut c_void, objname: *const c_char, ocvrs_return: *mut ResultVoid); + pub fn cv_HOGDescriptor_write_const_FileStorageR_const_StringR(instance: *const c_void, fs: *mut c_void, objname: *const c_char, ocvrs_return: *mut Result<()>); pub fn cv_HOGDescriptor_load_const_StringR_const_StringR(instance: *mut c_void, filename: *const c_char, objname: *const c_char, ocvrs_return: *mut Result); pub fn cv_HOGDescriptor_load_const_StringR(instance: *mut c_void, filename: *const c_char, ocvrs_return: *mut Result); - pub fn cv_HOGDescriptor_save_const_const_StringR_const_StringR(instance: *const c_void, filename: *const c_char, objname: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_HOGDescriptor_save_const_const_StringR(instance: *const c_void, filename: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_HOGDescriptor_copyTo_const_HOGDescriptorR(instance: *const c_void, c: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_HOGDescriptor_compute_const_const__InputArrayR_vectorLfloatGR_Size_Size_const_vectorLPointGR(instance: *const c_void, img: *const c_void, descriptors: *mut c_void, win_stride: *const core::Size, padding: *const core::Size, locations: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_HOGDescriptor_compute_const_const__InputArrayR_vectorLfloatGR(instance: *const c_void, img: *const c_void, descriptors: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_HOGDescriptor_detect_const_const__InputArrayR_vectorLPointGR_vectorLdoubleGR_double_Size_Size_const_vectorLPointGR(instance: *const c_void, img: *const c_void, found_locations: *mut c_void, weights: *mut c_void, hit_threshold: f64, win_stride: *const core::Size, padding: *const core::Size, search_locations: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_HOGDescriptor_detect_const_const__InputArrayR_vectorLPointGR_vectorLdoubleGR(instance: *const c_void, img: *const c_void, found_locations: *mut c_void, weights: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_HOGDescriptor_detect_const_const__InputArrayR_vectorLPointGR_double_Size_Size_const_vectorLPointGR(instance: *const c_void, img: *const c_void, found_locations: *mut c_void, hit_threshold: f64, win_stride: *const core::Size, padding: *const core::Size, search_locations: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_HOGDescriptor_detect_const_const__InputArrayR_vectorLPointGR(instance: *const c_void, img: *const c_void, found_locations: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_HOGDescriptor_detectMultiScale_const_const__InputArrayR_vectorLRectGR_vectorLdoubleGR_double_Size_Size_double_double_bool(instance: *const c_void, img: *const c_void, found_locations: *mut c_void, found_weights: *mut c_void, hit_threshold: f64, win_stride: *const core::Size, padding: *const core::Size, scale: f64, group_threshold: f64, use_meanshift_grouping: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_HOGDescriptor_detectMultiScale_const_const__InputArrayR_vectorLRectGR_vectorLdoubleGR(instance: *const c_void, img: *const c_void, found_locations: *mut c_void, found_weights: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_HOGDescriptor_detectMultiScale_const_const__InputArrayR_vectorLRectGR_double_Size_Size_double_double_bool(instance: *const c_void, img: *const c_void, found_locations: *mut c_void, hit_threshold: f64, win_stride: *const core::Size, padding: *const core::Size, scale: f64, group_threshold: f64, use_meanshift_grouping: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_HOGDescriptor_detectMultiScale_const_const__InputArrayR_vectorLRectGR(instance: *const c_void, img: *const c_void, found_locations: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_HOGDescriptor_computeGradient_const_const__InputArrayR_const__InputOutputArrayR_const__InputOutputArrayR_Size_Size(instance: *const c_void, img: *const c_void, grad: *const c_void, angle_ofs: *const c_void, padding_tl: *const core::Size, padding_br: *const core::Size, ocvrs_return: *mut ResultVoid); - pub fn cv_HOGDescriptor_computeGradient_const_const__InputArrayR_const__InputOutputArrayR_const__InputOutputArrayR(instance: *const c_void, img: *const c_void, grad: *const c_void, angle_ofs: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_HOGDescriptor_save_const_const_StringR_const_StringR(instance: *const c_void, filename: *const c_char, objname: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_HOGDescriptor_save_const_const_StringR(instance: *const c_void, filename: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_HOGDescriptor_copyTo_const_HOGDescriptorR(instance: *const c_void, c: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_HOGDescriptor_compute_const_const__InputArrayR_vectorLfloatGR_Size_Size_const_vectorLPointGR(instance: *const c_void, img: *const c_void, descriptors: *mut c_void, win_stride: *const core::Size, padding: *const core::Size, locations: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_HOGDescriptor_compute_const_const__InputArrayR_vectorLfloatGR(instance: *const c_void, img: *const c_void, descriptors: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_HOGDescriptor_detect_const_const__InputArrayR_vectorLPointGR_vectorLdoubleGR_double_Size_Size_const_vectorLPointGR(instance: *const c_void, img: *const c_void, found_locations: *mut c_void, weights: *mut c_void, hit_threshold: f64, win_stride: *const core::Size, padding: *const core::Size, search_locations: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_HOGDescriptor_detect_const_const__InputArrayR_vectorLPointGR_vectorLdoubleGR(instance: *const c_void, img: *const c_void, found_locations: *mut c_void, weights: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_HOGDescriptor_detect_const_const__InputArrayR_vectorLPointGR_double_Size_Size_const_vectorLPointGR(instance: *const c_void, img: *const c_void, found_locations: *mut c_void, hit_threshold: f64, win_stride: *const core::Size, padding: *const core::Size, search_locations: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_HOGDescriptor_detect_const_const__InputArrayR_vectorLPointGR(instance: *const c_void, img: *const c_void, found_locations: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_HOGDescriptor_detectMultiScale_const_const__InputArrayR_vectorLRectGR_vectorLdoubleGR_double_Size_Size_double_double_bool(instance: *const c_void, img: *const c_void, found_locations: *mut c_void, found_weights: *mut c_void, hit_threshold: f64, win_stride: *const core::Size, padding: *const core::Size, scale: f64, group_threshold: f64, use_meanshift_grouping: bool, ocvrs_return: *mut Result<()>); + pub fn cv_HOGDescriptor_detectMultiScale_const_const__InputArrayR_vectorLRectGR_vectorLdoubleGR(instance: *const c_void, img: *const c_void, found_locations: *mut c_void, found_weights: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_HOGDescriptor_detectMultiScale_const_const__InputArrayR_vectorLRectGR_double_Size_Size_double_double_bool(instance: *const c_void, img: *const c_void, found_locations: *mut c_void, hit_threshold: f64, win_stride: *const core::Size, padding: *const core::Size, scale: f64, group_threshold: f64, use_meanshift_grouping: bool, ocvrs_return: *mut Result<()>); + pub fn cv_HOGDescriptor_detectMultiScale_const_const__InputArrayR_vectorLRectGR(instance: *const c_void, img: *const c_void, found_locations: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_HOGDescriptor_computeGradient_const_const__InputArrayR_const__InputOutputArrayR_const__InputOutputArrayR_Size_Size(instance: *const c_void, img: *const c_void, grad: *const c_void, angle_ofs: *const c_void, padding_tl: *const core::Size, padding_br: *const core::Size, ocvrs_return: *mut Result<()>); + pub fn cv_HOGDescriptor_computeGradient_const_const__InputArrayR_const__InputOutputArrayR_const__InputOutputArrayR(instance: *const c_void, img: *const c_void, grad: *const c_void, angle_ofs: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_HOGDescriptor_getDefaultPeopleDetector(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_HOGDescriptor_getDaimlerPeopleDetector(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_HOGDescriptor_detectROI_const_const__InputArrayR_const_vectorLPointGR_vectorLPointGR_vectorLdoubleGR_double_Size_Size(instance: *const c_void, img: *const c_void, locations: *const c_void, found_locations: *mut c_void, confidences: *mut c_void, hit_threshold: f64, win_stride: *const core::Size, padding: *const core::Size, ocvrs_return: *mut ResultVoid); - pub fn cv_HOGDescriptor_detectROI_const_const__InputArrayR_const_vectorLPointGR_vectorLPointGR_vectorLdoubleGR(instance: *const c_void, img: *const c_void, locations: *const c_void, found_locations: *mut c_void, confidences: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_HOGDescriptor_detectMultiScaleROI_const_const__InputArrayR_vectorLRectGR_vectorLDetectionROIGR_double_int(instance: *const c_void, img: *const c_void, found_locations: *mut c_void, locations: *mut c_void, hit_threshold: f64, group_threshold: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_HOGDescriptor_detectMultiScaleROI_const_const__InputArrayR_vectorLRectGR_vectorLDetectionROIGR(instance: *const c_void, img: *const c_void, found_locations: *mut c_void, locations: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_HOGDescriptor_groupRectangles_const_vectorLRectGR_vectorLdoubleGR_int_double(instance: *const c_void, rect_list: *mut c_void, weights: *mut c_void, group_threshold: i32, eps: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_HOGDescriptor_detectROI_const_const__InputArrayR_const_vectorLPointGR_vectorLPointGR_vectorLdoubleGR_double_Size_Size(instance: *const c_void, img: *const c_void, locations: *const c_void, found_locations: *mut c_void, confidences: *mut c_void, hit_threshold: f64, win_stride: *const core::Size, padding: *const core::Size, ocvrs_return: *mut Result<()>); + pub fn cv_HOGDescriptor_detectROI_const_const__InputArrayR_const_vectorLPointGR_vectorLPointGR_vectorLdoubleGR(instance: *const c_void, img: *const c_void, locations: *const c_void, found_locations: *mut c_void, confidences: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_HOGDescriptor_detectMultiScaleROI_const_const__InputArrayR_vectorLRectGR_vectorLDetectionROIGR_double_int(instance: *const c_void, img: *const c_void, found_locations: *mut c_void, locations: *mut c_void, hit_threshold: f64, group_threshold: i32, ocvrs_return: *mut Result<()>); + pub fn cv_HOGDescriptor_detectMultiScaleROI_const_const__InputArrayR_vectorLRectGR_vectorLDetectionROIGR(instance: *const c_void, img: *const c_void, found_locations: *mut c_void, locations: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_HOGDescriptor_groupRectangles_const_vectorLRectGR_vectorLdoubleGR_int_double(instance: *const c_void, rect_list: *mut c_void, weights: *mut c_void, group_threshold: i32, eps: f64, ocvrs_return: *mut Result<()>); pub fn cv_HOGDescriptor_propWinSize_const(instance: *const c_void, ocvrs_return: *mut core::Size); pub fn cv_HOGDescriptor_propWinSize_const_Size(instance: *mut c_void, val: *const core::Size); pub fn cv_HOGDescriptor_propBlockSize_const(instance: *const c_void, ocvrs_return: *mut core::Size); @@ -11271,15 +11310,15 @@ mod objdetect_sys { pub fn cv_QRCodeDetectorAruco_getDetectorParameters_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_QRCodeDetectorAruco_setDetectorParameters_const_ParamsR(instance: *mut c_void, params: *const crate::objdetect::QRCodeDetectorAruco_Params, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_QRCodeDetectorAruco_getArucoParameters_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_QRCodeDetectorAruco_setArucoParameters_const_DetectorParametersR(instance: *mut c_void, params: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_QRCodeDetectorAruco_setArucoParameters_const_DetectorParametersR(instance: *mut c_void, params: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_QRCodeDetectorAruco_implicitClone_const(instance: *const c_void) -> *mut c_void; pub fn cv_QRCodeDetectorAruco_to_GraphicalCodeDetector(instance: *mut c_void) -> *mut c_void; pub fn cv_QRCodeDetectorAruco_delete(instance: *mut c_void); pub fn cv_QRCodeDetectorAruco_Params_Params(ocvrs_return: *mut Result); pub fn cv_QRCodeEncoder_create_const_ParamsR(parameters: *const crate::objdetect::QRCodeEncoder_Params, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_QRCodeEncoder_create(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_QRCodeEncoder_encode_const_StringR_const__OutputArrayR(instance: *mut c_void, encoded_info: *const c_char, qrcode: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_QRCodeEncoder_encodeStructuredAppend_const_StringR_const__OutputArrayR(instance: *mut c_void, encoded_info: *const c_char, qrcodes: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_QRCodeEncoder_encode_const_StringR_const__OutputArrayR(instance: *mut c_void, encoded_info: *const c_char, qrcode: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_QRCodeEncoder_encodeStructuredAppend_const_StringR_const__OutputArrayR(instance: *mut c_void, encoded_info: *const c_char, qrcodes: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_QRCodeEncoder_delete(instance: *mut c_void); pub fn cv_QRCodeEncoder_Params_Params(ocvrs_return: *mut Result); pub fn cv_SimilarRects_SimilarRects_double(_eps: f64, ocvrs_return: *mut Result<*mut c_void>); @@ -11289,19 +11328,19 @@ mod objdetect_sys { pub fn cv_SimilarRects_delete(instance: *mut c_void); pub fn cv_aruco_ArucoDetector_ArucoDetector_const_DictionaryR_const_DetectorParametersR_const_RefineParametersR(dictionary: *const c_void, detector_params: *const c_void, refine_params: *const crate::objdetect::RefineParameters, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_aruco_ArucoDetector_ArucoDetector(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_aruco_ArucoDetector_detectMarkers_const_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *const c_void, image: *const c_void, corners: *const c_void, ids: *const c_void, rejected_img_points: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_aruco_ArucoDetector_detectMarkers_const_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *const c_void, image: *const c_void, corners: *const c_void, ids: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_aruco_ArucoDetector_refineDetectedMarkers_const_const__InputArrayR_const_BoardR_const__InputOutputArrayR_const__InputOutputArrayR_const__InputOutputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR(instance: *const c_void, image: *const c_void, board: *const c_void, detected_corners: *const c_void, detected_ids: *const c_void, rejected_corners: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, recovered_idxs: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_aruco_ArucoDetector_refineDetectedMarkers_const_const__InputArrayR_const_BoardR_const__InputOutputArrayR_const__InputOutputArrayR_const__InputOutputArrayR(instance: *const c_void, image: *const c_void, board: *const c_void, detected_corners: *const c_void, detected_ids: *const c_void, rejected_corners: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_aruco_ArucoDetector_detectMarkers_const_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *const c_void, image: *const c_void, corners: *const c_void, ids: *const c_void, rejected_img_points: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_aruco_ArucoDetector_detectMarkers_const_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *const c_void, image: *const c_void, corners: *const c_void, ids: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_aruco_ArucoDetector_refineDetectedMarkers_const_const__InputArrayR_const_BoardR_const__InputOutputArrayR_const__InputOutputArrayR_const__InputOutputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR(instance: *const c_void, image: *const c_void, board: *const c_void, detected_corners: *const c_void, detected_ids: *const c_void, rejected_corners: *const c_void, camera_matrix: *const c_void, dist_coeffs: *const c_void, recovered_idxs: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_aruco_ArucoDetector_refineDetectedMarkers_const_const__InputArrayR_const_BoardR_const__InputOutputArrayR_const__InputOutputArrayR_const__InputOutputArrayR(instance: *const c_void, image: *const c_void, board: *const c_void, detected_corners: *const c_void, detected_ids: *const c_void, rejected_corners: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_aruco_ArucoDetector_getDictionary_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_aruco_ArucoDetector_setDictionary_const_DictionaryR(instance: *mut c_void, dictionary: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_aruco_ArucoDetector_setDictionary_const_DictionaryR(instance: *mut c_void, dictionary: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_aruco_ArucoDetector_getDetectorParameters_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_aruco_ArucoDetector_setDetectorParameters_const_DetectorParametersR(instance: *mut c_void, detector_parameters: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_aruco_ArucoDetector_setDetectorParameters_const_DetectorParametersR(instance: *mut c_void, detector_parameters: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_aruco_ArucoDetector_getRefineParameters_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_aruco_ArucoDetector_setRefineParameters_const_RefineParametersR(instance: *mut c_void, refine_parameters: *const crate::objdetect::RefineParameters, ocvrs_return: *mut ResultVoid); - pub fn cv_aruco_ArucoDetector_write_const_FileStorageR(instance: *const c_void, fs: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_aruco_ArucoDetector_write_FileStorageR_const_StringR(instance: *mut c_void, fs: *mut c_void, name: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_aruco_ArucoDetector_read_const_FileNodeR(instance: *mut c_void, fn_: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_aruco_ArucoDetector_setRefineParameters_const_RefineParametersR(instance: *mut c_void, refine_parameters: *const crate::objdetect::RefineParameters, ocvrs_return: *mut Result<()>); + pub fn cv_aruco_ArucoDetector_write_const_FileStorageR(instance: *const c_void, fs: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_aruco_ArucoDetector_write_FileStorageR_const_StringR(instance: *mut c_void, fs: *mut c_void, name: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_aruco_ArucoDetector_read_const_FileNodeR(instance: *mut c_void, fn_: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_aruco_ArucoDetector_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_aruco_ArucoDetector_delete(instance: *mut c_void); pub fn cv_aruco_Board_Board_const__InputArrayR_const_DictionaryR_const__InputArrayR(obj_points: *const c_void, dictionary: *const c_void, ids: *const c_void, ocvrs_return: *mut Result<*mut c_void>); @@ -11309,15 +11348,15 @@ mod objdetect_sys { pub fn cv_aruco_Board_getObjPoints_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_aruco_Board_getIds_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_aruco_Board_getRightBottomCorner_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_aruco_Board_matchImagePoints_const_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *const c_void, detected_corners: *const c_void, detected_ids: *const c_void, obj_points: *const c_void, img_points: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_aruco_Board_generateImage_const_Size_const__OutputArrayR_int_int(instance: *const c_void, out_size: *const core::Size, img: *const c_void, margin_size: i32, border_bits: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_aruco_Board_generateImage_const_Size_const__OutputArrayR(instance: *const c_void, out_size: *const core::Size, img: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_aruco_Board_matchImagePoints_const_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *const c_void, detected_corners: *const c_void, detected_ids: *const c_void, obj_points: *const c_void, img_points: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_aruco_Board_generateImage_const_Size_const__OutputArrayR_int_int(instance: *const c_void, out_size: *const core::Size, img: *const c_void, margin_size: i32, border_bits: i32, ocvrs_return: *mut Result<()>); + pub fn cv_aruco_Board_generateImage_const_Size_const__OutputArrayR(instance: *const c_void, out_size: *const core::Size, img: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_aruco_Board_Board(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_aruco_Board_implicitClone_const(instance: *const c_void) -> *mut c_void; pub fn cv_aruco_Board_delete(instance: *mut c_void); pub fn cv_aruco_CharucoBoard_CharucoBoard_const_SizeR_float_float_const_DictionaryR_const__InputArrayR(size: *const core::Size, square_length: f32, marker_length: f32, dictionary: *const c_void, ids: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_aruco_CharucoBoard_CharucoBoard_const_SizeR_float_float_const_DictionaryR(size: *const core::Size, square_length: f32, marker_length: f32, dictionary: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_aruco_CharucoBoard_setLegacyPattern_bool(instance: *mut c_void, legacy_pattern: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_aruco_CharucoBoard_setLegacyPattern_bool(instance: *mut c_void, legacy_pattern: bool, ocvrs_return: *mut Result<()>); pub fn cv_aruco_CharucoBoard_getLegacyPattern_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_aruco_CharucoBoard_getChessboardSize_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_aruco_CharucoBoard_getSquareLength_const(instance: *const c_void, ocvrs_return: *mut Result); @@ -11333,17 +11372,17 @@ mod objdetect_sys { pub fn cv_aruco_CharucoDetector_CharucoDetector_const_CharucoBoardR_const_CharucoParametersR_const_DetectorParametersR_const_RefineParametersR(board: *const c_void, charuco_params: *const c_void, detector_params: *const c_void, refine_params: *const crate::objdetect::RefineParameters, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_aruco_CharucoDetector_CharucoDetector_const_CharucoBoardR(board: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_aruco_CharucoDetector_getBoard_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_aruco_CharucoDetector_setBoard_const_CharucoBoardR(instance: *mut c_void, board: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_aruco_CharucoDetector_setBoard_const_CharucoBoardR(instance: *mut c_void, board: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_aruco_CharucoDetector_getCharucoParameters_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_aruco_CharucoDetector_setCharucoParameters_CharucoParametersR(instance: *mut c_void, charuco_parameters: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_aruco_CharucoDetector_setCharucoParameters_CharucoParametersR(instance: *mut c_void, charuco_parameters: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_aruco_CharucoDetector_getDetectorParameters_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_aruco_CharucoDetector_setDetectorParameters_const_DetectorParametersR(instance: *mut c_void, detector_parameters: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_aruco_CharucoDetector_setDetectorParameters_const_DetectorParametersR(instance: *mut c_void, detector_parameters: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_aruco_CharucoDetector_getRefineParameters_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_aruco_CharucoDetector_setRefineParameters_const_RefineParametersR(instance: *mut c_void, refine_parameters: *const crate::objdetect::RefineParameters, ocvrs_return: *mut ResultVoid); - pub fn cv_aruco_CharucoDetector_detectBoard_const_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__InputOutputArrayR_const__InputOutputArrayR(instance: *const c_void, image: *const c_void, charuco_corners: *const c_void, charuco_ids: *const c_void, marker_corners: *const c_void, marker_ids: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_aruco_CharucoDetector_detectBoard_const_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *const c_void, image: *const c_void, charuco_corners: *const c_void, charuco_ids: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_aruco_CharucoDetector_detectDiamonds_const_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__InputOutputArrayR_const__InputOutputArrayR(instance: *const c_void, image: *const c_void, diamond_corners: *const c_void, diamond_ids: *const c_void, marker_corners: *const c_void, marker_ids: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_aruco_CharucoDetector_detectDiamonds_const_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *const c_void, image: *const c_void, diamond_corners: *const c_void, diamond_ids: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_aruco_CharucoDetector_setRefineParameters_const_RefineParametersR(instance: *mut c_void, refine_parameters: *const crate::objdetect::RefineParameters, ocvrs_return: *mut Result<()>); + pub fn cv_aruco_CharucoDetector_detectBoard_const_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__InputOutputArrayR_const__InputOutputArrayR(instance: *const c_void, image: *const c_void, charuco_corners: *const c_void, charuco_ids: *const c_void, marker_corners: *const c_void, marker_ids: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_aruco_CharucoDetector_detectBoard_const_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *const c_void, image: *const c_void, charuco_corners: *const c_void, charuco_ids: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_aruco_CharucoDetector_detectDiamonds_const_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__InputOutputArrayR_const__InputOutputArrayR(instance: *const c_void, image: *const c_void, diamond_corners: *const c_void, diamond_ids: *const c_void, marker_corners: *const c_void, marker_ids: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_aruco_CharucoDetector_detectDiamonds_const_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *const c_void, image: *const c_void, diamond_corners: *const c_void, diamond_ids: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_aruco_CharucoDetector_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_aruco_CharucoDetector_delete(instance: *mut c_void); pub fn cv_aruco_CharucoParameters_CharucoParameters(ocvrs_return: *mut Result<*mut c_void>); @@ -11435,13 +11474,13 @@ mod objdetect_sys { pub fn cv_aruco_Dictionary_Dictionary_const_MatR_int_int(bytes_list: *const c_void, _marker_size: i32, maxcorr: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_aruco_Dictionary_Dictionary_const_MatR_int(bytes_list: *const c_void, _marker_size: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_aruco_Dictionary_readDictionary_const_FileNodeR(instance: *mut c_void, fn_: *const c_void, ocvrs_return: *mut Result); - pub fn cv_aruco_Dictionary_writeDictionary_FileStorageR_const_StringR(instance: *mut c_void, fs: *mut c_void, name: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_aruco_Dictionary_writeDictionary_FileStorageR(instance: *mut c_void, fs: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_aruco_Dictionary_writeDictionary_FileStorageR_const_StringR(instance: *mut c_void, fs: *mut c_void, name: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_aruco_Dictionary_writeDictionary_FileStorageR(instance: *mut c_void, fs: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_aruco_Dictionary_identify_const_const_MatR_intR_intR_double(instance: *const c_void, only_bits: *const c_void, idx: *mut i32, rotation: *mut i32, max_correction_rate: f64, ocvrs_return: *mut Result); pub fn cv_aruco_Dictionary_getDistanceToId_const_const__InputArrayR_int_bool(instance: *const c_void, bits: *const c_void, id: i32, all_rotations: bool, ocvrs_return: *mut Result); pub fn cv_aruco_Dictionary_getDistanceToId_const_const__InputArrayR_int(instance: *const c_void, bits: *const c_void, id: i32, ocvrs_return: *mut Result); - pub fn cv_aruco_Dictionary_generateImageMarker_const_int_int_const__OutputArrayR_int(instance: *const c_void, id: i32, side_pixels: i32, _img: *const c_void, border_bits: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_aruco_Dictionary_generateImageMarker_const_int_int_const__OutputArrayR(instance: *const c_void, id: i32, side_pixels: i32, _img: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_aruco_Dictionary_generateImageMarker_const_int_int_const__OutputArrayR_int(instance: *const c_void, id: i32, side_pixels: i32, _img: *const c_void, border_bits: i32, ocvrs_return: *mut Result<()>); + pub fn cv_aruco_Dictionary_generateImageMarker_const_int_int_const__OutputArrayR(instance: *const c_void, id: i32, side_pixels: i32, _img: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_aruco_Dictionary_getByteListFromBits_const_MatR(bits: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_aruco_Dictionary_getBitsFromByteList_const_MatR_int(byte_list: *const c_void, marker_size: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_aruco_Dictionary_implicitClone_const(instance: *const c_void) -> *mut c_void; @@ -11473,7 +11512,7 @@ mod objdetect_sys { pub fn cv_barcode_BarcodeDetector_detectAndDecodeWithType_const_const__InputArrayR_vectorLstringGR_vectorLstringGR(instance: *const c_void, img: *const c_void, decoded_info: *mut c_void, decoded_type: *mut c_void, ocvrs_return: *mut Result); pub fn cv_barcode_BarcodeDetector_getDownsamplingThreshold_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_barcode_BarcodeDetector_setDownsamplingThreshold_double(instance: *mut c_void, thresh: f64, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_barcode_BarcodeDetector_getDetectorScales_const_vectorLfloatGR(instance: *const c_void, sizes: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_barcode_BarcodeDetector_getDetectorScales_const_vectorLfloatGR(instance: *const c_void, sizes: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_barcode_BarcodeDetector_setDetectorScales_const_vectorLfloatGR(instance: *mut c_void, sizes: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_barcode_BarcodeDetector_getGradientThreshold_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_barcode_BarcodeDetector_setGradientThreshold_double(instance: *mut c_void, thresh: f64, ocvrs_return: *mut Result<*mut c_void>); @@ -11588,27 +11627,25 @@ mod objdetect_sys { pub fn std_vectorLcv_DetectionROIG_set_size_t_const_DetectionROI(instance: *mut c_void, index: size_t, val: *const c_void); } } -#[cfg(ocvrs_has_module_objdetect)] pub use objdetect_sys::*; -#[cfg(ocvrs_has_module_optflow)] mod optflow_sys { use super::*; extern "C" { pub fn cv_motempl_calcGlobalOrientation_const__InputArrayR_const__InputArrayR_const__InputArrayR_double_double(orientation: *const c_void, mask: *const c_void, mhi: *const c_void, timestamp: f64, duration: f64, ocvrs_return: *mut Result); - pub fn cv_motempl_calcMotionGradient_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_double_double(mhi: *const c_void, mask: *const c_void, orientation: *const c_void, delta1: f64, delta2: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_motempl_calcMotionGradient_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_double_double_int(mhi: *const c_void, mask: *const c_void, orientation: *const c_void, delta1: f64, delta2: f64, aperture_size: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_motempl_segmentMotion_const__InputArrayR_const__OutputArrayR_vectorLRectGR_double_double(mhi: *const c_void, segmask: *const c_void, bounding_rects: *mut c_void, timestamp: f64, seg_thresh: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_motempl_updateMotionHistory_const__InputArrayR_const__InputOutputArrayR_double_double(silhouette: *const c_void, mhi: *const c_void, timestamp: f64, duration: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_optflow_calcOpticalFlowDenseRLOF_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR(i0: *const c_void, i1: *const c_void, flow: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_optflow_calcOpticalFlowDenseRLOF_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_PtrLRLOFOpticalFlowParameterG_float_Size_InterpolationType_int_float_float_int_int_bool_float_float_bool(i0: *const c_void, i1: *const c_void, flow: *const c_void, rlof_param: *mut c_void, forward_backward_threshold: f32, grid_step: *const core::Size, interp_type: crate::optflow::InterpolationType, epic_k: i32, epic_sigma: f32, epic_lambda: f32, ric_sp_size: i32, ric_slic_type: i32, use_post_proc: bool, fgs_lambda: f32, fgs_sigma: f32, use_variational_refinement: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_optflow_calcOpticalFlowSF_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int_int_int(from: *const c_void, to: *const c_void, flow: *const c_void, layers: i32, averaging_block_size: i32, max_flow: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_optflow_calcOpticalFlowSF_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int_int_int_double_double_int_double_double_double_int_double_double_double(from: *const c_void, to: *const c_void, flow: *const c_void, layers: i32, averaging_block_size: i32, max_flow: i32, sigma_dist: f64, sigma_color: f64, postprocess_window: i32, sigma_dist_fix: f64, sigma_color_fix: f64, occ_thr: f64, upscale_averaging_radius: i32, upscale_sigma_dist: f64, upscale_sigma_color: f64, speed_up_thr: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_optflow_calcOpticalFlowSparseRLOF_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__OutputArrayR_const__OutputArrayR(prev_img: *const c_void, next_img: *const c_void, prev_pts: *const c_void, next_pts: *const c_void, status: *const c_void, err: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_optflow_calcOpticalFlowSparseRLOF_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__OutputArrayR_const__OutputArrayR_PtrLRLOFOpticalFlowParameterG_float(prev_img: *const c_void, next_img: *const c_void, prev_pts: *const c_void, next_pts: *const c_void, status: *const c_void, err: *const c_void, rlof_param: *mut c_void, forward_backward_threshold: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_optflow_calcOpticalFlowSparseToDense_const__InputArrayR_const__InputArrayR_const__OutputArrayR(from: *const c_void, to: *const c_void, flow: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_optflow_calcOpticalFlowSparseToDense_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int_int_float_bool_float_float(from: *const c_void, to: *const c_void, flow: *const c_void, grid_step: i32, k: i32, sigma: f32, use_post_proc: bool, fgs_lambda: f32, fgs_sigma: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_motempl_calcMotionGradient_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_double_double(mhi: *const c_void, mask: *const c_void, orientation: *const c_void, delta1: f64, delta2: f64, ocvrs_return: *mut Result<()>); + pub fn cv_motempl_calcMotionGradient_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_double_double_int(mhi: *const c_void, mask: *const c_void, orientation: *const c_void, delta1: f64, delta2: f64, aperture_size: i32, ocvrs_return: *mut Result<()>); + pub fn cv_motempl_segmentMotion_const__InputArrayR_const__OutputArrayR_vectorLRectGR_double_double(mhi: *const c_void, segmask: *const c_void, bounding_rects: *mut c_void, timestamp: f64, seg_thresh: f64, ocvrs_return: *mut Result<()>); + pub fn cv_motempl_updateMotionHistory_const__InputArrayR_const__InputOutputArrayR_double_double(silhouette: *const c_void, mhi: *const c_void, timestamp: f64, duration: f64, ocvrs_return: *mut Result<()>); + pub fn cv_optflow_calcOpticalFlowDenseRLOF_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR(i0: *const c_void, i1: *const c_void, flow: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_optflow_calcOpticalFlowDenseRLOF_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_PtrLRLOFOpticalFlowParameterG_float_Size_InterpolationType_int_float_float_int_int_bool_float_float_bool(i0: *const c_void, i1: *const c_void, flow: *const c_void, rlof_param: *mut c_void, forward_backward_threshold: f32, grid_step: *const core::Size, interp_type: crate::optflow::InterpolationType, epic_k: i32, epic_sigma: f32, epic_lambda: f32, ric_sp_size: i32, ric_slic_type: i32, use_post_proc: bool, fgs_lambda: f32, fgs_sigma: f32, use_variational_refinement: bool, ocvrs_return: *mut Result<()>); + pub fn cv_optflow_calcOpticalFlowSF_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int_int_int(from: *const c_void, to: *const c_void, flow: *const c_void, layers: i32, averaging_block_size: i32, max_flow: i32, ocvrs_return: *mut Result<()>); + pub fn cv_optflow_calcOpticalFlowSF_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int_int_int_double_double_int_double_double_double_int_double_double_double(from: *const c_void, to: *const c_void, flow: *const c_void, layers: i32, averaging_block_size: i32, max_flow: i32, sigma_dist: f64, sigma_color: f64, postprocess_window: i32, sigma_dist_fix: f64, sigma_color_fix: f64, occ_thr: f64, upscale_averaging_radius: i32, upscale_sigma_dist: f64, upscale_sigma_color: f64, speed_up_thr: f64, ocvrs_return: *mut Result<()>); + pub fn cv_optflow_calcOpticalFlowSparseRLOF_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__OutputArrayR_const__OutputArrayR(prev_img: *const c_void, next_img: *const c_void, prev_pts: *const c_void, next_pts: *const c_void, status: *const c_void, err: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_optflow_calcOpticalFlowSparseRLOF_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__OutputArrayR_const__OutputArrayR_PtrLRLOFOpticalFlowParameterG_float(prev_img: *const c_void, next_img: *const c_void, prev_pts: *const c_void, next_pts: *const c_void, status: *const c_void, err: *const c_void, rlof_param: *mut c_void, forward_backward_threshold: f32, ocvrs_return: *mut Result<()>); + pub fn cv_optflow_calcOpticalFlowSparseToDense_const__InputArrayR_const__InputArrayR_const__OutputArrayR(from: *const c_void, to: *const c_void, flow: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_optflow_calcOpticalFlowSparseToDense_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int_int_float_bool_float_float(from: *const c_void, to: *const c_void, flow: *const c_void, grid_step: i32, k: i32, sigma: f32, use_post_proc: bool, fgs_lambda: f32, fgs_sigma: f32, ocvrs_return: *mut Result<()>); pub fn cv_optflow_createOptFlow_DeepFlow(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_optflow_createOptFlow_DenseRLOF(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_optflow_createOptFlow_DualTVL1(ocvrs_return: *mut Result<*mut c_void>); @@ -11617,33 +11654,33 @@ mod optflow_sys { pub fn cv_optflow_createOptFlow_SimpleFlow(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_optflow_createOptFlow_SparseRLOF(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_optflow_createOptFlow_SparseToDense(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_read_const_FileNodeR_NodeR_Node(fn_: *const c_void, node: *mut crate::optflow::GPCTree_Node, unnamed: *const crate::optflow::GPCTree_Node, ocvrs_return: *mut ResultVoid); - pub fn cv_write_FileStorageR_const_StringR_const_NodeR(fs: *mut c_void, name: *const c_char, node: *const crate::optflow::GPCTree_Node, ocvrs_return: *mut ResultVoid); - pub fn cv_optflow_DenseRLOFOpticalFlow_setRLOFOpticalFlowParameter_PtrLRLOFOpticalFlowParameterG(instance: *mut c_void, val: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_read_const_FileNodeR_NodeR_Node(fn_: *const c_void, node: *mut crate::optflow::GPCTree_Node, unnamed: *const crate::optflow::GPCTree_Node, ocvrs_return: *mut Result<()>); + pub fn cv_write_FileStorageR_const_StringR_const_NodeR(fs: *mut c_void, name: *const c_char, node: *const crate::optflow::GPCTree_Node, ocvrs_return: *mut Result<()>); + pub fn cv_optflow_DenseRLOFOpticalFlow_setRLOFOpticalFlowParameter_PtrLRLOFOpticalFlowParameterG(instance: *mut c_void, val: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_optflow_DenseRLOFOpticalFlow_getRLOFOpticalFlowParameter_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_optflow_DenseRLOFOpticalFlow_setForwardBackward_float(instance: *mut c_void, val: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_optflow_DenseRLOFOpticalFlow_setForwardBackward_float(instance: *mut c_void, val: f32, ocvrs_return: *mut Result<()>); pub fn cv_optflow_DenseRLOFOpticalFlow_getForwardBackward_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_optflow_DenseRLOFOpticalFlow_getGridStep_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_optflow_DenseRLOFOpticalFlow_setGridStep_Size(instance: *mut c_void, val: *const core::Size, ocvrs_return: *mut ResultVoid); - pub fn cv_optflow_DenseRLOFOpticalFlow_setInterpolation_InterpolationType(instance: *mut c_void, val: crate::optflow::InterpolationType, ocvrs_return: *mut ResultVoid); + pub fn cv_optflow_DenseRLOFOpticalFlow_setGridStep_Size(instance: *mut c_void, val: *const core::Size, ocvrs_return: *mut Result<()>); + pub fn cv_optflow_DenseRLOFOpticalFlow_setInterpolation_InterpolationType(instance: *mut c_void, val: crate::optflow::InterpolationType, ocvrs_return: *mut Result<()>); pub fn cv_optflow_DenseRLOFOpticalFlow_getInterpolation_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_optflow_DenseRLOFOpticalFlow_getEPICK_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_optflow_DenseRLOFOpticalFlow_setEPICK_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_optflow_DenseRLOFOpticalFlow_setEPICK_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_optflow_DenseRLOFOpticalFlow_getEPICSigma_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_optflow_DenseRLOFOpticalFlow_setEPICSigma_float(instance: *mut c_void, val: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_optflow_DenseRLOFOpticalFlow_setEPICSigma_float(instance: *mut c_void, val: f32, ocvrs_return: *mut Result<()>); pub fn cv_optflow_DenseRLOFOpticalFlow_getEPICLambda_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_optflow_DenseRLOFOpticalFlow_setEPICLambda_float(instance: *mut c_void, val: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_optflow_DenseRLOFOpticalFlow_setEPICLambda_float(instance: *mut c_void, val: f32, ocvrs_return: *mut Result<()>); pub fn cv_optflow_DenseRLOFOpticalFlow_getFgsLambda_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_optflow_DenseRLOFOpticalFlow_setFgsLambda_float(instance: *mut c_void, val: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_optflow_DenseRLOFOpticalFlow_setFgsLambda_float(instance: *mut c_void, val: f32, ocvrs_return: *mut Result<()>); pub fn cv_optflow_DenseRLOFOpticalFlow_getFgsSigma_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_optflow_DenseRLOFOpticalFlow_setFgsSigma_float(instance: *mut c_void, val: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_optflow_DenseRLOFOpticalFlow_setUsePostProc_bool(instance: *mut c_void, val: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_optflow_DenseRLOFOpticalFlow_setFgsSigma_float(instance: *mut c_void, val: f32, ocvrs_return: *mut Result<()>); + pub fn cv_optflow_DenseRLOFOpticalFlow_setUsePostProc_bool(instance: *mut c_void, val: bool, ocvrs_return: *mut Result<()>); pub fn cv_optflow_DenseRLOFOpticalFlow_getUsePostProc_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_optflow_DenseRLOFOpticalFlow_setUseVariationalRefinement_bool(instance: *mut c_void, val: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_optflow_DenseRLOFOpticalFlow_setUseVariationalRefinement_bool(instance: *mut c_void, val: bool, ocvrs_return: *mut Result<()>); pub fn cv_optflow_DenseRLOFOpticalFlow_getUseVariationalRefinement_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_optflow_DenseRLOFOpticalFlow_setRICSPSize_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_optflow_DenseRLOFOpticalFlow_setRICSPSize_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_optflow_DenseRLOFOpticalFlow_getRICSPSize_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_optflow_DenseRLOFOpticalFlow_setRICSLICType_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_optflow_DenseRLOFOpticalFlow_setRICSLICType_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_optflow_DenseRLOFOpticalFlow_getRICSLICType_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_optflow_DenseRLOFOpticalFlow_create_PtrLRLOFOpticalFlowParameterG_float_Size_InterpolationType_int_float_float_int_int_bool_float_float_bool(rlof_param: *mut c_void, forward_backward_threshold: f32, grid_step: *const core::Size, interp_type: crate::optflow::InterpolationType, epic_k: i32, epic_sigma: f32, epic_lambda: f32, ric_sp_size: i32, ric_slic_type: i32, use_post_proc: bool, fgs_lambda: f32, fgs_sigma: f32, use_variational_refinement: bool, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_optflow_DenseRLOFOpticalFlow_create(ocvrs_return: *mut Result<*mut c_void>); @@ -11651,50 +11688,50 @@ mod optflow_sys { pub fn cv_optflow_DenseRLOFOpticalFlow_to_DenseOpticalFlow(instance: *mut c_void) -> *mut c_void; pub fn cv_optflow_DenseRLOFOpticalFlow_delete(instance: *mut c_void); pub fn cv_optflow_DualTVL1OpticalFlow_getTau_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_optflow_DualTVL1OpticalFlow_setTau_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_optflow_DualTVL1OpticalFlow_setTau_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_optflow_DualTVL1OpticalFlow_getLambda_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_optflow_DualTVL1OpticalFlow_setLambda_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_optflow_DualTVL1OpticalFlow_setLambda_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_optflow_DualTVL1OpticalFlow_getTheta_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_optflow_DualTVL1OpticalFlow_setTheta_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_optflow_DualTVL1OpticalFlow_setTheta_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_optflow_DualTVL1OpticalFlow_getGamma_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_optflow_DualTVL1OpticalFlow_setGamma_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_optflow_DualTVL1OpticalFlow_setGamma_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_optflow_DualTVL1OpticalFlow_getScalesNumber_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_optflow_DualTVL1OpticalFlow_setScalesNumber_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_optflow_DualTVL1OpticalFlow_setScalesNumber_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_optflow_DualTVL1OpticalFlow_getWarpingsNumber_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_optflow_DualTVL1OpticalFlow_setWarpingsNumber_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_optflow_DualTVL1OpticalFlow_setWarpingsNumber_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_optflow_DualTVL1OpticalFlow_getEpsilon_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_optflow_DualTVL1OpticalFlow_setEpsilon_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_optflow_DualTVL1OpticalFlow_setEpsilon_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_optflow_DualTVL1OpticalFlow_getInnerIterations_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_optflow_DualTVL1OpticalFlow_setInnerIterations_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_optflow_DualTVL1OpticalFlow_setInnerIterations_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_optflow_DualTVL1OpticalFlow_getOuterIterations_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_optflow_DualTVL1OpticalFlow_setOuterIterations_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_optflow_DualTVL1OpticalFlow_setOuterIterations_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_optflow_DualTVL1OpticalFlow_getUseInitialFlow_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_optflow_DualTVL1OpticalFlow_setUseInitialFlow_bool(instance: *mut c_void, val: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_optflow_DualTVL1OpticalFlow_setUseInitialFlow_bool(instance: *mut c_void, val: bool, ocvrs_return: *mut Result<()>); pub fn cv_optflow_DualTVL1OpticalFlow_getScaleStep_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_optflow_DualTVL1OpticalFlow_setScaleStep_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_optflow_DualTVL1OpticalFlow_setScaleStep_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_optflow_DualTVL1OpticalFlow_getMedianFiltering_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_optflow_DualTVL1OpticalFlow_setMedianFiltering_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_optflow_DualTVL1OpticalFlow_setMedianFiltering_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_optflow_DualTVL1OpticalFlow_create_double_double_double_int_int_double_int_int_double_double_int_bool(tau: f64, lambda: f64, theta: f64, nscales: i32, warps: i32, epsilon: f64, innner_iterations: i32, outer_iterations: i32, scale_step: f64, gamma: f64, median_filtering: i32, use_initial_flow: bool, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_optflow_DualTVL1OpticalFlow_create(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_optflow_DualTVL1OpticalFlow_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_optflow_DualTVL1OpticalFlow_to_DenseOpticalFlow(instance: *mut c_void) -> *mut c_void; pub fn cv_optflow_DualTVL1OpticalFlow_delete(instance: *mut c_void); - pub fn cv_optflow_GPCDetails_dropOutliers_vectorLpairLcv_Point2i__cv_Point2iGGR(corr: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_optflow_GPCDetails_getAllDescriptorsForImage_const_MatX_vectorLGPCPatchDescriptorGR_const_GPCMatchingParamsR_int(img_ch: *const c_void, descr: *mut c_void, mp: *const crate::optflow::GPCMatchingParams, typ: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_optflow_GPCDetails_getCoordinatesFromIndex_size_t_Size_intR_intR(index: size_t, sz: *const core::Size, x: *mut i32, y: *mut i32, ocvrs_return: *mut ResultVoid); + pub fn cv_optflow_GPCDetails_dropOutliers_vectorLpairLcv_Point2i__cv_Point2iGGR(corr: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_optflow_GPCDetails_getAllDescriptorsForImage_const_MatX_vectorLGPCPatchDescriptorGR_const_GPCMatchingParamsR_int(img_ch: *const c_void, descr: *mut c_void, mp: *const crate::optflow::GPCMatchingParams, typ: i32, ocvrs_return: *mut Result<()>); + pub fn cv_optflow_GPCDetails_getCoordinatesFromIndex_size_t_Size_intR_intR(index: size_t, sz: *const core::Size, x: *mut i32, y: *mut i32, ocvrs_return: *mut Result<()>); pub fn cv_optflow_GPCDetails_defaultNew_const() -> *mut c_void; pub fn cv_optflow_GPCDetails_delete(instance: *mut c_void); pub fn cv_optflow_GPCMatchingParams_GPCMatchingParams_bool(_use_opencl: bool, ocvrs_return: *mut Result); pub fn cv_optflow_GPCMatchingParams_GPCMatchingParams(ocvrs_return: *mut Result); pub fn cv_optflow_GPCMatchingParams_GPCMatchingParams_const_GPCMatchingParamsR(params: *const crate::optflow::GPCMatchingParams, ocvrs_return: *mut Result); pub fn cv_optflow_GPCPatchDescriptor_dot_const_const_VecLdouble__18GR(instance: *const c_void, coef: *const core::VecN, ocvrs_return: *mut Result); - pub fn cv_optflow_GPCPatchDescriptor_markAsSeparated(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_optflow_GPCPatchDescriptor_markAsSeparated(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_optflow_GPCPatchDescriptor_isSeparated_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_optflow_GPCPatchDescriptor_defaultNew_const() -> *mut c_void; pub fn cv_optflow_GPCPatchDescriptor_propFeature_const(instance: *const c_void, ocvrs_return: *mut core::VecN); pub fn cv_optflow_GPCPatchDescriptor_propFeature_const_VecLdouble__18G(instance: *mut c_void, val: *const core::VecN); pub fn cv_optflow_GPCPatchDescriptor_delete(instance: *mut c_void); - pub fn cv_optflow_GPCPatchSample_getDirections_const_boolR_boolR_boolR_const_VecLdouble__18GR_double(instance: *const c_void, refdir: *mut bool, posdir: *mut bool, negdir: *mut bool, coef: *const core::VecN, rhs: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_optflow_GPCPatchSample_getDirections_const_boolR_boolR_boolR_const_VecLdouble__18GR_double(instance: *const c_void, refdir: *mut bool, posdir: *mut bool, negdir: *mut bool, coef: *const core::VecN, rhs: f64, ocvrs_return: *mut Result<()>); pub fn cv_optflow_GPCPatchSample_defaultNew_const() -> *mut c_void; pub fn cv_optflow_GPCPatchSample_propRef_const(instance: *const c_void) -> *mut c_void; pub fn cv_optflow_GPCPatchSample_propRef_const_GPCPatchDescriptor(instance: *mut c_void, val: *const c_void); @@ -11712,10 +11749,10 @@ mod optflow_sys { pub fn cv_optflow_GPCTrainingSamples_type_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_optflow_GPCTrainingSamples_defaultNew_const() -> *mut c_void; pub fn cv_optflow_GPCTrainingSamples_delete(instance: *mut c_void); - pub fn cv_optflow_GPCTree_train_GPCTrainingSamplesR_const_GPCTrainingParams(instance: *mut c_void, samples: *mut c_void, params: *const crate::optflow::GPCTrainingParams, ocvrs_return: *mut ResultVoid); - pub fn cv_optflow_GPCTree_train_GPCTrainingSamplesR(instance: *mut c_void, samples: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_optflow_GPCTree_write_const_FileStorageR(instance: *const c_void, fs: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_optflow_GPCTree_read_const_FileNodeR(instance: *mut c_void, fn_: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_optflow_GPCTree_train_GPCTrainingSamplesR_const_GPCTrainingParams(instance: *mut c_void, samples: *mut c_void, params: *const crate::optflow::GPCTrainingParams, ocvrs_return: *mut Result<()>); + pub fn cv_optflow_GPCTree_train_GPCTrainingSamplesR(instance: *mut c_void, samples: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_optflow_GPCTree_write_const_FileStorageR(instance: *const c_void, fs: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_optflow_GPCTree_read_const_FileNodeR(instance: *mut c_void, fn_: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_optflow_GPCTree_findLeafForPatch_const_const_GPCPatchDescriptorR(instance: *const c_void, descr: *const c_void, ocvrs_return: *mut Result); pub fn cv_optflow_GPCTree_create(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_optflow_GPCTree_operatorEQ_const_const_GPCTreeR(instance: *const c_void, t: *const c_void, ocvrs_return: *mut Result); @@ -11726,45 +11763,45 @@ mod optflow_sys { pub fn cv_optflow_GPCTree_Node_operatorEQ_const_const_NodeR(instance: *const crate::optflow::GPCTree_Node, n: *const crate::optflow::GPCTree_Node, ocvrs_return: *mut Result); pub fn cv_optflow_OpticalFlowPCAFlow_OpticalFlowPCAFlow_PtrLconst_PCAPriorG_const_Size_float_float_float_float_float(_prior: *const c_void, _basis_size: *const core::Size, _sparse_rate: f32, _retained_corners_fraction: f32, _occlusions_threshold: f32, _damping_factor: f32, _clahe_clip: f32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_optflow_OpticalFlowPCAFlow_OpticalFlowPCAFlow(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_optflow_OpticalFlowPCAFlow_calc_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR(instance: *mut c_void, i0: *const c_void, i1: *const c_void, flow: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_optflow_OpticalFlowPCAFlow_collectGarbage(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_optflow_OpticalFlowPCAFlow_calc_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR(instance: *mut c_void, i0: *const c_void, i1: *const c_void, flow: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_optflow_OpticalFlowPCAFlow_collectGarbage(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_optflow_OpticalFlowPCAFlow_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_optflow_OpticalFlowPCAFlow_to_DenseOpticalFlow(instance: *mut c_void) -> *mut c_void; pub fn cv_optflow_OpticalFlowPCAFlow_delete(instance: *mut c_void); pub fn cv_optflow_PCAPrior_PCAPrior_const_charX(path_to_prior: *const c_char, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_optflow_PCAPrior_getPadding_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_optflow_PCAPrior_getBasisSize_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_optflow_PCAPrior_fillConstraints_const_floatX_floatX_floatX_floatX(instance: *const c_void, a1: *mut f32, a2: *mut f32, b1: *mut f32, b2: *mut f32, ocvrs_return: *mut ResultVoid); + pub fn cv_optflow_PCAPrior_fillConstraints_const_floatX_floatX_floatX_floatX(instance: *const c_void, a1: *mut f32, a2: *mut f32, b1: *mut f32, b2: *mut f32, ocvrs_return: *mut Result<()>); pub fn cv_optflow_PCAPrior_delete(instance: *mut c_void); pub fn cv_optflow_RLOFOpticalFlowParameter_RLOFOpticalFlowParameter(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_optflow_RLOFOpticalFlowParameter_setUseMEstimator_bool(instance: *mut c_void, val: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_optflow_RLOFOpticalFlowParameter_setSolverType_SolverType(instance: *mut c_void, val: crate::optflow::SolverType, ocvrs_return: *mut ResultVoid); + pub fn cv_optflow_RLOFOpticalFlowParameter_setUseMEstimator_bool(instance: *mut c_void, val: bool, ocvrs_return: *mut Result<()>); + pub fn cv_optflow_RLOFOpticalFlowParameter_setSolverType_SolverType(instance: *mut c_void, val: crate::optflow::SolverType, ocvrs_return: *mut Result<()>); pub fn cv_optflow_RLOFOpticalFlowParameter_getSolverType_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_optflow_RLOFOpticalFlowParameter_setSupportRegionType_SupportRegionType(instance: *mut c_void, val: crate::optflow::SupportRegionType, ocvrs_return: *mut ResultVoid); + pub fn cv_optflow_RLOFOpticalFlowParameter_setSupportRegionType_SupportRegionType(instance: *mut c_void, val: crate::optflow::SupportRegionType, ocvrs_return: *mut Result<()>); pub fn cv_optflow_RLOFOpticalFlowParameter_getSupportRegionType_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_optflow_RLOFOpticalFlowParameter_setNormSigma0_float(instance: *mut c_void, val: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_optflow_RLOFOpticalFlowParameter_setNormSigma0_float(instance: *mut c_void, val: f32, ocvrs_return: *mut Result<()>); pub fn cv_optflow_RLOFOpticalFlowParameter_getNormSigma0_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_optflow_RLOFOpticalFlowParameter_setNormSigma1_float(instance: *mut c_void, val: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_optflow_RLOFOpticalFlowParameter_setNormSigma1_float(instance: *mut c_void, val: f32, ocvrs_return: *mut Result<()>); pub fn cv_optflow_RLOFOpticalFlowParameter_getNormSigma1_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_optflow_RLOFOpticalFlowParameter_setSmallWinSize_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_optflow_RLOFOpticalFlowParameter_setSmallWinSize_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_optflow_RLOFOpticalFlowParameter_getSmallWinSize_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_optflow_RLOFOpticalFlowParameter_setLargeWinSize_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_optflow_RLOFOpticalFlowParameter_setLargeWinSize_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_optflow_RLOFOpticalFlowParameter_getLargeWinSize_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_optflow_RLOFOpticalFlowParameter_setCrossSegmentationThreshold_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_optflow_RLOFOpticalFlowParameter_setCrossSegmentationThreshold_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_optflow_RLOFOpticalFlowParameter_getCrossSegmentationThreshold_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_optflow_RLOFOpticalFlowParameter_setMaxLevel_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_optflow_RLOFOpticalFlowParameter_setMaxLevel_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_optflow_RLOFOpticalFlowParameter_getMaxLevel_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_optflow_RLOFOpticalFlowParameter_setUseInitialFlow_bool(instance: *mut c_void, val: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_optflow_RLOFOpticalFlowParameter_setUseInitialFlow_bool(instance: *mut c_void, val: bool, ocvrs_return: *mut Result<()>); pub fn cv_optflow_RLOFOpticalFlowParameter_getUseInitialFlow_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_optflow_RLOFOpticalFlowParameter_setUseIlluminationModel_bool(instance: *mut c_void, val: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_optflow_RLOFOpticalFlowParameter_setUseIlluminationModel_bool(instance: *mut c_void, val: bool, ocvrs_return: *mut Result<()>); pub fn cv_optflow_RLOFOpticalFlowParameter_getUseIlluminationModel_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_optflow_RLOFOpticalFlowParameter_setUseGlobalMotionPrior_bool(instance: *mut c_void, val: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_optflow_RLOFOpticalFlowParameter_setUseGlobalMotionPrior_bool(instance: *mut c_void, val: bool, ocvrs_return: *mut Result<()>); pub fn cv_optflow_RLOFOpticalFlowParameter_getUseGlobalMotionPrior_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_optflow_RLOFOpticalFlowParameter_setMaxIteration_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_optflow_RLOFOpticalFlowParameter_setMaxIteration_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_optflow_RLOFOpticalFlowParameter_getMaxIteration_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_optflow_RLOFOpticalFlowParameter_setMinEigenValue_float(instance: *mut c_void, val: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_optflow_RLOFOpticalFlowParameter_setMinEigenValue_float(instance: *mut c_void, val: f32, ocvrs_return: *mut Result<()>); pub fn cv_optflow_RLOFOpticalFlowParameter_getMinEigenValue_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_optflow_RLOFOpticalFlowParameter_setGlobalMotionRansacThreshold_float(instance: *mut c_void, val: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_optflow_RLOFOpticalFlowParameter_setGlobalMotionRansacThreshold_float(instance: *mut c_void, val: f32, ocvrs_return: *mut Result<()>); pub fn cv_optflow_RLOFOpticalFlowParameter_getGlobalMotionRansacThreshold_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_optflow_RLOFOpticalFlowParameter_create(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_optflow_RLOFOpticalFlowParameter_propSolverType_const(instance: *const c_void, ocvrs_return: *mut crate::optflow::SolverType); @@ -11796,9 +11833,9 @@ mod optflow_sys { pub fn cv_optflow_RLOFOpticalFlowParameter_propGlobalMotionRansacThreshold_const(instance: *const c_void) -> f32; pub fn cv_optflow_RLOFOpticalFlowParameter_propGlobalMotionRansacThreshold_const_float(instance: *mut c_void, val: f32); pub fn cv_optflow_RLOFOpticalFlowParameter_delete(instance: *mut c_void); - pub fn cv_optflow_SparseRLOFOpticalFlow_setRLOFOpticalFlowParameter_PtrLRLOFOpticalFlowParameterG(instance: *mut c_void, val: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_optflow_SparseRLOFOpticalFlow_setRLOFOpticalFlowParameter_PtrLRLOFOpticalFlowParameterG(instance: *mut c_void, val: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_optflow_SparseRLOFOpticalFlow_getRLOFOpticalFlowParameter_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_optflow_SparseRLOFOpticalFlow_setForwardBackward_float(instance: *mut c_void, val: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_optflow_SparseRLOFOpticalFlow_setForwardBackward_float(instance: *mut c_void, val: f32, ocvrs_return: *mut Result<()>); pub fn cv_optflow_SparseRLOFOpticalFlow_getForwardBackward_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_optflow_SparseRLOFOpticalFlow_create_PtrLRLOFOpticalFlowParameterG_float(rlof_param: *mut c_void, forward_backward_threshold: f32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_optflow_SparseRLOFOpticalFlow_create(ocvrs_return: *mut Result<*mut c_void>); @@ -11881,73 +11918,71 @@ mod optflow_sys { pub fn std_vectorLcv_optflow_GPCPatchSampleG_set_size_t_const_GPCPatchSample(instance: *mut c_void, index: size_t, val: *const c_void); } } -#[cfg(ocvrs_has_module_optflow)] pub use optflow_sys::*; -#[cfg(ocvrs_has_module_ovis)] mod ovis_sys { use super::*; extern "C" { - pub fn cv_ovis_addResourceLocation_const_StringR(path: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_ovis_createGridMesh_const_StringR_const_Size2fR(name: *const c_char, size: *const core::Size2f, ocvrs_return: *mut ResultVoid); - pub fn cv_ovis_createGridMesh_const_StringR_const_Size2fR_const_SizeR(name: *const c_char, size: *const core::Size2f, segments: *const core::Size, ocvrs_return: *mut ResultVoid); - pub fn cv_ovis_createPlaneMesh_const_StringR_const_Size2fR(name: *const c_char, size: *const core::Size2f, ocvrs_return: *mut ResultVoid); - pub fn cv_ovis_createPlaneMesh_const_StringR_const_Size2fR_const__InputArrayR(name: *const c_char, size: *const core::Size2f, image: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ovis_createPointCloudMesh_const_StringR_const__InputArrayR(name: *const c_char, vertices: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ovis_createPointCloudMesh_const_StringR_const__InputArrayR_const__InputArrayR(name: *const c_char, vertices: *const c_void, colors: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ovis_createTriangleMesh_const_StringR_const__InputArrayR(name: *const c_char, vertices: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ovis_createTriangleMesh_const_StringR_const__InputArrayR_const__InputArrayR_const__InputArrayR(name: *const c_char, vertices: *const c_void, normals: *const c_void, indices: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ovis_addResourceLocation_const_StringR(path: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_ovis_createGridMesh_const_StringR_const_Size2fR(name: *const c_char, size: *const core::Size2f, ocvrs_return: *mut Result<()>); + pub fn cv_ovis_createGridMesh_const_StringR_const_Size2fR_const_SizeR(name: *const c_char, size: *const core::Size2f, segments: *const core::Size, ocvrs_return: *mut Result<()>); + pub fn cv_ovis_createPlaneMesh_const_StringR_const_Size2fR(name: *const c_char, size: *const core::Size2f, ocvrs_return: *mut Result<()>); + pub fn cv_ovis_createPlaneMesh_const_StringR_const_Size2fR_const__InputArrayR(name: *const c_char, size: *const core::Size2f, image: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ovis_createPointCloudMesh_const_StringR_const__InputArrayR(name: *const c_char, vertices: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ovis_createPointCloudMesh_const_StringR_const__InputArrayR_const__InputArrayR(name: *const c_char, vertices: *const c_void, colors: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ovis_createTriangleMesh_const_StringR_const__InputArrayR(name: *const c_char, vertices: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ovis_createTriangleMesh_const_StringR_const__InputArrayR_const__InputArrayR_const__InputArrayR(name: *const c_char, vertices: *const c_void, normals: *const c_void, indices: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_ovis_createWindow_const_StringR_const_SizeR(title: *const c_char, size: *const core::Size, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ovis_createWindow_const_StringR_const_SizeR_int(title: *const c_char, size: *const core::Size, flags: i32, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_ovis_setMaterialProperty_const_StringR_const_StringR_const_ScalarR(name: *const c_char, prop: *const c_char, value: *const core::Scalar, ocvrs_return: *mut ResultVoid); - pub fn cv_ovis_setMaterialProperty_const_StringR_int_const_ScalarR(name: *const c_char, prop: i32, value: *const core::Scalar, ocvrs_return: *mut ResultVoid); - pub fn cv_ovis_setMaterialProperty_const_StringR_int_const_StringR(name: *const c_char, prop: i32, value: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_ovis_setMaterialProperty_const_StringR_int_const__InputArrayR(name: *const c_char, prop: i32, value: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ovis_updateTexture_const_StringR_const__InputArrayR(name: *const c_char, image: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ovis_setMaterialProperty_const_StringR_const_StringR_const_ScalarR(name: *const c_char, prop: *const c_char, value: *const core::Scalar, ocvrs_return: *mut Result<()>); + pub fn cv_ovis_setMaterialProperty_const_StringR_int_const_ScalarR(name: *const c_char, prop: i32, value: *const core::Scalar, ocvrs_return: *mut Result<()>); + pub fn cv_ovis_setMaterialProperty_const_StringR_int_const_StringR(name: *const c_char, prop: i32, value: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_ovis_setMaterialProperty_const_StringR_int_const__InputArrayR(name: *const c_char, prop: i32, value: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ovis_updateTexture_const_StringR_const__InputArrayR(name: *const c_char, image: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_ovis_waitKey(ocvrs_return: *mut Result); pub fn cv_ovis_waitKey_int(delay: i32, ocvrs_return: *mut Result); - pub fn cv_ovis_WindowScene_setBackground_const__InputArrayR(instance: *mut c_void, image: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ovis_WindowScene_setBackground_const_ScalarR(instance: *mut c_void, color: *const core::Scalar, ocvrs_return: *mut ResultVoid); - pub fn cv_ovis_WindowScene_setCompositors_const_vectorLStringGR(instance: *mut c_void, names: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ovis_WindowScene_createEntity_const_StringR_const_StringR_const__InputArrayR_const__InputArrayR(instance: *mut c_void, name: *const c_char, meshname: *const c_char, tvec: *const c_void, rot: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ovis_WindowScene_createEntity_const_StringR_const_StringR(instance: *mut c_void, name: *const c_char, meshname: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_ovis_WindowScene_removeEntity_const_StringR(instance: *mut c_void, name: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_ovis_WindowScene_setEntityProperty_const_StringR_int_const_StringR_int(instance: *mut c_void, name: *const c_char, prop: i32, value: *const c_char, sub_entity_idx: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_ovis_WindowScene_setEntityProperty_const_StringR_int_const_StringR(instance: *mut c_void, name: *const c_char, prop: i32, value: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_ovis_WindowScene_setEntityProperty_const_StringR_int_const_ScalarR(instance: *mut c_void, name: *const c_char, prop: i32, value: *const core::Scalar, ocvrs_return: *mut ResultVoid); - pub fn cv_ovis_WindowScene_getEntityProperty_const_StringR_int_const__OutputArrayR(instance: *mut c_void, name: *const c_char, prop: i32, value: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ovis_WindowScene_setBackground_const__InputArrayR(instance: *mut c_void, image: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ovis_WindowScene_setBackground_const_ScalarR(instance: *mut c_void, color: *const core::Scalar, ocvrs_return: *mut Result<()>); + pub fn cv_ovis_WindowScene_setCompositors_const_vectorLStringGR(instance: *mut c_void, names: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ovis_WindowScene_createEntity_const_StringR_const_StringR_const__InputArrayR_const__InputArrayR(instance: *mut c_void, name: *const c_char, meshname: *const c_char, tvec: *const c_void, rot: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ovis_WindowScene_createEntity_const_StringR_const_StringR(instance: *mut c_void, name: *const c_char, meshname: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_ovis_WindowScene_removeEntity_const_StringR(instance: *mut c_void, name: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_ovis_WindowScene_setEntityProperty_const_StringR_int_const_StringR_int(instance: *mut c_void, name: *const c_char, prop: i32, value: *const c_char, sub_entity_idx: i32, ocvrs_return: *mut Result<()>); + pub fn cv_ovis_WindowScene_setEntityProperty_const_StringR_int_const_StringR(instance: *mut c_void, name: *const c_char, prop: i32, value: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_ovis_WindowScene_setEntityProperty_const_StringR_int_const_ScalarR(instance: *mut c_void, name: *const c_char, prop: i32, value: *const core::Scalar, ocvrs_return: *mut Result<()>); + pub fn cv_ovis_WindowScene_getEntityProperty_const_StringR_int_const__OutputArrayR(instance: *mut c_void, name: *const c_char, prop: i32, value: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_ovis_WindowScene_createCameraEntity_const_StringR_const__InputArrayR_const_SizeR_float_const__InputArrayR_const__InputArrayR_const_ScalarR(instance: *mut c_void, name: *const c_char, k: *const c_void, imsize: *const core::Size, z_far: f32, tvec: *const c_void, rot: *const c_void, color: *const core::Scalar, ocvrs_return: *mut Result); pub fn cv_ovis_WindowScene_createCameraEntity_const_StringR_const__InputArrayR_const_SizeR_float(instance: *mut c_void, name: *const c_char, k: *const c_void, imsize: *const core::Size, z_far: f32, ocvrs_return: *mut Result); - pub fn cv_ovis_WindowScene_createLightEntity_const_StringR_const__InputArrayR_const__InputArrayR_const_ScalarR_const_ScalarR(instance: *mut c_void, name: *const c_char, tvec: *const c_void, rot: *const c_void, diffuse_color: *const core::Scalar, specular_color: *const core::Scalar, ocvrs_return: *mut ResultVoid); - pub fn cv_ovis_WindowScene_createLightEntity_const_StringR(instance: *mut c_void, name: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_ovis_WindowScene_updateEntityPose_const_StringR_const__InputArrayR_const__InputArrayR(instance: *mut c_void, name: *const c_char, tvec: *const c_void, rot: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ovis_WindowScene_updateEntityPose_const_StringR(instance: *mut c_void, name: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_ovis_WindowScene_setEntityPose_const_StringR_const__InputArrayR_const__InputArrayR_bool(instance: *mut c_void, name: *const c_char, tvec: *const c_void, rot: *const c_void, invert: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_ovis_WindowScene_setEntityPose_const_StringR(instance: *mut c_void, name: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_ovis_WindowScene_getEntityPose_const_StringR_const__OutputArrayR_const__OutputArrayR_bool(instance: *mut c_void, name: *const c_char, r: *const c_void, tvec: *const c_void, invert: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_ovis_WindowScene_getEntityPose_const_StringR(instance: *mut c_void, name: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_ovis_WindowScene_getEntityAnimations_const_StringR_vectorLStringGR(instance: *mut c_void, name: *const c_char, out: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ovis_WindowScene_playEntityAnimation_const_StringR_const_StringR_bool(instance: *mut c_void, name: *const c_char, animname: *const c_char, loop_: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_ovis_WindowScene_playEntityAnimation_const_StringR_const_StringR(instance: *mut c_void, name: *const c_char, animname: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_ovis_WindowScene_stopEntityAnimation_const_StringR_const_StringR(instance: *mut c_void, name: *const c_char, animname: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_ovis_WindowScene_getScreenshot_const__OutputArrayR(instance: *mut c_void, frame: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ovis_WindowScene_getCompositorTexture_const_StringR_const_StringR_const__OutputArrayR_int(instance: *mut c_void, compname: *const c_char, texname: *const c_char, out: *const c_void, mrt_index: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_ovis_WindowScene_getCompositorTexture_const_StringR_const_StringR_const__OutputArrayR(instance: *mut c_void, compname: *const c_char, texname: *const c_char, out: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ovis_WindowScene_getDepth_const__OutputArrayR(instance: *mut c_void, depth: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ovis_WindowScene_fixCameraYawAxis_bool_const__InputArrayR(instance: *mut c_void, use_fixed: bool, up: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ovis_WindowScene_fixCameraYawAxis_bool(instance: *mut c_void, use_fixed: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_ovis_WindowScene_setCameraPose_const__InputArrayR_const__InputArrayR_bool(instance: *mut c_void, tvec: *const c_void, rot: *const c_void, invert: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_ovis_WindowScene_setCameraPose(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ovis_WindowScene_setCameraLookAt_const_StringR_const__InputArrayR(instance: *mut c_void, target: *const c_char, offset: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ovis_WindowScene_setCameraLookAt_const_StringR(instance: *mut c_void, target: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_ovis_WindowScene_setEntityLookAt_const_StringR_const_StringR_const__InputArrayR(instance: *mut c_void, origin: *const c_char, target: *const c_char, offset: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ovis_WindowScene_setEntityLookAt_const_StringR_const_StringR(instance: *mut c_void, origin: *const c_char, target: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_ovis_WindowScene_getCameraPose_const__OutputArrayR_const__OutputArrayR_bool(instance: *mut c_void, r: *const c_void, tvec: *const c_void, invert: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_ovis_WindowScene_getCameraPose(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ovis_WindowScene_setCameraIntrinsics_const__InputArrayR_const_SizeR_float_float(instance: *mut c_void, k: *const c_void, imsize: *const core::Size, z_near: f32, z_far: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_ovis_WindowScene_setCameraIntrinsics_const__InputArrayR_const_SizeR(instance: *mut c_void, k: *const c_void, imsize: *const core::Size, ocvrs_return: *mut ResultVoid); - pub fn cv_ovis_WindowScene_update(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ovis_WindowScene_createLightEntity_const_StringR_const__InputArrayR_const__InputArrayR_const_ScalarR_const_ScalarR(instance: *mut c_void, name: *const c_char, tvec: *const c_void, rot: *const c_void, diffuse_color: *const core::Scalar, specular_color: *const core::Scalar, ocvrs_return: *mut Result<()>); + pub fn cv_ovis_WindowScene_createLightEntity_const_StringR(instance: *mut c_void, name: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_ovis_WindowScene_updateEntityPose_const_StringR_const__InputArrayR_const__InputArrayR(instance: *mut c_void, name: *const c_char, tvec: *const c_void, rot: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ovis_WindowScene_updateEntityPose_const_StringR(instance: *mut c_void, name: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_ovis_WindowScene_setEntityPose_const_StringR_const__InputArrayR_const__InputArrayR_bool(instance: *mut c_void, name: *const c_char, tvec: *const c_void, rot: *const c_void, invert: bool, ocvrs_return: *mut Result<()>); + pub fn cv_ovis_WindowScene_setEntityPose_const_StringR(instance: *mut c_void, name: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_ovis_WindowScene_getEntityPose_const_StringR_const__OutputArrayR_const__OutputArrayR_bool(instance: *mut c_void, name: *const c_char, r: *const c_void, tvec: *const c_void, invert: bool, ocvrs_return: *mut Result<()>); + pub fn cv_ovis_WindowScene_getEntityPose_const_StringR(instance: *mut c_void, name: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_ovis_WindowScene_getEntityAnimations_const_StringR_vectorLStringGR(instance: *mut c_void, name: *const c_char, out: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ovis_WindowScene_playEntityAnimation_const_StringR_const_StringR_bool(instance: *mut c_void, name: *const c_char, animname: *const c_char, loop_: bool, ocvrs_return: *mut Result<()>); + pub fn cv_ovis_WindowScene_playEntityAnimation_const_StringR_const_StringR(instance: *mut c_void, name: *const c_char, animname: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_ovis_WindowScene_stopEntityAnimation_const_StringR_const_StringR(instance: *mut c_void, name: *const c_char, animname: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_ovis_WindowScene_getScreenshot_const__OutputArrayR(instance: *mut c_void, frame: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ovis_WindowScene_getCompositorTexture_const_StringR_const_StringR_const__OutputArrayR_int(instance: *mut c_void, compname: *const c_char, texname: *const c_char, out: *const c_void, mrt_index: i32, ocvrs_return: *mut Result<()>); + pub fn cv_ovis_WindowScene_getCompositorTexture_const_StringR_const_StringR_const__OutputArrayR(instance: *mut c_void, compname: *const c_char, texname: *const c_char, out: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ovis_WindowScene_getDepth_const__OutputArrayR(instance: *mut c_void, depth: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ovis_WindowScene_fixCameraYawAxis_bool_const__InputArrayR(instance: *mut c_void, use_fixed: bool, up: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ovis_WindowScene_fixCameraYawAxis_bool(instance: *mut c_void, use_fixed: bool, ocvrs_return: *mut Result<()>); + pub fn cv_ovis_WindowScene_setCameraPose_const__InputArrayR_const__InputArrayR_bool(instance: *mut c_void, tvec: *const c_void, rot: *const c_void, invert: bool, ocvrs_return: *mut Result<()>); + pub fn cv_ovis_WindowScene_setCameraPose(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ovis_WindowScene_setCameraLookAt_const_StringR_const__InputArrayR(instance: *mut c_void, target: *const c_char, offset: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ovis_WindowScene_setCameraLookAt_const_StringR(instance: *mut c_void, target: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_ovis_WindowScene_setEntityLookAt_const_StringR_const_StringR_const__InputArrayR(instance: *mut c_void, origin: *const c_char, target: *const c_char, offset: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ovis_WindowScene_setEntityLookAt_const_StringR_const_StringR(instance: *mut c_void, origin: *const c_char, target: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_ovis_WindowScene_getCameraPose_const__OutputArrayR_const__OutputArrayR_bool(instance: *mut c_void, r: *const c_void, tvec: *const c_void, invert: bool, ocvrs_return: *mut Result<()>); + pub fn cv_ovis_WindowScene_getCameraPose(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ovis_WindowScene_setCameraIntrinsics_const__InputArrayR_const_SizeR_float_float(instance: *mut c_void, k: *const c_void, imsize: *const core::Size, z_near: f32, z_far: f32, ocvrs_return: *mut Result<()>); + pub fn cv_ovis_WindowScene_setCameraIntrinsics_const__InputArrayR_const_SizeR(instance: *mut c_void, k: *const c_void, imsize: *const core::Size, ocvrs_return: *mut Result<()>); + pub fn cv_ovis_WindowScene_update(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_ovis_WindowScene_delete(instance: *mut c_void); pub fn cv_PtrLcv_ovis_WindowSceneG_getInnerPtr_const(instance: *const c_void) -> *mut c_void; pub fn cv_PtrLcv_ovis_WindowSceneG_getInnerPtrMut(instance: *mut c_void) -> *mut c_void; @@ -11955,23 +11990,21 @@ mod ovis_sys { pub fn cv_PtrLcv_ovis_WindowSceneG_delete(instance: *mut c_void); } } -#[cfg(ocvrs_has_module_ovis)] pub use ovis_sys::*; -#[cfg(ocvrs_has_module_phase_unwrapping)] mod phase_unwrapping_sys { use super::*; extern "C" { pub fn cv_phase_unwrapping_HistogramPhaseUnwrapping_create_const_ParamsR(parameters: *const crate::phase_unwrapping::HistogramPhaseUnwrapping_Params, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_phase_unwrapping_HistogramPhaseUnwrapping_create(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_phase_unwrapping_HistogramPhaseUnwrapping_getInverseReliabilityMap_const__OutputArrayR(instance: *mut c_void, reliability_map: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_phase_unwrapping_HistogramPhaseUnwrapping_getInverseReliabilityMap_const__OutputArrayR(instance: *mut c_void, reliability_map: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_phase_unwrapping_HistogramPhaseUnwrapping_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_phase_unwrapping_HistogramPhaseUnwrapping_to_PhaseUnwrapping(instance: *mut c_void) -> *mut c_void; pub fn cv_phase_unwrapping_HistogramPhaseUnwrapping_delete(instance: *mut c_void); pub fn cv_phase_unwrapping_HistogramPhaseUnwrapping_Params_Params(ocvrs_return: *mut Result); - pub fn cv_phase_unwrapping_PhaseUnwrapping_unwrapPhaseMap_const__InputArrayR_const__OutputArrayR_const__InputArrayR(instance: *mut c_void, wrapped_phase_map: *const c_void, unwrapped_phase_map: *const c_void, shadow_mask: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_phase_unwrapping_PhaseUnwrapping_unwrapPhaseMap_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, wrapped_phase_map: *const c_void, unwrapped_phase_map: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_phase_unwrapping_PhaseUnwrapping_unwrapPhaseMap_const__InputArrayR_const__OutputArrayR_const__InputArrayR(instance: *mut c_void, wrapped_phase_map: *const c_void, unwrapped_phase_map: *const c_void, shadow_mask: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_phase_unwrapping_PhaseUnwrapping_unwrapPhaseMap_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, wrapped_phase_map: *const c_void, unwrapped_phase_map: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_phase_unwrapping_PhaseUnwrapping_to_HistogramPhaseUnwrapping(instance: *mut c_void) -> *mut c_void; pub fn cv_phase_unwrapping_PhaseUnwrapping_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_phase_unwrapping_PhaseUnwrapping_delete(instance: *mut c_void); @@ -11988,16 +12021,14 @@ mod phase_unwrapping_sys { pub fn cv_PtrLcv_phase_unwrapping_PhaseUnwrappingG_to_PtrOfAlgorithm(instance: *mut c_void) -> *mut c_void; } } -#[cfg(ocvrs_has_module_phase_unwrapping)] pub use phase_unwrapping_sys::*; -#[cfg(ocvrs_has_module_photo)] mod photo_sys { use super::*; extern "C" { - pub fn cv_colorChange_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src: *const c_void, mask: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_colorChange_const__InputArrayR_const__InputArrayR_const__OutputArrayR_float_float_float(src: *const c_void, mask: *const c_void, dst: *const c_void, red_mul: f32, green_mul: f32, blue_mul: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_colorChange_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src: *const c_void, mask: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_colorChange_const__InputArrayR_const__InputArrayR_const__OutputArrayR_float_float_float(src: *const c_void, mask: *const c_void, dst: *const c_void, red_mul: f32, green_mul: f32, blue_mul: f32, ocvrs_return: *mut Result<()>); pub fn cv_createAlignMTB(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_createAlignMTB_int_int_bool(max_bits: i32, exclude_range: i32, cut: bool, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_createCalibrateDebevec(ocvrs_return: *mut Result<*mut c_void>); @@ -12016,142 +12047,142 @@ mod photo_sys { pub fn cv_createTonemapReinhard(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_createTonemapReinhard_float_float_float_float(gamma: f32, intensity: f32, light_adapt: f32, color_adapt: f32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_createTonemap_float(gamma: f32, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_cuda_fastNlMeansDenoisingColored_const_GpuMatR_GpuMatR_float_float(src: *const c_void, dst: *mut c_void, h_luminance: f32, photo_render: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_fastNlMeansDenoisingColored_const_GpuMatR_GpuMatR_float_float_int_int_StreamR(src: *const c_void, dst: *mut c_void, h_luminance: f32, photo_render: f32, search_window: i32, block_size: i32, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_fastNlMeansDenoisingColored_const__InputArrayR_const__OutputArrayR_float_float(src: *const c_void, dst: *const c_void, h_luminance: f32, photo_render: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_fastNlMeansDenoisingColored_const__InputArrayR_const__OutputArrayR_float_float_int_int_StreamR(src: *const c_void, dst: *const c_void, h_luminance: f32, photo_render: f32, search_window: i32, block_size: i32, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_fastNlMeansDenoising_const_GpuMatR_GpuMatR_float(src: *const c_void, dst: *mut c_void, h: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_fastNlMeansDenoising_const_GpuMatR_GpuMatR_float_int_int_StreamR(src: *const c_void, dst: *mut c_void, h: f32, search_window: i32, block_size: i32, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_fastNlMeansDenoising_const__InputArrayR_const__OutputArrayR_float(src: *const c_void, dst: *const c_void, h: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_fastNlMeansDenoising_const__InputArrayR_const__OutputArrayR_float_int_int_StreamR(src: *const c_void, dst: *const c_void, h: f32, search_window: i32, block_size: i32, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_nonLocalMeans_const_GpuMatR_GpuMatR_float(src: *const c_void, dst: *mut c_void, h: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_nonLocalMeans_const_GpuMatR_GpuMatR_float_int_int_int_StreamR(src: *const c_void, dst: *mut c_void, h: f32, search_window: i32, block_size: i32, border_mode: i32, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_nonLocalMeans_const__InputArrayR_const__OutputArrayR_float(src: *const c_void, dst: *const c_void, h: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_nonLocalMeans_const__InputArrayR_const__OutputArrayR_float_int_int_int_StreamR(src: *const c_void, dst: *const c_void, h: f32, search_window: i32, block_size: i32, border_mode: i32, stream: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_decolor_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(src: *const c_void, grayscale: *const c_void, color_boost: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_denoise_TVL1_const_vectorLMatGR_MatR(observations: *const c_void, result: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_denoise_TVL1_const_vectorLMatGR_MatR_double_int(observations: *const c_void, result: *mut c_void, lambda: f64, niters: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_detailEnhance_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detailEnhance_const__InputArrayR_const__OutputArrayR_float_float(src: *const c_void, dst: *const c_void, sigma_s: f32, sigma_r: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_edgePreservingFilter_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_edgePreservingFilter_const__InputArrayR_const__OutputArrayR_int_float_float(src: *const c_void, dst: *const c_void, flags: i32, sigma_s: f32, sigma_r: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_fastNlMeansDenoisingColoredMulti_const__InputArrayR_const__OutputArrayR_int_int(src_imgs: *const c_void, dst: *const c_void, img_to_denoise_index: i32, temporal_window_size: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_fastNlMeansDenoisingColoredMulti_const__InputArrayR_const__OutputArrayR_int_int_float_float_int_int(src_imgs: *const c_void, dst: *const c_void, img_to_denoise_index: i32, temporal_window_size: i32, h: f32, h_color: f32, template_window_size: i32, search_window_size: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_fastNlMeansDenoisingColored_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_fastNlMeansDenoisingColored_const__InputArrayR_const__OutputArrayR_float_float_int_int(src: *const c_void, dst: *const c_void, h: f32, h_color: f32, template_window_size: i32, search_window_size: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_fastNlMeansDenoisingMulti_const__InputArrayR_const__OutputArrayR_int_int(src_imgs: *const c_void, dst: *const c_void, img_to_denoise_index: i32, temporal_window_size: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_fastNlMeansDenoisingMulti_const__InputArrayR_const__OutputArrayR_int_int_const_vectorLfloatGR(src_imgs: *const c_void, dst: *const c_void, img_to_denoise_index: i32, temporal_window_size: i32, h: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_fastNlMeansDenoisingMulti_const__InputArrayR_const__OutputArrayR_int_int_const_vectorLfloatGR_int_int_int(src_imgs: *const c_void, dst: *const c_void, img_to_denoise_index: i32, temporal_window_size: i32, h: *const c_void, template_window_size: i32, search_window_size: i32, norm_type: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_fastNlMeansDenoisingMulti_const__InputArrayR_const__OutputArrayR_int_int_float_int_int(src_imgs: *const c_void, dst: *const c_void, img_to_denoise_index: i32, temporal_window_size: i32, h: f32, template_window_size: i32, search_window_size: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_fastNlMeansDenoising_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_fastNlMeansDenoising_const__InputArrayR_const__OutputArrayR_const_vectorLfloatGR(src: *const c_void, dst: *const c_void, h: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_fastNlMeansDenoising_const__InputArrayR_const__OutputArrayR_const_vectorLfloatGR_int_int_int(src: *const c_void, dst: *const c_void, h: *const c_void, template_window_size: i32, search_window_size: i32, norm_type: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_fastNlMeansDenoising_const__InputArrayR_const__OutputArrayR_float_int_int(src: *const c_void, dst: *const c_void, h: f32, template_window_size: i32, search_window_size: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_illuminationChange_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src: *const c_void, mask: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_illuminationChange_const__InputArrayR_const__InputArrayR_const__OutputArrayR_float_float(src: *const c_void, mask: *const c_void, dst: *const c_void, alpha: f32, beta: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_inpaint_const__InputArrayR_const__InputArrayR_const__OutputArrayR_double_int(src: *const c_void, inpaint_mask: *const c_void, dst: *const c_void, inpaint_radius: f64, flags: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_pencilSketch_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(src: *const c_void, dst1: *const c_void, dst2: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_pencilSketch_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_float_float_float(src: *const c_void, dst1: *const c_void, dst2: *const c_void, sigma_s: f32, sigma_r: f32, shade_factor: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_seamlessClone_const__InputArrayR_const__InputArrayR_const__InputArrayR_Point_const__OutputArrayR_int(src: *const c_void, dst: *const c_void, mask: *const c_void, p: *const core::Point, blend: *const c_void, flags: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_stylization_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_stylization_const__InputArrayR_const__OutputArrayR_float_float(src: *const c_void, dst: *const c_void, sigma_s: f32, sigma_r: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_textureFlattening_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src: *const c_void, mask: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_textureFlattening_const__InputArrayR_const__InputArrayR_const__OutputArrayR_float_float_int(src: *const c_void, mask: *const c_void, dst: *const c_void, low_threshold: f32, high_threshold: f32, kernel_size: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_AlignExposures_process_const__InputArrayR_vectorLMatGR_const__InputArrayR_const__InputArrayR(instance: *mut c_void, src: *const c_void, dst: *mut c_void, times: *const c_void, response: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_fastNlMeansDenoisingColored_const_GpuMatR_GpuMatR_float_float(src: *const c_void, dst: *mut c_void, h_luminance: f32, photo_render: f32, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_fastNlMeansDenoisingColored_const_GpuMatR_GpuMatR_float_float_int_int_StreamR(src: *const c_void, dst: *mut c_void, h_luminance: f32, photo_render: f32, search_window: i32, block_size: i32, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_fastNlMeansDenoisingColored_const__InputArrayR_const__OutputArrayR_float_float(src: *const c_void, dst: *const c_void, h_luminance: f32, photo_render: f32, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_fastNlMeansDenoisingColored_const__InputArrayR_const__OutputArrayR_float_float_int_int_StreamR(src: *const c_void, dst: *const c_void, h_luminance: f32, photo_render: f32, search_window: i32, block_size: i32, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_fastNlMeansDenoising_const_GpuMatR_GpuMatR_float(src: *const c_void, dst: *mut c_void, h: f32, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_fastNlMeansDenoising_const_GpuMatR_GpuMatR_float_int_int_StreamR(src: *const c_void, dst: *mut c_void, h: f32, search_window: i32, block_size: i32, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_fastNlMeansDenoising_const__InputArrayR_const__OutputArrayR_float(src: *const c_void, dst: *const c_void, h: f32, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_fastNlMeansDenoising_const__InputArrayR_const__OutputArrayR_float_int_int_StreamR(src: *const c_void, dst: *const c_void, h: f32, search_window: i32, block_size: i32, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_nonLocalMeans_const_GpuMatR_GpuMatR_float(src: *const c_void, dst: *mut c_void, h: f32, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_nonLocalMeans_const_GpuMatR_GpuMatR_float_int_int_int_StreamR(src: *const c_void, dst: *mut c_void, h: f32, search_window: i32, block_size: i32, border_mode: i32, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_nonLocalMeans_const__InputArrayR_const__OutputArrayR_float(src: *const c_void, dst: *const c_void, h: f32, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_nonLocalMeans_const__InputArrayR_const__OutputArrayR_float_int_int_int_StreamR(src: *const c_void, dst: *const c_void, h: f32, search_window: i32, block_size: i32, border_mode: i32, stream: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_decolor_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(src: *const c_void, grayscale: *const c_void, color_boost: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_denoise_TVL1_const_vectorLMatGR_MatR(observations: *const c_void, result: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_denoise_TVL1_const_vectorLMatGR_MatR_double_int(observations: *const c_void, result: *mut c_void, lambda: f64, niters: i32, ocvrs_return: *mut Result<()>); + pub fn cv_detailEnhance_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detailEnhance_const__InputArrayR_const__OutputArrayR_float_float(src: *const c_void, dst: *const c_void, sigma_s: f32, sigma_r: f32, ocvrs_return: *mut Result<()>); + pub fn cv_edgePreservingFilter_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_edgePreservingFilter_const__InputArrayR_const__OutputArrayR_int_float_float(src: *const c_void, dst: *const c_void, flags: i32, sigma_s: f32, sigma_r: f32, ocvrs_return: *mut Result<()>); + pub fn cv_fastNlMeansDenoisingColoredMulti_const__InputArrayR_const__OutputArrayR_int_int(src_imgs: *const c_void, dst: *const c_void, img_to_denoise_index: i32, temporal_window_size: i32, ocvrs_return: *mut Result<()>); + pub fn cv_fastNlMeansDenoisingColoredMulti_const__InputArrayR_const__OutputArrayR_int_int_float_float_int_int(src_imgs: *const c_void, dst: *const c_void, img_to_denoise_index: i32, temporal_window_size: i32, h: f32, h_color: f32, template_window_size: i32, search_window_size: i32, ocvrs_return: *mut Result<()>); + pub fn cv_fastNlMeansDenoisingColored_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_fastNlMeansDenoisingColored_const__InputArrayR_const__OutputArrayR_float_float_int_int(src: *const c_void, dst: *const c_void, h: f32, h_color: f32, template_window_size: i32, search_window_size: i32, ocvrs_return: *mut Result<()>); + pub fn cv_fastNlMeansDenoisingMulti_const__InputArrayR_const__OutputArrayR_int_int(src_imgs: *const c_void, dst: *const c_void, img_to_denoise_index: i32, temporal_window_size: i32, ocvrs_return: *mut Result<()>); + pub fn cv_fastNlMeansDenoisingMulti_const__InputArrayR_const__OutputArrayR_int_int_const_vectorLfloatGR(src_imgs: *const c_void, dst: *const c_void, img_to_denoise_index: i32, temporal_window_size: i32, h: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_fastNlMeansDenoisingMulti_const__InputArrayR_const__OutputArrayR_int_int_const_vectorLfloatGR_int_int_int(src_imgs: *const c_void, dst: *const c_void, img_to_denoise_index: i32, temporal_window_size: i32, h: *const c_void, template_window_size: i32, search_window_size: i32, norm_type: i32, ocvrs_return: *mut Result<()>); + pub fn cv_fastNlMeansDenoisingMulti_const__InputArrayR_const__OutputArrayR_int_int_float_int_int(src_imgs: *const c_void, dst: *const c_void, img_to_denoise_index: i32, temporal_window_size: i32, h: f32, template_window_size: i32, search_window_size: i32, ocvrs_return: *mut Result<()>); + pub fn cv_fastNlMeansDenoising_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_fastNlMeansDenoising_const__InputArrayR_const__OutputArrayR_const_vectorLfloatGR(src: *const c_void, dst: *const c_void, h: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_fastNlMeansDenoising_const__InputArrayR_const__OutputArrayR_const_vectorLfloatGR_int_int_int(src: *const c_void, dst: *const c_void, h: *const c_void, template_window_size: i32, search_window_size: i32, norm_type: i32, ocvrs_return: *mut Result<()>); + pub fn cv_fastNlMeansDenoising_const__InputArrayR_const__OutputArrayR_float_int_int(src: *const c_void, dst: *const c_void, h: f32, template_window_size: i32, search_window_size: i32, ocvrs_return: *mut Result<()>); + pub fn cv_illuminationChange_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src: *const c_void, mask: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_illuminationChange_const__InputArrayR_const__InputArrayR_const__OutputArrayR_float_float(src: *const c_void, mask: *const c_void, dst: *const c_void, alpha: f32, beta: f32, ocvrs_return: *mut Result<()>); + pub fn cv_inpaint_const__InputArrayR_const__InputArrayR_const__OutputArrayR_double_int(src: *const c_void, inpaint_mask: *const c_void, dst: *const c_void, inpaint_radius: f64, flags: i32, ocvrs_return: *mut Result<()>); + pub fn cv_pencilSketch_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(src: *const c_void, dst1: *const c_void, dst2: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_pencilSketch_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_float_float_float(src: *const c_void, dst1: *const c_void, dst2: *const c_void, sigma_s: f32, sigma_r: f32, shade_factor: f32, ocvrs_return: *mut Result<()>); + pub fn cv_seamlessClone_const__InputArrayR_const__InputArrayR_const__InputArrayR_Point_const__OutputArrayR_int(src: *const c_void, dst: *const c_void, mask: *const c_void, p: *const core::Point, blend: *const c_void, flags: i32, ocvrs_return: *mut Result<()>); + pub fn cv_stylization_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_stylization_const__InputArrayR_const__OutputArrayR_float_float(src: *const c_void, dst: *const c_void, sigma_s: f32, sigma_r: f32, ocvrs_return: *mut Result<()>); + pub fn cv_textureFlattening_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src: *const c_void, mask: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_textureFlattening_const__InputArrayR_const__InputArrayR_const__OutputArrayR_float_float_int(src: *const c_void, mask: *const c_void, dst: *const c_void, low_threshold: f32, high_threshold: f32, kernel_size: i32, ocvrs_return: *mut Result<()>); + pub fn cv_AlignExposures_process_const__InputArrayR_vectorLMatGR_const__InputArrayR_const__InputArrayR(instance: *mut c_void, src: *const c_void, dst: *mut c_void, times: *const c_void, response: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_AlignExposures_to_AlignMTB(instance: *mut c_void) -> *mut c_void; pub fn cv_AlignExposures_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_AlignExposures_delete(instance: *mut c_void); - pub fn cv_AlignMTB_process_const__InputArrayR_vectorLMatGR_const__InputArrayR_const__InputArrayR(instance: *mut c_void, src: *const c_void, dst: *mut c_void, times: *const c_void, response: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_AlignMTB_process_const__InputArrayR_vectorLMatGR(instance: *mut c_void, src: *const c_void, dst: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_AlignMTB_process_const__InputArrayR_vectorLMatGR_const__InputArrayR_const__InputArrayR(instance: *mut c_void, src: *const c_void, dst: *mut c_void, times: *const c_void, response: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_AlignMTB_process_const__InputArrayR_vectorLMatGR(instance: *mut c_void, src: *const c_void, dst: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_AlignMTB_calculateShift_const__InputArrayR_const__InputArrayR(instance: *mut c_void, img0: *const c_void, img1: *const c_void, ocvrs_return: *mut Result); - pub fn cv_AlignMTB_shiftMat_const__InputArrayR_const__OutputArrayR_const_Point(instance: *mut c_void, src: *const c_void, dst: *const c_void, shift: *const core::Point, ocvrs_return: *mut ResultVoid); - pub fn cv_AlignMTB_computeBitmaps_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *mut c_void, img: *const c_void, tb: *const c_void, eb: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_AlignMTB_shiftMat_const__InputArrayR_const__OutputArrayR_const_Point(instance: *mut c_void, src: *const c_void, dst: *const c_void, shift: *const core::Point, ocvrs_return: *mut Result<()>); + pub fn cv_AlignMTB_computeBitmaps_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *mut c_void, img: *const c_void, tb: *const c_void, eb: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_AlignMTB_getMaxBits_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_AlignMTB_setMaxBits_int(instance: *mut c_void, max_bits: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_AlignMTB_setMaxBits_int(instance: *mut c_void, max_bits: i32, ocvrs_return: *mut Result<()>); pub fn cv_AlignMTB_getExcludeRange_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_AlignMTB_setExcludeRange_int(instance: *mut c_void, exclude_range: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_AlignMTB_setExcludeRange_int(instance: *mut c_void, exclude_range: i32, ocvrs_return: *mut Result<()>); pub fn cv_AlignMTB_getCut_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_AlignMTB_setCut_bool(instance: *mut c_void, value: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_AlignMTB_setCut_bool(instance: *mut c_void, value: bool, ocvrs_return: *mut Result<()>); pub fn cv_AlignMTB_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_AlignMTB_to_AlignExposures(instance: *mut c_void) -> *mut c_void; pub fn cv_AlignMTB_delete(instance: *mut c_void); - pub fn cv_CalibrateCRF_process_const__InputArrayR_const__OutputArrayR_const__InputArrayR(instance: *mut c_void, src: *const c_void, dst: *const c_void, times: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_CalibrateCRF_process_const__InputArrayR_const__OutputArrayR_const__InputArrayR(instance: *mut c_void, src: *const c_void, dst: *const c_void, times: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_CalibrateCRF_to_CalibrateDebevec(instance: *mut c_void) -> *mut c_void; pub fn cv_CalibrateCRF_to_CalibrateRobertson(instance: *mut c_void) -> *mut c_void; pub fn cv_CalibrateCRF_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_CalibrateCRF_delete(instance: *mut c_void); pub fn cv_CalibrateDebevec_getLambda_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_CalibrateDebevec_setLambda_float(instance: *mut c_void, lambda: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_CalibrateDebevec_setLambda_float(instance: *mut c_void, lambda: f32, ocvrs_return: *mut Result<()>); pub fn cv_CalibrateDebevec_getSamples_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_CalibrateDebevec_setSamples_int(instance: *mut c_void, samples: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_CalibrateDebevec_setSamples_int(instance: *mut c_void, samples: i32, ocvrs_return: *mut Result<()>); pub fn cv_CalibrateDebevec_getRandom_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_CalibrateDebevec_setRandom_bool(instance: *mut c_void, random: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_CalibrateDebevec_setRandom_bool(instance: *mut c_void, random: bool, ocvrs_return: *mut Result<()>); pub fn cv_CalibrateDebevec_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_CalibrateDebevec_to_CalibrateCRF(instance: *mut c_void) -> *mut c_void; pub fn cv_CalibrateDebevec_delete(instance: *mut c_void); pub fn cv_CalibrateRobertson_getMaxIter_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_CalibrateRobertson_setMaxIter_int(instance: *mut c_void, max_iter: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_CalibrateRobertson_setMaxIter_int(instance: *mut c_void, max_iter: i32, ocvrs_return: *mut Result<()>); pub fn cv_CalibrateRobertson_getThreshold_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_CalibrateRobertson_setThreshold_float(instance: *mut c_void, threshold: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_CalibrateRobertson_setThreshold_float(instance: *mut c_void, threshold: f32, ocvrs_return: *mut Result<()>); pub fn cv_CalibrateRobertson_getRadiance_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_CalibrateRobertson_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_CalibrateRobertson_to_CalibrateCRF(instance: *mut c_void) -> *mut c_void; pub fn cv_CalibrateRobertson_delete(instance: *mut c_void); - pub fn cv_MergeDebevec_process_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR(instance: *mut c_void, src: *const c_void, dst: *const c_void, times: *const c_void, response: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_MergeDebevec_process_const__InputArrayR_const__OutputArrayR_const__InputArrayR(instance: *mut c_void, src: *const c_void, dst: *const c_void, times: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_MergeDebevec_process_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR(instance: *mut c_void, src: *const c_void, dst: *const c_void, times: *const c_void, response: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_MergeDebevec_process_const__InputArrayR_const__OutputArrayR_const__InputArrayR(instance: *mut c_void, src: *const c_void, dst: *const c_void, times: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_MergeDebevec_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_MergeDebevec_to_MergeExposures(instance: *mut c_void) -> *mut c_void; pub fn cv_MergeDebevec_delete(instance: *mut c_void); - pub fn cv_MergeExposures_process_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR(instance: *mut c_void, src: *const c_void, dst: *const c_void, times: *const c_void, response: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_MergeExposures_process_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR(instance: *mut c_void, src: *const c_void, dst: *const c_void, times: *const c_void, response: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_MergeExposures_to_MergeDebevec(instance: *mut c_void) -> *mut c_void; pub fn cv_MergeExposures_to_MergeMertens(instance: *mut c_void) -> *mut c_void; pub fn cv_MergeExposures_to_MergeRobertson(instance: *mut c_void) -> *mut c_void; pub fn cv_MergeExposures_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_MergeExposures_delete(instance: *mut c_void); - pub fn cv_MergeMertens_process_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR(instance: *mut c_void, src: *const c_void, dst: *const c_void, times: *const c_void, response: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_MergeMertens_process_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_MergeMertens_process_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR(instance: *mut c_void, src: *const c_void, dst: *const c_void, times: *const c_void, response: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_MergeMertens_process_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_MergeMertens_getContrastWeight_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_MergeMertens_setContrastWeight_float(instance: *mut c_void, contrast_weiht: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_MergeMertens_setContrastWeight_float(instance: *mut c_void, contrast_weiht: f32, ocvrs_return: *mut Result<()>); pub fn cv_MergeMertens_getSaturationWeight_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_MergeMertens_setSaturationWeight_float(instance: *mut c_void, saturation_weight: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_MergeMertens_setSaturationWeight_float(instance: *mut c_void, saturation_weight: f32, ocvrs_return: *mut Result<()>); pub fn cv_MergeMertens_getExposureWeight_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_MergeMertens_setExposureWeight_float(instance: *mut c_void, exposure_weight: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_MergeMertens_setExposureWeight_float(instance: *mut c_void, exposure_weight: f32, ocvrs_return: *mut Result<()>); pub fn cv_MergeMertens_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_MergeMertens_to_MergeExposures(instance: *mut c_void) -> *mut c_void; pub fn cv_MergeMertens_delete(instance: *mut c_void); - pub fn cv_MergeRobertson_process_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR(instance: *mut c_void, src: *const c_void, dst: *const c_void, times: *const c_void, response: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_MergeRobertson_process_const__InputArrayR_const__OutputArrayR_const__InputArrayR(instance: *mut c_void, src: *const c_void, dst: *const c_void, times: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_MergeRobertson_process_const__InputArrayR_const__OutputArrayR_const__InputArrayR_const__InputArrayR(instance: *mut c_void, src: *const c_void, dst: *const c_void, times: *const c_void, response: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_MergeRobertson_process_const__InputArrayR_const__OutputArrayR_const__InputArrayR(instance: *mut c_void, src: *const c_void, dst: *const c_void, times: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_MergeRobertson_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_MergeRobertson_to_MergeExposures(instance: *mut c_void) -> *mut c_void; pub fn cv_MergeRobertson_delete(instance: *mut c_void); - pub fn cv_Tonemap_process_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_Tonemap_process_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_Tonemap_getGamma_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_Tonemap_setGamma_float(instance: *mut c_void, gamma: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_Tonemap_setGamma_float(instance: *mut c_void, gamma: f32, ocvrs_return: *mut Result<()>); pub fn cv_Tonemap_to_TonemapDrago(instance: *mut c_void) -> *mut c_void; pub fn cv_Tonemap_to_TonemapMantiuk(instance: *mut c_void) -> *mut c_void; pub fn cv_Tonemap_to_TonemapReinhard(instance: *mut c_void) -> *mut c_void; pub fn cv_Tonemap_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_Tonemap_delete(instance: *mut c_void); pub fn cv_TonemapDrago_getSaturation_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_TonemapDrago_setSaturation_float(instance: *mut c_void, saturation: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_TonemapDrago_setSaturation_float(instance: *mut c_void, saturation: f32, ocvrs_return: *mut Result<()>); pub fn cv_TonemapDrago_getBias_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_TonemapDrago_setBias_float(instance: *mut c_void, bias: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_TonemapDrago_setBias_float(instance: *mut c_void, bias: f32, ocvrs_return: *mut Result<()>); pub fn cv_TonemapDrago_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_TonemapDrago_to_Tonemap(instance: *mut c_void) -> *mut c_void; pub fn cv_TonemapDrago_delete(instance: *mut c_void); pub fn cv_TonemapMantiuk_getScale_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_TonemapMantiuk_setScale_float(instance: *mut c_void, scale: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_TonemapMantiuk_setScale_float(instance: *mut c_void, scale: f32, ocvrs_return: *mut Result<()>); pub fn cv_TonemapMantiuk_getSaturation_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_TonemapMantiuk_setSaturation_float(instance: *mut c_void, saturation: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_TonemapMantiuk_setSaturation_float(instance: *mut c_void, saturation: f32, ocvrs_return: *mut Result<()>); pub fn cv_TonemapMantiuk_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_TonemapMantiuk_to_Tonemap(instance: *mut c_void) -> *mut c_void; pub fn cv_TonemapMantiuk_delete(instance: *mut c_void); pub fn cv_TonemapReinhard_getIntensity_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_TonemapReinhard_setIntensity_float(instance: *mut c_void, intensity: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_TonemapReinhard_setIntensity_float(instance: *mut c_void, intensity: f32, ocvrs_return: *mut Result<()>); pub fn cv_TonemapReinhard_getLightAdaptation_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_TonemapReinhard_setLightAdaptation_float(instance: *mut c_void, light_adapt: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_TonemapReinhard_setLightAdaptation_float(instance: *mut c_void, light_adapt: f32, ocvrs_return: *mut Result<()>); pub fn cv_TonemapReinhard_getColorAdaptation_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_TonemapReinhard_setColorAdaptation_float(instance: *mut c_void, color_adapt: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_TonemapReinhard_setColorAdaptation_float(instance: *mut c_void, color_adapt: f32, ocvrs_return: *mut Result<()>); pub fn cv_TonemapReinhard_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_TonemapReinhard_to_Tonemap(instance: *mut c_void) -> *mut c_void; pub fn cv_TonemapReinhard_delete(instance: *mut c_void); @@ -12231,32 +12262,30 @@ mod photo_sys { pub fn cv_PtrLcv_TonemapReinhardG_to_PtrOfTonemap(instance: *mut c_void) -> *mut c_void; } } -#[cfg(ocvrs_has_module_photo)] pub use photo_sys::*; -#[cfg(ocvrs_has_module_plot)] mod plot_sys { use super::*; extern "C" { - pub fn cv_plot_Plot2d_setMinX_double(instance: *mut c_void, _plot_min_x: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_plot_Plot2d_setMinY_double(instance: *mut c_void, _plot_min_y: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_plot_Plot2d_setMaxX_double(instance: *mut c_void, _plot_max_x: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_plot_Plot2d_setMaxY_double(instance: *mut c_void, _plot_max_y: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_plot_Plot2d_setPlotLineWidth_int(instance: *mut c_void, _plot_line_width: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_plot_Plot2d_setNeedPlotLine_bool(instance: *mut c_void, _need_plot_line: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_plot_Plot2d_setPlotLineColor_Scalar(instance: *mut c_void, _plot_line_color: *const core::Scalar, ocvrs_return: *mut ResultVoid); - pub fn cv_plot_Plot2d_setPlotBackgroundColor_Scalar(instance: *mut c_void, _plot_background_color: *const core::Scalar, ocvrs_return: *mut ResultVoid); - pub fn cv_plot_Plot2d_setPlotAxisColor_Scalar(instance: *mut c_void, _plot_axis_color: *const core::Scalar, ocvrs_return: *mut ResultVoid); - pub fn cv_plot_Plot2d_setPlotGridColor_Scalar(instance: *mut c_void, _plot_grid_color: *const core::Scalar, ocvrs_return: *mut ResultVoid); - pub fn cv_plot_Plot2d_setPlotTextColor_Scalar(instance: *mut c_void, _plot_text_color: *const core::Scalar, ocvrs_return: *mut ResultVoid); - pub fn cv_plot_Plot2d_setPlotSize_int_int(instance: *mut c_void, _plot_size_width: i32, _plot_size_height: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_plot_Plot2d_setShowGrid_bool(instance: *mut c_void, need_show_grid: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_plot_Plot2d_setShowText_bool(instance: *mut c_void, need_show_text: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_plot_Plot2d_setGridLinesNumber_int(instance: *mut c_void, grid_lines_number: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_plot_Plot2d_setInvertOrientation_bool(instance: *mut c_void, _invert_orientation: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_plot_Plot2d_setPointIdxToPrint_int(instance: *mut c_void, point_idx: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_plot_Plot2d_render_const__OutputArrayR(instance: *mut c_void, _plot_result: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_plot_Plot2d_setMinX_double(instance: *mut c_void, _plot_min_x: f64, ocvrs_return: *mut Result<()>); + pub fn cv_plot_Plot2d_setMinY_double(instance: *mut c_void, _plot_min_y: f64, ocvrs_return: *mut Result<()>); + pub fn cv_plot_Plot2d_setMaxX_double(instance: *mut c_void, _plot_max_x: f64, ocvrs_return: *mut Result<()>); + pub fn cv_plot_Plot2d_setMaxY_double(instance: *mut c_void, _plot_max_y: f64, ocvrs_return: *mut Result<()>); + pub fn cv_plot_Plot2d_setPlotLineWidth_int(instance: *mut c_void, _plot_line_width: i32, ocvrs_return: *mut Result<()>); + pub fn cv_plot_Plot2d_setNeedPlotLine_bool(instance: *mut c_void, _need_plot_line: bool, ocvrs_return: *mut Result<()>); + pub fn cv_plot_Plot2d_setPlotLineColor_Scalar(instance: *mut c_void, _plot_line_color: *const core::Scalar, ocvrs_return: *mut Result<()>); + pub fn cv_plot_Plot2d_setPlotBackgroundColor_Scalar(instance: *mut c_void, _plot_background_color: *const core::Scalar, ocvrs_return: *mut Result<()>); + pub fn cv_plot_Plot2d_setPlotAxisColor_Scalar(instance: *mut c_void, _plot_axis_color: *const core::Scalar, ocvrs_return: *mut Result<()>); + pub fn cv_plot_Plot2d_setPlotGridColor_Scalar(instance: *mut c_void, _plot_grid_color: *const core::Scalar, ocvrs_return: *mut Result<()>); + pub fn cv_plot_Plot2d_setPlotTextColor_Scalar(instance: *mut c_void, _plot_text_color: *const core::Scalar, ocvrs_return: *mut Result<()>); + pub fn cv_plot_Plot2d_setPlotSize_int_int(instance: *mut c_void, _plot_size_width: i32, _plot_size_height: i32, ocvrs_return: *mut Result<()>); + pub fn cv_plot_Plot2d_setShowGrid_bool(instance: *mut c_void, need_show_grid: bool, ocvrs_return: *mut Result<()>); + pub fn cv_plot_Plot2d_setShowText_bool(instance: *mut c_void, need_show_text: bool, ocvrs_return: *mut Result<()>); + pub fn cv_plot_Plot2d_setGridLinesNumber_int(instance: *mut c_void, grid_lines_number: i32, ocvrs_return: *mut Result<()>); + pub fn cv_plot_Plot2d_setInvertOrientation_bool(instance: *mut c_void, _invert_orientation: bool, ocvrs_return: *mut Result<()>); + pub fn cv_plot_Plot2d_setPointIdxToPrint_int(instance: *mut c_void, point_idx: i32, ocvrs_return: *mut Result<()>); + pub fn cv_plot_Plot2d_render_const__OutputArrayR(instance: *mut c_void, _plot_result: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_plot_Plot2d_create_const__InputArrayR(data: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_plot_Plot2d_create_const__InputArrayR_const__InputArrayR(data_x: *const c_void, data_y: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_plot_Plot2d_to_Algorithm(instance: *mut c_void) -> *mut c_void; @@ -12268,10 +12297,8 @@ mod plot_sys { pub fn cv_PtrLcv_plot_Plot2dG_to_PtrOfAlgorithm(instance: *mut c_void) -> *mut c_void; } } -#[cfg(ocvrs_has_module_plot)] pub use plot_sys::*; -#[cfg(ocvrs_has_module_quality)] mod quality_sys { use super::*; @@ -12280,13 +12307,13 @@ mod quality_sys { pub fn cv_quality_QualityBRISQUE_create_const_StringR_const_StringR(model_file_path: *const c_char, range_file_path: *const c_char, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_quality_QualityBRISQUE_create_const_PtrLSVMGR_const_MatR(model: *const c_void, range: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_quality_QualityBRISQUE_compute_const__InputArrayR_const_StringR_const_StringR(img: *const c_void, model_file_path: *const c_char, range_file_path: *const c_char, ocvrs_return: *mut Result); - pub fn cv_quality_QualityBRISQUE_computeFeatures_const__InputArrayR_const__OutputArrayR(img: *const c_void, features: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_quality_QualityBRISQUE_computeFeatures_const__InputArrayR_const__OutputArrayR(img: *const c_void, features: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_quality_QualityBRISQUE_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_quality_QualityBRISQUE_to_QualityBase(instance: *mut c_void) -> *mut c_void; pub fn cv_quality_QualityBRISQUE_delete(instance: *mut c_void); pub fn cv_quality_QualityBase_compute_const__InputArrayR(instance: *mut c_void, img: *const c_void, ocvrs_return: *mut Result); - pub fn cv_quality_QualityBase_getQualityMap_const_const__OutputArrayR(instance: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_quality_QualityBase_clear(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_quality_QualityBase_getQualityMap_const_const__OutputArrayR(instance: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_quality_QualityBase_clear(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_quality_QualityBase_empty_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_quality_QualityBase_to_QualityBRISQUE(instance: *mut c_void) -> *mut c_void; pub fn cv_quality_QualityBase_to_QualityGMSD(instance: *mut c_void) -> *mut c_void; @@ -12297,7 +12324,7 @@ mod quality_sys { pub fn cv_quality_QualityBase_delete(instance: *mut c_void); pub fn cv_quality_QualityGMSD_compute_const__InputArrayR(instance: *mut c_void, cmp: *const c_void, ocvrs_return: *mut Result); pub fn cv_quality_QualityGMSD_empty_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_quality_QualityGMSD_clear(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_quality_QualityGMSD_clear(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_quality_QualityGMSD_create_const__InputArrayR(ref_: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_quality_QualityGMSD_compute_const__InputArrayR_const__InputArrayR_const__OutputArrayR(ref_: *const c_void, cmp: *const c_void, quality_map: *const c_void, ocvrs_return: *mut Result); pub fn cv_quality_QualityGMSD_to_Algorithm(instance: *mut c_void) -> *mut c_void; @@ -12305,7 +12332,7 @@ mod quality_sys { pub fn cv_quality_QualityGMSD_delete(instance: *mut c_void); pub fn cv_quality_QualityMSE_compute_const__InputArrayR(instance: *mut c_void, cmp_imgs: *const c_void, ocvrs_return: *mut Result); pub fn cv_quality_QualityMSE_empty_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_quality_QualityMSE_clear(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_quality_QualityMSE_clear(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_quality_QualityMSE_create_const__InputArrayR(ref_: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_quality_QualityMSE_compute_const__InputArrayR_const__InputArrayR_const__OutputArrayR(ref_: *const c_void, cmp: *const c_void, quality_map: *const c_void, ocvrs_return: *mut Result); pub fn cv_quality_QualityMSE_to_Algorithm(instance: *mut c_void) -> *mut c_void; @@ -12315,17 +12342,17 @@ mod quality_sys { pub fn cv_quality_QualityPSNR_create_const__InputArrayR(ref_: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_quality_QualityPSNR_compute_const__InputArrayR(instance: *mut c_void, cmp: *const c_void, ocvrs_return: *mut Result); pub fn cv_quality_QualityPSNR_empty_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_quality_QualityPSNR_clear(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_quality_QualityPSNR_clear(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_quality_QualityPSNR_compute_const__InputArrayR_const__InputArrayR_const__OutputArrayR_double(ref_: *const c_void, cmp: *const c_void, quality_map: *const c_void, max_pixel_value: f64, ocvrs_return: *mut Result); pub fn cv_quality_QualityPSNR_compute_const__InputArrayR_const__InputArrayR_const__OutputArrayR(ref_: *const c_void, cmp: *const c_void, quality_map: *const c_void, ocvrs_return: *mut Result); pub fn cv_quality_QualityPSNR_getMaxPixelValue_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_quality_QualityPSNR_setMaxPixelValue_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_quality_QualityPSNR_setMaxPixelValue_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_quality_QualityPSNR_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_quality_QualityPSNR_to_QualityBase(instance: *mut c_void) -> *mut c_void; pub fn cv_quality_QualityPSNR_delete(instance: *mut c_void); pub fn cv_quality_QualitySSIM_compute_const__InputArrayR(instance: *mut c_void, cmp: *const c_void, ocvrs_return: *mut Result); pub fn cv_quality_QualitySSIM_empty_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_quality_QualitySSIM_clear(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_quality_QualitySSIM_clear(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_quality_QualitySSIM_create_const__InputArrayR(ref_: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_quality_QualitySSIM_compute_const__InputArrayR_const__InputArrayR_const__OutputArrayR(ref_: *const c_void, cmp: *const c_void, quality_map: *const c_void, ocvrs_return: *mut Result); pub fn cv_quality_QualitySSIM_to_Algorithm(instance: *mut c_void) -> *mut c_void; @@ -12373,25 +12400,23 @@ mod quality_sys { pub fn cv_PtrLcv_quality_QualitySSIMG_new_const_QualitySSIM(val: *mut c_void) -> *mut c_void; } } -#[cfg(ocvrs_has_module_quality)] pub use quality_sys::*; -#[cfg(ocvrs_has_module_rapid)] mod rapid_sys { use super::*; extern "C" { - pub fn cv_rapid_convertCorrespondencies_const__InputArrayR_const__InputArrayR_const__OutputArrayR(cols: *const c_void, src_locations: *const c_void, pts2d: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_rapid_convertCorrespondencies_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__InputOutputArrayR_const__InputArrayR(cols: *const c_void, src_locations: *const c_void, pts2d: *const c_void, pts3d: *const c_void, mask: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_rapid_drawCorrespondencies_const__InputOutputArrayR_const__InputArrayR(bundle: *const c_void, cols: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_rapid_drawCorrespondencies_const__InputOutputArrayR_const__InputArrayR_const__InputArrayR(bundle: *const c_void, cols: *const c_void, colors: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_rapid_drawSearchLines_const__InputOutputArrayR_const__InputArrayR_const_ScalarR(img: *const c_void, locations: *const c_void, color: *const core::Scalar, ocvrs_return: *mut ResultVoid); - pub fn cv_rapid_drawWireframe_const__InputOutputArrayR_const__InputArrayR_const__InputArrayR_const_ScalarR(img: *const c_void, pts2d: *const c_void, tris: *const c_void, color: *const core::Scalar, ocvrs_return: *mut ResultVoid); - pub fn cv_rapid_drawWireframe_const__InputOutputArrayR_const__InputArrayR_const__InputArrayR_const_ScalarR_int_bool(img: *const c_void, pts2d: *const c_void, tris: *const c_void, color: *const core::Scalar, typ: i32, cull_backface: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_rapid_extractControlPoints_int_int_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const_SizeR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(num: i32, len: i32, pts3d: *const c_void, rvec: *const c_void, tvec: *const c_void, k: *const c_void, imsize: *const core::Size, tris: *const c_void, ctl2d: *const c_void, ctl3d: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_rapid_extractLineBundle_int_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(len: i32, ctl2d: *const c_void, img: *const c_void, bundle: *const c_void, src_locations: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_rapid_findCorrespondencies_const__InputArrayR_const__OutputArrayR(bundle: *const c_void, cols: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_rapid_findCorrespondencies_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(bundle: *const c_void, cols: *const c_void, response: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_rapid_convertCorrespondencies_const__InputArrayR_const__InputArrayR_const__OutputArrayR(cols: *const c_void, src_locations: *const c_void, pts2d: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_rapid_convertCorrespondencies_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__InputOutputArrayR_const__InputArrayR(cols: *const c_void, src_locations: *const c_void, pts2d: *const c_void, pts3d: *const c_void, mask: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_rapid_drawCorrespondencies_const__InputOutputArrayR_const__InputArrayR(bundle: *const c_void, cols: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_rapid_drawCorrespondencies_const__InputOutputArrayR_const__InputArrayR_const__InputArrayR(bundle: *const c_void, cols: *const c_void, colors: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_rapid_drawSearchLines_const__InputOutputArrayR_const__InputArrayR_const_ScalarR(img: *const c_void, locations: *const c_void, color: *const core::Scalar, ocvrs_return: *mut Result<()>); + pub fn cv_rapid_drawWireframe_const__InputOutputArrayR_const__InputArrayR_const__InputArrayR_const_ScalarR(img: *const c_void, pts2d: *const c_void, tris: *const c_void, color: *const core::Scalar, ocvrs_return: *mut Result<()>); + pub fn cv_rapid_drawWireframe_const__InputOutputArrayR_const__InputArrayR_const__InputArrayR_const_ScalarR_int_bool(img: *const c_void, pts2d: *const c_void, tris: *const c_void, color: *const core::Scalar, typ: i32, cull_backface: bool, ocvrs_return: *mut Result<()>); + pub fn cv_rapid_extractControlPoints_int_int_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const_SizeR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(num: i32, len: i32, pts3d: *const c_void, rvec: *const c_void, tvec: *const c_void, k: *const c_void, imsize: *const core::Size, tris: *const c_void, ctl2d: *const c_void, ctl3d: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_rapid_extractLineBundle_int_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(len: i32, ctl2d: *const c_void, img: *const c_void, bundle: *const c_void, src_locations: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_rapid_findCorrespondencies_const__InputArrayR_const__OutputArrayR(bundle: *const c_void, cols: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_rapid_findCorrespondencies_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(bundle: *const c_void, cols: *const c_void, response: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_rapid_rapid_const__InputArrayR_int_int_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__InputOutputArrayR(img: *const c_void, num: i32, len: i32, pts3d: *const c_void, tris: *const c_void, k: *const c_void, rvec: *const c_void, tvec: *const c_void, ocvrs_return: *mut Result); pub fn cv_rapid_rapid_const__InputArrayR_int_int_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__InputOutputArrayR_doubleX(img: *const c_void, num: i32, len: i32, pts3d: *const c_void, tris: *const c_void, k: *const c_void, rvec: *const c_void, tvec: *const c_void, rmsd: *mut f64, ocvrs_return: *mut Result); pub fn cv_rapid_GOSTracker_create_const__InputArrayR_const__InputArrayR_int_unsigned_char(pts3d: *const c_void, tris: *const c_void, hist_bins: i32, sobel_thesh: u8, ocvrs_return: *mut Result<*mut c_void>); @@ -12410,7 +12435,7 @@ mod rapid_sys { pub fn cv_rapid_Rapid_delete(instance: *mut c_void); pub fn cv_rapid_Tracker_compute_const__InputArrayR_int_int_const__InputArrayR_const__InputOutputArrayR_const__InputOutputArrayR_const_TermCriteriaR(instance: *mut c_void, img: *const c_void, num: i32, len: i32, k: *const c_void, rvec: *const c_void, tvec: *const c_void, termcrit: *const core::TermCriteria, ocvrs_return: *mut Result); pub fn cv_rapid_Tracker_compute_const__InputArrayR_int_int_const__InputArrayR_const__InputOutputArrayR_const__InputOutputArrayR(instance: *mut c_void, img: *const c_void, num: i32, len: i32, k: *const c_void, rvec: *const c_void, tvec: *const c_void, ocvrs_return: *mut Result); - pub fn cv_rapid_Tracker_clearState(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_rapid_Tracker_clearState(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_rapid_Tracker_to_Rapid_GOSTracker(instance: *mut c_void) -> *mut c_void; pub fn cv_rapid_Tracker_to_Rapid_OLSTracker(instance: *mut c_void) -> *mut c_void; pub fn cv_rapid_Tracker_to_Rapid_Rapid(instance: *mut c_void) -> *mut c_void; @@ -12441,52 +12466,50 @@ mod rapid_sys { pub fn cv_PtrLcv_rapid_TrackerG_to_PtrOfAlgorithm(instance: *mut c_void) -> *mut c_void; } } -#[cfg(ocvrs_has_module_rapid)] pub use rapid_sys::*; -#[cfg(ocvrs_has_module_rgbd)] mod rgbd_sys { use super::*; extern "C" { pub fn cv_kinfu_makeVolume_VolumeType_float_Matx44f_float_float_int_float_Vec3i(_volume_type: crate::rgbd::Kinfu_VolumeType, _voxel_size: f32, _pose: *const core::Matx44f, _raycast_step_factor: f32, _trunc_dist: f32, _max_weight: i32, _truncate_threshold: f32, _resolution: *const core::Vec3i, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_linemod_colormap_const_MatR_MatR(quantized: *const c_void, dst: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_linemod_drawFeatures_const__InputOutputArrayR_const_vectorLTemplateGR_const_Point2iR(img: *const c_void, templates: *const c_void, tl: *const core::Point2i, ocvrs_return: *mut ResultVoid); - pub fn cv_linemod_drawFeatures_const__InputOutputArrayR_const_vectorLTemplateGR_const_Point2iR_int(img: *const c_void, templates: *const c_void, tl: *const core::Point2i, size: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_linemod_colormap_const_MatR_MatR(quantized: *const c_void, dst: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_linemod_drawFeatures_const__InputOutputArrayR_const_vectorLTemplateGR_const_Point2iR(img: *const c_void, templates: *const c_void, tl: *const core::Point2i, ocvrs_return: *mut Result<()>); + pub fn cv_linemod_drawFeatures_const__InputOutputArrayR_const_vectorLTemplateGR_const_Point2iR_int(img: *const c_void, templates: *const c_void, tl: *const core::Point2i, size: i32, ocvrs_return: *mut Result<()>); pub fn cv_linemod_getDefaultLINE(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_linemod_getDefaultLINEMOD(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_rgbd_depthTo3dSparse_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR(depth: *const c_void, in_k: *const c_void, in_points: *const c_void, points3d: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_rgbd_depthTo3d_const__InputArrayR_const__InputArrayR_const__OutputArrayR(depth: *const c_void, k: *const c_void, points3d: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_rgbd_depthTo3d_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__InputArrayR(depth: *const c_void, k: *const c_void, points3d: *const c_void, mask: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_depthTo3dSparse_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR(depth: *const c_void, in_k: *const c_void, in_points: *const c_void, points3d: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_rgbd_depthTo3d_const__InputArrayR_const__InputArrayR_const__OutputArrayR(depth: *const c_void, k: *const c_void, points3d: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_rgbd_depthTo3d_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__InputArrayR(depth: *const c_void, k: *const c_void, points3d: *const c_void, mask: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_isValidDepth_const_doubleR(depth: *const f64, ocvrs_return: *mut Result); pub fn cv_rgbd_isValidDepth_const_floatR(depth: *const f32, ocvrs_return: *mut Result); pub fn cv_rgbd_isValidDepth_const_intR(depth: *const i32, ocvrs_return: *mut Result); pub fn cv_rgbd_isValidDepth_const_shortR(depth: *const i16, ocvrs_return: *mut Result); pub fn cv_rgbd_isValidDepth_const_unsigned_intR(depth: *const u32, ocvrs_return: *mut Result); pub fn cv_rgbd_isValidDepth_const_unsigned_shortR(depth: *const u16, ocvrs_return: *mut Result); - pub fn cv_rgbd_registerDepth_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const_SizeR_const__OutputArrayR(unregistered_camera_matrix: *const c_void, registered_camera_matrix: *const c_void, registered_dist_coeffs: *const c_void, rt: *const c_void, unregistered_depth: *const c_void, output_image_plane_size: *const core::Size, registered_depth: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_rgbd_registerDepth_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const_SizeR_const__OutputArrayR_bool(unregistered_camera_matrix: *const c_void, registered_camera_matrix: *const c_void, registered_dist_coeffs: *const c_void, rt: *const c_void, unregistered_depth: *const c_void, output_image_plane_size: *const core::Size, registered_depth: *const c_void, depth_dilation: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_rgbd_rescaleDepth_const__InputArrayR_int_const__OutputArrayR(in_: *const c_void, depth: i32, out: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_rgbd_rescaleDepth_const__InputArrayR_int_const__OutputArrayR_double(in_: *const c_void, depth: i32, out: *const c_void, depth_factor: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_rgbd_warpFrame_const_MatR_const_MatR_const_MatR_const_MatR_const_MatR_const_MatR_const__OutputArrayR(image: *const c_void, depth: *const c_void, mask: *const c_void, rt: *const c_void, camera_matrix: *const c_void, dist_coeff: *const c_void, warped_image: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_rgbd_warpFrame_const_MatR_const_MatR_const_MatR_const_MatR_const_MatR_const_MatR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(image: *const c_void, depth: *const c_void, mask: *const c_void, rt: *const c_void, camera_matrix: *const c_void, dist_coeff: *const c_void, warped_image: *const c_void, warped_depth: *const c_void, warped_mask: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_registerDepth_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const_SizeR_const__OutputArrayR(unregistered_camera_matrix: *const c_void, registered_camera_matrix: *const c_void, registered_dist_coeffs: *const c_void, rt: *const c_void, unregistered_depth: *const c_void, output_image_plane_size: *const core::Size, registered_depth: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_rgbd_registerDepth_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const_SizeR_const__OutputArrayR_bool(unregistered_camera_matrix: *const c_void, registered_camera_matrix: *const c_void, registered_dist_coeffs: *const c_void, rt: *const c_void, unregistered_depth: *const c_void, output_image_plane_size: *const core::Size, registered_depth: *const c_void, depth_dilation: bool, ocvrs_return: *mut Result<()>); + pub fn cv_rgbd_rescaleDepth_const__InputArrayR_int_const__OutputArrayR(in_: *const c_void, depth: i32, out: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_rgbd_rescaleDepth_const__InputArrayR_int_const__OutputArrayR_double(in_: *const c_void, depth: i32, out: *const c_void, depth_factor: f64, ocvrs_return: *mut Result<()>); + pub fn cv_rgbd_warpFrame_const_MatR_const_MatR_const_MatR_const_MatR_const_MatR_const_MatR_const__OutputArrayR(image: *const c_void, depth: *const c_void, mask: *const c_void, rt: *const c_void, camera_matrix: *const c_void, dist_coeff: *const c_void, warped_image: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_rgbd_warpFrame_const_MatR_const_MatR_const_MatR_const_MatR_const_MatR_const_MatR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(image: *const c_void, depth: *const c_void, mask: *const c_void, rt: *const c_void, camera_matrix: *const c_void, dist_coeff: *const c_void, warped_image: *const c_void, warped_depth: *const c_void, warped_mask: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_colored_kinfu_ColoredKinFu_create_const_PtrLParamsGR(_params: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_colored_kinfu_ColoredKinFu_getParams_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_colored_kinfu_ColoredKinFu_render_const_const__OutputArrayR(instance: *const c_void, image: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_colored_kinfu_ColoredKinFu_render_const_const__OutputArrayR_const_Matx44fR(instance: *const c_void, image: *const c_void, camera_pose: *const core::Matx44f, ocvrs_return: *mut ResultVoid); - pub fn cv_colored_kinfu_ColoredKinFu_getCloud_const_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *const c_void, points: *const c_void, normals: *const c_void, colors: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_colored_kinfu_ColoredKinFu_getCloud_const_const__OutputArrayR_const__OutputArrayR(instance: *const c_void, points: *const c_void, normals: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_colored_kinfu_ColoredKinFu_getPoints_const_const__OutputArrayR(instance: *const c_void, points: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_colored_kinfu_ColoredKinFu_getNormals_const_const__InputArrayR_const__OutputArrayR(instance: *const c_void, points: *const c_void, normals: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_colored_kinfu_ColoredKinFu_reset(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_colored_kinfu_ColoredKinFu_render_const_const__OutputArrayR(instance: *const c_void, image: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_colored_kinfu_ColoredKinFu_render_const_const__OutputArrayR_const_Matx44fR(instance: *const c_void, image: *const c_void, camera_pose: *const core::Matx44f, ocvrs_return: *mut Result<()>); + pub fn cv_colored_kinfu_ColoredKinFu_getCloud_const_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *const c_void, points: *const c_void, normals: *const c_void, colors: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_colored_kinfu_ColoredKinFu_getCloud_const_const__OutputArrayR_const__OutputArrayR(instance: *const c_void, points: *const c_void, normals: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_colored_kinfu_ColoredKinFu_getPoints_const_const__OutputArrayR(instance: *const c_void, points: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_colored_kinfu_ColoredKinFu_getNormals_const_const__InputArrayR_const__OutputArrayR(instance: *const c_void, points: *const c_void, normals: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_colored_kinfu_ColoredKinFu_reset(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_colored_kinfu_ColoredKinFu_getPose_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_colored_kinfu_ColoredKinFu_update_const__InputArrayR_const__InputArrayR(instance: *mut c_void, depth: *const c_void, rgb: *const c_void, ocvrs_return: *mut Result); pub fn cv_colored_kinfu_ColoredKinFu_delete(instance: *mut c_void); pub fn cv_colored_kinfu_Params_Params(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_colored_kinfu_Params_Params_Matx33f_Vec3f(volume_initial_pose_rot: *const core::Matx33f, volume_initial_pose_transl: *const core::Vec3f, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_colored_kinfu_Params_Params_Matx44f(volume_initial_pose: *const core::Matx44f, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_colored_kinfu_Params_setInitialVolumePose_Matx33f_Vec3f(instance: *mut c_void, r: *const core::Matx33f, t: *const core::Vec3f, ocvrs_return: *mut ResultVoid); - pub fn cv_colored_kinfu_Params_setInitialVolumePose_Matx44f(instance: *mut c_void, homogen_tf: *const core::Matx44f, ocvrs_return: *mut ResultVoid); + pub fn cv_colored_kinfu_Params_setInitialVolumePose_Matx33f_Vec3f(instance: *mut c_void, r: *const core::Matx33f, t: *const core::Vec3f, ocvrs_return: *mut Result<()>); + pub fn cv_colored_kinfu_Params_setInitialVolumePose_Matx44f(instance: *mut c_void, homogen_tf: *const core::Matx44f, ocvrs_return: *mut Result<()>); pub fn cv_colored_kinfu_Params_defaultParams(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_colored_kinfu_Params_coarseParams(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_colored_kinfu_Params_hashTSDFParams_bool(is_coarse: bool, ocvrs_return: *mut Result<*mut c_void>); @@ -12538,18 +12561,18 @@ mod rgbd_sys { pub fn cv_colored_kinfu_Params_delete(instance: *mut c_void); pub fn cv_dynafu_DynaFu_create_const_PtrLParamsGR(_params: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_dynafu_DynaFu_getParams_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_dynafu_DynaFu_render_const_const__OutputArrayR_const_Matx44fR(instance: *const c_void, image: *const c_void, camera_pose: *const core::Matx44f, ocvrs_return: *mut ResultVoid); - pub fn cv_dynafu_DynaFu_render_const_const__OutputArrayR(instance: *const c_void, image: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_dynafu_DynaFu_getCloud_const_const__OutputArrayR_const__OutputArrayR(instance: *const c_void, points: *const c_void, normals: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_dynafu_DynaFu_getPoints_const_const__OutputArrayR(instance: *const c_void, points: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_dynafu_DynaFu_getNormals_const_const__InputArrayR_const__OutputArrayR(instance: *const c_void, points: *const c_void, normals: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_dynafu_DynaFu_reset(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_dynafu_DynaFu_render_const_const__OutputArrayR_const_Matx44fR(instance: *const c_void, image: *const c_void, camera_pose: *const core::Matx44f, ocvrs_return: *mut Result<()>); + pub fn cv_dynafu_DynaFu_render_const_const__OutputArrayR(instance: *const c_void, image: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_dynafu_DynaFu_getCloud_const_const__OutputArrayR_const__OutputArrayR(instance: *const c_void, points: *const c_void, normals: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_dynafu_DynaFu_getPoints_const_const__OutputArrayR(instance: *const c_void, points: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_dynafu_DynaFu_getNormals_const_const__InputArrayR_const__OutputArrayR(instance: *const c_void, points: *const c_void, normals: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_dynafu_DynaFu_reset(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_dynafu_DynaFu_getPose_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_dynafu_DynaFu_update_const__InputArrayR(instance: *mut c_void, depth: *const c_void, ocvrs_return: *mut Result); pub fn cv_dynafu_DynaFu_getNodesPos_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_dynafu_DynaFu_marchCubes_const_const__OutputArrayR_const__OutputArrayR(instance: *const c_void, vertices: *const c_void, edges: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_dynafu_DynaFu_renderSurface_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_bool(instance: *mut c_void, depth_image: *const c_void, vert_image: *const c_void, norm_image: *const c_void, warp: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_dynafu_DynaFu_renderSurface_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *mut c_void, depth_image: *const c_void, vert_image: *const c_void, norm_image: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_dynafu_DynaFu_marchCubes_const_const__OutputArrayR_const__OutputArrayR(instance: *const c_void, vertices: *const c_void, edges: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_dynafu_DynaFu_renderSurface_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_bool(instance: *mut c_void, depth_image: *const c_void, vert_image: *const c_void, norm_image: *const c_void, warp: bool, ocvrs_return: *mut Result<()>); + pub fn cv_dynafu_DynaFu_renderSurface_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *mut c_void, depth_image: *const c_void, vert_image: *const c_void, norm_image: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_dynafu_DynaFu_delete(instance: *mut c_void); pub fn cv_kinfu_Intr_Intr(ocvrs_return: *mut Result); pub fn cv_kinfu_Intr_Intr_float_float_float_float(_fx: f32, _fy: f32, _cx: f32, _cy: f32, ocvrs_return: *mut Result); @@ -12563,20 +12586,20 @@ mod rgbd_sys { pub fn cv_kinfu_Intr_Reprojector_Reprojector_Intr(intr: *const crate::rgbd::Kinfu_Intr, ocvrs_return: *mut Result); pub fn cv_kinfu_KinFu_create_const_PtrLParamsGR(_params: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_kinfu_KinFu_getParams_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_kinfu_KinFu_render_const_const__OutputArrayR(instance: *const c_void, image: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_kinfu_KinFu_render_const_const__OutputArrayR_const_Matx44fR(instance: *const c_void, image: *const c_void, camera_pose: *const core::Matx44f, ocvrs_return: *mut ResultVoid); - pub fn cv_kinfu_KinFu_getCloud_const_const__OutputArrayR_const__OutputArrayR(instance: *const c_void, points: *const c_void, normals: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_kinfu_KinFu_getPoints_const_const__OutputArrayR(instance: *const c_void, points: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_kinfu_KinFu_getNormals_const_const__InputArrayR_const__OutputArrayR(instance: *const c_void, points: *const c_void, normals: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_kinfu_KinFu_reset(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_kinfu_KinFu_render_const_const__OutputArrayR(instance: *const c_void, image: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_kinfu_KinFu_render_const_const__OutputArrayR_const_Matx44fR(instance: *const c_void, image: *const c_void, camera_pose: *const core::Matx44f, ocvrs_return: *mut Result<()>); + pub fn cv_kinfu_KinFu_getCloud_const_const__OutputArrayR_const__OutputArrayR(instance: *const c_void, points: *const c_void, normals: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_kinfu_KinFu_getPoints_const_const__OutputArrayR(instance: *const c_void, points: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_kinfu_KinFu_getNormals_const_const__InputArrayR_const__OutputArrayR(instance: *const c_void, points: *const c_void, normals: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_kinfu_KinFu_reset(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_kinfu_KinFu_getPose_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_kinfu_KinFu_update_const__InputArrayR(instance: *mut c_void, depth: *const c_void, ocvrs_return: *mut Result); pub fn cv_kinfu_KinFu_delete(instance: *mut c_void); pub fn cv_kinfu_Params_Params(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_kinfu_Params_Params_Matx33f_Vec3f(volume_initial_pose_rot: *const core::Matx33f, volume_initial_pose_transl: *const core::Vec3f, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_kinfu_Params_Params_Matx44f(volume_initial_pose: *const core::Matx44f, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_kinfu_Params_setInitialVolumePose_Matx33f_Vec3f(instance: *mut c_void, r: *const core::Matx33f, t: *const core::Vec3f, ocvrs_return: *mut ResultVoid); - pub fn cv_kinfu_Params_setInitialVolumePose_Matx44f(instance: *mut c_void, homogen_tf: *const core::Matx44f, ocvrs_return: *mut ResultVoid); + pub fn cv_kinfu_Params_setInitialVolumePose_Matx33f_Vec3f(instance: *mut c_void, r: *const core::Matx33f, t: *const core::Vec3f, ocvrs_return: *mut Result<()>); + pub fn cv_kinfu_Params_setInitialVolumePose_Matx44f(instance: *mut c_void, homogen_tf: *const core::Matx44f, ocvrs_return: *mut Result<()>); pub fn cv_kinfu_Params_defaultParams(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_kinfu_Params_coarseParams(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_kinfu_Params_hashTSDFParams_bool(is_coarse: bool, ocvrs_return: *mut Result<*mut c_void>); @@ -12624,16 +12647,16 @@ mod rgbd_sys { pub fn cv_kinfu_Params_propTruncateThreshold_const(instance: *const c_void) -> f32; pub fn cv_kinfu_Params_propTruncateThreshold_const_float(instance: *mut c_void, val: f32); pub fn cv_kinfu_Params_delete(instance: *mut c_void); - pub fn cv_kinfu_Volume_integrate_const__InputArrayR_float_const_Matx44fR_const_IntrR_const_int(instance: *mut c_void, _depth: *const c_void, depth_factor: f32, camera_pose: *const core::Matx44f, intrinsics: *const crate::rgbd::Kinfu_Intr, frame_id: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_kinfu_Volume_integrate_const__InputArrayR_float_const_Matx44fR_const_IntrR(instance: *mut c_void, _depth: *const c_void, depth_factor: f32, camera_pose: *const core::Matx44f, intrinsics: *const crate::rgbd::Kinfu_Intr, ocvrs_return: *mut ResultVoid); - pub fn cv_kinfu_Volume_integrate_const__InputArrayR_const__InputArrayR_float_const_Matx44fR_const_IntrR_const_IntrR_const_int(instance: *mut c_void, _depth: *const c_void, _rgb: *const c_void, depth_factor: f32, camera_pose: *const core::Matx44f, intrinsics: *const crate::rgbd::Kinfu_Intr, rgb_intrinsics: *const crate::rgbd::Kinfu_Intr, frame_id: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_kinfu_Volume_integrate_const__InputArrayR_const__InputArrayR_float_const_Matx44fR_const_IntrR_const_IntrR(instance: *mut c_void, _depth: *const c_void, _rgb: *const c_void, depth_factor: f32, camera_pose: *const core::Matx44f, intrinsics: *const crate::rgbd::Kinfu_Intr, rgb_intrinsics: *const crate::rgbd::Kinfu_Intr, ocvrs_return: *mut ResultVoid); - pub fn cv_kinfu_Volume_raycast_const_const_Matx44fR_const_IntrR_const_SizeR_const__OutputArrayR_const__OutputArrayR(instance: *const c_void, camera_pose: *const core::Matx44f, intrinsics: *const crate::rgbd::Kinfu_Intr, frame_size: *const core::Size, points: *const c_void, normals: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_kinfu_Volume_raycast_const_const_Matx44fR_const_IntrR_const_SizeR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *const c_void, camera_pose: *const core::Matx44f, intrinsics: *const crate::rgbd::Kinfu_Intr, frame_size: *const core::Size, points: *const c_void, normals: *const c_void, colors: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_kinfu_Volume_fetchNormals_const_const__InputArrayR_const__OutputArrayR(instance: *const c_void, points: *const c_void, _normals: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_kinfu_Volume_fetchPointsNormals_const_const__OutputArrayR_const__OutputArrayR(instance: *const c_void, points: *const c_void, normals: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_kinfu_Volume_fetchPointsNormalsColors_const_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *const c_void, unnamed: *const c_void, unnamed_1: *const c_void, unnamed_2: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_kinfu_Volume_reset(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_kinfu_Volume_integrate_const__InputArrayR_float_const_Matx44fR_const_IntrR_const_int(instance: *mut c_void, _depth: *const c_void, depth_factor: f32, camera_pose: *const core::Matx44f, intrinsics: *const crate::rgbd::Kinfu_Intr, frame_id: i32, ocvrs_return: *mut Result<()>); + pub fn cv_kinfu_Volume_integrate_const__InputArrayR_float_const_Matx44fR_const_IntrR(instance: *mut c_void, _depth: *const c_void, depth_factor: f32, camera_pose: *const core::Matx44f, intrinsics: *const crate::rgbd::Kinfu_Intr, ocvrs_return: *mut Result<()>); + pub fn cv_kinfu_Volume_integrate_const__InputArrayR_const__InputArrayR_float_const_Matx44fR_const_IntrR_const_IntrR_const_int(instance: *mut c_void, _depth: *const c_void, _rgb: *const c_void, depth_factor: f32, camera_pose: *const core::Matx44f, intrinsics: *const crate::rgbd::Kinfu_Intr, rgb_intrinsics: *const crate::rgbd::Kinfu_Intr, frame_id: i32, ocvrs_return: *mut Result<()>); + pub fn cv_kinfu_Volume_integrate_const__InputArrayR_const__InputArrayR_float_const_Matx44fR_const_IntrR_const_IntrR(instance: *mut c_void, _depth: *const c_void, _rgb: *const c_void, depth_factor: f32, camera_pose: *const core::Matx44f, intrinsics: *const crate::rgbd::Kinfu_Intr, rgb_intrinsics: *const crate::rgbd::Kinfu_Intr, ocvrs_return: *mut Result<()>); + pub fn cv_kinfu_Volume_raycast_const_const_Matx44fR_const_IntrR_const_SizeR_const__OutputArrayR_const__OutputArrayR(instance: *const c_void, camera_pose: *const core::Matx44f, intrinsics: *const crate::rgbd::Kinfu_Intr, frame_size: *const core::Size, points: *const c_void, normals: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_kinfu_Volume_raycast_const_const_Matx44fR_const_IntrR_const_SizeR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *const c_void, camera_pose: *const core::Matx44f, intrinsics: *const crate::rgbd::Kinfu_Intr, frame_size: *const core::Size, points: *const c_void, normals: *const c_void, colors: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_kinfu_Volume_fetchNormals_const_const__InputArrayR_const__OutputArrayR(instance: *const c_void, points: *const c_void, _normals: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_kinfu_Volume_fetchPointsNormals_const_const__OutputArrayR_const__OutputArrayR(instance: *const c_void, points: *const c_void, normals: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_kinfu_Volume_fetchPointsNormalsColors_const_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *const c_void, unnamed: *const c_void, unnamed_1: *const c_void, unnamed_2: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_kinfu_Volume_reset(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_kinfu_Volume_propVoxelSize_const(instance: *const c_void) -> f32; pub fn cv_kinfu_Volume_propVoxelSizeInv_const(instance: *const c_void) -> f32; pub fn cv_kinfu_Volume_propPose_const(instance: *const c_void, ocvrs_return: *mut core::Affine3f); @@ -12662,15 +12685,15 @@ mod rgbd_sys { pub fn cv_kinfu_VolumeParams_propRaycastStepFactor_const_float(instance: *mut c_void, val: f32); pub fn cv_kinfu_VolumeParams_delete(instance: *mut c_void); pub fn cv_kinfu_detail_PoseGraph_create(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_kinfu_detail_PoseGraph_addNode_size_t_const_Affine3dR_bool(instance: *mut c_void, _node_id: size_t, _pose: *const core::Affine3d, fixed: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_kinfu_detail_PoseGraph_addNode_size_t_const_Affine3dR_bool(instance: *mut c_void, _node_id: size_t, _pose: *const core::Affine3d, fixed: bool, ocvrs_return: *mut Result<()>); pub fn cv_kinfu_detail_PoseGraph_isNodeExist_const_size_t(instance: *const c_void, node_id: size_t, ocvrs_return: *mut Result); pub fn cv_kinfu_detail_PoseGraph_setNodeFixed_size_t_bool(instance: *mut c_void, node_id: size_t, fixed: bool, ocvrs_return: *mut Result); pub fn cv_kinfu_detail_PoseGraph_isNodeFixed_const_size_t(instance: *const c_void, node_id: size_t, ocvrs_return: *mut Result); pub fn cv_kinfu_detail_PoseGraph_getNodePose_const_size_t(instance: *const c_void, node_id: size_t, ocvrs_return: *mut Result); pub fn cv_kinfu_detail_PoseGraph_getNodesIds_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_kinfu_detail_PoseGraph_getNumNodes_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_kinfu_detail_PoseGraph_addEdge_size_t_size_t_const_Affine3fR_const_Matx66fR(instance: *mut c_void, _source_node_id: size_t, _target_node_id: size_t, _transformation: *const core::Affine3f, _information: *const core::Matx66f, ocvrs_return: *mut ResultVoid); - pub fn cv_kinfu_detail_PoseGraph_addEdge_size_t_size_t_const_Affine3fR(instance: *mut c_void, _source_node_id: size_t, _target_node_id: size_t, _transformation: *const core::Affine3f, ocvrs_return: *mut ResultVoid); + pub fn cv_kinfu_detail_PoseGraph_addEdge_size_t_size_t_const_Affine3fR_const_Matx66fR(instance: *mut c_void, _source_node_id: size_t, _target_node_id: size_t, _transformation: *const core::Affine3f, _information: *const core::Matx66f, ocvrs_return: *mut Result<()>); + pub fn cv_kinfu_detail_PoseGraph_addEdge_size_t_size_t_const_Affine3fR(instance: *mut c_void, _source_node_id: size_t, _target_node_id: size_t, _transformation: *const core::Affine3f, ocvrs_return: *mut Result<()>); pub fn cv_kinfu_detail_PoseGraph_getEdgeStart_const_size_t(instance: *const c_void, i: size_t, ocvrs_return: *mut Result); pub fn cv_kinfu_detail_PoseGraph_getEdgeEnd_const_size_t(instance: *const c_void, i: size_t, ocvrs_return: *mut Result); pub fn cv_kinfu_detail_PoseGraph_getNumEdges_const(instance: *const c_void, ocvrs_return: *mut Result); @@ -12681,12 +12704,12 @@ mod rgbd_sys { pub fn cv_kinfu_detail_PoseGraph_delete(instance: *mut c_void); pub fn cv_large_kinfu_LargeKinfu_create_const_PtrLParamsGR(_params: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_large_kinfu_LargeKinfu_getParams_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_large_kinfu_LargeKinfu_render_const_const__OutputArrayR(instance: *const c_void, image: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_large_kinfu_LargeKinfu_render_const_const__OutputArrayR_const_Matx44fR(instance: *const c_void, image: *const c_void, camera_pose: *const core::Matx44f, ocvrs_return: *mut ResultVoid); - pub fn cv_large_kinfu_LargeKinfu_getCloud_const_const__OutputArrayR_const__OutputArrayR(instance: *const c_void, points: *const c_void, normals: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_large_kinfu_LargeKinfu_getPoints_const_const__OutputArrayR(instance: *const c_void, points: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_large_kinfu_LargeKinfu_getNormals_const_const__InputArrayR_const__OutputArrayR(instance: *const c_void, points: *const c_void, normals: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_large_kinfu_LargeKinfu_reset(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_large_kinfu_LargeKinfu_render_const_const__OutputArrayR(instance: *const c_void, image: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_large_kinfu_LargeKinfu_render_const_const__OutputArrayR_const_Matx44fR(instance: *const c_void, image: *const c_void, camera_pose: *const core::Matx44f, ocvrs_return: *mut Result<()>); + pub fn cv_large_kinfu_LargeKinfu_getCloud_const_const__OutputArrayR_const__OutputArrayR(instance: *const c_void, points: *const c_void, normals: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_large_kinfu_LargeKinfu_getPoints_const_const__OutputArrayR(instance: *const c_void, points: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_large_kinfu_LargeKinfu_getNormals_const_const__InputArrayR_const__OutputArrayR(instance: *const c_void, points: *const c_void, normals: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_large_kinfu_LargeKinfu_reset(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_large_kinfu_LargeKinfu_getPose_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_large_kinfu_LargeKinfu_update_const__InputArrayR(instance: *mut c_void, depth: *const c_void, ocvrs_return: *mut Result); pub fn cv_large_kinfu_LargeKinfu_delete(instance: *mut c_void); @@ -12729,8 +12752,8 @@ mod rgbd_sys { pub fn cv_linemod_ColorGradient_ColorGradient_float_size_t_float(weak_threshold: f32, num_features: size_t, strong_threshold: f32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_linemod_ColorGradient_create_float_size_t_float(weak_threshold: f32, num_features: size_t, strong_threshold: f32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_linemod_ColorGradient_name_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_linemod_ColorGradient_read_const_FileNodeR(instance: *mut c_void, fn_: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_linemod_ColorGradient_write_const_FileStorageR(instance: *const c_void, fs: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_linemod_ColorGradient_read_const_FileNodeR(instance: *mut c_void, fn_: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_linemod_ColorGradient_write_const_FileStorageR(instance: *const c_void, fs: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_linemod_ColorGradient_propWeak_threshold_const(instance: *const c_void) -> f32; pub fn cv_linemod_ColorGradient_propWeak_threshold_const_float(instance: *mut c_void, val: f32); pub fn cv_linemod_ColorGradient_propNum_features_const(instance: *const c_void) -> size_t; @@ -12743,8 +12766,8 @@ mod rgbd_sys { pub fn cv_linemod_DepthNormal_DepthNormal_int_int_size_t_int(distance_threshold: i32, difference_threshold: i32, num_features: size_t, extract_threshold: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_linemod_DepthNormal_create_int_int_size_t_int(distance_threshold: i32, difference_threshold: i32, num_features: size_t, extract_threshold: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_linemod_DepthNormal_name_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_linemod_DepthNormal_read_const_FileNodeR(instance: *mut c_void, fn_: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_linemod_DepthNormal_write_const_FileStorageR(instance: *const c_void, fs: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_linemod_DepthNormal_read_const_FileNodeR(instance: *mut c_void, fn_: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_linemod_DepthNormal_write_const_FileStorageR(instance: *const c_void, fs: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_linemod_DepthNormal_propDistance_threshold_const(instance: *const c_void) -> i32; pub fn cv_linemod_DepthNormal_propDistance_threshold_const_int(instance: *mut c_void, val: i32); pub fn cv_linemod_DepthNormal_propDifference_threshold_const(instance: *const c_void) -> i32; @@ -12757,8 +12780,8 @@ mod rgbd_sys { pub fn cv_linemod_DepthNormal_delete(instance: *mut c_void); pub fn cv_linemod_Detector_Detector(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_linemod_Detector_Detector_const_vectorLPtrLModalityGGR_const_vectorLintGR(modalities: *const c_void, t_pyramid: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_linemod_Detector_match_const_const_vectorLMatGR_float_vectorLMatchGR_const_vectorLStringGR_const__OutputArrayR_const_vectorLMatGR(instance: *const c_void, sources: *const c_void, threshold: f32, matches: *mut c_void, class_ids: *const c_void, quantized_images: *const c_void, masks: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_linemod_Detector_match_const_const_vectorLMatGR_float_vectorLMatchGR(instance: *const c_void, sources: *const c_void, threshold: f32, matches: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_linemod_Detector_match_const_const_vectorLMatGR_float_vectorLMatchGR_const_vectorLStringGR_const__OutputArrayR_const_vectorLMatGR(instance: *const c_void, sources: *const c_void, threshold: f32, matches: *mut c_void, class_ids: *const c_void, quantized_images: *const c_void, masks: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_linemod_Detector_match_const_const_vectorLMatGR_float_vectorLMatchGR(instance: *const c_void, sources: *const c_void, threshold: f32, matches: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_linemod_Detector_addTemplate_const_vectorLMatGR_const_StringR_const_MatR_RectX(instance: *mut c_void, sources: *const c_void, class_id: *const c_char, object_mask: *const c_void, bounding_box: *mut core::Rect, ocvrs_return: *mut Result); pub fn cv_linemod_Detector_addTemplate_const_vectorLMatGR_const_StringR_const_MatR(instance: *mut c_void, sources: *const c_void, class_id: *const c_char, object_mask: *const c_void, ocvrs_return: *mut Result); pub fn cv_linemod_Detector_addSyntheticTemplate_const_vectorLTemplateGR_const_StringR(instance: *mut c_void, templates: *const c_void, class_id: *const c_char, ocvrs_return: *mut Result); @@ -12770,20 +12793,20 @@ mod rgbd_sys { pub fn cv_linemod_Detector_numTemplates_const_const_StringR(instance: *const c_void, class_id: *const c_char, ocvrs_return: *mut Result); pub fn cv_linemod_Detector_numClasses_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_linemod_Detector_classIds_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_linemod_Detector_read_const_FileNodeR(instance: *mut c_void, fn_: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_linemod_Detector_write_const_FileStorageR(instance: *const c_void, fs: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_linemod_Detector_read_const_FileNodeR(instance: *mut c_void, fn_: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_linemod_Detector_write_const_FileStorageR(instance: *const c_void, fs: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_linemod_Detector_readClass_const_FileNodeR_const_StringR(instance: *mut c_void, fn_: *const c_void, class_id_override: *const c_char, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_linemod_Detector_readClass_const_FileNodeR(instance: *mut c_void, fn_: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_linemod_Detector_writeClass_const_const_StringR_FileStorageR(instance: *const c_void, class_id: *const c_char, fs: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_linemod_Detector_readClasses_const_vectorLStringGR_const_StringR(instance: *mut c_void, class_ids: *const c_void, format: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_linemod_Detector_readClasses_const_vectorLStringGR(instance: *mut c_void, class_ids: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_linemod_Detector_writeClasses_const_const_StringR(instance: *const c_void, format: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_linemod_Detector_writeClasses_const(instance: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_linemod_Detector_writeClass_const_const_StringR_FileStorageR(instance: *const c_void, class_id: *const c_char, fs: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_linemod_Detector_readClasses_const_vectorLStringGR_const_StringR(instance: *mut c_void, class_ids: *const c_void, format: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_linemod_Detector_readClasses_const_vectorLStringGR(instance: *mut c_void, class_ids: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_linemod_Detector_writeClasses_const_const_StringR(instance: *const c_void, format: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_linemod_Detector_writeClasses_const(instance: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_linemod_Detector_delete(instance: *mut c_void); pub fn cv_linemod_Feature_Feature(ocvrs_return: *mut Result); pub fn cv_linemod_Feature_Feature_int_int_int(x: i32, y: i32, label: i32, ocvrs_return: *mut Result); - pub fn cv_linemod_Feature_read_const_FileNodeR(instance: *const crate::rgbd::LineMod_Feature, fn_: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_linemod_Feature_write_const_FileStorageR(instance: *const crate::rgbd::LineMod_Feature, fs: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_linemod_Feature_read_const_FileNodeR(instance: *const crate::rgbd::LineMod_Feature, fn_: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_linemod_Feature_write_const_FileStorageR(instance: *const crate::rgbd::LineMod_Feature, fs: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_linemod_Match_Match(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_linemod_Match_Match_int_int_float_const_StringR_int(x: i32, y: i32, similarity: f32, class_id: *const c_char, template_id: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_linemod_Match_operatorL_const_const_MatchR(instance: *const c_void, rhs: *const c_void, ocvrs_return: *mut Result); @@ -12803,19 +12826,19 @@ mod rgbd_sys { pub fn cv_linemod_Modality_process_const_const_MatR_const_MatR(instance: *const c_void, src: *const c_void, mask: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_linemod_Modality_process_const_const_MatR(instance: *const c_void, src: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_linemod_Modality_name_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_linemod_Modality_read_const_FileNodeR(instance: *mut c_void, fn_: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_linemod_Modality_write_const_FileStorageR(instance: *const c_void, fs: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_linemod_Modality_read_const_FileNodeR(instance: *mut c_void, fn_: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_linemod_Modality_write_const_FileStorageR(instance: *const c_void, fs: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_linemod_Modality_create_const_StringR(modality_type: *const c_char, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_linemod_Modality_create_const_FileNodeR(fn_: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_linemod_Modality_to_LineMod_ColorGradient(instance: *mut c_void) -> *mut c_void; pub fn cv_linemod_Modality_to_LineMod_DepthNormal(instance: *mut c_void) -> *mut c_void; pub fn cv_linemod_Modality_delete(instance: *mut c_void); - pub fn cv_linemod_QuantizedPyramid_quantize_const_MatR(instance: *const c_void, dst: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_linemod_QuantizedPyramid_quantize_const_MatR(instance: *const c_void, dst: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_linemod_QuantizedPyramid_extractTemplate_const_TemplateR(instance: *const c_void, templ: *mut c_void, ocvrs_return: *mut Result); - pub fn cv_linemod_QuantizedPyramid_pyrDown(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_linemod_QuantizedPyramid_pyrDown(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_linemod_QuantizedPyramid_delete(instance: *mut c_void); - pub fn cv_linemod_Template_read_const_FileNodeR(instance: *mut c_void, fn_: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_linemod_Template_write_const_FileStorageR(instance: *const c_void, fs: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_linemod_Template_read_const_FileNodeR(instance: *mut c_void, fn_: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_linemod_Template_write_const_FileStorageR(instance: *const c_void, fs: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_linemod_Template_implicitClone_const(instance: *const c_void) -> *mut c_void; pub fn cv_linemod_Template_defaultNew_const() -> *mut c_void; pub fn cv_linemod_Template_propWidth_const(instance: *const c_void) -> i32; @@ -12832,14 +12855,14 @@ mod rgbd_sys { pub fn cv_rgbd_DepthCleaner_DepthCleaner_int(depth: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_rgbd_DepthCleaner_create_int_int_int(depth: i32, window_size: i32, method: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_rgbd_DepthCleaner_create_int(depth: i32, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_rgbd_DepthCleaner_operator___const_const__InputArrayR_const__OutputArrayR(instance: *const c_void, points: *const c_void, depth: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_rgbd_DepthCleaner_initialize_const(instance: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_DepthCleaner_operator___const_const__InputArrayR_const__OutputArrayR(instance: *const c_void, points: *const c_void, depth: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_rgbd_DepthCleaner_initialize_const(instance: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_DepthCleaner_getWindowSize_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_rgbd_DepthCleaner_setWindowSize_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_DepthCleaner_setWindowSize_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_DepthCleaner_getDepth_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_rgbd_DepthCleaner_setDepth_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_DepthCleaner_setDepth_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_DepthCleaner_getMethod_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_rgbd_DepthCleaner_setMethod_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_DepthCleaner_setMethod_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_DepthCleaner_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_rgbd_DepthCleaner_delete(instance: *mut c_void); pub fn cv_rgbd_FastICPOdometry_FastICPOdometry(ocvrs_return: *mut Result<*mut c_void>); @@ -12849,21 +12872,21 @@ mod rgbd_sys { pub fn cv_rgbd_FastICPOdometry_create_const_MatR(camera_matrix: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_rgbd_FastICPOdometry_prepareFrameCache_const_PtrLOdometryFrameGR_int(instance: *const c_void, frame: *mut c_void, cache_type: i32, ocvrs_return: *mut Result); pub fn cv_rgbd_FastICPOdometry_getCameraMatrix_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_rgbd_FastICPOdometry_setCameraMatrix_const_MatR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_FastICPOdometry_setCameraMatrix_const_MatR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_FastICPOdometry_getMaxDistDiff_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_rgbd_FastICPOdometry_setMaxDistDiff_float(instance: *mut c_void, val: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_FastICPOdometry_setMaxDistDiff_float(instance: *mut c_void, val: f32, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_FastICPOdometry_getAngleThreshold_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_rgbd_FastICPOdometry_setAngleThreshold_float(instance: *mut c_void, f: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_FastICPOdometry_setAngleThreshold_float(instance: *mut c_void, f: f32, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_FastICPOdometry_getSigmaDepth_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_rgbd_FastICPOdometry_setSigmaDepth_float(instance: *mut c_void, f: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_FastICPOdometry_setSigmaDepth_float(instance: *mut c_void, f: f32, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_FastICPOdometry_getSigmaSpatial_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_rgbd_FastICPOdometry_setSigmaSpatial_float(instance: *mut c_void, f: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_FastICPOdometry_setSigmaSpatial_float(instance: *mut c_void, f: f32, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_FastICPOdometry_getKernelSize_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_rgbd_FastICPOdometry_setKernelSize_int(instance: *mut c_void, f: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_FastICPOdometry_setKernelSize_int(instance: *mut c_void, f: i32, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_FastICPOdometry_getIterationCounts_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_rgbd_FastICPOdometry_setIterationCounts_const_MatR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_FastICPOdometry_setIterationCounts_const_MatR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_FastICPOdometry_getTransformType_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_rgbd_FastICPOdometry_setTransformType_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_FastICPOdometry_setTransformType_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_FastICPOdometry_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_rgbd_FastICPOdometry_to_Odometry(instance: *mut c_void) -> *mut c_void; pub fn cv_rgbd_FastICPOdometry_delete(instance: *mut c_void); @@ -12874,23 +12897,23 @@ mod rgbd_sys { pub fn cv_rgbd_ICPOdometry_create(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_rgbd_ICPOdometry_prepareFrameCache_const_PtrLOdometryFrameGR_int(instance: *const c_void, frame: *mut c_void, cache_type: i32, ocvrs_return: *mut Result); pub fn cv_rgbd_ICPOdometry_getCameraMatrix_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_rgbd_ICPOdometry_setCameraMatrix_const_MatR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_ICPOdometry_setCameraMatrix_const_MatR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_ICPOdometry_getMinDepth_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_rgbd_ICPOdometry_setMinDepth_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_ICPOdometry_setMinDepth_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_ICPOdometry_getMaxDepth_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_rgbd_ICPOdometry_setMaxDepth_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_ICPOdometry_setMaxDepth_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_ICPOdometry_getMaxDepthDiff_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_rgbd_ICPOdometry_setMaxDepthDiff_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_ICPOdometry_setMaxDepthDiff_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_ICPOdometry_getIterationCounts_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_rgbd_ICPOdometry_setIterationCounts_const_MatR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_ICPOdometry_setIterationCounts_const_MatR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_ICPOdometry_getMaxPointsPart_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_rgbd_ICPOdometry_setMaxPointsPart_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_ICPOdometry_setMaxPointsPart_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_ICPOdometry_getTransformType_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_rgbd_ICPOdometry_setTransformType_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_ICPOdometry_setTransformType_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_ICPOdometry_getMaxTranslation_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_rgbd_ICPOdometry_setMaxTranslation_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_ICPOdometry_setMaxTranslation_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_ICPOdometry_getMaxRotation_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_rgbd_ICPOdometry_setMaxRotation_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_ICPOdometry_setMaxRotation_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_ICPOdometry_getNormalsComputer_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_rgbd_ICPOdometry_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_rgbd_ICPOdometry_to_Odometry(instance: *mut c_void) -> *mut c_void; @@ -12908,9 +12931,9 @@ mod rgbd_sys { pub fn cv_rgbd_Odometry_prepareFrameCache_const_PtrLOdometryFrameGR_int(instance: *const c_void, frame: *mut c_void, cache_type: i32, ocvrs_return: *mut Result); pub fn cv_rgbd_Odometry_create_const_StringR(odometry_type: *const c_char, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_rgbd_Odometry_getCameraMatrix_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_rgbd_Odometry_setCameraMatrix_const_MatR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_Odometry_setCameraMatrix_const_MatR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_Odometry_getTransformType_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_rgbd_Odometry_setTransformType_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_Odometry_setTransformType_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_Odometry_to_FastICPOdometry(instance: *mut c_void) -> *mut c_void; pub fn cv_rgbd_Odometry_to_ICPOdometry(instance: *mut c_void) -> *mut c_void; pub fn cv_rgbd_Odometry_to_RgbdICPOdometry(instance: *mut c_void) -> *mut c_void; @@ -12922,8 +12945,8 @@ mod rgbd_sys { pub fn cv_rgbd_OdometryFrame_OdometryFrame_const_MatR_const_MatR(image: *const c_void, depth: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_rgbd_OdometryFrame_create_const_MatR_const_MatR_const_MatR_const_MatR_int(image: *const c_void, depth: *const c_void, mask: *const c_void, normals: *const c_void, id: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_rgbd_OdometryFrame_create(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_rgbd_OdometryFrame_release(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_rgbd_OdometryFrame_releasePyramids(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_OdometryFrame_release(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_rgbd_OdometryFrame_releasePyramids(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_OdometryFrame_propPyramidImage_const(instance: *const c_void) -> *mut c_void; pub fn cv_rgbd_OdometryFrame_propPyramidImage_const_vectorLMatG(instance: *mut c_void, val: *const c_void); pub fn cv_rgbd_OdometryFrame_propPyramidDepth_const(instance: *const c_void) -> *mut c_void; @@ -12949,7 +12972,7 @@ mod rgbd_sys { pub fn cv_rgbd_RgbdFrame_RgbdFrame_const_MatR_const_MatR(image: *const c_void, depth: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_rgbd_RgbdFrame_create_const_MatR_const_MatR_const_MatR_const_MatR_int(image: *const c_void, depth: *const c_void, mask: *const c_void, normals: *const c_void, id: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_rgbd_RgbdFrame_create(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_rgbd_RgbdFrame_release(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_RgbdFrame_release(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_RgbdFrame_propID_const(instance: *const c_void) -> i32; pub fn cv_rgbd_RgbdFrame_propID_const_int(instance: *mut c_void, val: i32); pub fn cv_rgbd_RgbdFrame_propImage_const(instance: *const c_void) -> *mut c_void; @@ -12969,25 +12992,25 @@ mod rgbd_sys { pub fn cv_rgbd_RgbdICPOdometry_create(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_rgbd_RgbdICPOdometry_prepareFrameCache_const_PtrLOdometryFrameGR_int(instance: *const c_void, frame: *mut c_void, cache_type: i32, ocvrs_return: *mut Result); pub fn cv_rgbd_RgbdICPOdometry_getCameraMatrix_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_rgbd_RgbdICPOdometry_setCameraMatrix_const_MatR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_RgbdICPOdometry_setCameraMatrix_const_MatR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_RgbdICPOdometry_getMinDepth_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_rgbd_RgbdICPOdometry_setMinDepth_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_RgbdICPOdometry_setMinDepth_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_RgbdICPOdometry_getMaxDepth_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_rgbd_RgbdICPOdometry_setMaxDepth_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_RgbdICPOdometry_setMaxDepth_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_RgbdICPOdometry_getMaxDepthDiff_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_rgbd_RgbdICPOdometry_setMaxDepthDiff_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_RgbdICPOdometry_setMaxDepthDiff_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_RgbdICPOdometry_getMaxPointsPart_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_rgbd_RgbdICPOdometry_setMaxPointsPart_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_RgbdICPOdometry_setMaxPointsPart_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_RgbdICPOdometry_getIterationCounts_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_rgbd_RgbdICPOdometry_setIterationCounts_const_MatR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_RgbdICPOdometry_setIterationCounts_const_MatR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_RgbdICPOdometry_getMinGradientMagnitudes_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_rgbd_RgbdICPOdometry_setMinGradientMagnitudes_const_MatR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_RgbdICPOdometry_setMinGradientMagnitudes_const_MatR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_RgbdICPOdometry_getTransformType_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_rgbd_RgbdICPOdometry_setTransformType_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_RgbdICPOdometry_setTransformType_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_RgbdICPOdometry_getMaxTranslation_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_rgbd_RgbdICPOdometry_setMaxTranslation_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_RgbdICPOdometry_setMaxTranslation_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_RgbdICPOdometry_getMaxRotation_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_rgbd_RgbdICPOdometry_setMaxRotation_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_RgbdICPOdometry_setMaxRotation_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_RgbdICPOdometry_getNormalsComputer_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_rgbd_RgbdICPOdometry_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_rgbd_RgbdICPOdometry_to_Odometry(instance: *mut c_void) -> *mut c_void; @@ -12997,20 +13020,20 @@ mod rgbd_sys { pub fn cv_rgbd_RgbdNormals_RgbdNormals_int_int_int_const__InputArrayR(rows: i32, cols: i32, depth: i32, k: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_rgbd_RgbdNormals_create_int_int_int_const__InputArrayR_int_int(rows: i32, cols: i32, depth: i32, k: *const c_void, window_size: i32, method: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_rgbd_RgbdNormals_create_int_int_int_const__InputArrayR(rows: i32, cols: i32, depth: i32, k: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_rgbd_RgbdNormals_operator___const_const__InputArrayR_const__OutputArrayR(instance: *const c_void, points: *const c_void, normals: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_rgbd_RgbdNormals_initialize_const(instance: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_RgbdNormals_operator___const_const__InputArrayR_const__OutputArrayR(instance: *const c_void, points: *const c_void, normals: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_rgbd_RgbdNormals_initialize_const(instance: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_RgbdNormals_getRows_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_rgbd_RgbdNormals_setRows_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_RgbdNormals_setRows_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_RgbdNormals_getCols_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_rgbd_RgbdNormals_setCols_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_RgbdNormals_setCols_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_RgbdNormals_getWindowSize_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_rgbd_RgbdNormals_setWindowSize_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_RgbdNormals_setWindowSize_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_RgbdNormals_getDepth_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_rgbd_RgbdNormals_setDepth_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_RgbdNormals_setDepth_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_RgbdNormals_getK_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_rgbd_RgbdNormals_setK_const_MatR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_RgbdNormals_setK_const_MatR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_RgbdNormals_getMethod_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_rgbd_RgbdNormals_setMethod_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_RgbdNormals_setMethod_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_RgbdNormals_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_rgbd_RgbdNormals_delete(instance: *mut c_void); pub fn cv_rgbd_RgbdOdometry_RgbdOdometry(ocvrs_return: *mut Result<*mut c_void>); @@ -13020,25 +13043,25 @@ mod rgbd_sys { pub fn cv_rgbd_RgbdOdometry_create(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_rgbd_RgbdOdometry_prepareFrameCache_const_PtrLOdometryFrameGR_int(instance: *const c_void, frame: *mut c_void, cache_type: i32, ocvrs_return: *mut Result); pub fn cv_rgbd_RgbdOdometry_getCameraMatrix_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_rgbd_RgbdOdometry_setCameraMatrix_const_MatR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_RgbdOdometry_setCameraMatrix_const_MatR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_RgbdOdometry_getMinDepth_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_rgbd_RgbdOdometry_setMinDepth_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_RgbdOdometry_setMinDepth_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_RgbdOdometry_getMaxDepth_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_rgbd_RgbdOdometry_setMaxDepth_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_RgbdOdometry_setMaxDepth_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_RgbdOdometry_getMaxDepthDiff_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_rgbd_RgbdOdometry_setMaxDepthDiff_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_RgbdOdometry_setMaxDepthDiff_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_RgbdOdometry_getIterationCounts_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_rgbd_RgbdOdometry_setIterationCounts_const_MatR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_RgbdOdometry_setIterationCounts_const_MatR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_RgbdOdometry_getMinGradientMagnitudes_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_rgbd_RgbdOdometry_setMinGradientMagnitudes_const_MatR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_RgbdOdometry_setMinGradientMagnitudes_const_MatR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_RgbdOdometry_getMaxPointsPart_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_rgbd_RgbdOdometry_setMaxPointsPart_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_RgbdOdometry_setMaxPointsPart_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_RgbdOdometry_getTransformType_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_rgbd_RgbdOdometry_setTransformType_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_RgbdOdometry_setTransformType_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_RgbdOdometry_getMaxTranslation_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_rgbd_RgbdOdometry_setMaxTranslation_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_RgbdOdometry_setMaxTranslation_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_RgbdOdometry_getMaxRotation_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_rgbd_RgbdOdometry_setMaxRotation_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_RgbdOdometry_setMaxRotation_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_RgbdOdometry_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_rgbd_RgbdOdometry_to_Odometry(instance: *mut c_void) -> *mut c_void; pub fn cv_rgbd_RgbdOdometry_delete(instance: *mut c_void); @@ -13048,22 +13071,22 @@ mod rgbd_sys { pub fn cv_rgbd_RgbdPlane_RgbdPlane_int_int_int_double(method: i32, block_size: i32, min_size: i32, threshold: f64, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_rgbd_RgbdPlane_create_int_int_int_double_double_double_double(method: i32, block_size: i32, min_size: i32, threshold: f64, sensor_error_a: f64, sensor_error_b: f64, sensor_error_c: f64, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_rgbd_RgbdPlane_create_int_int_int_double(method: i32, block_size: i32, min_size: i32, threshold: f64, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_rgbd_RgbdPlane_operator___const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *mut c_void, points3d: *const c_void, normals: *const c_void, mask: *const c_void, plane_coefficients: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_rgbd_RgbdPlane_operator___const__InputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *mut c_void, points3d: *const c_void, mask: *const c_void, plane_coefficients: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_RgbdPlane_operator___const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *mut c_void, points3d: *const c_void, normals: *const c_void, mask: *const c_void, plane_coefficients: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_rgbd_RgbdPlane_operator___const__InputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *mut c_void, points3d: *const c_void, mask: *const c_void, plane_coefficients: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_RgbdPlane_getBlockSize_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_rgbd_RgbdPlane_setBlockSize_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_RgbdPlane_setBlockSize_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_RgbdPlane_getMinSize_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_rgbd_RgbdPlane_setMinSize_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_RgbdPlane_setMinSize_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_RgbdPlane_getMethod_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_rgbd_RgbdPlane_setMethod_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_RgbdPlane_setMethod_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_RgbdPlane_getThreshold_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_rgbd_RgbdPlane_setThreshold_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_RgbdPlane_setThreshold_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_RgbdPlane_getSensorErrorA_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_rgbd_RgbdPlane_setSensorErrorA_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_RgbdPlane_setSensorErrorA_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_RgbdPlane_getSensorErrorB_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_rgbd_RgbdPlane_setSensorErrorB_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_RgbdPlane_setSensorErrorB_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_RgbdPlane_getSensorErrorC_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_rgbd_RgbdPlane_setSensorErrorC_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_rgbd_RgbdPlane_setSensorErrorC_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_rgbd_RgbdPlane_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_rgbd_RgbdPlane_delete(instance: *mut c_void); pub fn cv_PtrLcv_colored_kinfu_ColoredKinFuG_getInnerPtr_const(instance: *const c_void) -> *mut c_void; @@ -13259,10 +13282,8 @@ mod rgbd_sys { pub fn std_vectorLcv_PtrLcv_linemod_ModalityGG_set_size_t_const_PtrLModalityG(instance: *mut c_void, index: size_t, val: *const c_void); } } -#[cfg(ocvrs_has_module_rgbd)] pub use rgbd_sys::*; -#[cfg(ocvrs_has_module_saliency)] mod saliency_sys { use super::*; @@ -13274,12 +13295,12 @@ mod saliency_sys { pub fn cv_saliency_MotionSaliencyBinWangApr2014_MotionSaliencyBinWangApr2014(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_saliency_MotionSaliencyBinWangApr2014_create(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_saliency_MotionSaliencyBinWangApr2014_computeSaliency_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, saliency_map: *const c_void, ocvrs_return: *mut Result); - pub fn cv_saliency_MotionSaliencyBinWangApr2014_setImagesize_int_int(instance: *mut c_void, w: i32, h: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_saliency_MotionSaliencyBinWangApr2014_setImagesize_int_int(instance: *mut c_void, w: i32, h: i32, ocvrs_return: *mut Result<()>); pub fn cv_saliency_MotionSaliencyBinWangApr2014_init(instance: *mut c_void, ocvrs_return: *mut Result); pub fn cv_saliency_MotionSaliencyBinWangApr2014_getImageWidth_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_saliency_MotionSaliencyBinWangApr2014_setImageWidth_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_saliency_MotionSaliencyBinWangApr2014_setImageWidth_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_saliency_MotionSaliencyBinWangApr2014_getImageHeight_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_saliency_MotionSaliencyBinWangApr2014_setImageHeight_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_saliency_MotionSaliencyBinWangApr2014_setImageHeight_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_saliency_MotionSaliencyBinWangApr2014_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_saliency_MotionSaliencyBinWangApr2014_to_MotionSaliency(instance: *mut c_void) -> *mut c_void; pub fn cv_saliency_MotionSaliencyBinWangApr2014_to_Saliency(instance: *mut c_void) -> *mut c_void; @@ -13291,17 +13312,17 @@ mod saliency_sys { pub fn cv_saliency_ObjectnessBING_ObjectnessBING(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_saliency_ObjectnessBING_create(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_saliency_ObjectnessBING_computeSaliency_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, saliency_map: *const c_void, ocvrs_return: *mut Result); - pub fn cv_saliency_ObjectnessBING_read(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_saliency_ObjectnessBING_write_const(instance: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_saliency_ObjectnessBING_read(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_saliency_ObjectnessBING_write_const(instance: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_saliency_ObjectnessBING_getobjectnessValues(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_saliency_ObjectnessBING_setTrainingPath_const_StringR(instance: *mut c_void, training_path: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_saliency_ObjectnessBING_setBBResDir_const_StringR(instance: *mut c_void, results_dir: *const c_char, ocvrs_return: *mut ResultVoid); + pub fn cv_saliency_ObjectnessBING_setTrainingPath_const_StringR(instance: *mut c_void, training_path: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_saliency_ObjectnessBING_setBBResDir_const_StringR(instance: *mut c_void, results_dir: *const c_char, ocvrs_return: *mut Result<()>); pub fn cv_saliency_ObjectnessBING_getBase_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_saliency_ObjectnessBING_setBase_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_saliency_ObjectnessBING_setBase_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_saliency_ObjectnessBING_getNSS_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_saliency_ObjectnessBING_setNSS_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_saliency_ObjectnessBING_setNSS_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_saliency_ObjectnessBING_getW_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_saliency_ObjectnessBING_setW_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_saliency_ObjectnessBING_setW_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_saliency_ObjectnessBING_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_saliency_ObjectnessBING_to_Objectness(instance: *mut c_void) -> *mut c_void; pub fn cv_saliency_ObjectnessBING_to_Saliency(instance: *mut c_void) -> *mut c_void; @@ -13332,12 +13353,12 @@ mod saliency_sys { pub fn cv_saliency_StaticSaliencySpectralResidual_StaticSaliencySpectralResidual(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_saliency_StaticSaliencySpectralResidual_create(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_saliency_StaticSaliencySpectralResidual_computeSaliency_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, saliency_map: *const c_void, ocvrs_return: *mut Result); - pub fn cv_saliency_StaticSaliencySpectralResidual_read_const_FileNodeR(instance: *mut c_void, fn_: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_saliency_StaticSaliencySpectralResidual_write_const_FileStorageR(instance: *const c_void, fs: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_saliency_StaticSaliencySpectralResidual_read_const_FileNodeR(instance: *mut c_void, fn_: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_saliency_StaticSaliencySpectralResidual_write_const_FileStorageR(instance: *const c_void, fs: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_saliency_StaticSaliencySpectralResidual_getImageWidth_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_saliency_StaticSaliencySpectralResidual_setImageWidth_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_saliency_StaticSaliencySpectralResidual_setImageWidth_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_saliency_StaticSaliencySpectralResidual_getImageHeight_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_saliency_StaticSaliencySpectralResidual_setImageHeight_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_saliency_StaticSaliencySpectralResidual_setImageHeight_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_saliency_StaticSaliencySpectralResidual_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_saliency_StaticSaliencySpectralResidual_to_Saliency(instance: *mut c_void) -> *mut c_void; pub fn cv_saliency_StaticSaliencySpectralResidual_to_StaticSaliency(instance: *mut c_void) -> *mut c_void; @@ -13399,74 +13420,72 @@ mod saliency_sys { pub fn cv_PtrLcv_saliency_StaticSaliencySpectralResidualG_new_const_StaticSaliencySpectralResidual(val: *mut c_void) -> *mut c_void; } } -#[cfg(ocvrs_has_module_saliency)] pub use saliency_sys::*; -#[cfg(ocvrs_has_module_sfm)] mod sfm_sys { use super::*; extern "C" { - pub fn cv_sfm_KRtFromProjection_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(p: *const c_void, k: *const c_void, r: *const c_void, t: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_sfm_applyTransformationToPoints_const__InputArrayR_const__InputArrayR_const__OutputArrayR(points: *const c_void, t: *const c_void, transformed_points: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_sfm_computeOrientation_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_double(x1: *const c_void, x2: *const c_void, r: *const c_void, t: *const c_void, s: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_sfm_KRtFromProjection_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(p: *const c_void, k: *const c_void, r: *const c_void, t: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_sfm_applyTransformationToPoints_const__InputArrayR_const__InputArrayR_const__OutputArrayR(points: *const c_void, t: *const c_void, transformed_points: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_sfm_computeOrientation_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_double(x1: *const c_void, x2: *const c_void, r: *const c_void, t: *const c_void, s: f64, ocvrs_return: *mut Result<()>); pub fn cv_sfm_depth_const__InputArrayR_const__InputArrayR_const__InputArrayR(r: *const c_void, t: *const c_void, x: *const c_void, ocvrs_return: *mut Result); - pub fn cv_sfm_essentialFromFundamental_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR(f: *const c_void, k1: *const c_void, k2: *const c_void, e: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_sfm_essentialFromRt_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR(r1: *const c_void, t1: *const c_void, r2: *const c_void, t2: *const c_void, e: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_sfm_euclideanToHomogeneous_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_sfm_essentialFromFundamental_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR(f: *const c_void, k1: *const c_void, k2: *const c_void, e: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_sfm_essentialFromRt_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR(r1: *const c_void, t1: *const c_void, r2: *const c_void, t2: *const c_void, e: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_sfm_euclideanToHomogeneous_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_sfm_fundamentalFromCorrespondences7PointRobust_const__InputArrayR_const__InputArrayR_double_const__OutputArrayR_const__OutputArrayR(x1: *const c_void, x2: *const c_void, max_error: f64, f: *const c_void, inliers: *const c_void, ocvrs_return: *mut Result); pub fn cv_sfm_fundamentalFromCorrespondences7PointRobust_const__InputArrayR_const__InputArrayR_double_const__OutputArrayR_const__OutputArrayR_double(x1: *const c_void, x2: *const c_void, max_error: f64, f: *const c_void, inliers: *const c_void, outliers_probability: f64, ocvrs_return: *mut Result); pub fn cv_sfm_fundamentalFromCorrespondences8PointRobust_const__InputArrayR_const__InputArrayR_double_const__OutputArrayR_const__OutputArrayR(x1: *const c_void, x2: *const c_void, max_error: f64, f: *const c_void, inliers: *const c_void, ocvrs_return: *mut Result); pub fn cv_sfm_fundamentalFromCorrespondences8PointRobust_const__InputArrayR_const__InputArrayR_double_const__OutputArrayR_const__OutputArrayR_double(x1: *const c_void, x2: *const c_void, max_error: f64, f: *const c_void, inliers: *const c_void, outliers_probability: f64, ocvrs_return: *mut Result); - pub fn cv_sfm_fundamentalFromEssential_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR(e: *const c_void, k1: *const c_void, k2: *const c_void, f: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_sfm_fundamentalFromProjections_const__InputArrayR_const__InputArrayR_const__OutputArrayR(p1: *const c_void, p2: *const c_void, f: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_sfm_homogeneousToEuclidean_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_sfm_importReconstruction_const_StringR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(file: *const c_char, rs: *const c_void, ts: *const c_void, ks: *const c_void, points3d: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_sfm_importReconstruction_const_StringR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_int(file: *const c_char, rs: *const c_void, ts: *const c_void, ks: *const c_void, points3d: *const c_void, file_format: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_sfm_isotropicPreconditionerFromPoints_const__InputArrayR_const__OutputArrayR(points: *const c_void, t: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_sfm_meanAndVarianceAlongRows_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(a: *const c_void, mean: *const c_void, variance: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_sfm_fundamentalFromEssential_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR(e: *const c_void, k1: *const c_void, k2: *const c_void, f: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_sfm_fundamentalFromProjections_const__InputArrayR_const__InputArrayR_const__OutputArrayR(p1: *const c_void, p2: *const c_void, f: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_sfm_homogeneousToEuclidean_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_sfm_importReconstruction_const_StringR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(file: *const c_char, rs: *const c_void, ts: *const c_void, ks: *const c_void, points3d: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_sfm_importReconstruction_const_StringR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR_int(file: *const c_char, rs: *const c_void, ts: *const c_void, ks: *const c_void, points3d: *const c_void, file_format: i32, ocvrs_return: *mut Result<()>); + pub fn cv_sfm_isotropicPreconditionerFromPoints_const__InputArrayR_const__OutputArrayR(points: *const c_void, t: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_sfm_meanAndVarianceAlongRows_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(a: *const c_void, mean: *const c_void, variance: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_sfm_motionFromEssentialChooseSolution_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR(rs: *const c_void, ts: *const c_void, k1: *const c_void, x1: *const c_void, k2: *const c_void, x2: *const c_void, ocvrs_return: *mut Result); - pub fn cv_sfm_motionFromEssential_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(e: *const c_void, rs: *const c_void, ts: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_sfm_normalizeFundamental_const__InputArrayR_const__OutputArrayR(f: *const c_void, f_normalized: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_sfm_normalizeIsotropicPoints_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(points: *const c_void, normalized_points: *const c_void, t: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_sfm_normalizePoints_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(points: *const c_void, normalized_points: *const c_void, t: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_sfm_normalizedEightPointSolver_const__InputArrayR_const__InputArrayR_const__OutputArrayR(x1: *const c_void, x2: *const c_void, f: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_sfm_preconditionerFromPoints_const__InputArrayR_const__OutputArrayR(points: *const c_void, t: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_sfm_projectionFromKRt_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR(k: *const c_void, r: *const c_void, t: *const c_void, p: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_sfm_projectionsFromFundamental_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(f: *const c_void, p1: *const c_void, p2: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_sfm_reconstruct_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__InputOutputArrayR(points2d: *const c_void, ps: *const c_void, points3d: *const c_void, k: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_sfm_reconstruct_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__InputOutputArrayR_bool(points2d: *const c_void, ps: *const c_void, points3d: *const c_void, k: *const c_void, is_projective: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_sfm_reconstruct_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__InputOutputArrayR_const__OutputArrayR(points2d: *const c_void, rs: *const c_void, ts: *const c_void, k: *const c_void, points3d: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_sfm_reconstruct_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__InputOutputArrayR_const__OutputArrayR_bool(points2d: *const c_void, rs: *const c_void, ts: *const c_void, k: *const c_void, points3d: *const c_void, is_projective: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_sfm_reconstruct_const_vectorLStringG_const__OutputArrayR_const__OutputArrayR_const__InputOutputArrayR(images: *const c_void, ps: *const c_void, points3d: *const c_void, k: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_sfm_reconstruct_const_vectorLStringG_const__OutputArrayR_const__OutputArrayR_const__InputOutputArrayR_bool(images: *const c_void, ps: *const c_void, points3d: *const c_void, k: *const c_void, is_projective: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_sfm_reconstruct_const_vectorLStringG_const__OutputArrayR_const__OutputArrayR_const__InputOutputArrayR_const__OutputArrayR(images: *const c_void, rs: *const c_void, ts: *const c_void, k: *const c_void, points3d: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_sfm_reconstruct_const_vectorLStringG_const__OutputArrayR_const__OutputArrayR_const__InputOutputArrayR_const__OutputArrayR_bool(images: *const c_void, rs: *const c_void, ts: *const c_void, k: *const c_void, points3d: *const c_void, is_projective: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_sfm_relativeCameraMotion_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(r1: *const c_void, t1: *const c_void, r2: *const c_void, t2: *const c_void, r: *const c_void, t: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_sfm_motionFromEssential_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(e: *const c_void, rs: *const c_void, ts: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_sfm_normalizeFundamental_const__InputArrayR_const__OutputArrayR(f: *const c_void, f_normalized: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_sfm_normalizeIsotropicPoints_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(points: *const c_void, normalized_points: *const c_void, t: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_sfm_normalizePoints_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(points: *const c_void, normalized_points: *const c_void, t: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_sfm_normalizedEightPointSolver_const__InputArrayR_const__InputArrayR_const__OutputArrayR(x1: *const c_void, x2: *const c_void, f: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_sfm_preconditionerFromPoints_const__InputArrayR_const__OutputArrayR(points: *const c_void, t: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_sfm_projectionFromKRt_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR(k: *const c_void, r: *const c_void, t: *const c_void, p: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_sfm_projectionsFromFundamental_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(f: *const c_void, p1: *const c_void, p2: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_sfm_reconstruct_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__InputOutputArrayR(points2d: *const c_void, ps: *const c_void, points3d: *const c_void, k: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_sfm_reconstruct_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__InputOutputArrayR_bool(points2d: *const c_void, ps: *const c_void, points3d: *const c_void, k: *const c_void, is_projective: bool, ocvrs_return: *mut Result<()>); + pub fn cv_sfm_reconstruct_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__InputOutputArrayR_const__OutputArrayR(points2d: *const c_void, rs: *const c_void, ts: *const c_void, k: *const c_void, points3d: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_sfm_reconstruct_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__InputOutputArrayR_const__OutputArrayR_bool(points2d: *const c_void, rs: *const c_void, ts: *const c_void, k: *const c_void, points3d: *const c_void, is_projective: bool, ocvrs_return: *mut Result<()>); + pub fn cv_sfm_reconstruct_const_vectorLStringG_const__OutputArrayR_const__OutputArrayR_const__InputOutputArrayR(images: *const c_void, ps: *const c_void, points3d: *const c_void, k: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_sfm_reconstruct_const_vectorLStringG_const__OutputArrayR_const__OutputArrayR_const__InputOutputArrayR_bool(images: *const c_void, ps: *const c_void, points3d: *const c_void, k: *const c_void, is_projective: bool, ocvrs_return: *mut Result<()>); + pub fn cv_sfm_reconstruct_const_vectorLStringG_const__OutputArrayR_const__OutputArrayR_const__InputOutputArrayR_const__OutputArrayR(images: *const c_void, rs: *const c_void, ts: *const c_void, k: *const c_void, points3d: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_sfm_reconstruct_const_vectorLStringG_const__OutputArrayR_const__OutputArrayR_const__InputOutputArrayR_const__OutputArrayR_bool(images: *const c_void, rs: *const c_void, ts: *const c_void, k: *const c_void, points3d: *const c_void, is_projective: bool, ocvrs_return: *mut Result<()>); + pub fn cv_sfm_relativeCameraMotion_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(r1: *const c_void, t1: *const c_void, r2: *const c_void, t2: *const c_void, r: *const c_void, t: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_sfm_skew_const__InputArrayR(x: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_sfm_triangulatePoints_const__InputArrayR_const__InputArrayR_const__OutputArrayR(points2d: *const c_void, projection_matrices: *const c_void, points3d: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_sfm_BaseSFM_run_const__InputArrayR(instance: *mut c_void, points2d: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_sfm_BaseSFM_run_const__InputArrayR_const__InputOutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *mut c_void, points2d: *const c_void, k: *const c_void, rs: *const c_void, ts: *const c_void, points3d: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_sfm_BaseSFM_run_const_vectorLStringGR(instance: *mut c_void, images: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_sfm_BaseSFM_run_const_vectorLStringGR_const__InputOutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *mut c_void, images: *const c_void, k: *const c_void, rs: *const c_void, ts: *const c_void, points3d: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_sfm_triangulatePoints_const__InputArrayR_const__InputArrayR_const__OutputArrayR(points2d: *const c_void, projection_matrices: *const c_void, points3d: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_sfm_BaseSFM_run_const__InputArrayR(instance: *mut c_void, points2d: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_sfm_BaseSFM_run_const__InputArrayR_const__InputOutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *mut c_void, points2d: *const c_void, k: *const c_void, rs: *const c_void, ts: *const c_void, points3d: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_sfm_BaseSFM_run_const_vectorLStringGR(instance: *mut c_void, images: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_sfm_BaseSFM_run_const_vectorLStringGR_const__InputOutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *mut c_void, images: *const c_void, k: *const c_void, rs: *const c_void, ts: *const c_void, points3d: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_sfm_BaseSFM_getError_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_sfm_BaseSFM_getPoints_const__OutputArrayR(instance: *mut c_void, points3d: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_sfm_BaseSFM_getPoints_const__OutputArrayR(instance: *mut c_void, points3d: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_sfm_BaseSFM_getIntrinsics_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_sfm_BaseSFM_getCameras_const__OutputArrayR_const__OutputArrayR(instance: *mut c_void, rs: *const c_void, ts: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_sfm_BaseSFM_setReconstructionOptions_const_libmv_ReconstructionOptionsR(instance: *mut c_void, libmv_reconstruction_options: *const crate::sfm::libmv_ReconstructionOptions, ocvrs_return: *mut ResultVoid); - pub fn cv_sfm_BaseSFM_setCameraIntrinsicOptions_const_libmv_CameraIntrinsicsOptionsR(instance: *mut c_void, libmv_camera_intrinsics_options: *const crate::sfm::libmv_CameraIntrinsicsOptions, ocvrs_return: *mut ResultVoid); + pub fn cv_sfm_BaseSFM_getCameras_const__OutputArrayR_const__OutputArrayR(instance: *mut c_void, rs: *const c_void, ts: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_sfm_BaseSFM_setReconstructionOptions_const_libmv_ReconstructionOptionsR(instance: *mut c_void, libmv_reconstruction_options: *const crate::sfm::libmv_ReconstructionOptions, ocvrs_return: *mut Result<()>); + pub fn cv_sfm_BaseSFM_setCameraIntrinsicOptions_const_libmv_CameraIntrinsicsOptionsR(instance: *mut c_void, libmv_camera_intrinsics_options: *const crate::sfm::libmv_CameraIntrinsicsOptions, ocvrs_return: *mut Result<()>); pub fn cv_sfm_BaseSFM_to_SFMLibmvEuclideanReconstruction(instance: *mut c_void) -> *mut c_void; pub fn cv_sfm_BaseSFM_delete(instance: *mut c_void); - pub fn cv_sfm_SFMLibmvEuclideanReconstruction_run_const__InputArrayR(instance: *mut c_void, points2d: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_sfm_SFMLibmvEuclideanReconstruction_run_const__InputArrayR_const__InputOutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *mut c_void, points2d: *const c_void, k: *const c_void, rs: *const c_void, ts: *const c_void, points3d: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_sfm_SFMLibmvEuclideanReconstruction_run_const_vectorLStringGR(instance: *mut c_void, images: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_sfm_SFMLibmvEuclideanReconstruction_run_const_vectorLStringGR_const__InputOutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *mut c_void, images: *const c_void, k: *const c_void, rs: *const c_void, ts: *const c_void, points3d: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_sfm_SFMLibmvEuclideanReconstruction_run_const__InputArrayR(instance: *mut c_void, points2d: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_sfm_SFMLibmvEuclideanReconstruction_run_const__InputArrayR_const__InputOutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *mut c_void, points2d: *const c_void, k: *const c_void, rs: *const c_void, ts: *const c_void, points3d: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_sfm_SFMLibmvEuclideanReconstruction_run_const_vectorLStringGR(instance: *mut c_void, images: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_sfm_SFMLibmvEuclideanReconstruction_run_const_vectorLStringGR_const__InputOutputArrayR_const__OutputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *mut c_void, images: *const c_void, k: *const c_void, rs: *const c_void, ts: *const c_void, points3d: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_sfm_SFMLibmvEuclideanReconstruction_getError_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_sfm_SFMLibmvEuclideanReconstruction_getPoints_const__OutputArrayR(instance: *mut c_void, points3d: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_sfm_SFMLibmvEuclideanReconstruction_getPoints_const__OutputArrayR(instance: *mut c_void, points3d: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_sfm_SFMLibmvEuclideanReconstruction_getIntrinsics_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_sfm_SFMLibmvEuclideanReconstruction_getCameras_const__OutputArrayR_const__OutputArrayR(instance: *mut c_void, rs: *const c_void, ts: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_sfm_SFMLibmvEuclideanReconstruction_setReconstructionOptions_const_libmv_ReconstructionOptionsR(instance: *mut c_void, libmv_reconstruction_options: *const crate::sfm::libmv_ReconstructionOptions, ocvrs_return: *mut ResultVoid); - pub fn cv_sfm_SFMLibmvEuclideanReconstruction_setCameraIntrinsicOptions_const_libmv_CameraIntrinsicsOptionsR(instance: *mut c_void, libmv_camera_intrinsics_options: *const crate::sfm::libmv_CameraIntrinsicsOptions, ocvrs_return: *mut ResultVoid); + pub fn cv_sfm_SFMLibmvEuclideanReconstruction_getCameras_const__OutputArrayR_const__OutputArrayR(instance: *mut c_void, rs: *const c_void, ts: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_sfm_SFMLibmvEuclideanReconstruction_setReconstructionOptions_const_libmv_ReconstructionOptionsR(instance: *mut c_void, libmv_reconstruction_options: *const crate::sfm::libmv_ReconstructionOptions, ocvrs_return: *mut Result<()>); + pub fn cv_sfm_SFMLibmvEuclideanReconstruction_setCameraIntrinsicOptions_const_libmv_CameraIntrinsicsOptionsR(instance: *mut c_void, libmv_camera_intrinsics_options: *const crate::sfm::libmv_CameraIntrinsicsOptions, ocvrs_return: *mut Result<()>); pub fn cv_sfm_SFMLibmvEuclideanReconstruction_create_const_libmv_CameraIntrinsicsOptionsR_const_libmv_ReconstructionOptionsR(camera_instrinsic_options: *const crate::sfm::libmv_CameraIntrinsicsOptions, reconstruction_options: *const crate::sfm::libmv_ReconstructionOptions, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_sfm_SFMLibmvEuclideanReconstruction_create(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_sfm_SFMLibmvEuclideanReconstruction_to_BaseSFM(instance: *mut c_void) -> *mut c_void; @@ -13486,10 +13505,8 @@ mod sfm_sys { pub fn cv_PtrLcv_sfm_SFMLibmvEuclideanReconstructionG_to_PtrOfBaseSFM(instance: *mut c_void) -> *mut c_void; } } -#[cfg(ocvrs_has_module_sfm)] pub use sfm_sys::*; -#[cfg(ocvrs_has_module_shape)] mod shape_sys { use super::*; @@ -13510,7 +13527,7 @@ mod shape_sys { pub fn cv_createShapeContextDistanceExtractor_int_int_float_float_int_const_PtrLHistogramCostExtractorGR_const_PtrLShapeTransformerGR(n_angular_bins: i32, n_radial_bins: i32, inner_radius: f32, outer_radius: f32, iterations: i32, comparer: *const c_void, transformer: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_createThinPlateSplineShapeTransformer(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_createThinPlateSplineShapeTransformer_double(regularization_parameter: f64, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_AffineTransformer_setFullAffine_bool(instance: *mut c_void, full_affine: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_AffineTransformer_setFullAffine_bool(instance: *mut c_void, full_affine: bool, ocvrs_return: *mut Result<()>); pub fn cv_AffineTransformer_getFullAffine_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_AffineTransformer_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_AffineTransformer_to_ShapeTransformer(instance: *mut c_void) -> *mut c_void; @@ -13518,7 +13535,7 @@ mod shape_sys { pub fn cv_ChiHistogramCostExtractor_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_ChiHistogramCostExtractor_to_HistogramCostExtractor(instance: *mut c_void) -> *mut c_void; pub fn cv_ChiHistogramCostExtractor_delete(instance: *mut c_void); - pub fn cv_EMDHistogramCostExtractor_setNormFlag_int(instance: *mut c_void, flag: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_EMDHistogramCostExtractor_setNormFlag_int(instance: *mut c_void, flag: i32, ocvrs_return: *mut Result<()>); pub fn cv_EMDHistogramCostExtractor_getNormFlag_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_EMDHistogramCostExtractor_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_EMDHistogramCostExtractor_to_HistogramCostExtractor(instance: *mut c_void) -> *mut c_void; @@ -13526,17 +13543,17 @@ mod shape_sys { pub fn cv_EMDL1HistogramCostExtractor_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_EMDL1HistogramCostExtractor_to_HistogramCostExtractor(instance: *mut c_void) -> *mut c_void; pub fn cv_EMDL1HistogramCostExtractor_delete(instance: *mut c_void); - pub fn cv_HausdorffDistanceExtractor_setDistanceFlag_int(instance: *mut c_void, distance_flag: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_HausdorffDistanceExtractor_setDistanceFlag_int(instance: *mut c_void, distance_flag: i32, ocvrs_return: *mut Result<()>); pub fn cv_HausdorffDistanceExtractor_getDistanceFlag_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_HausdorffDistanceExtractor_setRankProportion_float(instance: *mut c_void, rank_proportion: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_HausdorffDistanceExtractor_setRankProportion_float(instance: *mut c_void, rank_proportion: f32, ocvrs_return: *mut Result<()>); pub fn cv_HausdorffDistanceExtractor_getRankProportion_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_HausdorffDistanceExtractor_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_HausdorffDistanceExtractor_to_ShapeDistanceExtractor(instance: *mut c_void) -> *mut c_void; pub fn cv_HausdorffDistanceExtractor_delete(instance: *mut c_void); - pub fn cv_HistogramCostExtractor_buildCostMatrix_const__InputArrayR_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, descriptors1: *const c_void, descriptors2: *const c_void, cost_matrix: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_HistogramCostExtractor_setNDummies_int(instance: *mut c_void, n_dummies: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_HistogramCostExtractor_buildCostMatrix_const__InputArrayR_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, descriptors1: *const c_void, descriptors2: *const c_void, cost_matrix: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_HistogramCostExtractor_setNDummies_int(instance: *mut c_void, n_dummies: i32, ocvrs_return: *mut Result<()>); pub fn cv_HistogramCostExtractor_getNDummies_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_HistogramCostExtractor_setDefaultCost_float(instance: *mut c_void, default_cost: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_HistogramCostExtractor_setDefaultCost_float(instance: *mut c_void, default_cost: f32, ocvrs_return: *mut Result<()>); pub fn cv_HistogramCostExtractor_getDefaultCost_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_HistogramCostExtractor_to_ChiHistogramCostExtractor(instance: *mut c_void) -> *mut c_void; pub fn cv_HistogramCostExtractor_to_EMDHistogramCostExtractor(instance: *mut c_void) -> *mut c_void; @@ -13544,36 +13561,36 @@ mod shape_sys { pub fn cv_HistogramCostExtractor_to_NormHistogramCostExtractor(instance: *mut c_void) -> *mut c_void; pub fn cv_HistogramCostExtractor_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_HistogramCostExtractor_delete(instance: *mut c_void); - pub fn cv_NormHistogramCostExtractor_setNormFlag_int(instance: *mut c_void, flag: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_NormHistogramCostExtractor_setNormFlag_int(instance: *mut c_void, flag: i32, ocvrs_return: *mut Result<()>); pub fn cv_NormHistogramCostExtractor_getNormFlag_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_NormHistogramCostExtractor_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_NormHistogramCostExtractor_to_HistogramCostExtractor(instance: *mut c_void) -> *mut c_void; pub fn cv_NormHistogramCostExtractor_delete(instance: *mut c_void); - pub fn cv_ShapeContextDistanceExtractor_setAngularBins_int(instance: *mut c_void, n_angular_bins: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_ShapeContextDistanceExtractor_setAngularBins_int(instance: *mut c_void, n_angular_bins: i32, ocvrs_return: *mut Result<()>); pub fn cv_ShapeContextDistanceExtractor_getAngularBins_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ShapeContextDistanceExtractor_setRadialBins_int(instance: *mut c_void, n_radial_bins: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_ShapeContextDistanceExtractor_setRadialBins_int(instance: *mut c_void, n_radial_bins: i32, ocvrs_return: *mut Result<()>); pub fn cv_ShapeContextDistanceExtractor_getRadialBins_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ShapeContextDistanceExtractor_setInnerRadius_float(instance: *mut c_void, inner_radius: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_ShapeContextDistanceExtractor_setInnerRadius_float(instance: *mut c_void, inner_radius: f32, ocvrs_return: *mut Result<()>); pub fn cv_ShapeContextDistanceExtractor_getInnerRadius_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ShapeContextDistanceExtractor_setOuterRadius_float(instance: *mut c_void, outer_radius: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_ShapeContextDistanceExtractor_setOuterRadius_float(instance: *mut c_void, outer_radius: f32, ocvrs_return: *mut Result<()>); pub fn cv_ShapeContextDistanceExtractor_getOuterRadius_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ShapeContextDistanceExtractor_setRotationInvariant_bool(instance: *mut c_void, rotation_invariant: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_ShapeContextDistanceExtractor_setRotationInvariant_bool(instance: *mut c_void, rotation_invariant: bool, ocvrs_return: *mut Result<()>); pub fn cv_ShapeContextDistanceExtractor_getRotationInvariant_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ShapeContextDistanceExtractor_setShapeContextWeight_float(instance: *mut c_void, shape_context_weight: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_ShapeContextDistanceExtractor_setShapeContextWeight_float(instance: *mut c_void, shape_context_weight: f32, ocvrs_return: *mut Result<()>); pub fn cv_ShapeContextDistanceExtractor_getShapeContextWeight_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ShapeContextDistanceExtractor_setImageAppearanceWeight_float(instance: *mut c_void, image_appearance_weight: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_ShapeContextDistanceExtractor_setImageAppearanceWeight_float(instance: *mut c_void, image_appearance_weight: f32, ocvrs_return: *mut Result<()>); pub fn cv_ShapeContextDistanceExtractor_getImageAppearanceWeight_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ShapeContextDistanceExtractor_setBendingEnergyWeight_float(instance: *mut c_void, bending_energy_weight: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_ShapeContextDistanceExtractor_setBendingEnergyWeight_float(instance: *mut c_void, bending_energy_weight: f32, ocvrs_return: *mut Result<()>); pub fn cv_ShapeContextDistanceExtractor_getBendingEnergyWeight_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ShapeContextDistanceExtractor_setImages_const__InputArrayR_const__InputArrayR(instance: *mut c_void, image1: *const c_void, image2: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ShapeContextDistanceExtractor_getImages_const_const__OutputArrayR_const__OutputArrayR(instance: *const c_void, image1: *const c_void, image2: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ShapeContextDistanceExtractor_setIterations_int(instance: *mut c_void, iterations: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_ShapeContextDistanceExtractor_setImages_const__InputArrayR_const__InputArrayR(instance: *mut c_void, image1: *const c_void, image2: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ShapeContextDistanceExtractor_getImages_const_const__OutputArrayR_const__OutputArrayR(instance: *const c_void, image1: *const c_void, image2: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ShapeContextDistanceExtractor_setIterations_int(instance: *mut c_void, iterations: i32, ocvrs_return: *mut Result<()>); pub fn cv_ShapeContextDistanceExtractor_getIterations_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ShapeContextDistanceExtractor_setCostExtractor_PtrLHistogramCostExtractorG(instance: *mut c_void, comparer: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ShapeContextDistanceExtractor_setCostExtractor_PtrLHistogramCostExtractorG(instance: *mut c_void, comparer: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_ShapeContextDistanceExtractor_getCostExtractor_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_ShapeContextDistanceExtractor_setStdDev_float(instance: *mut c_void, sigma: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_ShapeContextDistanceExtractor_setStdDev_float(instance: *mut c_void, sigma: f32, ocvrs_return: *mut Result<()>); pub fn cv_ShapeContextDistanceExtractor_getStdDev_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ShapeContextDistanceExtractor_setTransformAlgorithm_PtrLShapeTransformerG(instance: *mut c_void, transformer: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ShapeContextDistanceExtractor_setTransformAlgorithm_PtrLShapeTransformerG(instance: *mut c_void, transformer: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_ShapeContextDistanceExtractor_getTransformAlgorithm_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ShapeContextDistanceExtractor_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_ShapeContextDistanceExtractor_to_ShapeDistanceExtractor(instance: *mut c_void) -> *mut c_void; @@ -13583,16 +13600,16 @@ mod shape_sys { pub fn cv_ShapeDistanceExtractor_to_ShapeContextDistanceExtractor(instance: *mut c_void) -> *mut c_void; pub fn cv_ShapeDistanceExtractor_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_ShapeDistanceExtractor_delete(instance: *mut c_void); - pub fn cv_ShapeTransformer_estimateTransformation_const__InputArrayR_const__InputArrayR_vectorLDMatchGR(instance: *mut c_void, transforming_shape: *const c_void, target_shape: *const c_void, matches: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ShapeTransformer_estimateTransformation_const__InputArrayR_const__InputArrayR_vectorLDMatchGR(instance: *mut c_void, transforming_shape: *const c_void, target_shape: *const c_void, matches: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_ShapeTransformer_applyTransformation_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, input: *const c_void, output: *const c_void, ocvrs_return: *mut Result); pub fn cv_ShapeTransformer_applyTransformation_const__InputArrayR(instance: *mut c_void, input: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ShapeTransformer_warpImage_const_const__InputArrayR_const__OutputArrayR_int_int_const_ScalarR(instance: *const c_void, transforming_image: *const c_void, output: *const c_void, flags: i32, border_mode: i32, border_value: *const core::Scalar, ocvrs_return: *mut ResultVoid); - pub fn cv_ShapeTransformer_warpImage_const_const__InputArrayR_const__OutputArrayR(instance: *const c_void, transforming_image: *const c_void, output: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ShapeTransformer_warpImage_const_const__InputArrayR_const__OutputArrayR_int_int_const_ScalarR(instance: *const c_void, transforming_image: *const c_void, output: *const c_void, flags: i32, border_mode: i32, border_value: *const core::Scalar, ocvrs_return: *mut Result<()>); + pub fn cv_ShapeTransformer_warpImage_const_const__InputArrayR_const__OutputArrayR(instance: *const c_void, transforming_image: *const c_void, output: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_ShapeTransformer_to_AffineTransformer(instance: *mut c_void) -> *mut c_void; pub fn cv_ShapeTransformer_to_ThinPlateSplineShapeTransformer(instance: *mut c_void) -> *mut c_void; pub fn cv_ShapeTransformer_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_ShapeTransformer_delete(instance: *mut c_void); - pub fn cv_ThinPlateSplineShapeTransformer_setRegularizationParameter_double(instance: *mut c_void, beta: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_ThinPlateSplineShapeTransformer_setRegularizationParameter_double(instance: *mut c_void, beta: f64, ocvrs_return: *mut Result<()>); pub fn cv_ThinPlateSplineShapeTransformer_getRegularizationParameter_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_ThinPlateSplineShapeTransformer_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_ThinPlateSplineShapeTransformer_to_ShapeTransformer(instance: *mut c_void) -> *mut c_void; @@ -13662,42 +13679,38 @@ mod shape_sys { pub fn cv_PtrLcv_ThinPlateSplineShapeTransformerG_to_PtrOfShapeTransformer(instance: *mut c_void) -> *mut c_void; } } -#[cfg(ocvrs_has_module_shape)] pub use shape_sys::*; -#[cfg(ocvrs_has_module_signal)] mod signal_sys { use super::*; extern "C" { - pub fn cv_signal_resampleSignal_const__InputArrayR_const__OutputArrayR_const_int_const_int(input_signal: *const c_void, out_signal: *const c_void, in_freq: i32, out_freq: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_signal_resampleSignal_const__InputArrayR_const__OutputArrayR_const_int_const_int(input_signal: *const c_void, out_signal: *const c_void, in_freq: i32, out_freq: i32, ocvrs_return: *mut Result<()>); } } -#[cfg(ocvrs_has_module_signal)] pub use signal_sys::*; -#[cfg(ocvrs_has_module_stereo)] mod stereo_sys { use super::*; extern "C" { - pub fn cv_stereo_censusTransform_const_MatR_const_MatR_int_MatR_MatR_const_int(image1: *const c_void, image2: *const c_void, kernel_size: i32, dist1: *mut c_void, dist2: *mut c_void, typ: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_stereo_censusTransform_const_MatR_int_MatR_const_int(image1: *const c_void, kernel_size: i32, dist1: *mut c_void, typ: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_stereo_modifiedCensusTransform_const_MatR_const_MatR_int_MatR_MatR_const_int(img1: *const c_void, img2: *const c_void, kernel_size: i32, dist1: *mut c_void, dist2: *mut c_void, typ: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_stereo_modifiedCensusTransform_const_MatR_const_MatR_int_MatR_MatR_const_int_int_const_MatR_const_MatR(img1: *const c_void, img2: *const c_void, kernel_size: i32, dist1: *mut c_void, dist2: *mut c_void, typ: i32, t: i32, integral_image1: *const c_void, integral_image2: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_stereo_modifiedCensusTransform_const_MatR_int_MatR_const_int(img1: *const c_void, kernel_size: i32, dist: *mut c_void, typ: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_stereo_modifiedCensusTransform_const_MatR_int_MatR_const_int_int_const_MatR(img1: *const c_void, kernel_size: i32, dist: *mut c_void, typ: i32, t: i32, integral_image: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_stereo_starCensusTransform_const_MatR_const_MatR_int_MatR_MatR(img1: *const c_void, img2: *const c_void, kernel_size: i32, dist1: *mut c_void, dist2: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_stereo_starCensusTransform_const_MatR_int_MatR(img1: *const c_void, kernel_size: i32, dist: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_stereo_symetricCensusTransform_const_MatR_const_MatR_int_MatR_MatR_const_int(img1: *const c_void, img2: *const c_void, kernel_size: i32, dist1: *mut c_void, dist2: *mut c_void, typ: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_stereo_symetricCensusTransform_const_MatR_int_MatR_const_int(img1: *const c_void, kernel_size: i32, dist1: *mut c_void, typ: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_stereo_censusTransform_const_MatR_const_MatR_int_MatR_MatR_const_int(image1: *const c_void, image2: *const c_void, kernel_size: i32, dist1: *mut c_void, dist2: *mut c_void, typ: i32, ocvrs_return: *mut Result<()>); + pub fn cv_stereo_censusTransform_const_MatR_int_MatR_const_int(image1: *const c_void, kernel_size: i32, dist1: *mut c_void, typ: i32, ocvrs_return: *mut Result<()>); + pub fn cv_stereo_modifiedCensusTransform_const_MatR_const_MatR_int_MatR_MatR_const_int(img1: *const c_void, img2: *const c_void, kernel_size: i32, dist1: *mut c_void, dist2: *mut c_void, typ: i32, ocvrs_return: *mut Result<()>); + pub fn cv_stereo_modifiedCensusTransform_const_MatR_const_MatR_int_MatR_MatR_const_int_int_const_MatR_const_MatR(img1: *const c_void, img2: *const c_void, kernel_size: i32, dist1: *mut c_void, dist2: *mut c_void, typ: i32, t: i32, integral_image1: *const c_void, integral_image2: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_stereo_modifiedCensusTransform_const_MatR_int_MatR_const_int(img1: *const c_void, kernel_size: i32, dist: *mut c_void, typ: i32, ocvrs_return: *mut Result<()>); + pub fn cv_stereo_modifiedCensusTransform_const_MatR_int_MatR_const_int_int_const_MatR(img1: *const c_void, kernel_size: i32, dist: *mut c_void, typ: i32, t: i32, integral_image: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_stereo_starCensusTransform_const_MatR_const_MatR_int_MatR_MatR(img1: *const c_void, img2: *const c_void, kernel_size: i32, dist1: *mut c_void, dist2: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_stereo_starCensusTransform_const_MatR_int_MatR(img1: *const c_void, kernel_size: i32, dist: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_stereo_symetricCensusTransform_const_MatR_const_MatR_int_MatR_MatR_const_int(img1: *const c_void, img2: *const c_void, kernel_size: i32, dist1: *mut c_void, dist2: *mut c_void, typ: i32, ocvrs_return: *mut Result<()>); + pub fn cv_stereo_symetricCensusTransform_const_MatR_int_MatR_const_int(img1: *const c_void, kernel_size: i32, dist1: *mut c_void, typ: i32, ocvrs_return: *mut Result<()>); pub fn cv_stereo_MatchQuasiDense_MatchQuasiDense(ocvrs_return: *mut Result); pub fn cv_stereo_MatchQuasiDense_operatorL_const_const_MatchQuasiDenseR(instance: *const crate::stereo::MatchQuasiDense, rhs: *const crate::stereo::MatchQuasiDense, ocvrs_return: *mut Result); pub fn cv_stereo_QuasiDenseStereo_loadParameters_String(instance: *mut c_void, filepath: *const c_char, ocvrs_return: *mut Result); pub fn cv_stereo_QuasiDenseStereo_saveParameters_String(instance: *mut c_void, filepath: *const c_char, ocvrs_return: *mut Result); - pub fn cv_stereo_QuasiDenseStereo_getSparseMatches_vectorLMatchQuasiDenseGR(instance: *mut c_void, s_matches: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_stereo_QuasiDenseStereo_getDenseMatches_vectorLMatchQuasiDenseGR(instance: *mut c_void, dense_matches: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_stereo_QuasiDenseStereo_process_const_MatR_const_MatR(instance: *mut c_void, img_left: *const c_void, img_right: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_stereo_QuasiDenseStereo_getSparseMatches_vectorLMatchQuasiDenseGR(instance: *mut c_void, s_matches: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_stereo_QuasiDenseStereo_getDenseMatches_vectorLMatchQuasiDenseGR(instance: *mut c_void, dense_matches: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_stereo_QuasiDenseStereo_process_const_MatR_const_MatR(instance: *mut c_void, img_left: *const c_void, img_right: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_stereo_QuasiDenseStereo_getMatch_const_int_const_int(instance: *mut c_void, x: i32, y: i32, ocvrs_return: *mut Result); pub fn cv_stereo_QuasiDenseStereo_getDisparity(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_stereo_QuasiDenseStereo_create_Size_String(mono_img_size: *const core::Size, param_filepath: *const c_char, ocvrs_return: *mut Result<*mut c_void>); @@ -13729,36 +13742,34 @@ mod stereo_sys { pub fn cv_fromSlice_const_const_MatchQuasiDenseX_size_t(data: *const crate::stereo::MatchQuasiDense, len: size_t) -> *mut c_void; } } -#[cfg(ocvrs_has_module_stereo)] pub use stereo_sys::*; -#[cfg(ocvrs_has_module_stitching)] mod stitching_sys { use super::*; extern "C" { pub fn cv_detail_autoDetectWaveCorrectKind_const_vectorLMatGR(rmats: *const c_void, ocvrs_return: *mut Result); - pub fn cv_detail_computeImageFeatures_const_PtrLFeature2DGR_const__InputArrayR_ImageFeaturesR(features_finder: *const c_void, image: *const c_void, features: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_computeImageFeatures_const_PtrLFeature2DGR_const__InputArrayR_ImageFeaturesR_const__InputArrayR(features_finder: *const c_void, image: *const c_void, features: *mut c_void, mask: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_computeImageFeatures_const_PtrLFeature2DGR_const__InputArrayR_vectorLImageFeaturesGR(features_finder: *const c_void, images: *const c_void, features: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_computeImageFeatures_const_PtrLFeature2DGR_const__InputArrayR_vectorLImageFeaturesGR_const__InputArrayR(features_finder: *const c_void, images: *const c_void, features: *mut c_void, masks: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_createLaplacePyrGpu_const__InputArrayR_int_vectorLUMatGR(img: *const c_void, num_levels: i32, pyr: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_createLaplacePyr_const__InputArrayR_int_vectorLUMatGR(img: *const c_void, num_levels: i32, pyr: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_createWeightMap_const__InputArrayR_float_const__InputOutputArrayR(mask: *const c_void, sharpness: f32, weight: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_findMaxSpanningTree_int_const_vectorLMatchesInfoGR_GraphR_vectorLintGR(num_images: i32, pairwise_matches: *const c_void, span_tree: *mut c_void, centers: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_computeImageFeatures_const_PtrLFeature2DGR_const__InputArrayR_ImageFeaturesR(features_finder: *const c_void, image: *const c_void, features: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detail_computeImageFeatures_const_PtrLFeature2DGR_const__InputArrayR_ImageFeaturesR_const__InputArrayR(features_finder: *const c_void, image: *const c_void, features: *mut c_void, mask: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detail_computeImageFeatures_const_PtrLFeature2DGR_const__InputArrayR_vectorLImageFeaturesGR(features_finder: *const c_void, images: *const c_void, features: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detail_computeImageFeatures_const_PtrLFeature2DGR_const__InputArrayR_vectorLImageFeaturesGR_const__InputArrayR(features_finder: *const c_void, images: *const c_void, features: *mut c_void, masks: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detail_createLaplacePyrGpu_const__InputArrayR_int_vectorLUMatGR(img: *const c_void, num_levels: i32, pyr: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detail_createLaplacePyr_const__InputArrayR_int_vectorLUMatGR(img: *const c_void, num_levels: i32, pyr: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detail_createWeightMap_const__InputArrayR_float_const__InputOutputArrayR(mask: *const c_void, sharpness: f32, weight: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detail_findMaxSpanningTree_int_const_vectorLMatchesInfoGR_GraphR_vectorLintGR(num_images: i32, pairwise_matches: *const c_void, span_tree: *mut c_void, centers: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_detail_leaveBiggestComponent_vectorLImageFeaturesGR_vectorLMatchesInfoGR_float(features: *mut c_void, pairwise_matches: *mut c_void, conf_threshold: f32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_detail_matchesGraphAsString_vectorLStringGR_vectorLMatchesInfoGR_float(paths: *mut c_void, pairwise_matches: *mut c_void, conf_threshold: f32, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_detail_normalizeUsingWeightMap_const__InputArrayR_const__InputOutputArrayR(weight: *const c_void, src: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_normalizeUsingWeightMap_const__InputArrayR_const__InputOutputArrayR(weight: *const c_void, src: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_detail_overlapRoi_Point_Point_Size_Size_RectR(tl1: *const core::Point, tl2: *const core::Point, sz1: *const core::Size, sz2: *const core::Size, roi: *mut core::Rect, ocvrs_return: *mut Result); - pub fn cv_detail_restoreImageFromLaplacePyrGpu_vectorLUMatGR(pyr: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_restoreImageFromLaplacePyr_vectorLUMatGR(pyr: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_restoreImageFromLaplacePyrGpu_vectorLUMatGR(pyr: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detail_restoreImageFromLaplacePyr_vectorLUMatGR(pyr: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_detail_resultRoiIntersection_const_vectorLPointGR_const_vectorLSizeGR(corners: *const c_void, sizes: *const c_void, ocvrs_return: *mut Result); pub fn cv_detail_resultRoi_const_vectorLPointGR_const_vectorLSizeGR(corners: *const c_void, sizes: *const c_void, ocvrs_return: *mut Result); pub fn cv_detail_resultRoi_const_vectorLPointGR_const_vectorLUMatGR(corners: *const c_void, images: *const c_void, ocvrs_return: *mut Result); pub fn cv_detail_resultTl_const_vectorLPointGR(corners: *const c_void, ocvrs_return: *mut Result); - pub fn cv_detail_selectRandomSubset_int_int_vectorLintGR(count: i32, size: i32, subset: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_selectRandomSubset_int_int_vectorLintGR(count: i32, size: i32, subset: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_detail_stitchingLogLevel(ocvrs_return: *mut Result); - pub fn cv_detail_waveCorrect_vectorLMatGR_WaveCorrectKind(rmats: *mut c_void, kind: crate::stitching::Detail_WaveCorrectKind, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_waveCorrect_vectorLMatGR_WaveCorrectKind(rmats: *mut c_void, kind: crate::stitching::Detail_WaveCorrectKind, ocvrs_return: *mut Result<()>); pub fn cv_AffineWarper_create_const_float(instance: *const c_void, scale: f32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_AffineWarper_defaultNew_const() -> *mut c_void; pub fn cv_AffineWarper_to_WarperCreator(instance: *mut c_void) -> *mut c_void; @@ -13813,10 +13824,10 @@ mod stitching_sys { pub fn cv_PyRotationWarper_warpPointBackward_const_Point2fR_const__InputArrayR_const__InputArrayR(instance: *mut c_void, pt: *const core::Point2f, k: *const c_void, r: *const c_void, ocvrs_return: *mut Result); pub fn cv_PyRotationWarper_buildMaps_Size_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *mut c_void, src_size: *const core::Size, k: *const c_void, r: *const c_void, xmap: *const c_void, ymap: *const c_void, ocvrs_return: *mut Result); pub fn cv_PyRotationWarper_warp_const__InputArrayR_const__InputArrayR_const__InputArrayR_int_int_const__OutputArrayR(instance: *mut c_void, src: *const c_void, k: *const c_void, r: *const c_void, interp_mode: i32, border_mode: i32, dst: *const c_void, ocvrs_return: *mut Result); - pub fn cv_PyRotationWarper_warpBackward_const__InputArrayR_const__InputArrayR_const__InputArrayR_int_int_Size_const__OutputArrayR(instance: *mut c_void, src: *const c_void, k: *const c_void, r: *const c_void, interp_mode: i32, border_mode: i32, dst_size: *const core::Size, dst: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_PyRotationWarper_warpBackward_const__InputArrayR_const__InputArrayR_const__InputArrayR_int_int_Size_const__OutputArrayR(instance: *mut c_void, src: *const c_void, k: *const c_void, r: *const c_void, interp_mode: i32, border_mode: i32, dst_size: *const core::Size, dst: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_PyRotationWarper_warpRoi_Size_const__InputArrayR_const__InputArrayR(instance: *mut c_void, src_size: *const core::Size, k: *const c_void, r: *const c_void, ocvrs_return: *mut Result); pub fn cv_PyRotationWarper_getScale_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_PyRotationWarper_setScale_float(instance: *mut c_void, unnamed: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_PyRotationWarper_setScale_float(instance: *mut c_void, unnamed: f32, ocvrs_return: *mut Result<()>); pub fn cv_PyRotationWarper_delete(instance: *mut c_void); pub fn cv_SphericalWarper_create_const_float(instance: *const c_void, scale: f32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_SphericalWarper_defaultNew_const() -> *mut c_void; @@ -13833,45 +13844,45 @@ mod stitching_sys { pub fn cv_Stitcher_create_Mode(mode: crate::stitching::Stitcher_Mode, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_Stitcher_create(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_Stitcher_registrationResol_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_Stitcher_setRegistrationResol_double(instance: *mut c_void, resol_mpx: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_Stitcher_setRegistrationResol_double(instance: *mut c_void, resol_mpx: f64, ocvrs_return: *mut Result<()>); pub fn cv_Stitcher_seamEstimationResol_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_Stitcher_setSeamEstimationResol_double(instance: *mut c_void, resol_mpx: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_Stitcher_setSeamEstimationResol_double(instance: *mut c_void, resol_mpx: f64, ocvrs_return: *mut Result<()>); pub fn cv_Stitcher_compositingResol_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_Stitcher_setCompositingResol_double(instance: *mut c_void, resol_mpx: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_Stitcher_setCompositingResol_double(instance: *mut c_void, resol_mpx: f64, ocvrs_return: *mut Result<()>); pub fn cv_Stitcher_panoConfidenceThresh_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_Stitcher_setPanoConfidenceThresh_double(instance: *mut c_void, conf_thresh: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_Stitcher_setPanoConfidenceThresh_double(instance: *mut c_void, conf_thresh: f64, ocvrs_return: *mut Result<()>); pub fn cv_Stitcher_waveCorrection_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_Stitcher_setWaveCorrection_bool(instance: *mut c_void, flag: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_Stitcher_setWaveCorrection_bool(instance: *mut c_void, flag: bool, ocvrs_return: *mut Result<()>); pub fn cv_Stitcher_interpolationFlags_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_Stitcher_setInterpolationFlags_InterpolationFlags(instance: *mut c_void, interp_flags: crate::imgproc::InterpolationFlags, ocvrs_return: *mut ResultVoid); + pub fn cv_Stitcher_setInterpolationFlags_InterpolationFlags(instance: *mut c_void, interp_flags: crate::imgproc::InterpolationFlags, ocvrs_return: *mut Result<()>); pub fn cv_Stitcher_waveCorrectKind_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_Stitcher_setWaveCorrectKind_WaveCorrectKind(instance: *mut c_void, kind: crate::stitching::Detail_WaveCorrectKind, ocvrs_return: *mut ResultVoid); + pub fn cv_Stitcher_setWaveCorrectKind_WaveCorrectKind(instance: *mut c_void, kind: crate::stitching::Detail_WaveCorrectKind, ocvrs_return: *mut Result<()>); pub fn cv_Stitcher_featuresFinder(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_Stitcher_featuresFinder_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_Stitcher_setFeaturesFinder_PtrLFeature2DG(instance: *mut c_void, features_finder: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_Stitcher_setFeaturesFinder_PtrLFeature2DG(instance: *mut c_void, features_finder: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_Stitcher_featuresMatcher(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_Stitcher_featuresMatcher_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_Stitcher_setFeaturesMatcher_PtrLFeaturesMatcherG(instance: *mut c_void, features_matcher: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_Stitcher_setFeaturesMatcher_PtrLFeaturesMatcherG(instance: *mut c_void, features_matcher: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_Stitcher_matchingMask_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_Stitcher_setMatchingMask_const_UMatR(instance: *mut c_void, mask: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_Stitcher_setMatchingMask_const_UMatR(instance: *mut c_void, mask: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_Stitcher_bundleAdjuster(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_Stitcher_bundleAdjuster_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_Stitcher_setBundleAdjuster_PtrLBundleAdjusterBaseG(instance: *mut c_void, bundle_adjuster: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_Stitcher_setBundleAdjuster_PtrLBundleAdjusterBaseG(instance: *mut c_void, bundle_adjuster: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_Stitcher_estimator(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_Stitcher_estimator_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_Stitcher_setEstimator_PtrLEstimatorG(instance: *mut c_void, estimator: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_Stitcher_setEstimator_PtrLEstimatorG(instance: *mut c_void, estimator: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_Stitcher_warper(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_Stitcher_warper_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_Stitcher_setWarper_PtrLWarperCreatorG(instance: *mut c_void, creator: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_Stitcher_setWarper_PtrLWarperCreatorG(instance: *mut c_void, creator: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_Stitcher_exposureCompensator(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_Stitcher_exposureCompensator_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_Stitcher_setExposureCompensator_PtrLExposureCompensatorG(instance: *mut c_void, exposure_comp: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_Stitcher_setExposureCompensator_PtrLExposureCompensatorG(instance: *mut c_void, exposure_comp: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_Stitcher_seamFinder(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_Stitcher_seamFinder_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_Stitcher_setSeamFinder_PtrLSeamFinderG(instance: *mut c_void, seam_finder: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_Stitcher_setSeamFinder_PtrLSeamFinderG(instance: *mut c_void, seam_finder: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_Stitcher_blender(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_Stitcher_blender_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_Stitcher_setBlender_PtrLBlenderG(instance: *mut c_void, b: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_Stitcher_setBlender_PtrLBlenderG(instance: *mut c_void, b: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_Stitcher_estimateTransform_const__InputArrayR_const__InputArrayR(instance: *mut c_void, images: *const c_void, masks: *const c_void, ocvrs_return: *mut Result); pub fn cv_Stitcher_estimateTransform_const__InputArrayR(instance: *mut c_void, images: *const c_void, ocvrs_return: *mut Result); pub fn cv_Stitcher_setTransform_const__InputArrayR_const_vectorLCameraParamsGR_const_vectorLintGR(instance: *mut c_void, images: *const c_void, cameras: *const c_void, component: *const c_void, ocvrs_return: *mut Result); @@ -13927,7 +13938,7 @@ mod stitching_sys { pub fn cv_detail_AffineWarper_delete(instance: *mut c_void); pub fn cv_detail_BestOf2NearestMatcher_BestOf2NearestMatcher_bool_float_int_int_double(try_use_gpu: bool, match_conf: f32, num_matches_thresh1: i32, num_matches_thresh2: i32, matches_confindece_thresh: f64, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_detail_BestOf2NearestMatcher_BestOf2NearestMatcher(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_detail_BestOf2NearestMatcher_collectGarbage(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_BestOf2NearestMatcher_collectGarbage(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_detail_BestOf2NearestMatcher_create_bool_float_int_int_double(try_use_gpu: bool, match_conf: f32, num_matches_thresh1: i32, num_matches_thresh2: i32, matches_confindece_thresh: f64, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_detail_BestOf2NearestMatcher_create(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_detail_BestOf2NearestMatcher_to_Detail_AffineBestOf2NearestMatcher(instance: *mut c_void) -> *mut c_void; @@ -13941,31 +13952,31 @@ mod stitching_sys { pub fn cv_detail_BestOf2NearestRangeMatcher_delete(instance: *mut c_void); pub fn cv_detail_Blender_createDefault_int_bool(typ: i32, try_gpu: bool, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_detail_Blender_createDefault_int(typ: i32, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_detail_Blender_prepare_const_vectorLPointGR_const_vectorLSizeGR(instance: *mut c_void, corners: *const c_void, sizes: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_Blender_prepare_Rect(instance: *mut c_void, dst_roi: *const core::Rect, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_Blender_feed_const__InputArrayR_const__InputArrayR_Point(instance: *mut c_void, img: *const c_void, mask: *const c_void, tl: *const core::Point, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_Blender_blend_const__InputOutputArrayR_const__InputOutputArrayR(instance: *mut c_void, dst: *const c_void, dst_mask: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_Blender_prepare_const_vectorLPointGR_const_vectorLSizeGR(instance: *mut c_void, corners: *const c_void, sizes: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detail_Blender_prepare_Rect(instance: *mut c_void, dst_roi: *const core::Rect, ocvrs_return: *mut Result<()>); + pub fn cv_detail_Blender_feed_const__InputArrayR_const__InputArrayR_Point(instance: *mut c_void, img: *const c_void, mask: *const c_void, tl: *const core::Point, ocvrs_return: *mut Result<()>); + pub fn cv_detail_Blender_blend_const__InputOutputArrayR_const__InputOutputArrayR(instance: *mut c_void, dst: *const c_void, dst_mask: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_detail_Blender_defaultNew_const() -> *mut c_void; pub fn cv_detail_Blender_to_Detail_FeatherBlender(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_Blender_to_Detail_MultiBandBlender(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_Blender_delete(instance: *mut c_void); pub fn cv_detail_BlocksChannelsCompensator_BlocksChannelsCompensator_int_int_int(bl_width: i32, bl_height: i32, nr_feeds: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_detail_BlocksChannelsCompensator_BlocksChannelsCompensator(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_detail_BlocksChannelsCompensator_feed_const_vectorLPointGR_const_vectorLUMatGR_const_vectorLpairLcv_UMat__unsigned_charGGR(instance: *mut c_void, corners: *const c_void, images: *const c_void, masks: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_BlocksChannelsCompensator_feed_const_vectorLPointGR_const_vectorLUMatGR_const_vectorLpairLcv_UMat__unsigned_charGGR(instance: *mut c_void, corners: *const c_void, images: *const c_void, masks: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_detail_BlocksChannelsCompensator_to_Detail_BlocksCompensator(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_BlocksChannelsCompensator_to_Detail_ExposureCompensator(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_BlocksChannelsCompensator_delete(instance: *mut c_void); - pub fn cv_detail_BlocksCompensator_apply_int_Point_const__InputOutputArrayR_const__InputArrayR(instance: *mut c_void, index: i32, corner: *const core::Point, image: *const c_void, mask: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_BlocksCompensator_getMatGains_vectorLMatGR(instance: *mut c_void, umv: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_BlocksCompensator_setMatGains_vectorLMatGR(instance: *mut c_void, umv: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_BlocksCompensator_setNrFeeds_int(instance: *mut c_void, nr_feeds: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_BlocksCompensator_apply_int_Point_const__InputOutputArrayR_const__InputArrayR(instance: *mut c_void, index: i32, corner: *const core::Point, image: *const c_void, mask: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detail_BlocksCompensator_getMatGains_vectorLMatGR(instance: *mut c_void, umv: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detail_BlocksCompensator_setMatGains_vectorLMatGR(instance: *mut c_void, umv: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detail_BlocksCompensator_setNrFeeds_int(instance: *mut c_void, nr_feeds: i32, ocvrs_return: *mut Result<()>); pub fn cv_detail_BlocksCompensator_getNrFeeds(instance: *mut c_void, ocvrs_return: *mut Result); - pub fn cv_detail_BlocksCompensator_setSimilarityThreshold_double(instance: *mut c_void, similarity_threshold: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_BlocksCompensator_setSimilarityThreshold_double(instance: *mut c_void, similarity_threshold: f64, ocvrs_return: *mut Result<()>); pub fn cv_detail_BlocksCompensator_getSimilarityThreshold_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_detail_BlocksCompensator_setBlockSize_int_int(instance: *mut c_void, width: i32, height: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_BlocksCompensator_setBlockSize_Size(instance: *mut c_void, size: *const core::Size, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_BlocksCompensator_setBlockSize_int_int(instance: *mut c_void, width: i32, height: i32, ocvrs_return: *mut Result<()>); + pub fn cv_detail_BlocksCompensator_setBlockSize_Size(instance: *mut c_void, size: *const core::Size, ocvrs_return: *mut Result<()>); pub fn cv_detail_BlocksCompensator_getBlockSize_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_detail_BlocksCompensator_setNrGainsFilteringIterations_int(instance: *mut c_void, nr_iterations: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_BlocksCompensator_setNrGainsFilteringIterations_int(instance: *mut c_void, nr_iterations: i32, ocvrs_return: *mut Result<()>); pub fn cv_detail_BlocksCompensator_getNrGainsFilteringIterations_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_detail_BlocksCompensator_to_Detail_BlocksChannelsCompensator(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_BlocksCompensator_to_Detail_BlocksGainCompensator(instance: *mut c_void) -> *mut c_void; @@ -13974,10 +13985,10 @@ mod stitching_sys { pub fn cv_detail_BlocksGainCompensator_BlocksGainCompensator_int_int(bl_width: i32, bl_height: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_detail_BlocksGainCompensator_BlocksGainCompensator(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_detail_BlocksGainCompensator_BlocksGainCompensator_int_int_int(bl_width: i32, bl_height: i32, nr_feeds: i32, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_detail_BlocksGainCompensator_feed_const_vectorLPointGR_const_vectorLUMatGR_const_vectorLpairLcv_UMat__unsigned_charGGR(instance: *mut c_void, corners: *const c_void, images: *const c_void, masks: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_BlocksGainCompensator_apply_int_Point_const__InputOutputArrayR_const__InputArrayR(instance: *mut c_void, index: i32, corner: *const core::Point, image: *const c_void, mask: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_BlocksGainCompensator_getMatGains_vectorLMatGR(instance: *mut c_void, umv: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_BlocksGainCompensator_setMatGains_vectorLMatGR(instance: *mut c_void, umv: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_BlocksGainCompensator_feed_const_vectorLPointGR_const_vectorLUMatGR_const_vectorLpairLcv_UMat__unsigned_charGGR(instance: *mut c_void, corners: *const c_void, images: *const c_void, masks: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detail_BlocksGainCompensator_apply_int_Point_const__InputOutputArrayR_const__InputArrayR(instance: *mut c_void, index: i32, corner: *const core::Point, image: *const c_void, mask: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detail_BlocksGainCompensator_getMatGains_vectorLMatGR(instance: *mut c_void, umv: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detail_BlocksGainCompensator_setMatGains_vectorLMatGR(instance: *mut c_void, umv: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_detail_BlocksGainCompensator_to_Detail_BlocksCompensator(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_BlocksGainCompensator_to_Detail_ExposureCompensator(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_BlocksGainCompensator_delete(instance: *mut c_void); @@ -13990,11 +14001,11 @@ mod stitching_sys { pub fn cv_detail_BundleAdjusterAffinePartial_to_Detail_Estimator(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_BundleAdjusterAffinePartial_delete(instance: *mut c_void); pub fn cv_detail_BundleAdjusterBase_refinementMask_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_detail_BundleAdjusterBase_setRefinementMask_const_MatR(instance: *mut c_void, mask: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_BundleAdjusterBase_setRefinementMask_const_MatR(instance: *mut c_void, mask: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_detail_BundleAdjusterBase_confThresh_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_detail_BundleAdjusterBase_setConfThresh_double(instance: *mut c_void, conf_thresh: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_BundleAdjusterBase_setConfThresh_double(instance: *mut c_void, conf_thresh: f64, ocvrs_return: *mut Result<()>); pub fn cv_detail_BundleAdjusterBase_termCriteria(instance: *mut c_void, ocvrs_return: *mut Result); - pub fn cv_detail_BundleAdjusterBase_setTermCriteria_const_TermCriteriaR(instance: *mut c_void, term_criteria: *const core::TermCriteria, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_BundleAdjusterBase_setTermCriteria_const_TermCriteriaR(instance: *mut c_void, term_criteria: *const core::TermCriteria, ocvrs_return: *mut Result<()>); pub fn cv_detail_BundleAdjusterBase_to_Detail_BundleAdjusterAffine(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_BundleAdjusterBase_to_Detail_BundleAdjusterAffinePartial(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_BundleAdjusterBase_to_Detail_BundleAdjusterRay(instance: *mut c_void) -> *mut c_void; @@ -14012,7 +14023,7 @@ mod stitching_sys { pub fn cv_detail_BundleAdjusterReproj_delete(instance: *mut c_void); pub fn cv_detail_CameraParams_CameraParams(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_detail_CameraParams_CameraParams_const_CameraParamsR(other: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_detail_CameraParams_operatorST_const_CameraParamsR(instance: *mut c_void, other: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_CameraParams_operatorST_const_CameraParamsR(instance: *mut c_void, other: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_detail_CameraParams_K_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_detail_CameraParams_implicitClone_const(instance: *const c_void) -> *mut c_void; pub fn cv_detail_CameraParams_propFocal_const(instance: *const c_void) -> f64; @@ -14030,19 +14041,19 @@ mod stitching_sys { pub fn cv_detail_CameraParams_delete(instance: *mut c_void); pub fn cv_detail_ChannelsCompensator_ChannelsCompensator_int(nr_feeds: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_detail_ChannelsCompensator_ChannelsCompensator(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_detail_ChannelsCompensator_feed_const_vectorLPointGR_const_vectorLUMatGR_const_vectorLpairLcv_UMat__unsigned_charGGR(instance: *mut c_void, corners: *const c_void, images: *const c_void, masks: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_ChannelsCompensator_apply_int_Point_const__InputOutputArrayR_const__InputArrayR(instance: *mut c_void, index: i32, corner: *const core::Point, image: *const c_void, mask: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_ChannelsCompensator_getMatGains_vectorLMatGR(instance: *mut c_void, umv: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_ChannelsCompensator_setMatGains_vectorLMatGR(instance: *mut c_void, umv: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_ChannelsCompensator_setNrFeeds_int(instance: *mut c_void, nr_feeds: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_ChannelsCompensator_feed_const_vectorLPointGR_const_vectorLUMatGR_const_vectorLpairLcv_UMat__unsigned_charGGR(instance: *mut c_void, corners: *const c_void, images: *const c_void, masks: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detail_ChannelsCompensator_apply_int_Point_const__InputOutputArrayR_const__InputArrayR(instance: *mut c_void, index: i32, corner: *const core::Point, image: *const c_void, mask: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detail_ChannelsCompensator_getMatGains_vectorLMatGR(instance: *mut c_void, umv: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detail_ChannelsCompensator_setMatGains_vectorLMatGR(instance: *mut c_void, umv: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detail_ChannelsCompensator_setNrFeeds_int(instance: *mut c_void, nr_feeds: i32, ocvrs_return: *mut Result<()>); pub fn cv_detail_ChannelsCompensator_getNrFeeds(instance: *mut c_void, ocvrs_return: *mut Result); - pub fn cv_detail_ChannelsCompensator_setSimilarityThreshold_double(instance: *mut c_void, similarity_threshold: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_ChannelsCompensator_setSimilarityThreshold_double(instance: *mut c_void, similarity_threshold: f64, ocvrs_return: *mut Result<()>); pub fn cv_detail_ChannelsCompensator_getSimilarityThreshold_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_detail_ChannelsCompensator_gains_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_detail_ChannelsCompensator_to_Detail_ExposureCompensator(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_ChannelsCompensator_delete(instance: *mut c_void); - pub fn cv_detail_CompressedRectilinearPortraitProjector_mapForward_float_float_floatR_floatR(instance: *mut c_void, x: f32, y: f32, u: *mut f32, v: *mut f32, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_CompressedRectilinearPortraitProjector_mapBackward_float_float_floatR_floatR(instance: *mut c_void, u: f32, v: f32, x: *mut f32, y: *mut f32, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_CompressedRectilinearPortraitProjector_mapForward_float_float_floatR_floatR(instance: *mut c_void, x: f32, y: f32, u: *mut f32, v: *mut f32, ocvrs_return: *mut Result<()>); + pub fn cv_detail_CompressedRectilinearPortraitProjector_mapBackward_float_float_floatR_floatR(instance: *mut c_void, u: f32, v: f32, x: *mut f32, y: *mut f32, ocvrs_return: *mut Result<()>); pub fn cv_detail_CompressedRectilinearPortraitProjector_defaultNew_const() -> *mut c_void; pub fn cv_detail_CompressedRectilinearPortraitProjector_propA_const(instance: *const c_void) -> f32; pub fn cv_detail_CompressedRectilinearPortraitProjector_propA_const_float(instance: *mut c_void, val: f32); @@ -14054,8 +14065,8 @@ mod stitching_sys { pub fn cv_detail_CompressedRectilinearPortraitWarper_CompressedRectilinearPortraitWarper_float(scale: f32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_detail_CompressedRectilinearPortraitWarper_to_Detail_RotationWarper(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_CompressedRectilinearPortraitWarper_delete(instance: *mut c_void); - pub fn cv_detail_CompressedRectilinearProjector_mapForward_float_float_floatR_floatR(instance: *mut c_void, x: f32, y: f32, u: *mut f32, v: *mut f32, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_CompressedRectilinearProjector_mapBackward_float_float_floatR_floatR(instance: *mut c_void, u: f32, v: f32, x: *mut f32, y: *mut f32, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_CompressedRectilinearProjector_mapForward_float_float_floatR_floatR(instance: *mut c_void, x: f32, y: f32, u: *mut f32, v: *mut f32, ocvrs_return: *mut Result<()>); + pub fn cv_detail_CompressedRectilinearProjector_mapBackward_float_float_floatR_floatR(instance: *mut c_void, u: f32, v: f32, x: *mut f32, y: *mut f32, ocvrs_return: *mut Result<()>); pub fn cv_detail_CompressedRectilinearProjector_defaultNew_const() -> *mut c_void; pub fn cv_detail_CompressedRectilinearProjector_propA_const(instance: *const c_void) -> f32; pub fn cv_detail_CompressedRectilinearProjector_propA_const_float(instance: *mut c_void, val: f32); @@ -14067,16 +14078,16 @@ mod stitching_sys { pub fn cv_detail_CompressedRectilinearWarper_CompressedRectilinearWarper_float(scale: f32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_detail_CompressedRectilinearWarper_to_Detail_RotationWarper(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_CompressedRectilinearWarper_delete(instance: *mut c_void); - pub fn cv_detail_CylindricalPortraitProjector_mapForward_float_float_floatR_floatR(instance: *mut c_void, x: f32, y: f32, u: *mut f32, v: *mut f32, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_CylindricalPortraitProjector_mapBackward_float_float_floatR_floatR(instance: *mut c_void, u: f32, v: f32, x: *mut f32, y: *mut f32, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_CylindricalPortraitProjector_mapForward_float_float_floatR_floatR(instance: *mut c_void, x: f32, y: f32, u: *mut f32, v: *mut f32, ocvrs_return: *mut Result<()>); + pub fn cv_detail_CylindricalPortraitProjector_mapBackward_float_float_floatR_floatR(instance: *mut c_void, u: f32, v: f32, x: *mut f32, y: *mut f32, ocvrs_return: *mut Result<()>); pub fn cv_detail_CylindricalPortraitProjector_defaultNew_const() -> *mut c_void; pub fn cv_detail_CylindricalPortraitProjector_to_Detail_ProjectorBase(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_CylindricalPortraitProjector_delete(instance: *mut c_void); pub fn cv_detail_CylindricalPortraitWarper_CylindricalPortraitWarper_float(scale: f32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_detail_CylindricalPortraitWarper_to_Detail_RotationWarper(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_CylindricalPortraitWarper_delete(instance: *mut c_void); - pub fn cv_detail_CylindricalProjector_mapForward_float_float_floatR_floatR(instance: *mut c_void, x: f32, y: f32, u: *mut f32, v: *mut f32, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_CylindricalProjector_mapBackward_float_float_floatR_floatR(instance: *mut c_void, u: f32, v: f32, x: *mut f32, y: *mut f32, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_CylindricalProjector_mapForward_float_float_floatR_floatR(instance: *mut c_void, x: f32, y: f32, u: *mut f32, v: *mut f32, ocvrs_return: *mut Result<()>); + pub fn cv_detail_CylindricalProjector_mapBackward_float_float_floatR_floatR(instance: *mut c_void, u: f32, v: f32, x: *mut f32, y: *mut f32, ocvrs_return: *mut Result<()>); pub fn cv_detail_CylindricalProjector_defaultNew_const() -> *mut c_void; pub fn cv_detail_CylindricalProjector_to_Detail_ProjectorBase(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_CylindricalProjector_delete(instance: *mut c_void); @@ -14096,7 +14107,7 @@ mod stitching_sys { pub fn cv_detail_CylindricalWarperGpu_delete(instance: *mut c_void); pub fn cv_detail_DisjointSets_DisjointSets_int(elem_count: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_detail_DisjointSets_DisjointSets(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_detail_DisjointSets_createOneElemSets_int(instance: *mut c_void, elem_count: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_DisjointSets_createOneElemSets_int(instance: *mut c_void, elem_count: i32, ocvrs_return: *mut Result<()>); pub fn cv_detail_DisjointSets_findSetByElem_int(instance: *mut c_void, elem: i32, ocvrs_return: *mut Result); pub fn cv_detail_DisjointSets_mergeSets_int_int(instance: *mut c_void, set1: i32, set2: i32, ocvrs_return: *mut Result); pub fn cv_detail_DisjointSets_propParent_const(instance: *const c_void) -> *mut c_void; @@ -14108,9 +14119,9 @@ mod stitching_sys { pub fn cv_detail_DpSeamFinder_DpSeamFinder(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_detail_DpSeamFinder_DpSeamFinder_String(cost_func: *const c_char, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_detail_DpSeamFinder_costFunction_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_detail_DpSeamFinder_setCostFunction_CostFunction(instance: *mut c_void, val: crate::stitching::Detail_DpSeamFinder_CostFunction, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_DpSeamFinder_setCostFunction_String(instance: *mut c_void, val: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_DpSeamFinder_find_const_vectorLUMatGR_const_vectorLPointGR_vectorLUMatGR(instance: *mut c_void, src: *const c_void, corners: *const c_void, masks: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_DpSeamFinder_setCostFunction_CostFunction(instance: *mut c_void, val: crate::stitching::Detail_DpSeamFinder_CostFunction, ocvrs_return: *mut Result<()>); + pub fn cv_detail_DpSeamFinder_setCostFunction_String(instance: *mut c_void, val: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_detail_DpSeamFinder_find_const_vectorLUMatGR_const_vectorLPointGR_vectorLUMatGR(instance: *mut c_void, src: *const c_void, corners: *const c_void, masks: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_detail_DpSeamFinder_to_Detail_SeamFinder(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_DpSeamFinder_delete(instance: *mut c_void); pub fn cv_detail_Estimator_operator___const_vectorLImageFeaturesGR_const_vectorLMatchesInfoGR_vectorLCameraParamsGR(instance: *mut c_void, features: *const c_void, pairwise_matches: *const c_void, cameras: *mut c_void, ocvrs_return: *mut Result); @@ -14124,12 +14135,12 @@ mod stitching_sys { pub fn cv_detail_Estimator_to_Detail_NoBundleAdjuster(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_Estimator_delete(instance: *mut c_void); pub fn cv_detail_ExposureCompensator_createDefault_int(typ: i32, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_detail_ExposureCompensator_feed_const_vectorLPointGR_const_vectorLUMatGR_const_vectorLUMatGR(instance: *mut c_void, corners: *const c_void, images: *const c_void, masks: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_ExposureCompensator_feed_const_vectorLPointGR_const_vectorLUMatGR_const_vectorLpairLcv_UMat__unsigned_charGGR(instance: *mut c_void, corners: *const c_void, images: *const c_void, masks: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_ExposureCompensator_apply_int_Point_const__InputOutputArrayR_const__InputArrayR(instance: *mut c_void, index: i32, corner: *const core::Point, image: *const c_void, mask: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_ExposureCompensator_getMatGains_vectorLMatGR(instance: *mut c_void, unnamed: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_ExposureCompensator_setMatGains_vectorLMatGR(instance: *mut c_void, unnamed: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_ExposureCompensator_setUpdateGain_bool(instance: *mut c_void, b: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_ExposureCompensator_feed_const_vectorLPointGR_const_vectorLUMatGR_const_vectorLUMatGR(instance: *mut c_void, corners: *const c_void, images: *const c_void, masks: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detail_ExposureCompensator_feed_const_vectorLPointGR_const_vectorLUMatGR_const_vectorLpairLcv_UMat__unsigned_charGGR(instance: *mut c_void, corners: *const c_void, images: *const c_void, masks: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detail_ExposureCompensator_apply_int_Point_const__InputOutputArrayR_const__InputArrayR(instance: *mut c_void, index: i32, corner: *const core::Point, image: *const c_void, mask: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detail_ExposureCompensator_getMatGains_vectorLMatGR(instance: *mut c_void, unnamed: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detail_ExposureCompensator_setMatGains_vectorLMatGR(instance: *mut c_void, unnamed: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detail_ExposureCompensator_setUpdateGain_bool(instance: *mut c_void, b: bool, ocvrs_return: *mut Result<()>); pub fn cv_detail_ExposureCompensator_getUpdateGain(instance: *mut c_void, ocvrs_return: *mut Result); pub fn cv_detail_ExposureCompensator_to_Detail_BlocksChannelsCompensator(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_ExposureCompensator_to_Detail_BlocksCompensator(instance: *mut c_void) -> *mut c_void; @@ -14141,24 +14152,24 @@ mod stitching_sys { pub fn cv_detail_FeatherBlender_FeatherBlender_float(sharpness: f32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_detail_FeatherBlender_FeatherBlender(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_detail_FeatherBlender_sharpness_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_detail_FeatherBlender_setSharpness_float(instance: *mut c_void, val: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_FeatherBlender_prepare_Rect(instance: *mut c_void, dst_roi: *const core::Rect, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_FeatherBlender_feed_const__InputArrayR_const__InputArrayR_Point(instance: *mut c_void, img: *const c_void, mask: *const c_void, tl: *const core::Point, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_FeatherBlender_blend_const__InputOutputArrayR_const__InputOutputArrayR(instance: *mut c_void, dst: *const c_void, dst_mask: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_FeatherBlender_setSharpness_float(instance: *mut c_void, val: f32, ocvrs_return: *mut Result<()>); + pub fn cv_detail_FeatherBlender_prepare_Rect(instance: *mut c_void, dst_roi: *const core::Rect, ocvrs_return: *mut Result<()>); + pub fn cv_detail_FeatherBlender_feed_const__InputArrayR_const__InputArrayR_Point(instance: *mut c_void, img: *const c_void, mask: *const c_void, tl: *const core::Point, ocvrs_return: *mut Result<()>); + pub fn cv_detail_FeatherBlender_blend_const__InputOutputArrayR_const__InputOutputArrayR(instance: *mut c_void, dst: *const c_void, dst_mask: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_detail_FeatherBlender_createWeightMaps_const_vectorLUMatGR_const_vectorLPointGR_vectorLUMatGR(instance: *mut c_void, masks: *const c_void, corners: *const c_void, weight_maps: *mut c_void, ocvrs_return: *mut Result); pub fn cv_detail_FeatherBlender_to_Detail_Blender(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_FeatherBlender_delete(instance: *mut c_void); - pub fn cv_detail_FeaturesMatcher_operator___const_ImageFeaturesR_const_ImageFeaturesR_MatchesInfoR(instance: *mut c_void, features1: *const c_void, features2: *const c_void, matches_info: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_FeaturesMatcher_operator___const_vectorLImageFeaturesGR_vectorLMatchesInfoGR_const_UMatR(instance: *mut c_void, features: *const c_void, pairwise_matches: *mut c_void, mask: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_FeaturesMatcher_operator___const_vectorLImageFeaturesGR_vectorLMatchesInfoGR(instance: *mut c_void, features: *const c_void, pairwise_matches: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_FeaturesMatcher_operator___const_ImageFeaturesR_const_ImageFeaturesR_MatchesInfoR(instance: *mut c_void, features1: *const c_void, features2: *const c_void, matches_info: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detail_FeaturesMatcher_operator___const_vectorLImageFeaturesGR_vectorLMatchesInfoGR_const_UMatR(instance: *mut c_void, features: *const c_void, pairwise_matches: *mut c_void, mask: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detail_FeaturesMatcher_operator___const_vectorLImageFeaturesGR_vectorLMatchesInfoGR(instance: *mut c_void, features: *const c_void, pairwise_matches: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_detail_FeaturesMatcher_isThreadSafe_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_detail_FeaturesMatcher_collectGarbage(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_FeaturesMatcher_collectGarbage(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_detail_FeaturesMatcher_to_Detail_AffineBestOf2NearestMatcher(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_FeaturesMatcher_to_Detail_BestOf2NearestMatcher(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_FeaturesMatcher_to_Detail_BestOf2NearestRangeMatcher(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_FeaturesMatcher_delete(instance: *mut c_void); - pub fn cv_detail_FisheyeProjector_mapForward_float_float_floatR_floatR(instance: *mut c_void, x: f32, y: f32, u: *mut f32, v: *mut f32, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_FisheyeProjector_mapBackward_float_float_floatR_floatR(instance: *mut c_void, u: f32, v: f32, x: *mut f32, y: *mut f32, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_FisheyeProjector_mapForward_float_float_floatR_floatR(instance: *mut c_void, x: f32, y: f32, u: *mut f32, v: *mut f32, ocvrs_return: *mut Result<()>); + pub fn cv_detail_FisheyeProjector_mapBackward_float_float_floatR_floatR(instance: *mut c_void, u: f32, v: f32, x: *mut f32, y: *mut f32, ocvrs_return: *mut Result<()>); pub fn cv_detail_FisheyeProjector_defaultNew_const() -> *mut c_void; pub fn cv_detail_FisheyeProjector_to_Detail_ProjectorBase(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_FisheyeProjector_delete(instance: *mut c_void); @@ -14167,30 +14178,30 @@ mod stitching_sys { pub fn cv_detail_FisheyeWarper_delete(instance: *mut c_void); pub fn cv_detail_GainCompensator_GainCompensator(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_detail_GainCompensator_GainCompensator_int(nr_feeds: i32, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_detail_GainCompensator_feed_const_vectorLPointGR_const_vectorLUMatGR_const_vectorLpairLcv_UMat__unsigned_charGGR(instance: *mut c_void, corners: *const c_void, images: *const c_void, masks: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_GainCompensator_singleFeed_const_vectorLPointGR_const_vectorLUMatGR_const_vectorLpairLcv_UMat__unsigned_charGGR(instance: *mut c_void, corners: *const c_void, images: *const c_void, masks: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_GainCompensator_apply_int_Point_const__InputOutputArrayR_const__InputArrayR(instance: *mut c_void, index: i32, corner: *const core::Point, image: *const c_void, mask: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_GainCompensator_getMatGains_vectorLMatGR(instance: *mut c_void, umv: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_GainCompensator_setMatGains_vectorLMatGR(instance: *mut c_void, umv: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_GainCompensator_setNrFeeds_int(instance: *mut c_void, nr_feeds: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_GainCompensator_feed_const_vectorLPointGR_const_vectorLUMatGR_const_vectorLpairLcv_UMat__unsigned_charGGR(instance: *mut c_void, corners: *const c_void, images: *const c_void, masks: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detail_GainCompensator_singleFeed_const_vectorLPointGR_const_vectorLUMatGR_const_vectorLpairLcv_UMat__unsigned_charGGR(instance: *mut c_void, corners: *const c_void, images: *const c_void, masks: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detail_GainCompensator_apply_int_Point_const__InputOutputArrayR_const__InputArrayR(instance: *mut c_void, index: i32, corner: *const core::Point, image: *const c_void, mask: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detail_GainCompensator_getMatGains_vectorLMatGR(instance: *mut c_void, umv: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detail_GainCompensator_setMatGains_vectorLMatGR(instance: *mut c_void, umv: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detail_GainCompensator_setNrFeeds_int(instance: *mut c_void, nr_feeds: i32, ocvrs_return: *mut Result<()>); pub fn cv_detail_GainCompensator_getNrFeeds(instance: *mut c_void, ocvrs_return: *mut Result); - pub fn cv_detail_GainCompensator_setSimilarityThreshold_double(instance: *mut c_void, similarity_threshold: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_GainCompensator_setSimilarityThreshold_double(instance: *mut c_void, similarity_threshold: f64, ocvrs_return: *mut Result<()>); pub fn cv_detail_GainCompensator_getSimilarityThreshold_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_detail_GainCompensator_prepareSimilarityMask_const_vectorLPointGR_const_vectorLUMatGR(instance: *mut c_void, corners: *const c_void, images: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_GainCompensator_prepareSimilarityMask_const_vectorLPointGR_const_vectorLUMatGR(instance: *mut c_void, corners: *const c_void, images: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_detail_GainCompensator_gains_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_detail_GainCompensator_to_Detail_ExposureCompensator(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_GainCompensator_delete(instance: *mut c_void); pub fn cv_detail_Graph_Graph_int(num_vertices: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_detail_Graph_Graph(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_detail_Graph_create_int(instance: *mut c_void, num_vertices: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_Graph_create_int(instance: *mut c_void, num_vertices: i32, ocvrs_return: *mut Result<()>); pub fn cv_detail_Graph_numVertices_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_detail_Graph_addEdge_int_int_float(instance: *mut c_void, from: i32, to: i32, weight: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_Graph_addEdge_int_int_float(instance: *mut c_void, from: i32, to: i32, weight: f32, ocvrs_return: *mut Result<()>); pub fn cv_detail_Graph_delete(instance: *mut c_void); pub fn cv_detail_GraphCutSeamFinder_GraphCutSeamFinder_int_float_float(cost_type: i32, terminal_cost: f32, bad_region_penalty: f32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_detail_GraphCutSeamFinder_GraphCutSeamFinder(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_detail_GraphCutSeamFinder_GraphCutSeamFinder_String_float_float(cost_type: *const c_char, terminal_cost: f32, bad_region_penalty: f32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_detail_GraphCutSeamFinder_GraphCutSeamFinder_String(cost_type: *const c_char, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_detail_GraphCutSeamFinder_find_const_vectorLUMatGR_const_vectorLPointGR_vectorLUMatGR(instance: *mut c_void, src: *const c_void, corners: *const c_void, masks: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_GraphCutSeamFinder_find_const_vectorLUMatGR_const_vectorLPointGR_vectorLUMatGR(instance: *mut c_void, src: *const c_void, corners: *const c_void, masks: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_detail_GraphCutSeamFinder_to_Detail_GraphCutSeamFinderBase(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_GraphCutSeamFinder_to_Detail_SeamFinder(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_GraphCutSeamFinder_delete(instance: *mut c_void); @@ -14198,8 +14209,8 @@ mod stitching_sys { pub fn cv_detail_GraphCutSeamFinderBase_delete(instance: *mut c_void); pub fn cv_detail_GraphCutSeamFinderGpu_GraphCutSeamFinderGpu_int_float_float(cost_type: i32, terminal_cost: f32, bad_region_penalty: f32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_detail_GraphCutSeamFinderGpu_GraphCutSeamFinderGpu(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_detail_GraphCutSeamFinderGpu_find_const_vectorLUMatGR_const_vectorLPointGR_vectorLUMatGR(instance: *mut c_void, src: *const c_void, corners: *const c_void, masks: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_GraphCutSeamFinderGpu_findInPair_size_t_size_t_Rect(instance: *mut c_void, first: size_t, second: size_t, roi: *const core::Rect, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_GraphCutSeamFinderGpu_find_const_vectorLUMatGR_const_vectorLPointGR_vectorLUMatGR(instance: *mut c_void, src: *const c_void, corners: *const c_void, masks: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detail_GraphCutSeamFinderGpu_findInPair_size_t_size_t_Rect(instance: *mut c_void, first: size_t, second: size_t, roi: *const core::Rect, ocvrs_return: *mut Result<()>); pub fn cv_detail_GraphCutSeamFinderGpu_to_Detail_GraphCutSeamFinderBase(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_GraphCutSeamFinderGpu_to_Detail_PairwiseSeamFinder(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_GraphCutSeamFinderGpu_to_Detail_SeamFinder(instance: *mut c_void) -> *mut c_void; @@ -14232,7 +14243,7 @@ mod stitching_sys { pub fn cv_detail_ImageFeatures_delete(instance: *mut c_void); pub fn cv_detail_MatchesInfo_MatchesInfo(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_detail_MatchesInfo_MatchesInfo_const_MatchesInfoR(other: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_detail_MatchesInfo_operatorST_const_MatchesInfoR(instance: *mut c_void, other: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_MatchesInfo_operatorST_const_MatchesInfoR(instance: *mut c_void, other: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_detail_MatchesInfo_getMatches(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_detail_MatchesInfo_getInliers(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_detail_MatchesInfo_implicitClone_const(instance: *const c_void) -> *mut c_void; @@ -14251,8 +14262,8 @@ mod stitching_sys { pub fn cv_detail_MatchesInfo_propConfidence_const(instance: *const c_void) -> f64; pub fn cv_detail_MatchesInfo_propConfidence_const_double(instance: *mut c_void, val: f64); pub fn cv_detail_MatchesInfo_delete(instance: *mut c_void); - pub fn cv_detail_MercatorProjector_mapForward_float_float_floatR_floatR(instance: *mut c_void, x: f32, y: f32, u: *mut f32, v: *mut f32, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_MercatorProjector_mapBackward_float_float_floatR_floatR(instance: *mut c_void, u: f32, v: f32, x: *mut f32, y: *mut f32, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_MercatorProjector_mapForward_float_float_floatR_floatR(instance: *mut c_void, x: f32, y: f32, u: *mut f32, v: *mut f32, ocvrs_return: *mut Result<()>); + pub fn cv_detail_MercatorProjector_mapBackward_float_float_floatR_floatR(instance: *mut c_void, u: f32, v: f32, x: *mut f32, y: *mut f32, ocvrs_return: *mut Result<()>); pub fn cv_detail_MercatorProjector_defaultNew_const() -> *mut c_void; pub fn cv_detail_MercatorProjector_to_Detail_ProjectorBase(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_MercatorProjector_delete(instance: *mut c_void); @@ -14262,34 +14273,34 @@ mod stitching_sys { pub fn cv_detail_MultiBandBlender_MultiBandBlender_int_int_int(try_gpu: i32, num_bands: i32, weight_type: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_detail_MultiBandBlender_MultiBandBlender(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_detail_MultiBandBlender_numBands_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_detail_MultiBandBlender_setNumBands_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_MultiBandBlender_prepare_Rect(instance: *mut c_void, dst_roi: *const core::Rect, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_MultiBandBlender_feed_const__InputArrayR_const__InputArrayR_Point(instance: *mut c_void, img: *const c_void, mask: *const c_void, tl: *const core::Point, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_MultiBandBlender_blend_const__InputOutputArrayR_const__InputOutputArrayR(instance: *mut c_void, dst: *const c_void, dst_mask: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_MultiBandBlender_setNumBands_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); + pub fn cv_detail_MultiBandBlender_prepare_Rect(instance: *mut c_void, dst_roi: *const core::Rect, ocvrs_return: *mut Result<()>); + pub fn cv_detail_MultiBandBlender_feed_const__InputArrayR_const__InputArrayR_Point(instance: *mut c_void, img: *const c_void, mask: *const c_void, tl: *const core::Point, ocvrs_return: *mut Result<()>); + pub fn cv_detail_MultiBandBlender_blend_const__InputOutputArrayR_const__InputOutputArrayR(instance: *mut c_void, dst: *const c_void, dst_mask: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_detail_MultiBandBlender_to_Detail_Blender(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_MultiBandBlender_delete(instance: *mut c_void); pub fn cv_detail_NoBundleAdjuster_NoBundleAdjuster(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_detail_NoBundleAdjuster_to_Detail_BundleAdjusterBase(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_NoBundleAdjuster_to_Detail_Estimator(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_NoBundleAdjuster_delete(instance: *mut c_void); - pub fn cv_detail_NoExposureCompensator_feed_const_vectorLPointGR_const_vectorLUMatGR_const_vectorLpairLcv_UMat__unsigned_charGGR(instance: *mut c_void, unnamed: *const c_void, unnamed_1: *const c_void, unnamed_2: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_NoExposureCompensator_apply_int_Point_const__InputOutputArrayR_const__InputArrayR(instance: *mut c_void, unnamed: i32, unnamed_1: *const core::Point, unnamed_2: *const c_void, unnamed_3: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_NoExposureCompensator_getMatGains_vectorLMatGR(instance: *mut c_void, umv: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_NoExposureCompensator_setMatGains_vectorLMatGR(instance: *mut c_void, umv: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_NoExposureCompensator_feed_const_vectorLPointGR_const_vectorLUMatGR_const_vectorLpairLcv_UMat__unsigned_charGGR(instance: *mut c_void, unnamed: *const c_void, unnamed_1: *const c_void, unnamed_2: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detail_NoExposureCompensator_apply_int_Point_const__InputOutputArrayR_const__InputArrayR(instance: *mut c_void, unnamed: i32, unnamed_1: *const core::Point, unnamed_2: *const c_void, unnamed_3: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detail_NoExposureCompensator_getMatGains_vectorLMatGR(instance: *mut c_void, umv: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detail_NoExposureCompensator_setMatGains_vectorLMatGR(instance: *mut c_void, umv: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_detail_NoExposureCompensator_defaultNew_const() -> *mut c_void; pub fn cv_detail_NoExposureCompensator_to_Detail_ExposureCompensator(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_NoExposureCompensator_delete(instance: *mut c_void); - pub fn cv_detail_NoSeamFinder_find_const_vectorLUMatGR_const_vectorLPointGR_vectorLUMatGR(instance: *mut c_void, unnamed: *const c_void, unnamed_1: *const c_void, unnamed_2: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_NoSeamFinder_find_const_vectorLUMatGR_const_vectorLPointGR_vectorLUMatGR(instance: *mut c_void, unnamed: *const c_void, unnamed_1: *const c_void, unnamed_2: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_detail_NoSeamFinder_defaultNew_const() -> *mut c_void; pub fn cv_detail_NoSeamFinder_to_Detail_SeamFinder(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_NoSeamFinder_delete(instance: *mut c_void); - pub fn cv_detail_PairwiseSeamFinder_find_const_vectorLUMatGR_const_vectorLPointGR_vectorLUMatGR(instance: *mut c_void, src: *const c_void, corners: *const c_void, masks: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_PairwiseSeamFinder_find_const_vectorLUMatGR_const_vectorLPointGR_vectorLUMatGR(instance: *mut c_void, src: *const c_void, corners: *const c_void, masks: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_detail_PairwiseSeamFinder_to_Detail_GraphCutSeamFinderGpu(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_PairwiseSeamFinder_to_Detail_VoronoiSeamFinder(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_PairwiseSeamFinder_to_Detail_SeamFinder(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_PairwiseSeamFinder_delete(instance: *mut c_void); - pub fn cv_detail_PaniniPortraitProjector_mapForward_float_float_floatR_floatR(instance: *mut c_void, x: f32, y: f32, u: *mut f32, v: *mut f32, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_PaniniPortraitProjector_mapBackward_float_float_floatR_floatR(instance: *mut c_void, u: f32, v: f32, x: *mut f32, y: *mut f32, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_PaniniPortraitProjector_mapForward_float_float_floatR_floatR(instance: *mut c_void, x: f32, y: f32, u: *mut f32, v: *mut f32, ocvrs_return: *mut Result<()>); + pub fn cv_detail_PaniniPortraitProjector_mapBackward_float_float_floatR_floatR(instance: *mut c_void, u: f32, v: f32, x: *mut f32, y: *mut f32, ocvrs_return: *mut Result<()>); pub fn cv_detail_PaniniPortraitProjector_defaultNew_const() -> *mut c_void; pub fn cv_detail_PaniniPortraitProjector_propA_const(instance: *const c_void) -> f32; pub fn cv_detail_PaniniPortraitProjector_propA_const_float(instance: *mut c_void, val: f32); @@ -14301,8 +14312,8 @@ mod stitching_sys { pub fn cv_detail_PaniniPortraitWarper_PaniniPortraitWarper_float(scale: f32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_detail_PaniniPortraitWarper_to_Detail_RotationWarper(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_PaniniPortraitWarper_delete(instance: *mut c_void); - pub fn cv_detail_PaniniProjector_mapForward_float_float_floatR_floatR(instance: *mut c_void, x: f32, y: f32, u: *mut f32, v: *mut f32, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_PaniniProjector_mapBackward_float_float_floatR_floatR(instance: *mut c_void, u: f32, v: f32, x: *mut f32, y: *mut f32, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_PaniniProjector_mapForward_float_float_floatR_floatR(instance: *mut c_void, x: f32, y: f32, u: *mut f32, v: *mut f32, ocvrs_return: *mut Result<()>); + pub fn cv_detail_PaniniProjector_mapBackward_float_float_floatR_floatR(instance: *mut c_void, u: f32, v: f32, x: *mut f32, y: *mut f32, ocvrs_return: *mut Result<()>); pub fn cv_detail_PaniniProjector_defaultNew_const() -> *mut c_void; pub fn cv_detail_PaniniProjector_propA_const(instance: *const c_void) -> f32; pub fn cv_detail_PaniniProjector_propA_const_float(instance: *mut c_void, val: f32); @@ -14314,16 +14325,16 @@ mod stitching_sys { pub fn cv_detail_PaniniWarper_PaniniWarper_float(scale: f32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_detail_PaniniWarper_to_Detail_RotationWarper(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_PaniniWarper_delete(instance: *mut c_void); - pub fn cv_detail_PlanePortraitProjector_mapForward_float_float_floatR_floatR(instance: *mut c_void, x: f32, y: f32, u: *mut f32, v: *mut f32, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_PlanePortraitProjector_mapBackward_float_float_floatR_floatR(instance: *mut c_void, u: f32, v: f32, x: *mut f32, y: *mut f32, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_PlanePortraitProjector_mapForward_float_float_floatR_floatR(instance: *mut c_void, x: f32, y: f32, u: *mut f32, v: *mut f32, ocvrs_return: *mut Result<()>); + pub fn cv_detail_PlanePortraitProjector_mapBackward_float_float_floatR_floatR(instance: *mut c_void, u: f32, v: f32, x: *mut f32, y: *mut f32, ocvrs_return: *mut Result<()>); pub fn cv_detail_PlanePortraitProjector_defaultNew_const() -> *mut c_void; pub fn cv_detail_PlanePortraitProjector_to_Detail_ProjectorBase(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_PlanePortraitProjector_delete(instance: *mut c_void); pub fn cv_detail_PlanePortraitWarper_PlanePortraitWarper_float(scale: f32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_detail_PlanePortraitWarper_to_Detail_RotationWarper(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_PlanePortraitWarper_delete(instance: *mut c_void); - pub fn cv_detail_PlaneProjector_mapForward_float_float_floatR_floatR(instance: *mut c_void, x: f32, y: f32, u: *mut f32, v: *mut f32, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_PlaneProjector_mapBackward_float_float_floatR_floatR(instance: *mut c_void, u: f32, v: f32, x: *mut f32, y: *mut f32, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_PlaneProjector_mapForward_float_float_floatR_floatR(instance: *mut c_void, x: f32, y: f32, u: *mut f32, v: *mut f32, ocvrs_return: *mut Result<()>); + pub fn cv_detail_PlaneProjector_mapBackward_float_float_floatR_floatR(instance: *mut c_void, u: f32, v: f32, x: *mut f32, y: *mut f32, ocvrs_return: *mut Result<()>); pub fn cv_detail_PlaneProjector_defaultNew_const() -> *mut c_void; pub fn cv_detail_PlaneProjector_to_Detail_ProjectorBase(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_PlaneProjector_delete(instance: *mut c_void); @@ -14356,8 +14367,8 @@ mod stitching_sys { pub fn cv_detail_PlaneWarperGpu_to_Detail_PlaneWarper(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_PlaneWarperGpu_to_Detail_RotationWarper(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_PlaneWarperGpu_delete(instance: *mut c_void); - pub fn cv_detail_ProjectorBase_setCameraParams_const__InputArrayR_const__InputArrayR_const__InputArrayR(instance: *mut c_void, k: *const c_void, r: *const c_void, t: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_ProjectorBase_setCameraParams(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_ProjectorBase_setCameraParams_const__InputArrayR_const__InputArrayR_const__InputArrayR(instance: *mut c_void, k: *const c_void, r: *const c_void, t: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detail_ProjectorBase_setCameraParams(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_detail_ProjectorBase_implicitClone_const(instance: *const c_void) -> *mut c_void; pub fn cv_detail_ProjectorBase_defaultNew_const() -> *mut c_void; pub fn cv_detail_ProjectorBase_propScale_const(instance: *const c_void) -> f32; @@ -14377,12 +14388,12 @@ mod stitching_sys { pub fn cv_detail_RotationWarper_warpPointBackward_const_Point2fR_const__InputArrayR_const__InputArrayR(instance: *mut c_void, pt: *const core::Point2f, k: *const c_void, r: *const c_void, ocvrs_return: *mut Result); pub fn cv_detail_RotationWarper_buildMaps_Size_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *mut c_void, src_size: *const core::Size, k: *const c_void, r: *const c_void, xmap: *const c_void, ymap: *const c_void, ocvrs_return: *mut Result); pub fn cv_detail_RotationWarper_warp_const__InputArrayR_const__InputArrayR_const__InputArrayR_int_int_const__OutputArrayR(instance: *mut c_void, src: *const c_void, k: *const c_void, r: *const c_void, interp_mode: i32, border_mode: i32, dst: *const c_void, ocvrs_return: *mut Result); - pub fn cv_detail_RotationWarper_warpBackward_const__InputArrayR_const__InputArrayR_const__InputArrayR_int_int_Size_const__OutputArrayR(instance: *mut c_void, src: *const c_void, k: *const c_void, r: *const c_void, interp_mode: i32, border_mode: i32, dst_size: *const core::Size, dst: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_RotationWarper_warpBackward_const__InputArrayR_const__InputArrayR_const__InputArrayR_int_int_Size_const__OutputArrayR(instance: *mut c_void, src: *const c_void, k: *const c_void, r: *const c_void, interp_mode: i32, border_mode: i32, dst_size: *const core::Size, dst: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_detail_RotationWarper_warpRoi_Size_const__InputArrayR_const__InputArrayR(instance: *mut c_void, src_size: *const core::Size, k: *const c_void, r: *const c_void, ocvrs_return: *mut Result); pub fn cv_detail_RotationWarper_getScale_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_detail_RotationWarper_setScale_float(instance: *mut c_void, unnamed: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_RotationWarper_setScale_float(instance: *mut c_void, unnamed: f32, ocvrs_return: *mut Result<()>); pub fn cv_detail_RotationWarper_delete(instance: *mut c_void); - pub fn cv_detail_SeamFinder_find_const_vectorLUMatGR_const_vectorLPointGR_vectorLUMatGR(instance: *mut c_void, src: *const c_void, corners: *const c_void, masks: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_SeamFinder_find_const_vectorLUMatGR_const_vectorLPointGR_vectorLUMatGR(instance: *mut c_void, src: *const c_void, corners: *const c_void, masks: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_detail_SeamFinder_createDefault_int(typ: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_detail_SeamFinder_to_Detail_DpSeamFinder(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_SeamFinder_to_Detail_GraphCutSeamFinder(instance: *mut c_void) -> *mut c_void; @@ -14391,16 +14402,16 @@ mod stitching_sys { pub fn cv_detail_SeamFinder_to_Detail_PairwiseSeamFinder(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_SeamFinder_to_Detail_VoronoiSeamFinder(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_SeamFinder_delete(instance: *mut c_void); - pub fn cv_detail_SphericalPortraitProjector_mapForward_float_float_floatR_floatR(instance: *mut c_void, x: f32, y: f32, u: *mut f32, v: *mut f32, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_SphericalPortraitProjector_mapBackward_float_float_floatR_floatR(instance: *mut c_void, u: f32, v: f32, x: *mut f32, y: *mut f32, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_SphericalPortraitProjector_mapForward_float_float_floatR_floatR(instance: *mut c_void, x: f32, y: f32, u: *mut f32, v: *mut f32, ocvrs_return: *mut Result<()>); + pub fn cv_detail_SphericalPortraitProjector_mapBackward_float_float_floatR_floatR(instance: *mut c_void, u: f32, v: f32, x: *mut f32, y: *mut f32, ocvrs_return: *mut Result<()>); pub fn cv_detail_SphericalPortraitProjector_defaultNew_const() -> *mut c_void; pub fn cv_detail_SphericalPortraitProjector_to_Detail_ProjectorBase(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_SphericalPortraitProjector_delete(instance: *mut c_void); pub fn cv_detail_SphericalPortraitWarper_SphericalPortraitWarper_float(scale: f32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_detail_SphericalPortraitWarper_to_Detail_RotationWarper(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_SphericalPortraitWarper_delete(instance: *mut c_void); - pub fn cv_detail_SphericalProjector_mapForward_float_float_floatR_floatR(instance: *mut c_void, x: f32, y: f32, u: *mut f32, v: *mut f32, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_SphericalProjector_mapBackward_float_float_floatR_floatR(instance: *mut c_void, u: f32, v: f32, x: *mut f32, y: *mut f32, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_SphericalProjector_mapForward_float_float_floatR_floatR(instance: *mut c_void, x: f32, y: f32, u: *mut f32, v: *mut f32, ocvrs_return: *mut Result<()>); + pub fn cv_detail_SphericalProjector_mapBackward_float_float_floatR_floatR(instance: *mut c_void, u: f32, v: f32, x: *mut f32, y: *mut f32, ocvrs_return: *mut Result<()>); pub fn cv_detail_SphericalProjector_implicitClone_const(instance: *const c_void) -> *mut c_void; pub fn cv_detail_SphericalProjector_defaultNew_const() -> *mut c_void; pub fn cv_detail_SphericalProjector_to_Detail_ProjectorBase(instance: *mut c_void) -> *mut c_void; @@ -14419,24 +14430,24 @@ mod stitching_sys { pub fn cv_detail_SphericalWarperGpu_to_Detail_RotationWarper(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_SphericalWarperGpu_to_Detail_SphericalWarper(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_SphericalWarperGpu_delete(instance: *mut c_void); - pub fn cv_detail_StereographicProjector_mapForward_float_float_floatR_floatR(instance: *mut c_void, x: f32, y: f32, u: *mut f32, v: *mut f32, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_StereographicProjector_mapBackward_float_float_floatR_floatR(instance: *mut c_void, u: f32, v: f32, x: *mut f32, y: *mut f32, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_StereographicProjector_mapForward_float_float_floatR_floatR(instance: *mut c_void, x: f32, y: f32, u: *mut f32, v: *mut f32, ocvrs_return: *mut Result<()>); + pub fn cv_detail_StereographicProjector_mapBackward_float_float_floatR_floatR(instance: *mut c_void, u: f32, v: f32, x: *mut f32, y: *mut f32, ocvrs_return: *mut Result<()>); pub fn cv_detail_StereographicProjector_defaultNew_const() -> *mut c_void; pub fn cv_detail_StereographicProjector_to_Detail_ProjectorBase(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_StereographicProjector_delete(instance: *mut c_void); pub fn cv_detail_StereographicWarper_StereographicWarper_float(scale: f32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_detail_StereographicWarper_to_Detail_RotationWarper(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_StereographicWarper_delete(instance: *mut c_void); - pub fn cv_detail_TransverseMercatorProjector_mapForward_float_float_floatR_floatR(instance: *mut c_void, x: f32, y: f32, u: *mut f32, v: *mut f32, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_TransverseMercatorProjector_mapBackward_float_float_floatR_floatR(instance: *mut c_void, u: f32, v: f32, x: *mut f32, y: *mut f32, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_TransverseMercatorProjector_mapForward_float_float_floatR_floatR(instance: *mut c_void, x: f32, y: f32, u: *mut f32, v: *mut f32, ocvrs_return: *mut Result<()>); + pub fn cv_detail_TransverseMercatorProjector_mapBackward_float_float_floatR_floatR(instance: *mut c_void, u: f32, v: f32, x: *mut f32, y: *mut f32, ocvrs_return: *mut Result<()>); pub fn cv_detail_TransverseMercatorProjector_defaultNew_const() -> *mut c_void; pub fn cv_detail_TransverseMercatorProjector_to_Detail_ProjectorBase(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_TransverseMercatorProjector_delete(instance: *mut c_void); pub fn cv_detail_TransverseMercatorWarper_TransverseMercatorWarper_float(scale: f32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_detail_TransverseMercatorWarper_to_Detail_RotationWarper(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_TransverseMercatorWarper_delete(instance: *mut c_void); - pub fn cv_detail_VoronoiSeamFinder_find_const_vectorLUMatGR_const_vectorLPointGR_vectorLUMatGR(instance: *mut c_void, src: *const c_void, corners: *const c_void, masks: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_detail_VoronoiSeamFinder_find_const_vectorLSizeGR_const_vectorLPointGR_vectorLUMatGR(instance: *mut c_void, size: *const c_void, corners: *const c_void, masks: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_detail_VoronoiSeamFinder_find_const_vectorLUMatGR_const_vectorLPointGR_vectorLUMatGR(instance: *mut c_void, src: *const c_void, corners: *const c_void, masks: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_detail_VoronoiSeamFinder_find_const_vectorLSizeGR_const_vectorLPointGR_vectorLUMatGR(instance: *mut c_void, size: *const c_void, corners: *const c_void, masks: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_detail_VoronoiSeamFinder_defaultNew_const() -> *mut c_void; pub fn cv_detail_VoronoiSeamFinder_to_Detail_PairwiseSeamFinder(instance: *mut c_void) -> *mut c_void; pub fn cv_detail_VoronoiSeamFinder_to_Detail_SeamFinder(instance: *mut c_void) -> *mut c_void; @@ -14774,10 +14785,8 @@ mod stitching_sys { pub fn std_vectorLcv_detail_MatchesInfoG_set_size_t_const_MatchesInfo(instance: *mut c_void, index: size_t, val: *const c_void); } } -#[cfg(ocvrs_has_module_stitching)] pub use stitching_sys::*; -#[cfg(ocvrs_has_module_structured_light)] mod structured_light_sys { use super::*; @@ -14786,9 +14795,9 @@ mod structured_light_sys { pub fn cv_structured_light_GrayCodePattern_create(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_structured_light_GrayCodePattern_create_int_int(width: i32, height: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_structured_light_GrayCodePattern_getNumberOfPatternImages_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_structured_light_GrayCodePattern_setWhiteThreshold_size_t(instance: *mut c_void, value: size_t, ocvrs_return: *mut ResultVoid); - pub fn cv_structured_light_GrayCodePattern_setBlackThreshold_size_t(instance: *mut c_void, value: size_t, ocvrs_return: *mut ResultVoid); - pub fn cv_structured_light_GrayCodePattern_getImagesForShadowMasks_const_const__InputOutputArrayR_const__InputOutputArrayR(instance: *const c_void, black_image: *const c_void, white_image: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_structured_light_GrayCodePattern_setWhiteThreshold_size_t(instance: *mut c_void, value: size_t, ocvrs_return: *mut Result<()>); + pub fn cv_structured_light_GrayCodePattern_setBlackThreshold_size_t(instance: *mut c_void, value: size_t, ocvrs_return: *mut Result<()>); + pub fn cv_structured_light_GrayCodePattern_getImagesForShadowMasks_const_const__InputOutputArrayR_const__InputOutputArrayR(instance: *const c_void, black_image: *const c_void, white_image: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_structured_light_GrayCodePattern_getProjPixel_const_const__InputArrayR_int_int_PointR(instance: *const c_void, pattern_images: *const c_void, x: i32, y: i32, proj_pix: *mut core::Point, ocvrs_return: *mut Result); pub fn cv_structured_light_GrayCodePattern_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_structured_light_GrayCodePattern_to_StructuredLightPattern(instance: *mut c_void) -> *mut c_void; @@ -14801,12 +14810,12 @@ mod structured_light_sys { pub fn cv_structured_light_GrayCodePattern_Params_delete(instance: *mut c_void); pub fn cv_structured_light_SinusoidalPattern_create_PtrLParamsG(parameters: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_structured_light_SinusoidalPattern_create(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_structured_light_SinusoidalPattern_computePhaseMap_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__InputArrayR(instance: *mut c_void, pattern_images: *const c_void, wrapped_phase_map: *const c_void, shadow_mask: *const c_void, fundamental: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_structured_light_SinusoidalPattern_computePhaseMap_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, pattern_images: *const c_void, wrapped_phase_map: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_structured_light_SinusoidalPattern_unwrapPhaseMap_const__InputArrayR_const__OutputArrayR_Size_const__InputArrayR(instance: *mut c_void, wrapped_phase_map: *const c_void, unwrapped_phase_map: *const c_void, cam_size: *const core::Size, shadow_mask: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_structured_light_SinusoidalPattern_unwrapPhaseMap_const__InputArrayR_const__OutputArrayR_Size(instance: *mut c_void, wrapped_phase_map: *const c_void, unwrapped_phase_map: *const c_void, cam_size: *const core::Size, ocvrs_return: *mut ResultVoid); - pub fn cv_structured_light_SinusoidalPattern_findProCamMatches_const__InputArrayR_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, proj_unwrapped_phase_map: *const c_void, cam_unwrapped_phase_map: *const c_void, matches: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_structured_light_SinusoidalPattern_computeDataModulationTerm_const__InputArrayR_const__OutputArrayR_const__InputArrayR(instance: *mut c_void, pattern_images: *const c_void, data_modulation_term: *const c_void, shadow_mask: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_structured_light_SinusoidalPattern_computePhaseMap_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_const__InputArrayR(instance: *mut c_void, pattern_images: *const c_void, wrapped_phase_map: *const c_void, shadow_mask: *const c_void, fundamental: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_structured_light_SinusoidalPattern_computePhaseMap_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, pattern_images: *const c_void, wrapped_phase_map: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_structured_light_SinusoidalPattern_unwrapPhaseMap_const__InputArrayR_const__OutputArrayR_Size_const__InputArrayR(instance: *mut c_void, wrapped_phase_map: *const c_void, unwrapped_phase_map: *const c_void, cam_size: *const core::Size, shadow_mask: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_structured_light_SinusoidalPattern_unwrapPhaseMap_const__InputArrayR_const__OutputArrayR_Size(instance: *mut c_void, wrapped_phase_map: *const c_void, unwrapped_phase_map: *const c_void, cam_size: *const core::Size, ocvrs_return: *mut Result<()>); + pub fn cv_structured_light_SinusoidalPattern_findProCamMatches_const__InputArrayR_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, proj_unwrapped_phase_map: *const c_void, cam_unwrapped_phase_map: *const c_void, matches: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_structured_light_SinusoidalPattern_computeDataModulationTerm_const__InputArrayR_const__OutputArrayR_const__InputArrayR(instance: *mut c_void, pattern_images: *const c_void, data_modulation_term: *const c_void, shadow_mask: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_structured_light_SinusoidalPattern_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_structured_light_SinusoidalPattern_to_StructuredLightPattern(instance: *mut c_void) -> *mut c_void; pub fn cv_structured_light_SinusoidalPattern_delete(instance: *mut c_void); @@ -14861,10 +14870,8 @@ mod structured_light_sys { pub fn cv_PtrLcv_structured_light_StructuredLightPatternG_to_PtrOfAlgorithm(instance: *mut c_void) -> *mut c_void; } } -#[cfg(ocvrs_has_module_structured_light)] pub use structured_light_sys::*; -#[cfg(ocvrs_has_module_superres)] mod superres_sys { use super::*; @@ -14883,23 +14890,23 @@ mod superres_sys { pub fn cv_superres_createSuperResolution_BTVL1(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_superres_createSuperResolution_BTVL1_CUDA(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_superres_BroxOpticalFlow_getAlpha_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_superres_BroxOpticalFlow_setAlpha_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_superres_BroxOpticalFlow_setAlpha_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_superres_BroxOpticalFlow_getGamma_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_superres_BroxOpticalFlow_setGamma_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_superres_BroxOpticalFlow_setGamma_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_superres_BroxOpticalFlow_getScaleFactor_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_superres_BroxOpticalFlow_setScaleFactor_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_superres_BroxOpticalFlow_setScaleFactor_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_superres_BroxOpticalFlow_getInnerIterations_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_superres_BroxOpticalFlow_setInnerIterations_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_superres_BroxOpticalFlow_setInnerIterations_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_superres_BroxOpticalFlow_getOuterIterations_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_superres_BroxOpticalFlow_setOuterIterations_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_superres_BroxOpticalFlow_setOuterIterations_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_superres_BroxOpticalFlow_getSolverIterations_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_superres_BroxOpticalFlow_setSolverIterations_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_superres_BroxOpticalFlow_setSolverIterations_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_superres_BroxOpticalFlow_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_superres_BroxOpticalFlow_to_SuperRes_DenseOpticalFlowExt(instance: *mut c_void) -> *mut c_void; pub fn cv_superres_BroxOpticalFlow_delete(instance: *mut c_void); - pub fn cv_superres_DenseOpticalFlowExt_calc_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *mut c_void, frame0: *const c_void, frame1: *const c_void, flow1: *const c_void, flow2: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_superres_DenseOpticalFlowExt_calc_const__InputArrayR_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, frame0: *const c_void, frame1: *const c_void, flow1: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_superres_DenseOpticalFlowExt_collectGarbage(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_superres_DenseOpticalFlowExt_calc_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *mut c_void, frame0: *const c_void, frame1: *const c_void, flow1: *const c_void, flow2: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_superres_DenseOpticalFlowExt_calc_const__InputArrayR_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, frame0: *const c_void, frame1: *const c_void, flow1: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_superres_DenseOpticalFlowExt_collectGarbage(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_superres_DenseOpticalFlowExt_to_SuperRes_BroxOpticalFlow(instance: *mut c_void) -> *mut c_void; pub fn cv_superres_DenseOpticalFlowExt_to_SuperRes_DualTVL1OpticalFlow(instance: *mut c_void) -> *mut c_void; pub fn cv_superres_DenseOpticalFlowExt_to_SuperRes_FarnebackOpticalFlow(instance: *mut c_void) -> *mut c_void; @@ -14907,78 +14914,78 @@ mod superres_sys { pub fn cv_superres_DenseOpticalFlowExt_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_superres_DenseOpticalFlowExt_delete(instance: *mut c_void); pub fn cv_superres_DualTVL1OpticalFlow_getTau_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_superres_DualTVL1OpticalFlow_setTau_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_superres_DualTVL1OpticalFlow_setTau_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_superres_DualTVL1OpticalFlow_getLambda_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_superres_DualTVL1OpticalFlow_setLambda_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_superres_DualTVL1OpticalFlow_setLambda_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_superres_DualTVL1OpticalFlow_getTheta_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_superres_DualTVL1OpticalFlow_setTheta_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_superres_DualTVL1OpticalFlow_setTheta_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_superres_DualTVL1OpticalFlow_getScalesNumber_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_superres_DualTVL1OpticalFlow_setScalesNumber_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_superres_DualTVL1OpticalFlow_setScalesNumber_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_superres_DualTVL1OpticalFlow_getWarpingsNumber_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_superres_DualTVL1OpticalFlow_setWarpingsNumber_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_superres_DualTVL1OpticalFlow_setWarpingsNumber_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_superres_DualTVL1OpticalFlow_getEpsilon_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_superres_DualTVL1OpticalFlow_setEpsilon_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_superres_DualTVL1OpticalFlow_setEpsilon_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_superres_DualTVL1OpticalFlow_getIterations_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_superres_DualTVL1OpticalFlow_setIterations_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_superres_DualTVL1OpticalFlow_setIterations_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_superres_DualTVL1OpticalFlow_getUseInitialFlow_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_superres_DualTVL1OpticalFlow_setUseInitialFlow_bool(instance: *mut c_void, val: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_superres_DualTVL1OpticalFlow_setUseInitialFlow_bool(instance: *mut c_void, val: bool, ocvrs_return: *mut Result<()>); pub fn cv_superres_DualTVL1OpticalFlow_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_superres_DualTVL1OpticalFlow_to_SuperRes_DenseOpticalFlowExt(instance: *mut c_void) -> *mut c_void; pub fn cv_superres_DualTVL1OpticalFlow_delete(instance: *mut c_void); pub fn cv_superres_FarnebackOpticalFlow_getPyrScale_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_superres_FarnebackOpticalFlow_setPyrScale_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_superres_FarnebackOpticalFlow_setPyrScale_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_superres_FarnebackOpticalFlow_getLevelsNumber_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_superres_FarnebackOpticalFlow_setLevelsNumber_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_superres_FarnebackOpticalFlow_setLevelsNumber_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_superres_FarnebackOpticalFlow_getWindowSize_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_superres_FarnebackOpticalFlow_setWindowSize_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_superres_FarnebackOpticalFlow_setWindowSize_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_superres_FarnebackOpticalFlow_getIterations_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_superres_FarnebackOpticalFlow_setIterations_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_superres_FarnebackOpticalFlow_setIterations_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_superres_FarnebackOpticalFlow_getPolyN_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_superres_FarnebackOpticalFlow_setPolyN_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_superres_FarnebackOpticalFlow_setPolyN_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_superres_FarnebackOpticalFlow_getPolySigma_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_superres_FarnebackOpticalFlow_setPolySigma_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_superres_FarnebackOpticalFlow_setPolySigma_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_superres_FarnebackOpticalFlow_getFlags_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_superres_FarnebackOpticalFlow_setFlags_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_superres_FarnebackOpticalFlow_setFlags_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_superres_FarnebackOpticalFlow_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_superres_FarnebackOpticalFlow_to_SuperRes_DenseOpticalFlowExt(instance: *mut c_void) -> *mut c_void; pub fn cv_superres_FarnebackOpticalFlow_delete(instance: *mut c_void); - pub fn cv_superres_FrameSource_nextFrame_const__OutputArrayR(instance: *mut c_void, frame: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_superres_FrameSource_reset(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_superres_FrameSource_nextFrame_const__OutputArrayR(instance: *mut c_void, frame: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_superres_FrameSource_reset(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_superres_FrameSource_to_SuperRes_SuperResolution(instance: *mut c_void) -> *mut c_void; pub fn cv_superres_FrameSource_delete(instance: *mut c_void); pub fn cv_superres_PyrLKOpticalFlow_getWindowSize_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_superres_PyrLKOpticalFlow_setWindowSize_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_superres_PyrLKOpticalFlow_setWindowSize_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_superres_PyrLKOpticalFlow_getMaxLevel_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_superres_PyrLKOpticalFlow_setMaxLevel_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_superres_PyrLKOpticalFlow_setMaxLevel_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_superres_PyrLKOpticalFlow_getIterations_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_superres_PyrLKOpticalFlow_setIterations_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_superres_PyrLKOpticalFlow_setIterations_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_superres_PyrLKOpticalFlow_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_superres_PyrLKOpticalFlow_to_SuperRes_DenseOpticalFlowExt(instance: *mut c_void) -> *mut c_void; pub fn cv_superres_PyrLKOpticalFlow_delete(instance: *mut c_void); - pub fn cv_superres_SuperResolution_setInput_const_PtrLFrameSourceGR(instance: *mut c_void, frame_source: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_superres_SuperResolution_nextFrame_const__OutputArrayR(instance: *mut c_void, frame: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_superres_SuperResolution_reset(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_superres_SuperResolution_collectGarbage(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_superres_SuperResolution_setInput_const_PtrLFrameSourceGR(instance: *mut c_void, frame_source: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_superres_SuperResolution_nextFrame_const__OutputArrayR(instance: *mut c_void, frame: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_superres_SuperResolution_reset(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_superres_SuperResolution_collectGarbage(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_superres_SuperResolution_getScale_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_superres_SuperResolution_setScale_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_superres_SuperResolution_setScale_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_superres_SuperResolution_getIterations_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_superres_SuperResolution_setIterations_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_superres_SuperResolution_setIterations_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_superres_SuperResolution_getTau_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_superres_SuperResolution_setTau_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_superres_SuperResolution_setTau_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_superres_SuperResolution_getLambda_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_superres_SuperResolution_setLambda_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_superres_SuperResolution_setLambda_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_superres_SuperResolution_getAlpha_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_superres_SuperResolution_setAlpha_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_superres_SuperResolution_setAlpha_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_superres_SuperResolution_getKernelSize_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_superres_SuperResolution_setKernelSize_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_superres_SuperResolution_setKernelSize_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_superres_SuperResolution_getBlurKernelSize_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_superres_SuperResolution_setBlurKernelSize_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_superres_SuperResolution_setBlurKernelSize_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_superres_SuperResolution_getBlurSigma_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_superres_SuperResolution_setBlurSigma_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_superres_SuperResolution_setBlurSigma_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_superres_SuperResolution_getTemporalAreaRadius_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_superres_SuperResolution_setTemporalAreaRadius_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_superres_SuperResolution_setTemporalAreaRadius_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_superres_SuperResolution_getOpticalFlow_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_superres_SuperResolution_setOpticalFlow_const_PtrLDenseOpticalFlowExtGR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_superres_SuperResolution_setOpticalFlow_const_PtrLDenseOpticalFlowExtGR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_superres_SuperResolution_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_superres_SuperResolution_to_SuperRes_FrameSource(instance: *mut c_void) -> *mut c_void; pub fn cv_superres_SuperResolution_delete(instance: *mut c_void); @@ -15023,10 +15030,8 @@ mod superres_sys { pub fn cv_PtrLcv_superres_SuperResolutionG_to_PtrOfSuperRes_FrameSource(instance: *mut c_void) -> *mut c_void; } } -#[cfg(ocvrs_has_module_superres)] pub use superres_sys::*; -#[cfg(ocvrs_has_module_surface_matching)] mod surface_matching_sys { use super::*; @@ -15040,20 +15045,20 @@ mod surface_matching_sys { pub fn cv_ppf_match_3d_PPF3DDetector_PPF3DDetector(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ppf_match_3d_PPF3DDetector_PPF3DDetector_const_double_const_double_const_double(relative_sampling_step: f64, relative_distance_step: f64, num_angles: f64, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ppf_match_3d_PPF3DDetector_PPF3DDetector_const_double(relative_sampling_step: f64, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_ppf_match_3d_PPF3DDetector_setSearchParams_const_double_const_double_const_bool(instance: *mut c_void, position_threshold: f64, rotation_threshold: f64, use_weighted_clustering: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_ppf_match_3d_PPF3DDetector_setSearchParams(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ppf_match_3d_PPF3DDetector_trainModel_const_MatR(instance: *mut c_void, model: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ppf_match_3d_PPF3DDetector_match_const_MatR_vectorLPose3DPtrGR_const_double_const_double(instance: *mut c_void, scene: *const c_void, results: *mut c_void, relative_scene_sample_step: f64, relative_scene_distance: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_ppf_match_3d_PPF3DDetector_match_const_MatR_vectorLPose3DPtrGR(instance: *mut c_void, scene: *const c_void, results: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ppf_match_3d_PPF3DDetector_setSearchParams_const_double_const_double_const_bool(instance: *mut c_void, position_threshold: f64, rotation_threshold: f64, use_weighted_clustering: bool, ocvrs_return: *mut Result<()>); + pub fn cv_ppf_match_3d_PPF3DDetector_setSearchParams(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ppf_match_3d_PPF3DDetector_trainModel_const_MatR(instance: *mut c_void, model: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ppf_match_3d_PPF3DDetector_match_const_MatR_vectorLPose3DPtrGR_const_double_const_double(instance: *mut c_void, scene: *const c_void, results: *mut c_void, relative_scene_sample_step: f64, relative_scene_distance: f64, ocvrs_return: *mut Result<()>); + pub fn cv_ppf_match_3d_PPF3DDetector_match_const_MatR_vectorLPose3DPtrGR(instance: *mut c_void, scene: *const c_void, results: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_ppf_match_3d_PPF3DDetector_delete(instance: *mut c_void); pub fn cv_ppf_match_3d_Pose3D_Pose3D(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ppf_match_3d_Pose3D_Pose3D_double_size_t_size_t(alpha: f64, model_index: size_t, num_votes: size_t, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ppf_match_3d_Pose3D_Pose3D_double(alpha: f64, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_ppf_match_3d_Pose3D_updatePose_Matx44dR(instance: *mut c_void, new_pose: *mut core::Matx44d, ocvrs_return: *mut ResultVoid); - pub fn cv_ppf_match_3d_Pose3D_updatePose_Matx33dR_Vec3dR(instance: *mut c_void, new_r: *mut core::Matx33d, new_t: *mut core::Vec3d, ocvrs_return: *mut ResultVoid); - pub fn cv_ppf_match_3d_Pose3D_updatePoseQuat_Vec4dR_Vec3dR(instance: *mut c_void, q: *mut core::Vec4d, new_t: *mut core::Vec3d, ocvrs_return: *mut ResultVoid); - pub fn cv_ppf_match_3d_Pose3D_appendPose_Matx44dR(instance: *mut c_void, incremental_pose: *mut core::Matx44d, ocvrs_return: *mut ResultVoid); - pub fn cv_ppf_match_3d_Pose3D_printPose(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ppf_match_3d_Pose3D_updatePose_Matx44dR(instance: *mut c_void, new_pose: *mut core::Matx44d, ocvrs_return: *mut Result<()>); + pub fn cv_ppf_match_3d_Pose3D_updatePose_Matx33dR_Vec3dR(instance: *mut c_void, new_r: *mut core::Matx33d, new_t: *mut core::Vec3d, ocvrs_return: *mut Result<()>); + pub fn cv_ppf_match_3d_Pose3D_updatePoseQuat_Vec4dR_Vec3dR(instance: *mut c_void, q: *mut core::Vec4d, new_t: *mut core::Vec3d, ocvrs_return: *mut Result<()>); + pub fn cv_ppf_match_3d_Pose3D_appendPose_Matx44dR(instance: *mut c_void, incremental_pose: *mut core::Matx44d, ocvrs_return: *mut Result<()>); + pub fn cv_ppf_match_3d_Pose3D_printPose(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_ppf_match_3d_Pose3D_clone(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ppf_match_3d_Pose3D_writePose_const_stringR(instance: *mut c_void, file_name: *const c_char, ocvrs_return: *mut Result); pub fn cv_ppf_match_3d_Pose3D_readPose_const_stringR(instance: *mut c_void, file_name: *const c_char, ocvrs_return: *mut Result); @@ -15077,7 +15082,7 @@ mod surface_matching_sys { pub fn cv_ppf_match_3d_PoseCluster3D_PoseCluster3D(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ppf_match_3d_PoseCluster3D_PoseCluster3D_Pose3DPtr(new_pose: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ppf_match_3d_PoseCluster3D_PoseCluster3D_Pose3DPtr_int(new_pose: *mut c_void, new_id: i32, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_ppf_match_3d_PoseCluster3D_addPose_Pose3DPtr(instance: *mut c_void, new_pose: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ppf_match_3d_PoseCluster3D_addPose_Pose3DPtr(instance: *mut c_void, new_pose: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_ppf_match_3d_PoseCluster3D_writePoseCluster_const_stringR(instance: *mut c_void, file_name: *const c_char, ocvrs_return: *mut Result); pub fn cv_ppf_match_3d_PoseCluster3D_readPoseCluster_const_stringR(instance: *mut c_void, file_name: *const c_char, ocvrs_return: *mut Result); pub fn cv_ppf_match_3d_PoseCluster3D_propPoseList_const(instance: *const c_void) -> *mut c_void; @@ -15113,17 +15118,15 @@ mod surface_matching_sys { pub fn std_vectorLcv_ppf_match_3d_Pose3DPtrG_set_size_t_const_Pose3DPtr(instance: *mut c_void, index: size_t, val: *const c_void); } } -#[cfg(ocvrs_has_module_surface_matching)] pub use surface_matching_sys::*; -#[cfg(ocvrs_has_module_text)] mod text_sys { use super::*; extern "C" { - pub fn cv_text_MSERsToERStats_const__InputArrayR_vectorLvectorLPointGGR_vectorLvectorLERStatGGR(image: *const c_void, contours: *mut c_void, regions: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_text_computeNMChannels_const__InputArrayR_const__OutputArrayR(_src: *const c_void, _channels: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_text_computeNMChannels_const__InputArrayR_const__OutputArrayR_int(_src: *const c_void, _channels: *const c_void, _mode: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_text_MSERsToERStats_const__InputArrayR_vectorLvectorLPointGGR_vectorLvectorLERStatGGR(image: *const c_void, contours: *mut c_void, regions: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_text_computeNMChannels_const__InputArrayR_const__OutputArrayR(_src: *const c_void, _channels: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_text_computeNMChannels_const__InputArrayR_const__OutputArrayR_int(_src: *const c_void, _channels: *const c_void, _mode: i32, ocvrs_return: *mut Result<()>); pub fn cv_text_createERFilterNM1_const_PtrLCallbackGR(cb: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_text_createERFilterNM1_const_PtrLCallbackGR_int_float_float_float_bool_float(cb: *const c_void, threshold_delta: i32, min_area: f32, max_area: f32, min_probability: f32, non_max_suppression: bool, min_probability_diff: f32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_text_createERFilterNM1_const_StringR(filename: *const c_char, ocvrs_return: *mut Result<*mut c_void>); @@ -15133,39 +15136,39 @@ mod text_sys { pub fn cv_text_createERFilterNM2_const_StringR(filename: *const c_char, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_text_createERFilterNM2_const_StringR_float(filename: *const c_char, min_probability: f32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_text_createOCRHMMTransitionsTable_const_StringR_vectorLStringGR(vocabulary: *const c_char, lexicon: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_text_createOCRHMMTransitionsTable_stringR_vectorLstringGR_const__OutputArrayR(vocabulary: *mut *mut c_void, lexicon: *mut c_void, transition_probabilities_table: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_text_detectRegions_const__InputArrayR_const_PtrLERFilterGR_const_PtrLERFilterGR_vectorLRectGR(image: *const c_void, er_filter1: *const c_void, er_filter2: *const c_void, groups_rects: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_text_detectRegions_const__InputArrayR_const_PtrLERFilterGR_const_PtrLERFilterGR_vectorLRectGR_int_const_StringR_float(image: *const c_void, er_filter1: *const c_void, er_filter2: *const c_void, groups_rects: *mut c_void, method: i32, filename: *const c_char, min_probability: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_text_detectRegions_const__InputArrayR_const_PtrLERFilterGR_const_PtrLERFilterGR_vectorLvectorLPointGGR(image: *const c_void, er_filter1: *const c_void, er_filter2: *const c_void, regions: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_text_detectTextSWT_const__InputArrayR_vectorLRectGR_bool(input: *const c_void, result: *mut c_void, dark_on_light: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_text_detectTextSWT_const__InputArrayR_vectorLRectGR_bool_const__OutputArrayR_const__OutputArrayR(input: *const c_void, result: *mut c_void, dark_on_light: bool, draw: *const c_void, chain_b_bs: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_text_erGrouping_const__InputArrayR_const__InputArrayR_vectorLvectorLERStatGGR_vectorLvectorLVec2iGGR_vectorLRectGR(img: *const c_void, channels: *const c_void, regions: *mut c_void, groups: *mut c_void, groups_rects: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_text_erGrouping_const__InputArrayR_const__InputArrayR_vectorLvectorLERStatGGR_vectorLvectorLVec2iGGR_vectorLRectGR_int_const_stringR_float(img: *const c_void, channels: *const c_void, regions: *mut c_void, groups: *mut c_void, groups_rects: *mut c_void, method: i32, filename: *const c_char, min_probablity: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_text_erGrouping_const__InputArrayR_const__InputArrayR_vectorLvectorLPointGG_vectorLRectGR(image: *const c_void, channel: *const c_void, regions: *mut c_void, groups_rects: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_text_erGrouping_const__InputArrayR_const__InputArrayR_vectorLvectorLPointGG_vectorLRectGR_int_const_StringR_float(image: *const c_void, channel: *const c_void, regions: *mut c_void, groups_rects: *mut c_void, method: i32, filename: *const c_char, min_probablity: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_text_createOCRHMMTransitionsTable_stringR_vectorLstringGR_const__OutputArrayR(vocabulary: *mut *mut c_void, lexicon: *mut c_void, transition_probabilities_table: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_text_detectRegions_const__InputArrayR_const_PtrLERFilterGR_const_PtrLERFilterGR_vectorLRectGR(image: *const c_void, er_filter1: *const c_void, er_filter2: *const c_void, groups_rects: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_text_detectRegions_const__InputArrayR_const_PtrLERFilterGR_const_PtrLERFilterGR_vectorLRectGR_int_const_StringR_float(image: *const c_void, er_filter1: *const c_void, er_filter2: *const c_void, groups_rects: *mut c_void, method: i32, filename: *const c_char, min_probability: f32, ocvrs_return: *mut Result<()>); + pub fn cv_text_detectRegions_const__InputArrayR_const_PtrLERFilterGR_const_PtrLERFilterGR_vectorLvectorLPointGGR(image: *const c_void, er_filter1: *const c_void, er_filter2: *const c_void, regions: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_text_detectTextSWT_const__InputArrayR_vectorLRectGR_bool(input: *const c_void, result: *mut c_void, dark_on_light: bool, ocvrs_return: *mut Result<()>); + pub fn cv_text_detectTextSWT_const__InputArrayR_vectorLRectGR_bool_const__OutputArrayR_const__OutputArrayR(input: *const c_void, result: *mut c_void, dark_on_light: bool, draw: *const c_void, chain_b_bs: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_text_erGrouping_const__InputArrayR_const__InputArrayR_vectorLvectorLERStatGGR_vectorLvectorLVec2iGGR_vectorLRectGR(img: *const c_void, channels: *const c_void, regions: *mut c_void, groups: *mut c_void, groups_rects: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_text_erGrouping_const__InputArrayR_const__InputArrayR_vectorLvectorLERStatGGR_vectorLvectorLVec2iGGR_vectorLRectGR_int_const_stringR_float(img: *const c_void, channels: *const c_void, regions: *mut c_void, groups: *mut c_void, groups_rects: *mut c_void, method: i32, filename: *const c_char, min_probablity: f32, ocvrs_return: *mut Result<()>); + pub fn cv_text_erGrouping_const__InputArrayR_const__InputArrayR_vectorLvectorLPointGG_vectorLRectGR(image: *const c_void, channel: *const c_void, regions: *mut c_void, groups_rects: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_text_erGrouping_const__InputArrayR_const__InputArrayR_vectorLvectorLPointGG_vectorLRectGR_int_const_StringR_float(image: *const c_void, channel: *const c_void, regions: *mut c_void, groups_rects: *mut c_void, method: i32, filename: *const c_char, min_probablity: f32, ocvrs_return: *mut Result<()>); pub fn cv_text_loadClassifierNM1_const_StringR(filename: *const c_char, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_text_loadClassifierNM2_const_StringR(filename: *const c_char, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_text_loadOCRBeamSearchClassifierCNN_const_StringR(filename: *const c_char, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_text_loadOCRHMMClassifierCNN_const_StringR(filename: *const c_char, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_text_loadOCRHMMClassifierNM_const_StringR(filename: *const c_char, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_text_loadOCRHMMClassifier_const_StringR_int(filename: *const c_char, classifier: i32, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_text_BaseOCR_run_MatR_stringR_vectorLRectGX_vectorLstringGX_vectorLfloatGX_int(instance: *mut c_void, image: *mut c_void, output_text: *mut *mut c_void, component_rects: *mut c_void, component_texts: *mut c_void, component_confidences: *mut c_void, component_level: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_text_BaseOCR_run_MatR_stringR(instance: *mut c_void, image: *mut c_void, output_text: *mut *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_text_BaseOCR_run_MatR_MatR_stringR_vectorLRectGX_vectorLstringGX_vectorLfloatGX_int(instance: *mut c_void, image: *mut c_void, mask: *mut c_void, output_text: *mut *mut c_void, component_rects: *mut c_void, component_texts: *mut c_void, component_confidences: *mut c_void, component_level: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_text_BaseOCR_run_MatR_MatR_stringR(instance: *mut c_void, image: *mut c_void, mask: *mut c_void, output_text: *mut *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_text_BaseOCR_run_MatR_stringR_vectorLRectGX_vectorLstringGX_vectorLfloatGX_int(instance: *mut c_void, image: *mut c_void, output_text: *mut *mut c_void, component_rects: *mut c_void, component_texts: *mut c_void, component_confidences: *mut c_void, component_level: i32, ocvrs_return: *mut Result<()>); + pub fn cv_text_BaseOCR_run_MatR_stringR(instance: *mut c_void, image: *mut c_void, output_text: *mut *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_text_BaseOCR_run_MatR_MatR_stringR_vectorLRectGX_vectorLstringGX_vectorLfloatGX_int(instance: *mut c_void, image: *mut c_void, mask: *mut c_void, output_text: *mut *mut c_void, component_rects: *mut c_void, component_texts: *mut c_void, component_confidences: *mut c_void, component_level: i32, ocvrs_return: *mut Result<()>); + pub fn cv_text_BaseOCR_run_MatR_MatR_stringR(instance: *mut c_void, image: *mut c_void, mask: *mut c_void, output_text: *mut *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_text_BaseOCR_to_OCRBeamSearchDecoder(instance: *mut c_void) -> *mut c_void; pub fn cv_text_BaseOCR_to_OCRHMMDecoder(instance: *mut c_void) -> *mut c_void; pub fn cv_text_BaseOCR_to_OCRHolisticWordRecognizer(instance: *mut c_void) -> *mut c_void; pub fn cv_text_BaseOCR_to_OCRTesseract(instance: *mut c_void) -> *mut c_void; pub fn cv_text_BaseOCR_delete(instance: *mut c_void); - pub fn cv_text_ERFilter_run_const__InputArrayR_vectorLERStatGR(instance: *mut c_void, image: *const c_void, regions: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_text_ERFilter_setCallback_const_PtrLCallbackGR(instance: *mut c_void, cb: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_text_ERFilter_setThresholdDelta_int(instance: *mut c_void, threshold_delta: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_text_ERFilter_setMinArea_float(instance: *mut c_void, min_area: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_text_ERFilter_setMaxArea_float(instance: *mut c_void, max_area: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_text_ERFilter_setMinProbability_float(instance: *mut c_void, min_probability: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_text_ERFilter_setMinProbabilityDiff_float(instance: *mut c_void, min_probability_diff: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_text_ERFilter_setNonMaxSuppression_bool(instance: *mut c_void, non_max_suppression: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_text_ERFilter_run_const__InputArrayR_vectorLERStatGR(instance: *mut c_void, image: *const c_void, regions: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_text_ERFilter_setCallback_const_PtrLCallbackGR(instance: *mut c_void, cb: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_text_ERFilter_setThresholdDelta_int(instance: *mut c_void, threshold_delta: i32, ocvrs_return: *mut Result<()>); + pub fn cv_text_ERFilter_setMinArea_float(instance: *mut c_void, min_area: f32, ocvrs_return: *mut Result<()>); + pub fn cv_text_ERFilter_setMaxArea_float(instance: *mut c_void, max_area: f32, ocvrs_return: *mut Result<()>); + pub fn cv_text_ERFilter_setMinProbability_float(instance: *mut c_void, min_probability: f32, ocvrs_return: *mut Result<()>); + pub fn cv_text_ERFilter_setMinProbabilityDiff_float(instance: *mut c_void, min_probability_diff: f32, ocvrs_return: *mut Result<()>); + pub fn cv_text_ERFilter_setNonMaxSuppression_bool(instance: *mut c_void, non_max_suppression: bool, ocvrs_return: *mut Result<()>); pub fn cv_text_ERFilter_getNumRejected_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_text_ERFilter_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_text_ERFilter_delete(instance: *mut c_void); @@ -15214,10 +15217,10 @@ mod text_sys { pub fn cv_text_ERStat_propMin_probability_ancestor(instance: *mut c_void) -> *mut c_void; pub fn cv_text_ERStat_propMin_probability_ancestor_ERStatX(instance: *mut c_void, val: *const c_void); pub fn cv_text_ERStat_delete(instance: *mut c_void); - pub fn cv_text_OCRBeamSearchDecoder_run_MatR_stringR_vectorLRectGX_vectorLstringGX_vectorLfloatGX_int(instance: *mut c_void, image: *mut c_void, output_text: *mut *mut c_void, component_rects: *mut c_void, component_texts: *mut c_void, component_confidences: *mut c_void, component_level: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_text_OCRBeamSearchDecoder_run_MatR_stringR(instance: *mut c_void, image: *mut c_void, output_text: *mut *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_text_OCRBeamSearchDecoder_run_MatR_MatR_stringR_vectorLRectGX_vectorLstringGX_vectorLfloatGX_int(instance: *mut c_void, image: *mut c_void, mask: *mut c_void, output_text: *mut *mut c_void, component_rects: *mut c_void, component_texts: *mut c_void, component_confidences: *mut c_void, component_level: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_text_OCRBeamSearchDecoder_run_MatR_MatR_stringR(instance: *mut c_void, image: *mut c_void, mask: *mut c_void, output_text: *mut *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_text_OCRBeamSearchDecoder_run_MatR_stringR_vectorLRectGX_vectorLstringGX_vectorLfloatGX_int(instance: *mut c_void, image: *mut c_void, output_text: *mut *mut c_void, component_rects: *mut c_void, component_texts: *mut c_void, component_confidences: *mut c_void, component_level: i32, ocvrs_return: *mut Result<()>); + pub fn cv_text_OCRBeamSearchDecoder_run_MatR_stringR(instance: *mut c_void, image: *mut c_void, output_text: *mut *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_text_OCRBeamSearchDecoder_run_MatR_MatR_stringR_vectorLRectGX_vectorLstringGX_vectorLfloatGX_int(instance: *mut c_void, image: *mut c_void, mask: *mut c_void, output_text: *mut *mut c_void, component_rects: *mut c_void, component_texts: *mut c_void, component_confidences: *mut c_void, component_level: i32, ocvrs_return: *mut Result<()>); + pub fn cv_text_OCRBeamSearchDecoder_run_MatR_MatR_stringR(instance: *mut c_void, image: *mut c_void, mask: *mut c_void, output_text: *mut *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_text_OCRBeamSearchDecoder_run_const__InputArrayR_int_int(instance: *mut c_void, image: *const c_void, min_confidence: i32, component_level: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_text_OCRBeamSearchDecoder_run_const__InputArrayR_int(instance: *mut c_void, image: *const c_void, min_confidence: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_text_OCRBeamSearchDecoder_run_const__InputArrayR_const__InputArrayR_int_int(instance: *mut c_void, image: *const c_void, mask: *const c_void, min_confidence: i32, component_level: i32, ocvrs_return: *mut Result<*mut c_void>); @@ -15228,15 +15231,15 @@ mod text_sys { pub fn cv_text_OCRBeamSearchDecoder_defaultNew_const() -> *mut c_void; pub fn cv_text_OCRBeamSearchDecoder_to_BaseOCR(instance: *mut c_void) -> *mut c_void; pub fn cv_text_OCRBeamSearchDecoder_delete(instance: *mut c_void); - pub fn cv_text_OCRBeamSearchDecoder_ClassifierCallback_eval_const__InputArrayR_vectorLvectorLdoubleGGR_vectorLintGR(instance: *mut c_void, image: *const c_void, recognition_probabilities: *mut c_void, oversegmentation: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_text_OCRBeamSearchDecoder_ClassifierCallback_eval_const__InputArrayR_vectorLvectorLdoubleGGR_vectorLintGR(instance: *mut c_void, image: *const c_void, recognition_probabilities: *mut c_void, oversegmentation: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_text_OCRBeamSearchDecoder_ClassifierCallback_getWindowSize(instance: *mut c_void, ocvrs_return: *mut Result); pub fn cv_text_OCRBeamSearchDecoder_ClassifierCallback_getStepSize(instance: *mut c_void, ocvrs_return: *mut Result); pub fn cv_text_OCRBeamSearchDecoder_ClassifierCallback_defaultNew_const() -> *mut c_void; pub fn cv_text_OCRBeamSearchDecoder_ClassifierCallback_delete(instance: *mut c_void); - pub fn cv_text_OCRHMMDecoder_run_MatR_stringR_vectorLRectGX_vectorLstringGX_vectorLfloatGX_int(instance: *mut c_void, image: *mut c_void, output_text: *mut *mut c_void, component_rects: *mut c_void, component_texts: *mut c_void, component_confidences: *mut c_void, component_level: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_text_OCRHMMDecoder_run_MatR_stringR(instance: *mut c_void, image: *mut c_void, output_text: *mut *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_text_OCRHMMDecoder_run_MatR_MatR_stringR_vectorLRectGX_vectorLstringGX_vectorLfloatGX_int(instance: *mut c_void, image: *mut c_void, mask: *mut c_void, output_text: *mut *mut c_void, component_rects: *mut c_void, component_texts: *mut c_void, component_confidences: *mut c_void, component_level: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_text_OCRHMMDecoder_run_MatR_MatR_stringR(instance: *mut c_void, image: *mut c_void, mask: *mut c_void, output_text: *mut *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_text_OCRHMMDecoder_run_MatR_stringR_vectorLRectGX_vectorLstringGX_vectorLfloatGX_int(instance: *mut c_void, image: *mut c_void, output_text: *mut *mut c_void, component_rects: *mut c_void, component_texts: *mut c_void, component_confidences: *mut c_void, component_level: i32, ocvrs_return: *mut Result<()>); + pub fn cv_text_OCRHMMDecoder_run_MatR_stringR(instance: *mut c_void, image: *mut c_void, output_text: *mut *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_text_OCRHMMDecoder_run_MatR_MatR_stringR_vectorLRectGX_vectorLstringGX_vectorLfloatGX_int(instance: *mut c_void, image: *mut c_void, mask: *mut c_void, output_text: *mut *mut c_void, component_rects: *mut c_void, component_texts: *mut c_void, component_confidences: *mut c_void, component_level: i32, ocvrs_return: *mut Result<()>); + pub fn cv_text_OCRHMMDecoder_run_MatR_MatR_stringR(instance: *mut c_void, image: *mut c_void, mask: *mut c_void, output_text: *mut *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_text_OCRHMMDecoder_run_const__InputArrayR_int_int(instance: *mut c_void, image: *const c_void, min_confidence: i32, component_level: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_text_OCRHMMDecoder_run_const__InputArrayR_int(instance: *mut c_void, image: *const c_void, min_confidence: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_text_OCRHMMDecoder_run_const__InputArrayR_const__InputArrayR_int_int(instance: *mut c_void, image: *const c_void, mask: *const c_void, min_confidence: i32, component_level: i32, ocvrs_return: *mut Result<*mut c_void>); @@ -15248,33 +15251,33 @@ mod text_sys { pub fn cv_text_OCRHMMDecoder_defaultNew_const() -> *mut c_void; pub fn cv_text_OCRHMMDecoder_to_BaseOCR(instance: *mut c_void) -> *mut c_void; pub fn cv_text_OCRHMMDecoder_delete(instance: *mut c_void); - pub fn cv_text_OCRHMMDecoder_ClassifierCallback_eval_const__InputArrayR_vectorLintGR_vectorLdoubleGR(instance: *mut c_void, image: *const c_void, out_class: *mut c_void, out_confidence: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_text_OCRHMMDecoder_ClassifierCallback_eval_const__InputArrayR_vectorLintGR_vectorLdoubleGR(instance: *mut c_void, image: *const c_void, out_class: *mut c_void, out_confidence: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_text_OCRHMMDecoder_ClassifierCallback_defaultNew_const() -> *mut c_void; pub fn cv_text_OCRHMMDecoder_ClassifierCallback_delete(instance: *mut c_void); - pub fn cv_text_OCRHolisticWordRecognizer_run_MatR_stringR_vectorLRectGX_vectorLstringGX_vectorLfloatGX_int(instance: *mut c_void, image: *mut c_void, output_text: *mut *mut c_void, component_rects: *mut c_void, component_texts: *mut c_void, component_confidences: *mut c_void, component_level: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_text_OCRHolisticWordRecognizer_run_MatR_stringR(instance: *mut c_void, image: *mut c_void, output_text: *mut *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_text_OCRHolisticWordRecognizer_run_MatR_MatR_stringR_vectorLRectGX_vectorLstringGX_vectorLfloatGX_int(instance: *mut c_void, image: *mut c_void, mask: *mut c_void, output_text: *mut *mut c_void, component_rects: *mut c_void, component_texts: *mut c_void, component_confidences: *mut c_void, component_level: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_text_OCRHolisticWordRecognizer_run_MatR_MatR_stringR(instance: *mut c_void, image: *mut c_void, mask: *mut c_void, output_text: *mut *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_text_OCRHolisticWordRecognizer_run_MatR_stringR_vectorLRectGX_vectorLstringGX_vectorLfloatGX_int(instance: *mut c_void, image: *mut c_void, output_text: *mut *mut c_void, component_rects: *mut c_void, component_texts: *mut c_void, component_confidences: *mut c_void, component_level: i32, ocvrs_return: *mut Result<()>); + pub fn cv_text_OCRHolisticWordRecognizer_run_MatR_stringR(instance: *mut c_void, image: *mut c_void, output_text: *mut *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_text_OCRHolisticWordRecognizer_run_MatR_MatR_stringR_vectorLRectGX_vectorLstringGX_vectorLfloatGX_int(instance: *mut c_void, image: *mut c_void, mask: *mut c_void, output_text: *mut *mut c_void, component_rects: *mut c_void, component_texts: *mut c_void, component_confidences: *mut c_void, component_level: i32, ocvrs_return: *mut Result<()>); + pub fn cv_text_OCRHolisticWordRecognizer_run_MatR_MatR_stringR(instance: *mut c_void, image: *mut c_void, mask: *mut c_void, output_text: *mut *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_text_OCRHolisticWordRecognizer_create_const_stringR_const_stringR_const_stringR(arch_filename: *const c_char, weights_filename: *const c_char, words_filename: *const c_char, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_text_OCRHolisticWordRecognizer_to_BaseOCR(instance: *mut c_void) -> *mut c_void; pub fn cv_text_OCRHolisticWordRecognizer_delete(instance: *mut c_void); - pub fn cv_text_OCRTesseract_run_MatR_stringR_vectorLRectGX_vectorLstringGX_vectorLfloatGX_int(instance: *mut c_void, image: *mut c_void, output_text: *mut *mut c_void, component_rects: *mut c_void, component_texts: *mut c_void, component_confidences: *mut c_void, component_level: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_text_OCRTesseract_run_MatR_stringR(instance: *mut c_void, image: *mut c_void, output_text: *mut *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_text_OCRTesseract_run_MatR_MatR_stringR_vectorLRectGX_vectorLstringGX_vectorLfloatGX_int(instance: *mut c_void, image: *mut c_void, mask: *mut c_void, output_text: *mut *mut c_void, component_rects: *mut c_void, component_texts: *mut c_void, component_confidences: *mut c_void, component_level: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_text_OCRTesseract_run_MatR_MatR_stringR(instance: *mut c_void, image: *mut c_void, mask: *mut c_void, output_text: *mut *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_text_OCRTesseract_run_MatR_stringR_vectorLRectGX_vectorLstringGX_vectorLfloatGX_int(instance: *mut c_void, image: *mut c_void, output_text: *mut *mut c_void, component_rects: *mut c_void, component_texts: *mut c_void, component_confidences: *mut c_void, component_level: i32, ocvrs_return: *mut Result<()>); + pub fn cv_text_OCRTesseract_run_MatR_stringR(instance: *mut c_void, image: *mut c_void, output_text: *mut *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_text_OCRTesseract_run_MatR_MatR_stringR_vectorLRectGX_vectorLstringGX_vectorLfloatGX_int(instance: *mut c_void, image: *mut c_void, mask: *mut c_void, output_text: *mut *mut c_void, component_rects: *mut c_void, component_texts: *mut c_void, component_confidences: *mut c_void, component_level: i32, ocvrs_return: *mut Result<()>); + pub fn cv_text_OCRTesseract_run_MatR_MatR_stringR(instance: *mut c_void, image: *mut c_void, mask: *mut c_void, output_text: *mut *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_text_OCRTesseract_run_const__InputArrayR_int_int(instance: *mut c_void, image: *const c_void, min_confidence: i32, component_level: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_text_OCRTesseract_run_const__InputArrayR_int(instance: *mut c_void, image: *const c_void, min_confidence: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_text_OCRTesseract_run_const__InputArrayR_const__InputArrayR_int_int(instance: *mut c_void, image: *const c_void, mask: *const c_void, min_confidence: i32, component_level: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_text_OCRTesseract_run_const__InputArrayR_const__InputArrayR_int(instance: *mut c_void, image: *const c_void, mask: *const c_void, min_confidence: i32, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_text_OCRTesseract_setWhiteList_const_StringR(instance: *mut c_void, char_whitelist: *const c_char, ocvrs_return: *mut ResultVoid); + pub fn cv_text_OCRTesseract_setWhiteList_const_StringR(instance: *mut c_void, char_whitelist: *const c_char, ocvrs_return: *mut Result<()>); pub fn cv_text_OCRTesseract_create_const_charX_const_charX_const_charX_int_int(datapath: *const c_char, language: *const c_char, char_whitelist: *const c_char, oem: i32, psmode: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_text_OCRTesseract_create(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_text_OCRTesseract_to_BaseOCR(instance: *mut c_void) -> *mut c_void; pub fn cv_text_OCRTesseract_delete(instance: *mut c_void); - pub fn cv_text_TextDetector_detect_const__InputArrayR_vectorLRectGR_vectorLfloatGR(instance: *mut c_void, input_image: *const c_void, bbox: *mut c_void, confidence: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_text_TextDetector_detect_const__InputArrayR_vectorLRectGR_vectorLfloatGR(instance: *mut c_void, input_image: *const c_void, bbox: *mut c_void, confidence: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_text_TextDetector_to_TextDetectorCNN(instance: *mut c_void) -> *mut c_void; pub fn cv_text_TextDetector_delete(instance: *mut c_void); - pub fn cv_text_TextDetectorCNN_detect_const__InputArrayR_vectorLRectGR_vectorLfloatGR(instance: *mut c_void, input_image: *const c_void, bbox: *mut c_void, confidence: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_text_TextDetectorCNN_detect_const__InputArrayR_vectorLRectGR_vectorLfloatGR(instance: *mut c_void, input_image: *const c_void, bbox: *mut c_void, confidence: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_text_TextDetectorCNN_create_const_StringR_const_StringR_vectorLSizeG(model_arch_filename: *const c_char, model_weights_filename: *const c_char, detection_sizes: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_text_TextDetectorCNN_create_const_StringR_const_StringR(model_arch_filename: *const c_char, model_weights_filename: *const c_char, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_text_TextDetectorCNN_to_TextDetector(instance: *mut c_void) -> *mut c_void; @@ -15363,17 +15366,15 @@ mod text_sys { pub fn std_vectorLstd_vectorLcv_text_ERStatGG_set_size_t_const_vectorLERStatG(instance: *mut c_void, index: size_t, val: *const c_void); } } -#[cfg(ocvrs_has_module_text)] pub use text_sys::*; -#[cfg(ocvrs_has_module_tracking)] mod tracking_sys { use super::*; extern "C" { pub fn cv_tracking_TrackerCSRT_create_const_ParamsR(parameters: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_tracking_TrackerCSRT_create(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_tracking_TrackerCSRT_setInitialMask_const__InputArrayR(instance: *mut c_void, mask: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_tracking_TrackerCSRT_setInitialMask_const__InputArrayR(instance: *mut c_void, mask: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_tracking_TrackerCSRT_to_Tracker(instance: *mut c_void) -> *mut c_void; pub fn cv_tracking_TrackerCSRT_delete(instance: *mut c_void); pub fn cv_tracking_TrackerCSRT_Params_Params(ocvrs_return: *mut Result<*mut c_void>); @@ -15435,8 +15436,8 @@ mod tracking_sys { pub fn cv_tracking_TrackerCSRT_Params_delete(instance: *mut c_void); pub fn cv_tracking_TrackerKCF_create_const_ParamsR(parameters: *const crate::tracking::TrackerKCF_Params, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_tracking_TrackerKCF_create(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_tracking_TrackerKCF_setFeatureExtractor_FeatureExtractorCallbackFN_bool(instance: *mut c_void, callback: Option ()>, pca_func: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_tracking_TrackerKCF_setFeatureExtractor_FeatureExtractorCallbackFN(instance: *mut c_void, callback: Option ()>, ocvrs_return: *mut ResultVoid); + pub fn cv_tracking_TrackerKCF_setFeatureExtractor_FeatureExtractorCallbackFN_bool(instance: *mut c_void, callback: Option ()>, pca_func: bool, ocvrs_return: *mut Result<()>); + pub fn cv_tracking_TrackerKCF_setFeatureExtractor_FeatureExtractorCallbackFN(instance: *mut c_void, callback: Option ()>, ocvrs_return: *mut Result<()>); pub fn cv_tracking_TrackerKCF_to_Tracker(instance: *mut c_void) -> *mut c_void; pub fn cv_tracking_TrackerKCF_delete(instance: *mut c_void); pub fn cv_tracking_TrackerKCF_Params_Params(ocvrs_return: *mut Result); @@ -15452,10 +15453,8 @@ mod tracking_sys { pub fn cv_PtrLcv_tracking_TrackerKCFG_to_PtrOfTracker(instance: *mut c_void) -> *mut c_void; } } -#[cfg(ocvrs_has_module_tracking)] pub use tracking_sys::*; -#[cfg(ocvrs_has_module_video)] mod video_sys { use super::*; @@ -15463,9 +15462,9 @@ mod video_sys { pub fn cv_CamShift_const__InputArrayR_RectR_TermCriteria(prob_image: *const c_void, window: *mut core::Rect, criteria: *const core::TermCriteria, ocvrs_return: *mut Result); pub fn cv_buildOpticalFlowPyramid_const__InputArrayR_const__OutputArrayR_Size_int(img: *const c_void, pyramid: *const c_void, win_size: *const core::Size, max_level: i32, ocvrs_return: *mut Result); pub fn cv_buildOpticalFlowPyramid_const__InputArrayR_const__OutputArrayR_Size_int_bool_int_int_bool(img: *const c_void, pyramid: *const c_void, win_size: *const core::Size, max_level: i32, with_derivatives: bool, pyr_border: i32, deriv_border: i32, try_reuse_input_image: bool, ocvrs_return: *mut Result); - pub fn cv_calcOpticalFlowFarneback_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_double_int_int_int_int_double_int(prev: *const c_void, next: *const c_void, flow: *const c_void, pyr_scale: f64, levels: i32, winsize: i32, iterations: i32, poly_n: i32, poly_sigma: f64, flags: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_calcOpticalFlowPyrLK_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__OutputArrayR_const__OutputArrayR(prev_img: *const c_void, next_img: *const c_void, prev_pts: *const c_void, next_pts: *const c_void, status: *const c_void, err: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_calcOpticalFlowPyrLK_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__OutputArrayR_const__OutputArrayR_Size_int_TermCriteria_int_double(prev_img: *const c_void, next_img: *const c_void, prev_pts: *const c_void, next_pts: *const c_void, status: *const c_void, err: *const c_void, win_size: *const core::Size, max_level: i32, criteria: *const core::TermCriteria, flags: i32, min_eig_threshold: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_calcOpticalFlowFarneback_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_double_int_int_int_int_double_int(prev: *const c_void, next: *const c_void, flow: *const c_void, pyr_scale: f64, levels: i32, winsize: i32, iterations: i32, poly_n: i32, poly_sigma: f64, flags: i32, ocvrs_return: *mut Result<()>); + pub fn cv_calcOpticalFlowPyrLK_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__OutputArrayR_const__OutputArrayR(prev_img: *const c_void, next_img: *const c_void, prev_pts: *const c_void, next_pts: *const c_void, status: *const c_void, err: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_calcOpticalFlowPyrLK_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__OutputArrayR_const__OutputArrayR_Size_int_TermCriteria_int_double(prev_img: *const c_void, next_img: *const c_void, prev_pts: *const c_void, next_pts: *const c_void, status: *const c_void, err: *const c_void, win_size: *const core::Size, max_level: i32, criteria: *const core::TermCriteria, flags: i32, min_eig_threshold: f64, ocvrs_return: *mut Result<()>); pub fn cv_computeECC_const__InputArrayR_const__InputArrayR(template_image: *const c_void, input_image: *const c_void, ocvrs_return: *mut Result); pub fn cv_computeECC_const__InputArrayR_const__InputArrayR_const__InputArrayR(template_image: *const c_void, input_image: *const c_void, input_mask: *const c_void, ocvrs_return: *mut Result); pub fn cv_createBackgroundSubtractorKNN(ocvrs_return: *mut Result<*mut c_void>); @@ -15479,109 +15478,109 @@ mod video_sys { pub fn cv_meanShift_const__InputArrayR_RectR_TermCriteria(prob_image: *const c_void, window: *mut core::Rect, criteria: *const core::TermCriteria, ocvrs_return: *mut Result); pub fn cv_readOpticalFlow_const_StringR(path: *const c_char, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_writeOpticalFlow_const_StringR_const__InputArrayR(path: *const c_char, flow: *const c_void, ocvrs_return: *mut Result); - pub fn cv_BackgroundSubtractor_apply_const__InputArrayR_const__OutputArrayR_double(instance: *mut c_void, image: *const c_void, fgmask: *const c_void, learning_rate: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_BackgroundSubtractor_apply_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, fgmask: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_BackgroundSubtractor_getBackgroundImage_const_const__OutputArrayR(instance: *const c_void, background_image: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_BackgroundSubtractor_apply_const__InputArrayR_const__OutputArrayR_double(instance: *mut c_void, image: *const c_void, fgmask: *const c_void, learning_rate: f64, ocvrs_return: *mut Result<()>); + pub fn cv_BackgroundSubtractor_apply_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, fgmask: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_BackgroundSubtractor_getBackgroundImage_const_const__OutputArrayR(instance: *const c_void, background_image: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_BackgroundSubtractor_to_BackgroundSubtractorKNN(instance: *mut c_void) -> *mut c_void; pub fn cv_BackgroundSubtractor_to_BackgroundSubtractorMOG2(instance: *mut c_void) -> *mut c_void; pub fn cv_BackgroundSubtractor_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_BackgroundSubtractor_delete(instance: *mut c_void); pub fn cv_BackgroundSubtractorKNN_getHistory_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_BackgroundSubtractorKNN_setHistory_int(instance: *mut c_void, history: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_BackgroundSubtractorKNN_setHistory_int(instance: *mut c_void, history: i32, ocvrs_return: *mut Result<()>); pub fn cv_BackgroundSubtractorKNN_getNSamples_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_BackgroundSubtractorKNN_setNSamples_int(instance: *mut c_void, _n_n: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_BackgroundSubtractorKNN_setNSamples_int(instance: *mut c_void, _n_n: i32, ocvrs_return: *mut Result<()>); pub fn cv_BackgroundSubtractorKNN_getDist2Threshold_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_BackgroundSubtractorKNN_setDist2Threshold_double(instance: *mut c_void, _dist2_threshold: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_BackgroundSubtractorKNN_setDist2Threshold_double(instance: *mut c_void, _dist2_threshold: f64, ocvrs_return: *mut Result<()>); pub fn cv_BackgroundSubtractorKNN_getkNNSamples_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_BackgroundSubtractorKNN_setkNNSamples_int(instance: *mut c_void, _nk_nn: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_BackgroundSubtractorKNN_setkNNSamples_int(instance: *mut c_void, _nk_nn: i32, ocvrs_return: *mut Result<()>); pub fn cv_BackgroundSubtractorKNN_getDetectShadows_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_BackgroundSubtractorKNN_setDetectShadows_bool(instance: *mut c_void, detect_shadows: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_BackgroundSubtractorKNN_setDetectShadows_bool(instance: *mut c_void, detect_shadows: bool, ocvrs_return: *mut Result<()>); pub fn cv_BackgroundSubtractorKNN_getShadowValue_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_BackgroundSubtractorKNN_setShadowValue_int(instance: *mut c_void, value: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_BackgroundSubtractorKNN_setShadowValue_int(instance: *mut c_void, value: i32, ocvrs_return: *mut Result<()>); pub fn cv_BackgroundSubtractorKNN_getShadowThreshold_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_BackgroundSubtractorKNN_setShadowThreshold_double(instance: *mut c_void, threshold: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_BackgroundSubtractorKNN_setShadowThreshold_double(instance: *mut c_void, threshold: f64, ocvrs_return: *mut Result<()>); pub fn cv_BackgroundSubtractorKNN_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_BackgroundSubtractorKNN_to_BackgroundSubtractor(instance: *mut c_void) -> *mut c_void; pub fn cv_BackgroundSubtractorKNN_delete(instance: *mut c_void); pub fn cv_BackgroundSubtractorMOG2_getHistory_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_BackgroundSubtractorMOG2_setHistory_int(instance: *mut c_void, history: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_BackgroundSubtractorMOG2_setHistory_int(instance: *mut c_void, history: i32, ocvrs_return: *mut Result<()>); pub fn cv_BackgroundSubtractorMOG2_getNMixtures_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_BackgroundSubtractorMOG2_setNMixtures_int(instance: *mut c_void, nmixtures: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_BackgroundSubtractorMOG2_setNMixtures_int(instance: *mut c_void, nmixtures: i32, ocvrs_return: *mut Result<()>); pub fn cv_BackgroundSubtractorMOG2_getBackgroundRatio_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_BackgroundSubtractorMOG2_setBackgroundRatio_double(instance: *mut c_void, ratio: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_BackgroundSubtractorMOG2_setBackgroundRatio_double(instance: *mut c_void, ratio: f64, ocvrs_return: *mut Result<()>); pub fn cv_BackgroundSubtractorMOG2_getVarThreshold_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_BackgroundSubtractorMOG2_setVarThreshold_double(instance: *mut c_void, var_threshold: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_BackgroundSubtractorMOG2_setVarThreshold_double(instance: *mut c_void, var_threshold: f64, ocvrs_return: *mut Result<()>); pub fn cv_BackgroundSubtractorMOG2_getVarThresholdGen_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_BackgroundSubtractorMOG2_setVarThresholdGen_double(instance: *mut c_void, var_threshold_gen: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_BackgroundSubtractorMOG2_setVarThresholdGen_double(instance: *mut c_void, var_threshold_gen: f64, ocvrs_return: *mut Result<()>); pub fn cv_BackgroundSubtractorMOG2_getVarInit_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_BackgroundSubtractorMOG2_setVarInit_double(instance: *mut c_void, var_init: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_BackgroundSubtractorMOG2_setVarInit_double(instance: *mut c_void, var_init: f64, ocvrs_return: *mut Result<()>); pub fn cv_BackgroundSubtractorMOG2_getVarMin_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_BackgroundSubtractorMOG2_setVarMin_double(instance: *mut c_void, var_min: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_BackgroundSubtractorMOG2_setVarMin_double(instance: *mut c_void, var_min: f64, ocvrs_return: *mut Result<()>); pub fn cv_BackgroundSubtractorMOG2_getVarMax_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_BackgroundSubtractorMOG2_setVarMax_double(instance: *mut c_void, var_max: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_BackgroundSubtractorMOG2_setVarMax_double(instance: *mut c_void, var_max: f64, ocvrs_return: *mut Result<()>); pub fn cv_BackgroundSubtractorMOG2_getComplexityReductionThreshold_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_BackgroundSubtractorMOG2_setComplexityReductionThreshold_double(instance: *mut c_void, ct: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_BackgroundSubtractorMOG2_setComplexityReductionThreshold_double(instance: *mut c_void, ct: f64, ocvrs_return: *mut Result<()>); pub fn cv_BackgroundSubtractorMOG2_getDetectShadows_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_BackgroundSubtractorMOG2_setDetectShadows_bool(instance: *mut c_void, detect_shadows: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_BackgroundSubtractorMOG2_setDetectShadows_bool(instance: *mut c_void, detect_shadows: bool, ocvrs_return: *mut Result<()>); pub fn cv_BackgroundSubtractorMOG2_getShadowValue_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_BackgroundSubtractorMOG2_setShadowValue_int(instance: *mut c_void, value: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_BackgroundSubtractorMOG2_setShadowValue_int(instance: *mut c_void, value: i32, ocvrs_return: *mut Result<()>); pub fn cv_BackgroundSubtractorMOG2_getShadowThreshold_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_BackgroundSubtractorMOG2_setShadowThreshold_double(instance: *mut c_void, threshold: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_BackgroundSubtractorMOG2_apply_const__InputArrayR_const__OutputArrayR_double(instance: *mut c_void, image: *const c_void, fgmask: *const c_void, learning_rate: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_BackgroundSubtractorMOG2_apply_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, fgmask: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_BackgroundSubtractorMOG2_setShadowThreshold_double(instance: *mut c_void, threshold: f64, ocvrs_return: *mut Result<()>); + pub fn cv_BackgroundSubtractorMOG2_apply_const__InputArrayR_const__OutputArrayR_double(instance: *mut c_void, image: *const c_void, fgmask: *const c_void, learning_rate: f64, ocvrs_return: *mut Result<()>); + pub fn cv_BackgroundSubtractorMOG2_apply_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, fgmask: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_BackgroundSubtractorMOG2_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_BackgroundSubtractorMOG2_to_BackgroundSubtractor(instance: *mut c_void) -> *mut c_void; pub fn cv_BackgroundSubtractorMOG2_delete(instance: *mut c_void); pub fn cv_DISOpticalFlow_getFinestScale_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_DISOpticalFlow_setFinestScale_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_DISOpticalFlow_setFinestScale_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_DISOpticalFlow_getPatchSize_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_DISOpticalFlow_setPatchSize_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_DISOpticalFlow_setPatchSize_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_DISOpticalFlow_getPatchStride_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_DISOpticalFlow_setPatchStride_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_DISOpticalFlow_setPatchStride_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_DISOpticalFlow_getGradientDescentIterations_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_DISOpticalFlow_setGradientDescentIterations_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_DISOpticalFlow_setGradientDescentIterations_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_DISOpticalFlow_getVariationalRefinementIterations_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_DISOpticalFlow_setVariationalRefinementIterations_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_DISOpticalFlow_setVariationalRefinementIterations_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_DISOpticalFlow_getVariationalRefinementAlpha_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_DISOpticalFlow_setVariationalRefinementAlpha_float(instance: *mut c_void, val: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_DISOpticalFlow_setVariationalRefinementAlpha_float(instance: *mut c_void, val: f32, ocvrs_return: *mut Result<()>); pub fn cv_DISOpticalFlow_getVariationalRefinementDelta_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_DISOpticalFlow_setVariationalRefinementDelta_float(instance: *mut c_void, val: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_DISOpticalFlow_setVariationalRefinementDelta_float(instance: *mut c_void, val: f32, ocvrs_return: *mut Result<()>); pub fn cv_DISOpticalFlow_getVariationalRefinementGamma_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_DISOpticalFlow_setVariationalRefinementGamma_float(instance: *mut c_void, val: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_DISOpticalFlow_setVariationalRefinementGamma_float(instance: *mut c_void, val: f32, ocvrs_return: *mut Result<()>); pub fn cv_DISOpticalFlow_getVariationalRefinementEpsilon_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_DISOpticalFlow_setVariationalRefinementEpsilon_float(instance: *mut c_void, val: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_DISOpticalFlow_setVariationalRefinementEpsilon_float(instance: *mut c_void, val: f32, ocvrs_return: *mut Result<()>); pub fn cv_DISOpticalFlow_getUseMeanNormalization_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_DISOpticalFlow_setUseMeanNormalization_bool(instance: *mut c_void, val: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_DISOpticalFlow_setUseMeanNormalization_bool(instance: *mut c_void, val: bool, ocvrs_return: *mut Result<()>); pub fn cv_DISOpticalFlow_getUseSpatialPropagation_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_DISOpticalFlow_setUseSpatialPropagation_bool(instance: *mut c_void, val: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_DISOpticalFlow_setUseSpatialPropagation_bool(instance: *mut c_void, val: bool, ocvrs_return: *mut Result<()>); pub fn cv_DISOpticalFlow_create_int(preset: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_DISOpticalFlow_create(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_DISOpticalFlow_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_DISOpticalFlow_to_DenseOpticalFlow(instance: *mut c_void) -> *mut c_void; pub fn cv_DISOpticalFlow_delete(instance: *mut c_void); - pub fn cv_DenseOpticalFlow_calc_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR(instance: *mut c_void, i0: *const c_void, i1: *const c_void, flow: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_DenseOpticalFlow_collectGarbage(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_DenseOpticalFlow_calc_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR(instance: *mut c_void, i0: *const c_void, i1: *const c_void, flow: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_DenseOpticalFlow_collectGarbage(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_DenseOpticalFlow_to_DISOpticalFlow(instance: *mut c_void) -> *mut c_void; pub fn cv_DenseOpticalFlow_to_FarnebackOpticalFlow(instance: *mut c_void) -> *mut c_void; pub fn cv_DenseOpticalFlow_to_VariationalRefinement(instance: *mut c_void) -> *mut c_void; pub fn cv_DenseOpticalFlow_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_DenseOpticalFlow_delete(instance: *mut c_void); pub fn cv_FarnebackOpticalFlow_getNumLevels_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_FarnebackOpticalFlow_setNumLevels_int(instance: *mut c_void, num_levels: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_FarnebackOpticalFlow_setNumLevels_int(instance: *mut c_void, num_levels: i32, ocvrs_return: *mut Result<()>); pub fn cv_FarnebackOpticalFlow_getPyrScale_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_FarnebackOpticalFlow_setPyrScale_double(instance: *mut c_void, pyr_scale: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_FarnebackOpticalFlow_setPyrScale_double(instance: *mut c_void, pyr_scale: f64, ocvrs_return: *mut Result<()>); pub fn cv_FarnebackOpticalFlow_getFastPyramids_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_FarnebackOpticalFlow_setFastPyramids_bool(instance: *mut c_void, fast_pyramids: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_FarnebackOpticalFlow_setFastPyramids_bool(instance: *mut c_void, fast_pyramids: bool, ocvrs_return: *mut Result<()>); pub fn cv_FarnebackOpticalFlow_getWinSize_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_FarnebackOpticalFlow_setWinSize_int(instance: *mut c_void, win_size: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_FarnebackOpticalFlow_setWinSize_int(instance: *mut c_void, win_size: i32, ocvrs_return: *mut Result<()>); pub fn cv_FarnebackOpticalFlow_getNumIters_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_FarnebackOpticalFlow_setNumIters_int(instance: *mut c_void, num_iters: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_FarnebackOpticalFlow_setNumIters_int(instance: *mut c_void, num_iters: i32, ocvrs_return: *mut Result<()>); pub fn cv_FarnebackOpticalFlow_getPolyN_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_FarnebackOpticalFlow_setPolyN_int(instance: *mut c_void, poly_n: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_FarnebackOpticalFlow_setPolyN_int(instance: *mut c_void, poly_n: i32, ocvrs_return: *mut Result<()>); pub fn cv_FarnebackOpticalFlow_getPolySigma_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_FarnebackOpticalFlow_setPolySigma_double(instance: *mut c_void, poly_sigma: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_FarnebackOpticalFlow_setPolySigma_double(instance: *mut c_void, poly_sigma: f64, ocvrs_return: *mut Result<()>); pub fn cv_FarnebackOpticalFlow_getFlags_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_FarnebackOpticalFlow_setFlags_int(instance: *mut c_void, flags: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_FarnebackOpticalFlow_setFlags_int(instance: *mut c_void, flags: i32, ocvrs_return: *mut Result<()>); pub fn cv_FarnebackOpticalFlow_create_int_double_bool_int_int_int_double_int(num_levels: i32, pyr_scale: f64, fast_pyramids: bool, win_size: i32, num_iters: i32, poly_n: i32, poly_sigma: f64, flags: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_FarnebackOpticalFlow_create(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_FarnebackOpticalFlow_to_Algorithm(instance: *mut c_void) -> *mut c_void; @@ -15590,8 +15589,8 @@ mod video_sys { pub fn cv_KalmanFilter_KalmanFilter(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_KalmanFilter_KalmanFilter_int_int_int_int(dynam_params: i32, measure_params: i32, control_params: i32, typ: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_KalmanFilter_KalmanFilter_int_int(dynam_params: i32, measure_params: i32, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_KalmanFilter_init_int_int_int_int(instance: *mut c_void, dynam_params: i32, measure_params: i32, control_params: i32, typ: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_KalmanFilter_init_int_int(instance: *mut c_void, dynam_params: i32, measure_params: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_KalmanFilter_init_int_int_int_int(instance: *mut c_void, dynam_params: i32, measure_params: i32, control_params: i32, typ: i32, ocvrs_return: *mut Result<()>); + pub fn cv_KalmanFilter_init_int_int(instance: *mut c_void, dynam_params: i32, measure_params: i32, ocvrs_return: *mut Result<()>); pub fn cv_KalmanFilter_predict_const_MatR(instance: *mut c_void, control: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_KalmanFilter_predict(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_KalmanFilter_correct_const_MatR(instance: *mut c_void, measurement: *const c_void, ocvrs_return: *mut Result<*mut c_void>); @@ -15626,27 +15625,27 @@ mod video_sys { pub fn cv_KalmanFilter_propTemp5_const(instance: *const c_void) -> *mut c_void; pub fn cv_KalmanFilter_propTemp5_const_Mat(instance: *mut c_void, val: *const c_void); pub fn cv_KalmanFilter_delete(instance: *mut c_void); - pub fn cv_SparseOpticalFlow_calc_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *mut c_void, prev_img: *const c_void, next_img: *const c_void, prev_pts: *const c_void, next_pts: *const c_void, status: *const c_void, err: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_SparseOpticalFlow_calc_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__OutputArrayR(instance: *mut c_void, prev_img: *const c_void, next_img: *const c_void, prev_pts: *const c_void, next_pts: *const c_void, status: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_SparseOpticalFlow_calc_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *mut c_void, prev_img: *const c_void, next_img: *const c_void, prev_pts: *const c_void, next_pts: *const c_void, status: *const c_void, err: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_SparseOpticalFlow_calc_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__OutputArrayR(instance: *mut c_void, prev_img: *const c_void, next_img: *const c_void, prev_pts: *const c_void, next_pts: *const c_void, status: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_SparseOpticalFlow_to_SparsePyrLKOpticalFlow(instance: *mut c_void) -> *mut c_void; pub fn cv_SparseOpticalFlow_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_SparseOpticalFlow_delete(instance: *mut c_void); pub fn cv_SparsePyrLKOpticalFlow_getWinSize_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_SparsePyrLKOpticalFlow_setWinSize_Size(instance: *mut c_void, win_size: *const core::Size, ocvrs_return: *mut ResultVoid); + pub fn cv_SparsePyrLKOpticalFlow_setWinSize_Size(instance: *mut c_void, win_size: *const core::Size, ocvrs_return: *mut Result<()>); pub fn cv_SparsePyrLKOpticalFlow_getMaxLevel_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_SparsePyrLKOpticalFlow_setMaxLevel_int(instance: *mut c_void, max_level: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_SparsePyrLKOpticalFlow_setMaxLevel_int(instance: *mut c_void, max_level: i32, ocvrs_return: *mut Result<()>); pub fn cv_SparsePyrLKOpticalFlow_getTermCriteria_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_SparsePyrLKOpticalFlow_setTermCriteria_TermCriteriaR(instance: *mut c_void, crit: *mut core::TermCriteria, ocvrs_return: *mut ResultVoid); + pub fn cv_SparsePyrLKOpticalFlow_setTermCriteria_TermCriteriaR(instance: *mut c_void, crit: *mut core::TermCriteria, ocvrs_return: *mut Result<()>); pub fn cv_SparsePyrLKOpticalFlow_getFlags_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_SparsePyrLKOpticalFlow_setFlags_int(instance: *mut c_void, flags: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_SparsePyrLKOpticalFlow_setFlags_int(instance: *mut c_void, flags: i32, ocvrs_return: *mut Result<()>); pub fn cv_SparsePyrLKOpticalFlow_getMinEigThreshold_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_SparsePyrLKOpticalFlow_setMinEigThreshold_double(instance: *mut c_void, min_eig_threshold: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_SparsePyrLKOpticalFlow_setMinEigThreshold_double(instance: *mut c_void, min_eig_threshold: f64, ocvrs_return: *mut Result<()>); pub fn cv_SparsePyrLKOpticalFlow_create_Size_int_TermCriteria_int_double(win_size: *const core::Size, max_level: i32, crit: *const core::TermCriteria, flags: i32, min_eig_threshold: f64, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_SparsePyrLKOpticalFlow_create(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_SparsePyrLKOpticalFlow_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_SparsePyrLKOpticalFlow_to_SparseOpticalFlow(instance: *mut c_void) -> *mut c_void; pub fn cv_SparsePyrLKOpticalFlow_delete(instance: *mut c_void); - pub fn cv_Tracker_init_const__InputArrayR_const_RectR(instance: *mut c_void, image: *const c_void, bounding_box: *const core::Rect, ocvrs_return: *mut ResultVoid); + pub fn cv_Tracker_init_const__InputArrayR_const_RectR(instance: *mut c_void, image: *const c_void, bounding_box: *const core::Rect, ocvrs_return: *mut Result<()>); pub fn cv_Tracker_update_const__InputArrayR_RectR(instance: *mut c_void, image: *const c_void, bounding_box: *mut core::Rect, ocvrs_return: *mut Result); pub fn cv_Tracker_to_TrackerDaSiamRPN(instance: *mut c_void) -> *mut c_void; pub fn cv_Tracker_to_TrackerGOTURN(instance: *mut c_void) -> *mut c_void; @@ -15724,21 +15723,21 @@ mod video_sys { pub fn cv_TrackerVit_Params_propTracking_score_threshold_const(instance: *const c_void) -> f32; pub fn cv_TrackerVit_Params_propTracking_score_threshold_const_float(instance: *mut c_void, val: f32); pub fn cv_TrackerVit_Params_delete(instance: *mut c_void); - pub fn cv_VariationalRefinement_calcUV_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__InputOutputArrayR(instance: *mut c_void, i0: *const c_void, i1: *const c_void, flow_u: *const c_void, flow_v: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_VariationalRefinement_calcUV_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__InputOutputArrayR(instance: *mut c_void, i0: *const c_void, i1: *const c_void, flow_u: *const c_void, flow_v: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_VariationalRefinement_getFixedPointIterations_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_VariationalRefinement_setFixedPointIterations_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_VariationalRefinement_setFixedPointIterations_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_VariationalRefinement_getSorIterations_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_VariationalRefinement_setSorIterations_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_VariationalRefinement_setSorIterations_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_VariationalRefinement_getOmega_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_VariationalRefinement_setOmega_float(instance: *mut c_void, val: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_VariationalRefinement_setOmega_float(instance: *mut c_void, val: f32, ocvrs_return: *mut Result<()>); pub fn cv_VariationalRefinement_getAlpha_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_VariationalRefinement_setAlpha_float(instance: *mut c_void, val: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_VariationalRefinement_setAlpha_float(instance: *mut c_void, val: f32, ocvrs_return: *mut Result<()>); pub fn cv_VariationalRefinement_getDelta_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_VariationalRefinement_setDelta_float(instance: *mut c_void, val: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_VariationalRefinement_setDelta_float(instance: *mut c_void, val: f32, ocvrs_return: *mut Result<()>); pub fn cv_VariationalRefinement_getGamma_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_VariationalRefinement_setGamma_float(instance: *mut c_void, val: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_VariationalRefinement_setGamma_float(instance: *mut c_void, val: f32, ocvrs_return: *mut Result<()>); pub fn cv_VariationalRefinement_getEpsilon_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_VariationalRefinement_setEpsilon_float(instance: *mut c_void, val: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_VariationalRefinement_setEpsilon_float(instance: *mut c_void, val: f32, ocvrs_return: *mut Result<()>); pub fn cv_VariationalRefinement_create(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_VariationalRefinement_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_VariationalRefinement_to_DenseOpticalFlow(instance: *mut c_void) -> *mut c_void; @@ -15825,10 +15824,8 @@ mod video_sys { pub fn cv_PtrLcv_VariationalRefinementG_to_PtrOfDenseOpticalFlow(instance: *mut c_void) -> *mut c_void; } } -#[cfg(ocvrs_has_module_video)] pub use video_sys::*; -#[cfg(ocvrs_has_module_videoio)] mod videoio_sys { use super::*; @@ -15864,7 +15861,7 @@ mod videoio_sys { pub fn cv_VideoCapture_open_int_int_const_vectorLintGR(instance: *mut c_void, index: i32, api_preference: i32, params: *const c_void, ocvrs_return: *mut Result); pub fn cv_VideoCapture_open_const_PtrLIStreamReaderGR_int_const_vectorLintGR(instance: *mut c_void, source: *const c_void, api_preference: i32, params: *const c_void, ocvrs_return: *mut Result); pub fn cv_VideoCapture_isOpened_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_VideoCapture_release(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_VideoCapture_release(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_VideoCapture_grab(instance: *mut c_void, ocvrs_return: *mut Result); pub fn cv_VideoCapture_retrieve_const__OutputArrayR_int(instance: *mut c_void, image: *const c_void, flag: i32, ocvrs_return: *mut Result); pub fn cv_VideoCapture_retrieve_const__OutputArrayR(instance: *mut c_void, image: *const c_void, ocvrs_return: *mut Result); @@ -15872,7 +15869,7 @@ mod videoio_sys { pub fn cv_VideoCapture_set_int_double(instance: *mut c_void, prop_id: i32, value: f64, ocvrs_return: *mut Result); pub fn cv_VideoCapture_get_const_int(instance: *const c_void, prop_id: i32, ocvrs_return: *mut Result); pub fn cv_VideoCapture_getBackendName_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_VideoCapture_setExceptionMode_bool(instance: *mut c_void, enable: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_VideoCapture_setExceptionMode_bool(instance: *mut c_void, enable: bool, ocvrs_return: *mut Result<()>); pub fn cv_VideoCapture_getExceptionMode_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_VideoCapture_waitAny_const_vectorLVideoCaptureGR_vectorLintGR_int64_t(streams: *const c_void, ready_index: *mut c_void, timeout_ns: i64, ocvrs_return: *mut Result); pub fn cv_VideoCapture_waitAny_const_vectorLVideoCaptureGR_vectorLintGR(streams: *const c_void, ready_index: *mut c_void, ocvrs_return: *mut Result); @@ -15891,8 +15888,8 @@ mod videoio_sys { pub fn cv_VideoWriter_open_const_StringR_int_double_const_SizeR_const_vectorLintGR(instance: *mut c_void, filename: *const c_char, fourcc: i32, fps: f64, frame_size: *const core::Size, params: *const c_void, ocvrs_return: *mut Result); pub fn cv_VideoWriter_open_const_StringR_int_int_double_const_SizeR_const_vectorLintGR(instance: *mut c_void, filename: *const c_char, api_preference: i32, fourcc: i32, fps: f64, frame_size: *const core::Size, params: *const c_void, ocvrs_return: *mut Result); pub fn cv_VideoWriter_isOpened_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_VideoWriter_release(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_VideoWriter_write_const__InputArrayR(instance: *mut c_void, image: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_VideoWriter_release(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_VideoWriter_write_const__InputArrayR(instance: *mut c_void, image: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_VideoWriter_set_int_double(instance: *mut c_void, prop_id: i32, value: f64, ocvrs_return: *mut Result); pub fn cv_VideoWriter_get_const_int(instance: *const c_void, prop_id: i32, ocvrs_return: *mut Result); pub fn cv_VideoWriter_fourcc_char_char_char_char(c1: c_char, c2: c_char, c3: c_char, c4: c_char, ocvrs_return: *mut Result); @@ -15936,17 +15933,15 @@ mod videoio_sys { pub fn cv_fromSlice_const_const_VideoCaptureAPIsX_size_t(data: *const crate::videoio::VideoCaptureAPIs, len: size_t) -> *mut c_void; } } -#[cfg(ocvrs_has_module_videoio)] pub use videoio_sys::*; -#[cfg(ocvrs_has_module_videostab)] mod videostab_sys { use super::*; extern "C" { pub fn cv_videostab_calcBlurriness_const_MatR(frame: *const c_void, ocvrs_return: *mut Result); - pub fn cv_videostab_calcFlowMask_const_MatR_const_MatR_const_MatR_float_const_MatR_const_MatR_MatR(flow_x: *const c_void, flow_y: *const c_void, errors: *const c_void, max_error: f32, mask0: *const c_void, mask1: *const c_void, flow_mask: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_videostab_completeFrameAccordingToFlow_const_MatR_const_MatR_const_MatR_const_MatR_const_MatR_float_MatR_MatR(flow_mask: *const c_void, flow_x: *const c_void, flow_y: *const c_void, frame1: *const c_void, mask1: *const c_void, dist_thresh: f32, frame0: *mut c_void, mask0: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_calcFlowMask_const_MatR_const_MatR_const_MatR_float_const_MatR_const_MatR_MatR(flow_x: *const c_void, flow_y: *const c_void, errors: *const c_void, max_error: f32, mask0: *const c_void, mask1: *const c_void, flow_mask: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_videostab_completeFrameAccordingToFlow_const_MatR_const_MatR_const_MatR_const_MatR_const_MatR_float_MatR_MatR(flow_mask: *const c_void, flow_x: *const c_void, flow_y: *const c_void, frame1: *const c_void, mask1: *const c_void, dist_thresh: f32, frame0: *mut c_void, mask0: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_ensureInclusionConstraint_const_MatR_Size_float(m: *const c_void, size: *const core::Size, trim_ratio: f32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_videostab_estimateGlobalMotionLeastSquares_const__InputOutputArrayR_const__InputOutputArrayR(points0: *const c_void, points1: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_videostab_estimateGlobalMotionLeastSquares_const__InputOutputArrayR_const__InputOutputArrayR_int_floatX(points0: *const c_void, points1: *const c_void, model: i32, rmse: *mut f32, ocvrs_return: *mut Result<*mut c_void>); @@ -15954,35 +15949,35 @@ mod videostab_sys { pub fn cv_videostab_estimateGlobalMotionRansac_const__InputArrayR_const__InputArrayR_int_const_RansacParamsR_floatX_intX(points0: *const c_void, points1: *const c_void, model: i32, params: *const c_void, rmse: *mut f32, ninliers: *mut i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_videostab_estimateOptimalTrimRatio_const_MatR_Size(m: *const c_void, size: *const core::Size, ocvrs_return: *mut Result); pub fn cv_videostab_getMotion_int_int_const_vectorLMatGR(from: i32, to: i32, motions: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_videostab_ColorAverageInpainter_inpaint_int_MatR_MatR(instance: *mut c_void, idx: i32, frame: *mut c_void, mask: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_ColorAverageInpainter_inpaint_int_MatR_MatR(instance: *mut c_void, idx: i32, frame: *mut c_void, mask: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_ColorAverageInpainter_defaultNew_const() -> *mut c_void; pub fn cv_videostab_ColorAverageInpainter_to_InpainterBase(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_ColorAverageInpainter_delete(instance: *mut c_void); pub fn cv_videostab_ColorInpainter_ColorInpainter_int_double(method: i32, radius: f64, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_videostab_ColorInpainter_ColorInpainter(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_videostab_ColorInpainter_inpaint_int_MatR_MatR(instance: *mut c_void, idx: i32, frame: *mut c_void, mask: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_ColorInpainter_inpaint_int_MatR_MatR(instance: *mut c_void, idx: i32, frame: *mut c_void, mask: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_ColorInpainter_to_InpainterBase(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_ColorInpainter_delete(instance: *mut c_void); pub fn cv_videostab_ConsistentMosaicInpainter_ConsistentMosaicInpainter(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_videostab_ConsistentMosaicInpainter_setStdevThresh_float(instance: *mut c_void, val: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_ConsistentMosaicInpainter_setStdevThresh_float(instance: *mut c_void, val: f32, ocvrs_return: *mut Result<()>); pub fn cv_videostab_ConsistentMosaicInpainter_stdevThresh_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_videostab_ConsistentMosaicInpainter_inpaint_int_MatR_MatR(instance: *mut c_void, idx: i32, frame: *mut c_void, mask: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_ConsistentMosaicInpainter_inpaint_int_MatR_MatR(instance: *mut c_void, idx: i32, frame: *mut c_void, mask: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_ConsistentMosaicInpainter_to_InpainterBase(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_ConsistentMosaicInpainter_delete(instance: *mut c_void); - pub fn cv_videostab_DeblurerBase_setRadius_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_DeblurerBase_setRadius_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_videostab_DeblurerBase_radius_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_videostab_DeblurerBase_deblur_int_MatR_const_RangeR(instance: *mut c_void, idx: i32, frame: *mut c_void, range: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_videostab_DeblurerBase_setFrames_const_vectorLMatGR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_DeblurerBase_deblur_int_MatR_const_RangeR(instance: *mut c_void, idx: i32, frame: *mut c_void, range: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_videostab_DeblurerBase_setFrames_const_vectorLMatGR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_DeblurerBase_frames_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_videostab_DeblurerBase_setMotions_const_vectorLMatGR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_DeblurerBase_setMotions_const_vectorLMatGR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_DeblurerBase_motions_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_videostab_DeblurerBase_setBlurrinessRates_const_vectorLfloatGR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_DeblurerBase_setBlurrinessRates_const_vectorLfloatGR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_DeblurerBase_blurrinessRates_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_videostab_DeblurerBase_to_NullDeblurer(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_DeblurerBase_to_WeightingDeblurer(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_DeblurerBase_delete(instance: *mut c_void); pub fn cv_videostab_DensePyrLkOptFlowEstimatorGpu_DensePyrLkOptFlowEstimatorGpu(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_videostab_DensePyrLkOptFlowEstimatorGpu_run_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__InputOutputArrayR_const__OutputArrayR(instance: *mut c_void, frame0: *const c_void, frame1: *const c_void, flow_x: *const c_void, flow_y: *const c_void, errors: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_DensePyrLkOptFlowEstimatorGpu_run_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__InputOutputArrayR_const__OutputArrayR(instance: *mut c_void, frame0: *const c_void, frame1: *const c_void, flow_x: *const c_void, flow_y: *const c_void, errors: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_DensePyrLkOptFlowEstimatorGpu_to_IDenseOptFlowEstimator(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_DensePyrLkOptFlowEstimatorGpu_to_PyrLkOptFlowEstimatorBase(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_DensePyrLkOptFlowEstimatorGpu_delete(instance: *mut c_void); @@ -15996,18 +15991,18 @@ mod videostab_sys { pub fn cv_videostab_FromFileMotionReader_delete(instance: *mut c_void); pub fn cv_videostab_GaussianMotionFilter_GaussianMotionFilter_int_float(radius: i32, stdev: f32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_videostab_GaussianMotionFilter_GaussianMotionFilter(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_videostab_GaussianMotionFilter_setParams_int_float(instance: *mut c_void, radius: i32, stdev: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_videostab_GaussianMotionFilter_setParams_int(instance: *mut c_void, radius: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_GaussianMotionFilter_setParams_int_float(instance: *mut c_void, radius: i32, stdev: f32, ocvrs_return: *mut Result<()>); + pub fn cv_videostab_GaussianMotionFilter_setParams_int(instance: *mut c_void, radius: i32, ocvrs_return: *mut Result<()>); pub fn cv_videostab_GaussianMotionFilter_radius_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_videostab_GaussianMotionFilter_stdev_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_videostab_GaussianMotionFilter_stabilize_int_const_vectorLMatGR_const_RangeR(instance: *mut c_void, idx: i32, motions: *const c_void, range: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_videostab_GaussianMotionFilter_to_IMotionStabilizer(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_GaussianMotionFilter_to_MotionFilterBase(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_GaussianMotionFilter_delete(instance: *mut c_void); - pub fn cv_videostab_IDenseOptFlowEstimator_run_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__InputOutputArrayR_const__OutputArrayR(instance: *mut c_void, frame0: *const c_void, frame1: *const c_void, flow_x: *const c_void, flow_y: *const c_void, errors: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_IDenseOptFlowEstimator_run_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__InputOutputArrayR_const__OutputArrayR(instance: *mut c_void, frame0: *const c_void, frame1: *const c_void, flow_x: *const c_void, flow_y: *const c_void, errors: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_IDenseOptFlowEstimator_to_DensePyrLkOptFlowEstimatorGpu(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_IDenseOptFlowEstimator_delete(instance: *mut c_void); - pub fn cv_videostab_IFrameSource_reset(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_IFrameSource_reset(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_IFrameSource_nextFrame(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_videostab_IFrameSource_to_MaskFrameSource(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_IFrameSource_to_NullFrameSource(instance: *mut c_void) -> *mut c_void; @@ -16015,27 +16010,27 @@ mod videostab_sys { pub fn cv_videostab_IFrameSource_to_TwoPassStabilizer(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_IFrameSource_to_VideoFileSource(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_IFrameSource_delete(instance: *mut c_void); - pub fn cv_videostab_ILog_print_const_charX(instance: *mut c_void, format: *const c_char, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_ILog_print_const_charX(instance: *mut c_void, format: *const c_char, ocvrs_return: *mut Result<()>); pub fn cv_videostab_ILog_to_LogToStdout(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_ILog_to_NullLog(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_ILog_delete(instance: *mut c_void); - pub fn cv_videostab_IMotionStabilizer_stabilize_int_const_vectorLMatGR_const_RangeR_MatX(instance: *mut c_void, size: i32, motions: *const c_void, range: *const c_void, stabilization_motions: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_IMotionStabilizer_stabilize_int_const_vectorLMatGR_const_RangeR_MatX(instance: *mut c_void, size: i32, motions: *const c_void, range: *const c_void, stabilization_motions: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_IMotionStabilizer_to_GaussianMotionFilter(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_IMotionStabilizer_to_LpMotionStabilizer(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_IMotionStabilizer_to_MotionFilterBase(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_IMotionStabilizer_to_MotionStabilizationPipeline(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_IMotionStabilizer_delete(instance: *mut c_void); - pub fn cv_videostab_IOutlierRejector_process_Size_const__InputArrayR_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, frame_size: *const core::Size, points0: *const c_void, points1: *const c_void, mask: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_IOutlierRejector_process_Size_const__InputArrayR_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, frame_size: *const core::Size, points0: *const c_void, points1: *const c_void, mask: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_IOutlierRejector_to_NullOutlierRejector(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_IOutlierRejector_to_TranslationBasedLocalOutlierRejector(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_IOutlierRejector_delete(instance: *mut c_void); - pub fn cv_videostab_ISparseOptFlowEstimator_run_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *mut c_void, frame0: *const c_void, frame1: *const c_void, points0: *const c_void, points1: *const c_void, status: *const c_void, errors: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_ISparseOptFlowEstimator_run_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *mut c_void, frame0: *const c_void, frame1: *const c_void, points0: *const c_void, points1: *const c_void, status: *const c_void, errors: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_ISparseOptFlowEstimator_to_SparsePyrLkOptFlowEstimator(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_ISparseOptFlowEstimator_to_SparsePyrLkOptFlowEstimatorGpu(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_ISparseOptFlowEstimator_delete(instance: *mut c_void); - pub fn cv_videostab_ImageMotionEstimatorBase_setMotionModel_MotionModel(instance: *mut c_void, val: crate::videostab::MotionModel, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_ImageMotionEstimatorBase_setMotionModel_MotionModel(instance: *mut c_void, val: crate::videostab::MotionModel, ocvrs_return: *mut Result<()>); pub fn cv_videostab_ImageMotionEstimatorBase_motionModel_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_videostab_ImageMotionEstimatorBase_setFrameMask_const__InputArrayR(instance: *mut c_void, mask: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_ImageMotionEstimatorBase_setFrameMask_const__InputArrayR(instance: *mut c_void, mask: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_ImageMotionEstimatorBase_estimate_const_MatR_const_MatR_boolX(instance: *mut c_void, frame0: *const c_void, frame1: *const c_void, ok: *mut bool, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_videostab_ImageMotionEstimatorBase_estimate_const_MatR_const_MatR(instance: *mut c_void, frame0: *const c_void, frame1: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_videostab_ImageMotionEstimatorBase_to_FromFileMotionReader(instance: *mut c_void) -> *mut c_void; @@ -16043,18 +16038,18 @@ mod videostab_sys { pub fn cv_videostab_ImageMotionEstimatorBase_to_KeypointBasedMotionEstimatorGpu(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_ImageMotionEstimatorBase_to_ToFileMotionWriter(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_ImageMotionEstimatorBase_delete(instance: *mut c_void); - pub fn cv_videostab_InpainterBase_setRadius_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_InpainterBase_setRadius_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_videostab_InpainterBase_radius_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_videostab_InpainterBase_setMotionModel_MotionModel(instance: *mut c_void, val: crate::videostab::MotionModel, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_InpainterBase_setMotionModel_MotionModel(instance: *mut c_void, val: crate::videostab::MotionModel, ocvrs_return: *mut Result<()>); pub fn cv_videostab_InpainterBase_motionModel_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_videostab_InpainterBase_inpaint_int_MatR_MatR(instance: *mut c_void, idx: i32, frame: *mut c_void, mask: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_videostab_InpainterBase_setFrames_const_vectorLMatGR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_InpainterBase_inpaint_int_MatR_MatR(instance: *mut c_void, idx: i32, frame: *mut c_void, mask: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_videostab_InpainterBase_setFrames_const_vectorLMatGR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_InpainterBase_frames_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_videostab_InpainterBase_setMotions_const_vectorLMatGR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_InpainterBase_setMotions_const_vectorLMatGR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_InpainterBase_motions_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_videostab_InpainterBase_setStabilizedFrames_const_vectorLMatGR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_InpainterBase_setStabilizedFrames_const_vectorLMatGR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_InpainterBase_stabilizedFrames_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_videostab_InpainterBase_setStabilizationMotions_const_vectorLMatGR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_InpainterBase_setStabilizationMotions_const_vectorLMatGR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_InpainterBase_stabilizationMotions_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_videostab_InpainterBase_to_ColorAverageInpainter(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_InpainterBase_to_ColorInpainter(instance: *mut c_void) -> *mut c_void; @@ -16063,28 +16058,28 @@ mod videostab_sys { pub fn cv_videostab_InpainterBase_to_MotionInpainter(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_InpainterBase_to_NullInpainter(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_InpainterBase_delete(instance: *mut c_void); - pub fn cv_videostab_InpaintingPipeline_pushBack_PtrLInpainterBaseG(instance: *mut c_void, inpainter: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_InpaintingPipeline_pushBack_PtrLInpainterBaseG(instance: *mut c_void, inpainter: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_InpaintingPipeline_empty_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_videostab_InpaintingPipeline_setRadius_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_videostab_InpaintingPipeline_setMotionModel_MotionModel(instance: *mut c_void, val: crate::videostab::MotionModel, ocvrs_return: *mut ResultVoid); - pub fn cv_videostab_InpaintingPipeline_setFrames_const_vectorLMatGR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_videostab_InpaintingPipeline_setMotions_const_vectorLMatGR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_videostab_InpaintingPipeline_setStabilizedFrames_const_vectorLMatGR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_videostab_InpaintingPipeline_setStabilizationMotions_const_vectorLMatGR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_videostab_InpaintingPipeline_inpaint_int_MatR_MatR(instance: *mut c_void, idx: i32, frame: *mut c_void, mask: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_InpaintingPipeline_setRadius_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); + pub fn cv_videostab_InpaintingPipeline_setMotionModel_MotionModel(instance: *mut c_void, val: crate::videostab::MotionModel, ocvrs_return: *mut Result<()>); + pub fn cv_videostab_InpaintingPipeline_setFrames_const_vectorLMatGR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_videostab_InpaintingPipeline_setMotions_const_vectorLMatGR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_videostab_InpaintingPipeline_setStabilizedFrames_const_vectorLMatGR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_videostab_InpaintingPipeline_setStabilizationMotions_const_vectorLMatGR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_videostab_InpaintingPipeline_inpaint_int_MatR_MatR(instance: *mut c_void, idx: i32, frame: *mut c_void, mask: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_InpaintingPipeline_defaultNew_const() -> *mut c_void; pub fn cv_videostab_InpaintingPipeline_to_InpainterBase(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_InpaintingPipeline_delete(instance: *mut c_void); pub fn cv_videostab_KeypointBasedMotionEstimator_KeypointBasedMotionEstimator_PtrLMotionEstimatorBaseG(estimator: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_videostab_KeypointBasedMotionEstimator_setMotionModel_MotionModel(instance: *mut c_void, val: crate::videostab::MotionModel, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_KeypointBasedMotionEstimator_setMotionModel_MotionModel(instance: *mut c_void, val: crate::videostab::MotionModel, ocvrs_return: *mut Result<()>); pub fn cv_videostab_KeypointBasedMotionEstimator_motionModel_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_videostab_KeypointBasedMotionEstimator_setDetector_PtrLFeature2DG(instance: *mut c_void, val: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_KeypointBasedMotionEstimator_setDetector_PtrLFeature2DG(instance: *mut c_void, val: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_KeypointBasedMotionEstimator_detector_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_videostab_KeypointBasedMotionEstimator_setOpticalFlowEstimator_PtrLISparseOptFlowEstimatorG(instance: *mut c_void, val: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_KeypointBasedMotionEstimator_setOpticalFlowEstimator_PtrLISparseOptFlowEstimatorG(instance: *mut c_void, val: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_KeypointBasedMotionEstimator_opticalFlowEstimator_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_videostab_KeypointBasedMotionEstimator_setOutlierRejector_PtrLIOutlierRejectorG(instance: *mut c_void, val: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_KeypointBasedMotionEstimator_setOutlierRejector_PtrLIOutlierRejectorG(instance: *mut c_void, val: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_KeypointBasedMotionEstimator_outlierRejector_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_videostab_KeypointBasedMotionEstimator_setFrameMask_const__InputArrayR(instance: *mut c_void, mask: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_KeypointBasedMotionEstimator_setFrameMask_const__InputArrayR(instance: *mut c_void, mask: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_KeypointBasedMotionEstimator_estimate_const_MatR_const_MatR_boolX(instance: *mut c_void, frame0: *const c_void, frame1: *const c_void, ok: *mut bool, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_videostab_KeypointBasedMotionEstimator_estimate_const_MatR_const_MatR(instance: *mut c_void, frame0: *const c_void, frame1: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_videostab_KeypointBasedMotionEstimator_estimate_const__InputArrayR_const__InputArrayR_boolX(instance: *mut c_void, frame0: *const c_void, frame1: *const c_void, ok: *mut bool, ocvrs_return: *mut Result<*mut c_void>); @@ -16092,9 +16087,9 @@ mod videostab_sys { pub fn cv_videostab_KeypointBasedMotionEstimator_to_ImageMotionEstimatorBase(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_KeypointBasedMotionEstimator_delete(instance: *mut c_void); pub fn cv_videostab_KeypointBasedMotionEstimatorGpu_KeypointBasedMotionEstimatorGpu_PtrLMotionEstimatorBaseG(estimator: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_videostab_KeypointBasedMotionEstimatorGpu_setMotionModel_MotionModel(instance: *mut c_void, val: crate::videostab::MotionModel, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_KeypointBasedMotionEstimatorGpu_setMotionModel_MotionModel(instance: *mut c_void, val: crate::videostab::MotionModel, ocvrs_return: *mut Result<()>); pub fn cv_videostab_KeypointBasedMotionEstimatorGpu_motionModel_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_videostab_KeypointBasedMotionEstimatorGpu_setOutlierRejector_PtrLIOutlierRejectorG(instance: *mut c_void, val: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_KeypointBasedMotionEstimatorGpu_setOutlierRejector_PtrLIOutlierRejectorG(instance: *mut c_void, val: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_KeypointBasedMotionEstimatorGpu_outlierRejector_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_videostab_KeypointBasedMotionEstimatorGpu_estimate_const_MatR_const_MatR_boolX(instance: *mut c_void, frame0: *const c_void, frame1: *const c_void, ok: *mut bool, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_videostab_KeypointBasedMotionEstimatorGpu_estimate_const_MatR_const_MatR(instance: *mut c_void, frame0: *const c_void, frame1: *const c_void, ocvrs_return: *mut Result<*mut c_void>); @@ -16102,52 +16097,52 @@ mod videostab_sys { pub fn cv_videostab_KeypointBasedMotionEstimatorGpu_estimate_const_GpuMatR_const_GpuMatR(instance: *mut c_void, frame0: *const c_void, frame1: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_videostab_KeypointBasedMotionEstimatorGpu_to_ImageMotionEstimatorBase(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_KeypointBasedMotionEstimatorGpu_delete(instance: *mut c_void); - pub fn cv_videostab_LogToStdout_print_const_charX(instance: *mut c_void, format: *const c_char, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_LogToStdout_print_const_charX(instance: *mut c_void, format: *const c_char, ocvrs_return: *mut Result<()>); pub fn cv_videostab_LogToStdout_defaultNew_const() -> *mut c_void; pub fn cv_videostab_LogToStdout_to_ILog(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_LogToStdout_delete(instance: *mut c_void); pub fn cv_videostab_LpMotionStabilizer_LpMotionStabilizer_MotionModel(model: crate::videostab::MotionModel, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_videostab_LpMotionStabilizer_LpMotionStabilizer(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_videostab_LpMotionStabilizer_setMotionModel_MotionModel(instance: *mut c_void, val: crate::videostab::MotionModel, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_LpMotionStabilizer_setMotionModel_MotionModel(instance: *mut c_void, val: crate::videostab::MotionModel, ocvrs_return: *mut Result<()>); pub fn cv_videostab_LpMotionStabilizer_motionModel_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_videostab_LpMotionStabilizer_setFrameSize_Size(instance: *mut c_void, val: *const core::Size, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_LpMotionStabilizer_setFrameSize_Size(instance: *mut c_void, val: *const core::Size, ocvrs_return: *mut Result<()>); pub fn cv_videostab_LpMotionStabilizer_frameSize_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_videostab_LpMotionStabilizer_setTrimRatio_float(instance: *mut c_void, val: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_LpMotionStabilizer_setTrimRatio_float(instance: *mut c_void, val: f32, ocvrs_return: *mut Result<()>); pub fn cv_videostab_LpMotionStabilizer_trimRatio_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_videostab_LpMotionStabilizer_setWeight1_float(instance: *mut c_void, val: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_LpMotionStabilizer_setWeight1_float(instance: *mut c_void, val: f32, ocvrs_return: *mut Result<()>); pub fn cv_videostab_LpMotionStabilizer_weight1_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_videostab_LpMotionStabilizer_setWeight2_float(instance: *mut c_void, val: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_LpMotionStabilizer_setWeight2_float(instance: *mut c_void, val: f32, ocvrs_return: *mut Result<()>); pub fn cv_videostab_LpMotionStabilizer_weight2_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_videostab_LpMotionStabilizer_setWeight3_float(instance: *mut c_void, val: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_LpMotionStabilizer_setWeight3_float(instance: *mut c_void, val: f32, ocvrs_return: *mut Result<()>); pub fn cv_videostab_LpMotionStabilizer_weight3_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_videostab_LpMotionStabilizer_setWeight4_float(instance: *mut c_void, val: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_LpMotionStabilizer_setWeight4_float(instance: *mut c_void, val: f32, ocvrs_return: *mut Result<()>); pub fn cv_videostab_LpMotionStabilizer_weight4_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_videostab_LpMotionStabilizer_stabilize_int_const_vectorLMatGR_const_RangeR_MatX(instance: *mut c_void, size: i32, motions: *const c_void, range: *const c_void, stabilization_motions: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_LpMotionStabilizer_stabilize_int_const_vectorLMatGR_const_RangeR_MatX(instance: *mut c_void, size: i32, motions: *const c_void, range: *const c_void, stabilization_motions: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_LpMotionStabilizer_to_IMotionStabilizer(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_LpMotionStabilizer_delete(instance: *mut c_void); pub fn cv_videostab_MaskFrameSource_MaskFrameSource_const_PtrLIFrameSourceGR(source: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_videostab_MaskFrameSource_reset(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_MaskFrameSource_reset(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_MaskFrameSource_nextFrame(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_videostab_MaskFrameSource_to_IFrameSource(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_MaskFrameSource_delete(instance: *mut c_void); - pub fn cv_videostab_MoreAccurateMotionWobbleSuppressor_suppress_int_const_MatR_MatR(instance: *mut c_void, idx: i32, frame: *const c_void, result: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_MoreAccurateMotionWobbleSuppressor_suppress_int_const_MatR_MatR(instance: *mut c_void, idx: i32, frame: *const c_void, result: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_MoreAccurateMotionWobbleSuppressor_defaultNew_const() -> *mut c_void; pub fn cv_videostab_MoreAccurateMotionWobbleSuppressor_to_MoreAccurateMotionWobbleSuppressorBase(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_MoreAccurateMotionWobbleSuppressor_to_WobbleSuppressorBase(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_MoreAccurateMotionWobbleSuppressor_delete(instance: *mut c_void); - pub fn cv_videostab_MoreAccurateMotionWobbleSuppressorBase_setPeriod_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_MoreAccurateMotionWobbleSuppressorBase_setPeriod_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_videostab_MoreAccurateMotionWobbleSuppressorBase_period_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_videostab_MoreAccurateMotionWobbleSuppressorBase_to_MoreAccurateMotionWobbleSuppressor(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_MoreAccurateMotionWobbleSuppressorBase_to_MoreAccurateMotionWobbleSuppressorGpu(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_MoreAccurateMotionWobbleSuppressorBase_to_WobbleSuppressorBase(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_MoreAccurateMotionWobbleSuppressorBase_delete(instance: *mut c_void); - pub fn cv_videostab_MoreAccurateMotionWobbleSuppressorGpu_suppress_int_const_GpuMatR_GpuMatR(instance: *mut c_void, idx: i32, frame: *const c_void, result: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_videostab_MoreAccurateMotionWobbleSuppressorGpu_suppress_int_const_MatR_MatR(instance: *mut c_void, idx: i32, frame: *const c_void, result: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_MoreAccurateMotionWobbleSuppressorGpu_suppress_int_const_GpuMatR_GpuMatR(instance: *mut c_void, idx: i32, frame: *const c_void, result: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_videostab_MoreAccurateMotionWobbleSuppressorGpu_suppress_int_const_MatR_MatR(instance: *mut c_void, idx: i32, frame: *const c_void, result: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_MoreAccurateMotionWobbleSuppressorGpu_defaultNew_const() -> *mut c_void; pub fn cv_videostab_MoreAccurateMotionWobbleSuppressorGpu_to_MoreAccurateMotionWobbleSuppressorBase(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_MoreAccurateMotionWobbleSuppressorGpu_to_WobbleSuppressorBase(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_MoreAccurateMotionWobbleSuppressorGpu_delete(instance: *mut c_void); - pub fn cv_videostab_MotionEstimatorBase_setMotionModel_MotionModel(instance: *mut c_void, val: crate::videostab::MotionModel, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_MotionEstimatorBase_setMotionModel_MotionModel(instance: *mut c_void, val: crate::videostab::MotionModel, ocvrs_return: *mut Result<()>); pub fn cv_videostab_MotionEstimatorBase_motionModel_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_videostab_MotionEstimatorBase_estimate_const__InputArrayR_const__InputArrayR_boolX(instance: *mut c_void, points0: *const c_void, points1: *const c_void, ok: *mut bool, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_videostab_MotionEstimatorBase_estimate_const__InputArrayR_const__InputArrayR(instance: *mut c_void, points0: *const c_void, points1: *const c_void, ocvrs_return: *mut Result<*mut c_void>); @@ -16162,74 +16157,74 @@ mod videostab_sys { pub fn cv_videostab_MotionEstimatorL1_delete(instance: *mut c_void); pub fn cv_videostab_MotionEstimatorRansacL2_MotionEstimatorRansacL2_MotionModel(model: crate::videostab::MotionModel, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_videostab_MotionEstimatorRansacL2_MotionEstimatorRansacL2(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_videostab_MotionEstimatorRansacL2_setRansacParams_const_RansacParamsR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_MotionEstimatorRansacL2_setRansacParams_const_RansacParamsR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_MotionEstimatorRansacL2_ransacParams_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_videostab_MotionEstimatorRansacL2_setMinInlierRatio_float(instance: *mut c_void, val: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_MotionEstimatorRansacL2_setMinInlierRatio_float(instance: *mut c_void, val: f32, ocvrs_return: *mut Result<()>); pub fn cv_videostab_MotionEstimatorRansacL2_minInlierRatio_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_videostab_MotionEstimatorRansacL2_estimate_const__InputArrayR_const__InputArrayR_boolX(instance: *mut c_void, points0: *const c_void, points1: *const c_void, ok: *mut bool, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_videostab_MotionEstimatorRansacL2_estimate_const__InputArrayR_const__InputArrayR(instance: *mut c_void, points0: *const c_void, points1: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_videostab_MotionEstimatorRansacL2_to_MotionEstimatorBase(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_MotionEstimatorRansacL2_delete(instance: *mut c_void); pub fn cv_videostab_MotionFilterBase_stabilize_int_const_vectorLMatGR_const_RangeR(instance: *mut c_void, idx: i32, motions: *const c_void, range: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_videostab_MotionFilterBase_stabilize_int_const_vectorLMatGR_const_RangeR_MatX(instance: *mut c_void, size: i32, motions: *const c_void, range: *const c_void, stabilization_motions: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_MotionFilterBase_stabilize_int_const_vectorLMatGR_const_RangeR_MatX(instance: *mut c_void, size: i32, motions: *const c_void, range: *const c_void, stabilization_motions: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_MotionFilterBase_to_GaussianMotionFilter(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_MotionFilterBase_to_IMotionStabilizer(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_MotionFilterBase_delete(instance: *mut c_void); pub fn cv_videostab_MotionInpainter_MotionInpainter(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_videostab_MotionInpainter_setOptFlowEstimator_PtrLIDenseOptFlowEstimatorG(instance: *mut c_void, val: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_MotionInpainter_setOptFlowEstimator_PtrLIDenseOptFlowEstimatorG(instance: *mut c_void, val: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_MotionInpainter_optFlowEstimator_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_videostab_MotionInpainter_setFlowErrorThreshold_float(instance: *mut c_void, val: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_MotionInpainter_setFlowErrorThreshold_float(instance: *mut c_void, val: f32, ocvrs_return: *mut Result<()>); pub fn cv_videostab_MotionInpainter_flowErrorThreshold_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_videostab_MotionInpainter_setDistThreshold_float(instance: *mut c_void, val: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_MotionInpainter_setDistThreshold_float(instance: *mut c_void, val: f32, ocvrs_return: *mut Result<()>); pub fn cv_videostab_MotionInpainter_distThresh_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_videostab_MotionInpainter_setBorderMode_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_MotionInpainter_setBorderMode_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_videostab_MotionInpainter_borderMode_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_videostab_MotionInpainter_inpaint_int_MatR_MatR(instance: *mut c_void, idx: i32, frame: *mut c_void, mask: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_MotionInpainter_inpaint_int_MatR_MatR(instance: *mut c_void, idx: i32, frame: *mut c_void, mask: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_MotionInpainter_to_InpainterBase(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_MotionInpainter_delete(instance: *mut c_void); - pub fn cv_videostab_MotionStabilizationPipeline_pushBack_PtrLIMotionStabilizerG(instance: *mut c_void, stabilizer: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_MotionStabilizationPipeline_pushBack_PtrLIMotionStabilizerG(instance: *mut c_void, stabilizer: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_MotionStabilizationPipeline_empty_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_videostab_MotionStabilizationPipeline_stabilize_int_const_vectorLMatGR_const_RangeR_MatX(instance: *mut c_void, size: i32, motions: *const c_void, range: *const c_void, stabilization_motions: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_MotionStabilizationPipeline_stabilize_int_const_vectorLMatGR_const_RangeR_MatX(instance: *mut c_void, size: i32, motions: *const c_void, range: *const c_void, stabilization_motions: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_MotionStabilizationPipeline_defaultNew_const() -> *mut c_void; pub fn cv_videostab_MotionStabilizationPipeline_to_IMotionStabilizer(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_MotionStabilizationPipeline_delete(instance: *mut c_void); - pub fn cv_videostab_NullDeblurer_deblur_int_MatR_const_RangeR(instance: *mut c_void, unnamed: i32, unnamed_1: *mut c_void, unnamed_2: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_NullDeblurer_deblur_int_MatR_const_RangeR(instance: *mut c_void, unnamed: i32, unnamed_1: *mut c_void, unnamed_2: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_NullDeblurer_defaultNew_const() -> *mut c_void; pub fn cv_videostab_NullDeblurer_to_DeblurerBase(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_NullDeblurer_delete(instance: *mut c_void); - pub fn cv_videostab_NullFrameSource_reset(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_NullFrameSource_reset(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_NullFrameSource_nextFrame(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_videostab_NullFrameSource_defaultNew_const() -> *mut c_void; pub fn cv_videostab_NullFrameSource_to_IFrameSource(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_NullFrameSource_delete(instance: *mut c_void); - pub fn cv_videostab_NullInpainter_inpaint_int_MatR_MatR(instance: *mut c_void, unnamed: i32, unnamed_1: *mut c_void, unnamed_2: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_NullInpainter_inpaint_int_MatR_MatR(instance: *mut c_void, unnamed: i32, unnamed_1: *mut c_void, unnamed_2: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_NullInpainter_defaultNew_const() -> *mut c_void; pub fn cv_videostab_NullInpainter_to_InpainterBase(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_NullInpainter_delete(instance: *mut c_void); - pub fn cv_videostab_NullLog_print_const_charX(instance: *mut c_void, unnamed: *const c_char, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_NullLog_print_const_charX(instance: *mut c_void, unnamed: *const c_char, ocvrs_return: *mut Result<()>); pub fn cv_videostab_NullLog_defaultNew_const() -> *mut c_void; pub fn cv_videostab_NullLog_to_ILog(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_NullLog_delete(instance: *mut c_void); - pub fn cv_videostab_NullOutlierRejector_process_Size_const__InputArrayR_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, frame_size: *const core::Size, points0: *const c_void, points1: *const c_void, mask: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_NullOutlierRejector_process_Size_const__InputArrayR_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, frame_size: *const core::Size, points0: *const c_void, points1: *const c_void, mask: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_NullOutlierRejector_defaultNew_const() -> *mut c_void; pub fn cv_videostab_NullOutlierRejector_to_IOutlierRejector(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_NullOutlierRejector_delete(instance: *mut c_void); - pub fn cv_videostab_NullWobbleSuppressor_suppress_int_const_MatR_MatR(instance: *mut c_void, idx: i32, frame: *const c_void, result: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_NullWobbleSuppressor_suppress_int_const_MatR_MatR(instance: *mut c_void, idx: i32, frame: *const c_void, result: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_NullWobbleSuppressor_defaultNew_const() -> *mut c_void; pub fn cv_videostab_NullWobbleSuppressor_to_WobbleSuppressorBase(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_NullWobbleSuppressor_delete(instance: *mut c_void); pub fn cv_videostab_OnePassStabilizer_OnePassStabilizer(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_videostab_OnePassStabilizer_setMotionFilter_PtrLMotionFilterBaseG(instance: *mut c_void, val: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_OnePassStabilizer_setMotionFilter_PtrLMotionFilterBaseG(instance: *mut c_void, val: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_OnePassStabilizer_motionFilter_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_videostab_OnePassStabilizer_reset(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_OnePassStabilizer_reset(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_OnePassStabilizer_nextFrame(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_videostab_OnePassStabilizer_to_IFrameSource(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_OnePassStabilizer_to_StabilizerBase(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_OnePassStabilizer_delete(instance: *mut c_void); pub fn cv_videostab_PyrLkOptFlowEstimatorBase_PyrLkOptFlowEstimatorBase(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_videostab_PyrLkOptFlowEstimatorBase_setWinSize_Size(instance: *mut c_void, val: *const core::Size, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_PyrLkOptFlowEstimatorBase_setWinSize_Size(instance: *mut c_void, val: *const core::Size, ocvrs_return: *mut Result<()>); pub fn cv_videostab_PyrLkOptFlowEstimatorBase_winSize_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_videostab_PyrLkOptFlowEstimatorBase_setMaxLevel_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_PyrLkOptFlowEstimatorBase_setMaxLevel_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_videostab_PyrLkOptFlowEstimatorBase_maxLevel_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_videostab_PyrLkOptFlowEstimatorBase_to_DensePyrLkOptFlowEstimatorGpu(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_PyrLkOptFlowEstimatorBase_to_SparsePyrLkOptFlowEstimator(instance: *mut c_void) -> *mut c_void; @@ -16248,72 +16243,72 @@ mod videostab_sys { pub fn cv_videostab_RansacParams_propProb_const(instance: *const c_void) -> f32; pub fn cv_videostab_RansacParams_propProb_const_float(instance: *mut c_void, val: f32); pub fn cv_videostab_RansacParams_delete(instance: *mut c_void); - pub fn cv_videostab_SparsePyrLkOptFlowEstimator_run_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *mut c_void, frame0: *const c_void, frame1: *const c_void, points0: *const c_void, points1: *const c_void, status: *const c_void, errors: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_SparsePyrLkOptFlowEstimator_run_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *mut c_void, frame0: *const c_void, frame1: *const c_void, points0: *const c_void, points1: *const c_void, status: *const c_void, errors: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_SparsePyrLkOptFlowEstimator_defaultNew_const() -> *mut c_void; pub fn cv_videostab_SparsePyrLkOptFlowEstimator_to_ISparseOptFlowEstimator(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_SparsePyrLkOptFlowEstimator_to_PyrLkOptFlowEstimatorBase(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_SparsePyrLkOptFlowEstimator_delete(instance: *mut c_void); pub fn cv_videostab_SparsePyrLkOptFlowEstimatorGpu_SparsePyrLkOptFlowEstimatorGpu(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_videostab_SparsePyrLkOptFlowEstimatorGpu_run_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *mut c_void, frame0: *const c_void, frame1: *const c_void, points0: *const c_void, points1: *const c_void, status: *const c_void, errors: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_videostab_SparsePyrLkOptFlowEstimatorGpu_run_const_GpuMatR_const_GpuMatR_const_GpuMatR_GpuMatR_GpuMatR_GpuMatR(instance: *mut c_void, frame0: *const c_void, frame1: *const c_void, points0: *const c_void, points1: *mut c_void, status: *mut c_void, errors: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_videostab_SparsePyrLkOptFlowEstimatorGpu_run_const_GpuMatR_const_GpuMatR_const_GpuMatR_GpuMatR_GpuMatR(instance: *mut c_void, frame0: *const c_void, frame1: *const c_void, points0: *const c_void, points1: *mut c_void, status: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_SparsePyrLkOptFlowEstimatorGpu_run_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputOutputArrayR_const__OutputArrayR_const__OutputArrayR(instance: *mut c_void, frame0: *const c_void, frame1: *const c_void, points0: *const c_void, points1: *const c_void, status: *const c_void, errors: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_videostab_SparsePyrLkOptFlowEstimatorGpu_run_const_GpuMatR_const_GpuMatR_const_GpuMatR_GpuMatR_GpuMatR_GpuMatR(instance: *mut c_void, frame0: *const c_void, frame1: *const c_void, points0: *const c_void, points1: *mut c_void, status: *mut c_void, errors: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_videostab_SparsePyrLkOptFlowEstimatorGpu_run_const_GpuMatR_const_GpuMatR_const_GpuMatR_GpuMatR_GpuMatR(instance: *mut c_void, frame0: *const c_void, frame1: *const c_void, points0: *const c_void, points1: *mut c_void, status: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_SparsePyrLkOptFlowEstimatorGpu_to_ISparseOptFlowEstimator(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_SparsePyrLkOptFlowEstimatorGpu_to_PyrLkOptFlowEstimatorBase(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_SparsePyrLkOptFlowEstimatorGpu_delete(instance: *mut c_void); - pub fn cv_videostab_StabilizerBase_setLog_PtrLILogG(instance: *mut c_void, ilog: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_StabilizerBase_setLog_PtrLILogG(instance: *mut c_void, ilog: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_StabilizerBase_log_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_videostab_StabilizerBase_setRadius_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_StabilizerBase_setRadius_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_videostab_StabilizerBase_radius_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_videostab_StabilizerBase_setFrameSource_PtrLIFrameSourceG(instance: *mut c_void, val: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_StabilizerBase_setFrameSource_PtrLIFrameSourceG(instance: *mut c_void, val: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_StabilizerBase_frameSource_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_videostab_StabilizerBase_setMaskSource_const_PtrLIFrameSourceGR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_StabilizerBase_setMaskSource_const_PtrLIFrameSourceGR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_StabilizerBase_maskSource_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_videostab_StabilizerBase_setMotionEstimator_PtrLImageMotionEstimatorBaseG(instance: *mut c_void, val: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_StabilizerBase_setMotionEstimator_PtrLImageMotionEstimatorBaseG(instance: *mut c_void, val: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_StabilizerBase_motionEstimator_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_videostab_StabilizerBase_setDeblurer_PtrLDeblurerBaseG(instance: *mut c_void, val: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_StabilizerBase_setDeblurer_PtrLDeblurerBaseG(instance: *mut c_void, val: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_StabilizerBase_deblurrer_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_videostab_StabilizerBase_setTrimRatio_float(instance: *mut c_void, val: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_StabilizerBase_setTrimRatio_float(instance: *mut c_void, val: f32, ocvrs_return: *mut Result<()>); pub fn cv_videostab_StabilizerBase_trimRatio_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_videostab_StabilizerBase_setCorrectionForInclusion_bool(instance: *mut c_void, val: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_StabilizerBase_setCorrectionForInclusion_bool(instance: *mut c_void, val: bool, ocvrs_return: *mut Result<()>); pub fn cv_videostab_StabilizerBase_doCorrectionForInclusion_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_videostab_StabilizerBase_setBorderMode_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_StabilizerBase_setBorderMode_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_videostab_StabilizerBase_borderMode_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_videostab_StabilizerBase_setInpainter_PtrLInpainterBaseG(instance: *mut c_void, val: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_StabilizerBase_setInpainter_PtrLInpainterBaseG(instance: *mut c_void, val: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_StabilizerBase_inpainter_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_videostab_StabilizerBase_to_OnePassStabilizer(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_StabilizerBase_to_TwoPassStabilizer(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_StabilizerBase_delete(instance: *mut c_void); pub fn cv_videostab_ToFileMotionWriter_ToFileMotionWriter_const_StringR_PtrLImageMotionEstimatorBaseG(path: *const c_char, estimator: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_videostab_ToFileMotionWriter_setMotionModel_MotionModel(instance: *mut c_void, val: crate::videostab::MotionModel, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_ToFileMotionWriter_setMotionModel_MotionModel(instance: *mut c_void, val: crate::videostab::MotionModel, ocvrs_return: *mut Result<()>); pub fn cv_videostab_ToFileMotionWriter_motionModel_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_videostab_ToFileMotionWriter_setFrameMask_const__InputArrayR(instance: *mut c_void, mask: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_ToFileMotionWriter_setFrameMask_const__InputArrayR(instance: *mut c_void, mask: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_ToFileMotionWriter_estimate_const_MatR_const_MatR_boolX(instance: *mut c_void, frame0: *const c_void, frame1: *const c_void, ok: *mut bool, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_videostab_ToFileMotionWriter_estimate_const_MatR_const_MatR(instance: *mut c_void, frame0: *const c_void, frame1: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_videostab_ToFileMotionWriter_to_ImageMotionEstimatorBase(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_ToFileMotionWriter_delete(instance: *mut c_void); pub fn cv_videostab_TranslationBasedLocalOutlierRejector_TranslationBasedLocalOutlierRejector(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_videostab_TranslationBasedLocalOutlierRejector_setCellSize_Size(instance: *mut c_void, val: *const core::Size, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_TranslationBasedLocalOutlierRejector_setCellSize_Size(instance: *mut c_void, val: *const core::Size, ocvrs_return: *mut Result<()>); pub fn cv_videostab_TranslationBasedLocalOutlierRejector_cellSize_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_videostab_TranslationBasedLocalOutlierRejector_setRansacParams_RansacParams(instance: *mut c_void, val: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_TranslationBasedLocalOutlierRejector_setRansacParams_RansacParams(instance: *mut c_void, val: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_TranslationBasedLocalOutlierRejector_ransacParams_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_videostab_TranslationBasedLocalOutlierRejector_process_Size_const__InputArrayR_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, frame_size: *const core::Size, points0: *const c_void, points1: *const c_void, mask: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_TranslationBasedLocalOutlierRejector_process_Size_const__InputArrayR_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, frame_size: *const core::Size, points0: *const c_void, points1: *const c_void, mask: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_TranslationBasedLocalOutlierRejector_to_IOutlierRejector(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_TranslationBasedLocalOutlierRejector_delete(instance: *mut c_void); pub fn cv_videostab_TwoPassStabilizer_TwoPassStabilizer(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_videostab_TwoPassStabilizer_setMotionStabilizer_PtrLIMotionStabilizerG(instance: *mut c_void, val: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_TwoPassStabilizer_setMotionStabilizer_PtrLIMotionStabilizerG(instance: *mut c_void, val: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_TwoPassStabilizer_motionStabilizer_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_videostab_TwoPassStabilizer_setWobbleSuppressor_PtrLWobbleSuppressorBaseG(instance: *mut c_void, val: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_TwoPassStabilizer_setWobbleSuppressor_PtrLWobbleSuppressorBaseG(instance: *mut c_void, val: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_TwoPassStabilizer_wobbleSuppressor_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_videostab_TwoPassStabilizer_setEstimateTrimRatio_bool(instance: *mut c_void, val: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_TwoPassStabilizer_setEstimateTrimRatio_bool(instance: *mut c_void, val: bool, ocvrs_return: *mut Result<()>); pub fn cv_videostab_TwoPassStabilizer_mustEstimateTrimaRatio_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_videostab_TwoPassStabilizer_reset(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_TwoPassStabilizer_reset(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_TwoPassStabilizer_nextFrame(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_videostab_TwoPassStabilizer_to_IFrameSource(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_TwoPassStabilizer_to_StabilizerBase(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_TwoPassStabilizer_delete(instance: *mut c_void); pub fn cv_videostab_VideoFileSource_VideoFileSource_const_StringR_bool(path: *const c_char, volatile_frame: bool, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_videostab_VideoFileSource_VideoFileSource_const_StringR(path: *const c_char, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_videostab_VideoFileSource_reset(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_VideoFileSource_reset(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_VideoFileSource_nextFrame(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_videostab_VideoFileSource_width(instance: *mut c_void, ocvrs_return: *mut Result); pub fn cv_videostab_VideoFileSource_height(instance: *mut c_void, ocvrs_return: *mut Result); @@ -16322,21 +16317,21 @@ mod videostab_sys { pub fn cv_videostab_VideoFileSource_to_IFrameSource(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_VideoFileSource_delete(instance: *mut c_void); pub fn cv_videostab_WeightingDeblurer_WeightingDeblurer(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_videostab_WeightingDeblurer_setSensitivity_float(instance: *mut c_void, val: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_WeightingDeblurer_setSensitivity_float(instance: *mut c_void, val: f32, ocvrs_return: *mut Result<()>); pub fn cv_videostab_WeightingDeblurer_sensitivity_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_videostab_WeightingDeblurer_deblur_int_MatR_const_RangeR(instance: *mut c_void, idx: i32, frame: *mut c_void, range: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_WeightingDeblurer_deblur_int_MatR_const_RangeR(instance: *mut c_void, idx: i32, frame: *mut c_void, range: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_WeightingDeblurer_to_DeblurerBase(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_WeightingDeblurer_delete(instance: *mut c_void); - pub fn cv_videostab_WobbleSuppressorBase_setMotionEstimator_PtrLImageMotionEstimatorBaseG(instance: *mut c_void, val: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_WobbleSuppressorBase_setMotionEstimator_PtrLImageMotionEstimatorBaseG(instance: *mut c_void, val: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_WobbleSuppressorBase_motionEstimator_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_videostab_WobbleSuppressorBase_suppress_int_const_MatR_MatR(instance: *mut c_void, idx: i32, frame: *const c_void, result: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_videostab_WobbleSuppressorBase_setFrameCount_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_WobbleSuppressorBase_suppress_int_const_MatR_MatR(instance: *mut c_void, idx: i32, frame: *const c_void, result: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_videostab_WobbleSuppressorBase_setFrameCount_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_videostab_WobbleSuppressorBase_frameCount_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_videostab_WobbleSuppressorBase_setMotions_const_vectorLMatGR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_WobbleSuppressorBase_setMotions_const_vectorLMatGR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_WobbleSuppressorBase_motions_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_videostab_WobbleSuppressorBase_setMotions2_const_vectorLMatGR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_WobbleSuppressorBase_setMotions2_const_vectorLMatGR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_WobbleSuppressorBase_motions2_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_videostab_WobbleSuppressorBase_setStabilizationMotions_const_vectorLMatGR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_videostab_WobbleSuppressorBase_setStabilizationMotions_const_vectorLMatGR(instance: *mut c_void, val: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_videostab_WobbleSuppressorBase_stabilizationMotions_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_videostab_WobbleSuppressorBase_to_MoreAccurateMotionWobbleSuppressor(instance: *mut c_void) -> *mut c_void; pub fn cv_videostab_WobbleSuppressorBase_to_MoreAccurateMotionWobbleSuppressorBase(instance: *mut c_void) -> *mut c_void; @@ -16608,15 +16603,13 @@ mod videostab_sys { pub fn cv_PtrLcv_videostab_WobbleSuppressorBaseG_delete(instance: *mut c_void); } } -#[cfg(ocvrs_has_module_videostab)] pub use videostab_sys::*; -#[cfg(ocvrs_has_module_viz)] mod viz_sys { use super::*; extern "C" { - pub fn cv_viz_computeNormals_const_MeshR_const__OutputArrayR(mesh: *const c_void, normals: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_viz_computeNormals_const_MeshR_const__OutputArrayR(mesh: *const c_void, normals: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_viz_getWindowByName_const_StringR(window_name: *const c_char, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_viz_imshow_const_StringR_const__InputArrayR(window_name: *const c_char, image: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_viz_imshow_const_StringR_const__InputArrayR_const_SizeR(window_name: *const c_char, image: *const c_void, window_size: *const core::Size, ocvrs_return: *mut Result<*mut c_void>); @@ -16628,28 +16621,28 @@ mod viz_sys { pub fn cv_viz_readMesh_const_StringR(file: *const c_char, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_viz_readPose_const_StringR_Affine3dR(file: *const c_char, pose: *mut core::Affine3d, ocvrs_return: *mut Result); pub fn cv_viz_readPose_const_StringR_Affine3dR_const_StringR(file: *const c_char, pose: *mut core::Affine3d, tag: *const c_char, ocvrs_return: *mut Result); - pub fn cv_viz_readTrajectory_const__OutputArrayR(traj: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_viz_readTrajectory_const__OutputArrayR_const_StringR_int_int_const_StringR(traj: *const c_void, files_format: *const c_char, start: i32, end: i32, tag: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_viz_unregisterAllWindows(ocvrs_return: *mut ResultVoid); - pub fn cv_viz_writeCloud_const_StringR_const__InputArrayR(file: *const c_char, cloud: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_viz_writeCloud_const_StringR_const__InputArrayR_const__InputArrayR_const__InputArrayR_bool(file: *const c_char, cloud: *const c_void, colors: *const c_void, normals: *const c_void, binary: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_viz_writePose_const_StringR_const_Affine3dR(file: *const c_char, pose: *const core::Affine3d, ocvrs_return: *mut ResultVoid); - pub fn cv_viz_writePose_const_StringR_const_Affine3dR_const_StringR(file: *const c_char, pose: *const core::Affine3d, tag: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_viz_writeTrajectory_const__InputArrayR(traj: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_viz_writeTrajectory_const__InputArrayR_const_StringR_int_const_StringR(traj: *const c_void, files_format: *const c_char, start: i32, tag: *const c_char, ocvrs_return: *mut ResultVoid); + pub fn cv_viz_readTrajectory_const__OutputArrayR(traj: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_viz_readTrajectory_const__OutputArrayR_const_StringR_int_int_const_StringR(traj: *const c_void, files_format: *const c_char, start: i32, end: i32, tag: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_viz_unregisterAllWindows(ocvrs_return: *mut Result<()>); + pub fn cv_viz_writeCloud_const_StringR_const__InputArrayR(file: *const c_char, cloud: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_viz_writeCloud_const_StringR_const__InputArrayR_const__InputArrayR_const__InputArrayR_bool(file: *const c_char, cloud: *const c_void, colors: *const c_void, normals: *const c_void, binary: bool, ocvrs_return: *mut Result<()>); + pub fn cv_viz_writePose_const_StringR_const_Affine3dR(file: *const c_char, pose: *const core::Affine3d, ocvrs_return: *mut Result<()>); + pub fn cv_viz_writePose_const_StringR_const_Affine3dR_const_StringR(file: *const c_char, pose: *const core::Affine3d, tag: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_viz_writeTrajectory_const__InputArrayR(traj: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_viz_writeTrajectory_const__InputArrayR_const_StringR_int_const_StringR(traj: *const c_void, files_format: *const c_char, start: i32, tag: *const c_char, ocvrs_return: *mut Result<()>); pub fn cv_viz_Camera_Camera_double_double_double_double_const_SizeR(fx: f64, fy: f64, cx: f64, cy: f64, window_size: *const core::Size, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_viz_Camera_Camera_const_Vec2dR_const_SizeR(fov: *const core::Vec2d, window_size: *const core::Size, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_viz_Camera_Camera_const_Matx33dR_const_SizeR(k: *const core::Matx33d, window_size: *const core::Size, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_viz_Camera_Camera_const_Matx44dR_const_SizeR(proj: *const core::Matx44d, window_size: *const core::Size, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_viz_Camera_getClip_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_viz_Camera_setClip_const_Vec2dR(instance: *mut c_void, clip: *const core::Vec2d, ocvrs_return: *mut ResultVoid); + pub fn cv_viz_Camera_setClip_const_Vec2dR(instance: *mut c_void, clip: *const core::Vec2d, ocvrs_return: *mut Result<()>); pub fn cv_viz_Camera_getWindowSize_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_viz_Camera_setWindowSize_const_SizeR(instance: *mut c_void, window_size: *const core::Size, ocvrs_return: *mut ResultVoid); + pub fn cv_viz_Camera_setWindowSize_const_SizeR(instance: *mut c_void, window_size: *const core::Size, ocvrs_return: *mut Result<()>); pub fn cv_viz_Camera_getFov_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_viz_Camera_setFov_const_Vec2dR(instance: *mut c_void, fov: *const core::Vec2d, ocvrs_return: *mut ResultVoid); + pub fn cv_viz_Camera_setFov_const_Vec2dR(instance: *mut c_void, fov: *const core::Vec2d, ocvrs_return: *mut Result<()>); pub fn cv_viz_Camera_getPrincipalPoint_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_viz_Camera_getFocalLength_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_viz_Camera_computeProjectionMatrix_const_Matx44dR(instance: *const c_void, proj: *mut core::Matx44d, ocvrs_return: *mut ResultVoid); + pub fn cv_viz_Camera_computeProjectionMatrix_const_Matx44dR(instance: *const c_void, proj: *mut core::Matx44d, ocvrs_return: *mut Result<()>); pub fn cv_viz_Camera_KinectCamera_const_SizeR(window_size: *const core::Size, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_viz_Camera_delete(instance: *mut c_void); pub fn cv_viz_Color_Color(ocvrs_return: *mut Result<*mut c_void>); @@ -16733,54 +16726,54 @@ mod viz_sys { pub fn cv_viz_Viz3d_Viz3d_const_StringR(window_name: *const c_char, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_viz_Viz3d_Viz3d(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_viz_Viz3d_Viz3d_const_Viz3dR(unnamed: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_viz_Viz3d_operatorST_const_Viz3dR(instance: *mut c_void, unnamed: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_viz_Viz3d_showWidget_const_StringR_const_WidgetR_const_Affine3dR(instance: *mut c_void, id: *const c_char, widget: *const c_void, pose: *const core::Affine3d, ocvrs_return: *mut ResultVoid); - pub fn cv_viz_Viz3d_showWidget_const_StringR_const_WidgetR(instance: *mut c_void, id: *const c_char, widget: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_viz_Viz3d_removeWidget_const_StringR(instance: *mut c_void, id: *const c_char, ocvrs_return: *mut ResultVoid); + pub fn cv_viz_Viz3d_operatorST_const_Viz3dR(instance: *mut c_void, unnamed: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_viz_Viz3d_showWidget_const_StringR_const_WidgetR_const_Affine3dR(instance: *mut c_void, id: *const c_char, widget: *const c_void, pose: *const core::Affine3d, ocvrs_return: *mut Result<()>); + pub fn cv_viz_Viz3d_showWidget_const_StringR_const_WidgetR(instance: *mut c_void, id: *const c_char, widget: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_viz_Viz3d_removeWidget_const_StringR(instance: *mut c_void, id: *const c_char, ocvrs_return: *mut Result<()>); pub fn cv_viz_Viz3d_getWidget_const_const_StringR(instance: *const c_void, id: *const c_char, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_viz_Viz3d_removeAllWidgets(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_viz_Viz3d_showImage_const__InputArrayR_const_SizeR(instance: *mut c_void, image: *const c_void, window_size: *const core::Size, ocvrs_return: *mut ResultVoid); - pub fn cv_viz_Viz3d_showImage_const__InputArrayR(instance: *mut c_void, image: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_viz_Viz3d_setWidgetPose_const_StringR_const_Affine3dR(instance: *mut c_void, id: *const c_char, pose: *const core::Affine3d, ocvrs_return: *mut ResultVoid); - pub fn cv_viz_Viz3d_updateWidgetPose_const_StringR_const_Affine3dR(instance: *mut c_void, id: *const c_char, pose: *const core::Affine3d, ocvrs_return: *mut ResultVoid); + pub fn cv_viz_Viz3d_removeAllWidgets(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_viz_Viz3d_showImage_const__InputArrayR_const_SizeR(instance: *mut c_void, image: *const c_void, window_size: *const core::Size, ocvrs_return: *mut Result<()>); + pub fn cv_viz_Viz3d_showImage_const__InputArrayR(instance: *mut c_void, image: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_viz_Viz3d_setWidgetPose_const_StringR_const_Affine3dR(instance: *mut c_void, id: *const c_char, pose: *const core::Affine3d, ocvrs_return: *mut Result<()>); + pub fn cv_viz_Viz3d_updateWidgetPose_const_StringR_const_Affine3dR(instance: *mut c_void, id: *const c_char, pose: *const core::Affine3d, ocvrs_return: *mut Result<()>); pub fn cv_viz_Viz3d_getWidgetPose_const_const_StringR(instance: *const c_void, id: *const c_char, ocvrs_return: *mut Result); - pub fn cv_viz_Viz3d_setCamera_const_CameraR(instance: *mut c_void, camera: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_viz_Viz3d_setCamera_const_CameraR(instance: *mut c_void, camera: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_viz_Viz3d_getCamera_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_viz_Viz3d_getViewerPose_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_viz_Viz3d_setViewerPose_const_Affine3dR(instance: *mut c_void, pose: *const core::Affine3d, ocvrs_return: *mut ResultVoid); - pub fn cv_viz_Viz3d_resetCameraViewpoint_const_StringR(instance: *mut c_void, id: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_viz_Viz3d_resetCamera(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_viz_Viz3d_convertToWindowCoordinates_const_Point3dR_Point3dR(instance: *mut c_void, pt: *const core::Point3d, window_coord: *mut core::Point3d, ocvrs_return: *mut ResultVoid); - pub fn cv_viz_Viz3d_converTo3DRay_const_Point3dR_Point3dR_Vec3dR(instance: *mut c_void, window_coord: *const core::Point3d, origin: *mut core::Point3d, direction: *mut core::Vec3d, ocvrs_return: *mut ResultVoid); + pub fn cv_viz_Viz3d_setViewerPose_const_Affine3dR(instance: *mut c_void, pose: *const core::Affine3d, ocvrs_return: *mut Result<()>); + pub fn cv_viz_Viz3d_resetCameraViewpoint_const_StringR(instance: *mut c_void, id: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_viz_Viz3d_resetCamera(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_viz_Viz3d_convertToWindowCoordinates_const_Point3dR_Point3dR(instance: *mut c_void, pt: *const core::Point3d, window_coord: *mut core::Point3d, ocvrs_return: *mut Result<()>); + pub fn cv_viz_Viz3d_converTo3DRay_const_Point3dR_Point3dR_Vec3dR(instance: *mut c_void, window_coord: *const core::Point3d, origin: *mut core::Point3d, direction: *mut core::Vec3d, ocvrs_return: *mut Result<()>); pub fn cv_viz_Viz3d_getWindowSize_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_viz_Viz3d_setWindowSize_const_SizeR(instance: *mut c_void, window_size: *const core::Size, ocvrs_return: *mut ResultVoid); + pub fn cv_viz_Viz3d_setWindowSize_const_SizeR(instance: *mut c_void, window_size: *const core::Size, ocvrs_return: *mut Result<()>); pub fn cv_viz_Viz3d_getWindowName_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_viz_Viz3d_getScreenshot_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_viz_Viz3d_saveScreenshot_const_StringR(instance: *mut c_void, file: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_viz_Viz3d_setWindowPosition_const_PointR(instance: *mut c_void, window_position: *const core::Point, ocvrs_return: *mut ResultVoid); - pub fn cv_viz_Viz3d_setFullScreen_bool(instance: *mut c_void, mode: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_viz_Viz3d_setFullScreen(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_viz_Viz3d_setBackgroundColor_const_ColorR_const_ColorR(instance: *mut c_void, color: *const c_void, color2: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_viz_Viz3d_setBackgroundColor(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_viz_Viz3d_setBackgroundTexture_const__InputArrayR(instance: *mut c_void, image: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_viz_Viz3d_setBackgroundTexture(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_viz_Viz3d_setBackgroundMeshLab(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_viz_Viz3d_spin(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_viz_Viz3d_spinOnce_int_bool(instance: *mut c_void, time: i32, force_redraw: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_viz_Viz3d_spinOnce(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_viz_Viz3d_setOffScreenRendering(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_viz_Viz3d_removeAllLights(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_viz_Viz3d_addLight_const_Vec3dR_const_Vec3dR_const_ColorR_const_ColorR_const_ColorR_const_ColorR(instance: *mut c_void, position: *const core::Vec3d, focal_point: *const core::Vec3d, color: *const c_void, diffuse_color: *const c_void, ambient_color: *const c_void, specular_color: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_viz_Viz3d_addLight_const_Vec3dR(instance: *mut c_void, position: *const core::Vec3d, ocvrs_return: *mut ResultVoid); + pub fn cv_viz_Viz3d_saveScreenshot_const_StringR(instance: *mut c_void, file: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_viz_Viz3d_setWindowPosition_const_PointR(instance: *mut c_void, window_position: *const core::Point, ocvrs_return: *mut Result<()>); + pub fn cv_viz_Viz3d_setFullScreen_bool(instance: *mut c_void, mode: bool, ocvrs_return: *mut Result<()>); + pub fn cv_viz_Viz3d_setFullScreen(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_viz_Viz3d_setBackgroundColor_const_ColorR_const_ColorR(instance: *mut c_void, color: *const c_void, color2: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_viz_Viz3d_setBackgroundColor(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_viz_Viz3d_setBackgroundTexture_const__InputArrayR(instance: *mut c_void, image: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_viz_Viz3d_setBackgroundTexture(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_viz_Viz3d_setBackgroundMeshLab(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_viz_Viz3d_spin(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_viz_Viz3d_spinOnce_int_bool(instance: *mut c_void, time: i32, force_redraw: bool, ocvrs_return: *mut Result<()>); + pub fn cv_viz_Viz3d_spinOnce(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_viz_Viz3d_setOffScreenRendering(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_viz_Viz3d_removeAllLights(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_viz_Viz3d_addLight_const_Vec3dR_const_Vec3dR_const_ColorR_const_ColorR_const_ColorR_const_ColorR(instance: *mut c_void, position: *const core::Vec3d, focal_point: *const core::Vec3d, color: *const c_void, diffuse_color: *const c_void, ambient_color: *const c_void, specular_color: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_viz_Viz3d_addLight_const_Vec3dR(instance: *mut c_void, position: *const core::Vec3d, ocvrs_return: *mut Result<()>); pub fn cv_viz_Viz3d_wasStopped_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_viz_Viz3d_close(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_viz_Viz3d_registerKeyboardCallback_KeyboardCallback_voidX(instance: *mut c_void, callback: Option ()>, cookie: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_viz_Viz3d_registerMouseCallback_MouseCallback_voidX(instance: *mut c_void, callback: Option ()>, cookie: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_viz_Viz3d_setRenderingProperty_const_StringR_int_double(instance: *mut c_void, id: *const c_char, property: i32, value: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_viz_Viz3d_close(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_viz_Viz3d_registerKeyboardCallback_KeyboardCallback_voidX(instance: *mut c_void, callback: Option ()>, cookie: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_viz_Viz3d_registerMouseCallback_MouseCallback_voidX(instance: *mut c_void, callback: Option ()>, cookie: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_viz_Viz3d_setRenderingProperty_const_StringR_int_double(instance: *mut c_void, id: *const c_char, property: i32, value: f64, ocvrs_return: *mut Result<()>); pub fn cv_viz_Viz3d_getRenderingProperty_const_StringR_int(instance: *mut c_void, id: *const c_char, property: i32, ocvrs_return: *mut Result); - pub fn cv_viz_Viz3d_setRepresentation_int(instance: *mut c_void, representation: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_viz_Viz3d_setGlobalWarnings_bool(instance: *mut c_void, enabled: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_viz_Viz3d_setGlobalWarnings(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_viz_Viz3d_setRepresentation_int(instance: *mut c_void, representation: i32, ocvrs_return: *mut Result<()>); + pub fn cv_viz_Viz3d_setGlobalWarnings_bool(instance: *mut c_void, enabled: bool, ocvrs_return: *mut Result<()>); + pub fn cv_viz_Viz3d_setGlobalWarnings(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_viz_Viz3d_delete(instance: *mut c_void); pub fn cv_viz_WArrow_WArrow_const_Point3dR_const_Point3dR_double_const_ColorR(pt1: *const core::Point3d, pt2: *const core::Point3d, thickness: f64, color: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_viz_WArrow_WArrow_const_Point3dR_const_Point3dR(pt1: *const core::Point3d, pt2: *const core::Point3d, ocvrs_return: *mut Result<*mut c_void>); @@ -16816,11 +16809,11 @@ mod viz_sys { pub fn cv_viz_WCloud_to_Widget3D(instance: *mut c_void) -> *mut c_void; pub fn cv_viz_WCloud_delete(instance: *mut c_void); pub fn cv_viz_WCloudCollection_WCloudCollection(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_viz_WCloudCollection_addCloud_const__InputArrayR_const__InputArrayR_const_Affine3dR(instance: *mut c_void, cloud: *const c_void, colors: *const c_void, pose: *const core::Affine3d, ocvrs_return: *mut ResultVoid); - pub fn cv_viz_WCloudCollection_addCloud_const__InputArrayR_const__InputArrayR(instance: *mut c_void, cloud: *const c_void, colors: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_viz_WCloudCollection_addCloud_const__InputArrayR_const_ColorR_const_Affine3dR(instance: *mut c_void, cloud: *const c_void, color: *const c_void, pose: *const core::Affine3d, ocvrs_return: *mut ResultVoid); - pub fn cv_viz_WCloudCollection_addCloud_const__InputArrayR(instance: *mut c_void, cloud: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_viz_WCloudCollection_finalize(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_viz_WCloudCollection_addCloud_const__InputArrayR_const__InputArrayR_const_Affine3dR(instance: *mut c_void, cloud: *const c_void, colors: *const c_void, pose: *const core::Affine3d, ocvrs_return: *mut Result<()>); + pub fn cv_viz_WCloudCollection_addCloud_const__InputArrayR_const__InputArrayR(instance: *mut c_void, cloud: *const c_void, colors: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_viz_WCloudCollection_addCloud_const__InputArrayR_const_ColorR_const_Affine3dR(instance: *mut c_void, cloud: *const c_void, color: *const c_void, pose: *const core::Affine3d, ocvrs_return: *mut Result<()>); + pub fn cv_viz_WCloudCollection_addCloud_const__InputArrayR(instance: *mut c_void, cloud: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_viz_WCloudCollection_finalize(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_viz_WCloudCollection_to_Widget(instance: *mut c_void) -> *mut c_void; pub fn cv_viz_WCloudCollection_to_Widget3D(instance: *mut c_void) -> *mut c_void; pub fn cv_viz_WCloudCollection_delete(instance: *mut c_void); @@ -16860,13 +16853,13 @@ mod viz_sys { pub fn cv_viz_WGrid_delete(instance: *mut c_void); pub fn cv_viz_WImage3D_WImage3D_const__InputArrayR_const_Size2dR(image: *const c_void, size: *const core::Size2d, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_viz_WImage3D_WImage3D_const__InputArrayR_const_Size2dR_const_Vec3dR_const_Vec3dR_const_Vec3dR(image: *const c_void, size: *const core::Size2d, center: *const core::Vec3d, normal: *const core::Vec3d, up_vector: *const core::Vec3d, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_viz_WImage3D_setImage_const__InputArrayR(instance: *mut c_void, image: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_viz_WImage3D_setSize_const_SizeR(instance: *mut c_void, size: *const core::Size, ocvrs_return: *mut ResultVoid); + pub fn cv_viz_WImage3D_setImage_const__InputArrayR(instance: *mut c_void, image: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_viz_WImage3D_setSize_const_SizeR(instance: *mut c_void, size: *const core::Size, ocvrs_return: *mut Result<()>); pub fn cv_viz_WImage3D_to_Widget(instance: *mut c_void) -> *mut c_void; pub fn cv_viz_WImage3D_to_Widget3D(instance: *mut c_void) -> *mut c_void; pub fn cv_viz_WImage3D_delete(instance: *mut c_void); pub fn cv_viz_WImageOverlay_WImageOverlay_const__InputArrayR_const_RectR(image: *const c_void, rect: *const core::Rect, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_viz_WImageOverlay_setImage_const__InputArrayR(instance: *mut c_void, image: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_viz_WImageOverlay_setImage_const__InputArrayR(instance: *mut c_void, image: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_viz_WImageOverlay_to_Widget(instance: *mut c_void) -> *mut c_void; pub fn cv_viz_WImageOverlay_to_Widget2D(instance: *mut c_void) -> *mut c_void; pub fn cv_viz_WImageOverlay_delete(instance: *mut c_void); @@ -16907,14 +16900,14 @@ mod viz_sys { pub fn cv_viz_WSphere_delete(instance: *mut c_void); pub fn cv_viz_WText_WText_const_StringR_const_PointR_int_const_ColorR(text: *const c_char, pos: *const core::Point, font_size: i32, color: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_viz_WText_WText_const_StringR_const_PointR(text: *const c_char, pos: *const core::Point, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_viz_WText_setText_const_StringR(instance: *mut c_void, text: *const c_char, ocvrs_return: *mut ResultVoid); + pub fn cv_viz_WText_setText_const_StringR(instance: *mut c_void, text: *const c_char, ocvrs_return: *mut Result<()>); pub fn cv_viz_WText_getText_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_viz_WText_to_Widget(instance: *mut c_void) -> *mut c_void; pub fn cv_viz_WText_to_Widget2D(instance: *mut c_void) -> *mut c_void; pub fn cv_viz_WText_delete(instance: *mut c_void); pub fn cv_viz_WText3D_WText3D_const_StringR_const_Point3dR_double_bool_const_ColorR(text: *const c_char, position: *const core::Point3d, text_scale: f64, face_camera: bool, color: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_viz_WText3D_WText3D_const_StringR_const_Point3dR(text: *const c_char, position: *const core::Point3d, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_viz_WText3D_setText_const_StringR(instance: *mut c_void, text: *const c_char, ocvrs_return: *mut ResultVoid); + pub fn cv_viz_WText3D_setText_const_StringR(instance: *mut c_void, text: *const c_char, ocvrs_return: *mut Result<()>); pub fn cv_viz_WText3D_getText_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_viz_WText3D_to_Widget(instance: *mut c_void) -> *mut c_void; pub fn cv_viz_WText3D_to_Widget3D(instance: *mut c_void) -> *mut c_void; @@ -16937,37 +16930,35 @@ mod viz_sys { pub fn cv_viz_WTrajectorySpheres_to_Widget3D(instance: *mut c_void) -> *mut c_void; pub fn cv_viz_WTrajectorySpheres_delete(instance: *mut c_void); pub fn cv_viz_WWidgetMerger_WWidgetMerger(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_viz_WWidgetMerger_addWidget_const_Widget3DR_const_Affine3dR(instance: *mut c_void, widget: *const c_void, pose: *const core::Affine3d, ocvrs_return: *mut ResultVoid); - pub fn cv_viz_WWidgetMerger_addWidget_const_Widget3DR(instance: *mut c_void, widget: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_viz_WWidgetMerger_finalize(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_viz_WWidgetMerger_addWidget_const_Widget3DR_const_Affine3dR(instance: *mut c_void, widget: *const c_void, pose: *const core::Affine3d, ocvrs_return: *mut Result<()>); + pub fn cv_viz_WWidgetMerger_addWidget_const_Widget3DR(instance: *mut c_void, widget: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_viz_WWidgetMerger_finalize(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_viz_WWidgetMerger_to_Widget(instance: *mut c_void) -> *mut c_void; pub fn cv_viz_WWidgetMerger_to_Widget3D(instance: *mut c_void) -> *mut c_void; pub fn cv_viz_WWidgetMerger_delete(instance: *mut c_void); pub fn cv_viz_Widget_Widget(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_viz_Widget_Widget_const_WidgetR(other: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_viz_Widget_operatorST_const_WidgetR(instance: *mut c_void, other: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_viz_Widget_operatorST_const_WidgetR(instance: *mut c_void, other: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_viz_Widget_fromPlyFile_const_StringR(file_name: *const c_char, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_viz_Widget_setRenderingProperty_int_double(instance: *mut c_void, property: i32, value: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_viz_Widget_setRenderingProperty_int_double(instance: *mut c_void, property: i32, value: f64, ocvrs_return: *mut Result<()>); pub fn cv_viz_Widget_getRenderingProperty_const_int(instance: *const c_void, property: i32, ocvrs_return: *mut Result); pub fn cv_viz_Widget_delete(instance: *mut c_void); pub fn cv_viz_Widget2D_Widget2D(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_viz_Widget2D_setColor_const_ColorR(instance: *mut c_void, color: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_viz_Widget2D_setColor_const_ColorR(instance: *mut c_void, color: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_viz_Widget2D_to_Widget(instance: *mut c_void) -> *mut c_void; pub fn cv_viz_Widget2D_delete(instance: *mut c_void); pub fn cv_viz_Widget3D_Widget3D(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_viz_Widget3D_setPose_const_Affine3dR(instance: *mut c_void, pose: *const core::Affine3d, ocvrs_return: *mut ResultVoid); - pub fn cv_viz_Widget3D_updatePose_const_Affine3dR(instance: *mut c_void, pose: *const core::Affine3d, ocvrs_return: *mut ResultVoid); + pub fn cv_viz_Widget3D_setPose_const_Affine3dR(instance: *mut c_void, pose: *const core::Affine3d, ocvrs_return: *mut Result<()>); + pub fn cv_viz_Widget3D_updatePose_const_Affine3dR(instance: *mut c_void, pose: *const core::Affine3d, ocvrs_return: *mut Result<()>); pub fn cv_viz_Widget3D_getPose_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_viz_Widget3D_applyTransform_const_Affine3dR(instance: *mut c_void, transform: *const core::Affine3d, ocvrs_return: *mut ResultVoid); - pub fn cv_viz_Widget3D_setColor_const_ColorR(instance: *mut c_void, color: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_viz_Widget3D_applyTransform_const_Affine3dR(instance: *mut c_void, transform: *const core::Affine3d, ocvrs_return: *mut Result<()>); + pub fn cv_viz_Widget3D_setColor_const_ColorR(instance: *mut c_void, color: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_viz_Widget3D_to_Widget(instance: *mut c_void) -> *mut c_void; pub fn cv_viz_Widget3D_delete(instance: *mut c_void); } } -#[cfg(ocvrs_has_module_viz)] pub use viz_sys::*; -#[cfg(ocvrs_has_module_wechat_qrcode)] mod wechat_qrcode_sys { use super::*; @@ -16976,24 +16967,22 @@ mod wechat_qrcode_sys { pub fn cv_wechat_qrcode_WeChatQRCode_WeChatQRCode(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_wechat_qrcode_WeChatQRCode_detectAndDecode_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, img: *const c_void, points: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_wechat_qrcode_WeChatQRCode_detectAndDecode_const__InputArrayR(instance: *mut c_void, img: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_wechat_qrcode_WeChatQRCode_setScaleFactor_float(instance: *mut c_void, _scaling_factor: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_wechat_qrcode_WeChatQRCode_setScaleFactor_float(instance: *mut c_void, _scaling_factor: f32, ocvrs_return: *mut Result<()>); pub fn cv_wechat_qrcode_WeChatQRCode_getScaleFactor(instance: *mut c_void, ocvrs_return: *mut Result); pub fn cv_wechat_qrcode_WeChatQRCode_delete(instance: *mut c_void); } } -#[cfg(ocvrs_has_module_wechat_qrcode)] pub use wechat_qrcode_sys::*; -#[cfg(ocvrs_has_module_xfeatures2d)] mod xfeatures2d_sys { use super::*; extern "C" { - pub fn cv_xfeatures2d_FASTForPointSet_const__InputArrayR_vectorLKeyPointGR_int(image: *const c_void, keypoints: *mut c_void, threshold: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_xfeatures2d_FASTForPointSet_const__InputArrayR_vectorLKeyPointGR_int_bool_DetectorType(image: *const c_void, keypoints: *mut c_void, threshold: i32, nonmax_suppression: bool, typ: crate::features2d::FastFeatureDetector_DetectorType, ocvrs_return: *mut ResultVoid); - pub fn cv_xfeatures2d_matchGMS_const_SizeR_const_SizeR_const_vectorLKeyPointGR_const_vectorLKeyPointGR_const_vectorLDMatchGR_vectorLDMatchGR(size1: *const core::Size, size2: *const core::Size, keypoints1: *const c_void, keypoints2: *const c_void, matches1to2: *const c_void, matches_gms: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_xfeatures2d_matchGMS_const_SizeR_const_SizeR_const_vectorLKeyPointGR_const_vectorLKeyPointGR_const_vectorLDMatchGR_vectorLDMatchGR_const_bool_const_bool_const_double(size1: *const core::Size, size2: *const core::Size, keypoints1: *const c_void, keypoints2: *const c_void, matches1to2: *const c_void, matches_gms: *mut c_void, with_rotation: bool, with_scale: bool, threshold_factor: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_xfeatures2d_matchLOGOS_const_vectorLKeyPointGR_const_vectorLKeyPointGR_const_vectorLintGR_const_vectorLintGR_vectorLDMatchGR(keypoints1: *const c_void, keypoints2: *const c_void, nn1: *const c_void, nn2: *const c_void, matches1to2: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_FASTForPointSet_const__InputArrayR_vectorLKeyPointGR_int(image: *const c_void, keypoints: *mut c_void, threshold: i32, ocvrs_return: *mut Result<()>); + pub fn cv_xfeatures2d_FASTForPointSet_const__InputArrayR_vectorLKeyPointGR_int_bool_DetectorType(image: *const c_void, keypoints: *mut c_void, threshold: i32, nonmax_suppression: bool, typ: crate::features2d::FastFeatureDetector_DetectorType, ocvrs_return: *mut Result<()>); + pub fn cv_xfeatures2d_matchGMS_const_SizeR_const_SizeR_const_vectorLKeyPointGR_const_vectorLKeyPointGR_const_vectorLDMatchGR_vectorLDMatchGR(size1: *const core::Size, size2: *const core::Size, keypoints1: *const c_void, keypoints2: *const c_void, matches1to2: *const c_void, matches_gms: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_xfeatures2d_matchGMS_const_SizeR_const_SizeR_const_vectorLKeyPointGR_const_vectorLKeyPointGR_const_vectorLDMatchGR_vectorLDMatchGR_const_bool_const_bool_const_double(size1: *const core::Size, size2: *const core::Size, keypoints1: *const c_void, keypoints2: *const c_void, matches1to2: *const c_void, matches_gms: *mut c_void, with_rotation: bool, with_scale: bool, threshold_factor: f64, ocvrs_return: *mut Result<()>); + pub fn cv_xfeatures2d_matchLOGOS_const_vectorLKeyPointGR_const_vectorLKeyPointGR_const_vectorLintGR_const_vectorLintGR_vectorLDMatchGR(keypoints1: *const c_void, keypoints2: *const c_void, nn1: *const c_void, nn2: *const c_void, matches1to2: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_cuda_SURF_CUDA_SURF_CUDA(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_SURF_CUDA_SURF_CUDA_double_int_int_bool_float_bool(_hessian_threshold: f64, _n_octaves: i32, _n_octave_layers: i32, _extended: bool, _keypoints_ratio: f32, _upright: bool, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_SURF_CUDA_SURF_CUDA_double(_hessian_threshold: f64, ocvrs_return: *mut Result<*mut c_void>); @@ -17001,21 +16990,21 @@ mod xfeatures2d_sys { pub fn cv_cuda_SURF_CUDA_create_double(_hessian_threshold: f64, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_cuda_SURF_CUDA_descriptorSize_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_cuda_SURF_CUDA_defaultNorm_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_cuda_SURF_CUDA_uploadKeypoints_const_vectorLKeyPointGR_GpuMatR(instance: *mut c_void, keypoints: *const c_void, keypoints_gpu: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_SURF_CUDA_downloadKeypoints_const_GpuMatR_vectorLKeyPointGR(instance: *mut c_void, keypoints_gpu: *const c_void, keypoints: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_SURF_CUDA_downloadDescriptors_const_GpuMatR_vectorLfloatGR(instance: *mut c_void, descriptors_gpu: *const c_void, descriptors: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_SURF_CUDA_operator___const_GpuMatR_const_GpuMatR_GpuMatR(instance: *mut c_void, img: *const c_void, mask: *const c_void, keypoints: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_SURF_CUDA_operator___const_GpuMatR_const_GpuMatR_GpuMatR_GpuMatR_bool(instance: *mut c_void, img: *const c_void, mask: *const c_void, keypoints: *mut c_void, descriptors: *mut c_void, use_provided_keypoints: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_SURF_CUDA_operator___const_GpuMatR_const_GpuMatR_GpuMatR_GpuMatR(instance: *mut c_void, img: *const c_void, mask: *const c_void, keypoints: *mut c_void, descriptors: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_SURF_CUDA_detect_const_GpuMatR_const_GpuMatR_GpuMatR(instance: *mut c_void, img: *const c_void, mask: *const c_void, keypoints: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_SURF_CUDA_operator___const_GpuMatR_const_GpuMatR_vectorLKeyPointGR(instance: *mut c_void, img: *const c_void, mask: *const c_void, keypoints: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_SURF_CUDA_operator___const_GpuMatR_const_GpuMatR_vectorLKeyPointGR_GpuMatR_bool(instance: *mut c_void, img: *const c_void, mask: *const c_void, keypoints: *mut c_void, descriptors: *mut c_void, use_provided_keypoints: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_SURF_CUDA_operator___const_GpuMatR_const_GpuMatR_vectorLKeyPointGR_GpuMatR(instance: *mut c_void, img: *const c_void, mask: *const c_void, keypoints: *mut c_void, descriptors: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_SURF_CUDA_detectWithDescriptors_const_GpuMatR_const_GpuMatR_GpuMatR_GpuMatR_bool(instance: *mut c_void, img: *const c_void, mask: *const c_void, keypoints: *mut c_void, descriptors: *mut c_void, use_provided_keypoints: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_SURF_CUDA_detectWithDescriptors_const_GpuMatR_const_GpuMatR_GpuMatR_GpuMatR(instance: *mut c_void, img: *const c_void, mask: *const c_void, keypoints: *mut c_void, descriptors: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_SURF_CUDA_operator___const_GpuMatR_const_GpuMatR_vectorLKeyPointGR_vectorLfloatGR_bool(instance: *mut c_void, img: *const c_void, mask: *const c_void, keypoints: *mut c_void, descriptors: *mut c_void, use_provided_keypoints: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_SURF_CUDA_operator___const_GpuMatR_const_GpuMatR_vectorLKeyPointGR_vectorLfloatGR(instance: *mut c_void, img: *const c_void, mask: *const c_void, keypoints: *mut c_void, descriptors: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_cuda_SURF_CUDA_releaseMemory(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_cuda_SURF_CUDA_uploadKeypoints_const_vectorLKeyPointGR_GpuMatR(instance: *mut c_void, keypoints: *const c_void, keypoints_gpu: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_SURF_CUDA_downloadKeypoints_const_GpuMatR_vectorLKeyPointGR(instance: *mut c_void, keypoints_gpu: *const c_void, keypoints: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_SURF_CUDA_downloadDescriptors_const_GpuMatR_vectorLfloatGR(instance: *mut c_void, descriptors_gpu: *const c_void, descriptors: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_SURF_CUDA_operator___const_GpuMatR_const_GpuMatR_GpuMatR(instance: *mut c_void, img: *const c_void, mask: *const c_void, keypoints: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_SURF_CUDA_operator___const_GpuMatR_const_GpuMatR_GpuMatR_GpuMatR_bool(instance: *mut c_void, img: *const c_void, mask: *const c_void, keypoints: *mut c_void, descriptors: *mut c_void, use_provided_keypoints: bool, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_SURF_CUDA_operator___const_GpuMatR_const_GpuMatR_GpuMatR_GpuMatR(instance: *mut c_void, img: *const c_void, mask: *const c_void, keypoints: *mut c_void, descriptors: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_SURF_CUDA_detect_const_GpuMatR_const_GpuMatR_GpuMatR(instance: *mut c_void, img: *const c_void, mask: *const c_void, keypoints: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_SURF_CUDA_operator___const_GpuMatR_const_GpuMatR_vectorLKeyPointGR(instance: *mut c_void, img: *const c_void, mask: *const c_void, keypoints: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_SURF_CUDA_operator___const_GpuMatR_const_GpuMatR_vectorLKeyPointGR_GpuMatR_bool(instance: *mut c_void, img: *const c_void, mask: *const c_void, keypoints: *mut c_void, descriptors: *mut c_void, use_provided_keypoints: bool, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_SURF_CUDA_operator___const_GpuMatR_const_GpuMatR_vectorLKeyPointGR_GpuMatR(instance: *mut c_void, img: *const c_void, mask: *const c_void, keypoints: *mut c_void, descriptors: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_SURF_CUDA_detectWithDescriptors_const_GpuMatR_const_GpuMatR_GpuMatR_GpuMatR_bool(instance: *mut c_void, img: *const c_void, mask: *const c_void, keypoints: *mut c_void, descriptors: *mut c_void, use_provided_keypoints: bool, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_SURF_CUDA_detectWithDescriptors_const_GpuMatR_const_GpuMatR_GpuMatR_GpuMatR(instance: *mut c_void, img: *const c_void, mask: *const c_void, keypoints: *mut c_void, descriptors: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_SURF_CUDA_operator___const_GpuMatR_const_GpuMatR_vectorLKeyPointGR_vectorLfloatGR_bool(instance: *mut c_void, img: *const c_void, mask: *const c_void, keypoints: *mut c_void, descriptors: *mut c_void, use_provided_keypoints: bool, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_SURF_CUDA_operator___const_GpuMatR_const_GpuMatR_vectorLKeyPointGR_vectorLfloatGR(instance: *mut c_void, img: *const c_void, mask: *const c_void, keypoints: *mut c_void, descriptors: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_cuda_SURF_CUDA_releaseMemory(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_cuda_SURF_CUDA_propHessianThreshold_const(instance: *const c_void) -> f64; pub fn cv_cuda_SURF_CUDA_propHessianThreshold_const_double(instance: *mut c_void, val: f64); pub fn cv_cuda_SURF_CUDA_propNOctaves_const(instance: *const c_void) -> i32; @@ -17043,17 +17032,17 @@ mod xfeatures2d_sys { pub fn cv_cuda_SURF_CUDA_delete(instance: *mut c_void); pub fn cv_xfeatures2d_AffineFeature2D_create_PtrLFeature2DG_PtrLFeature2DG(keypoint_detector: *mut c_void, descriptor_extractor: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_xfeatures2d_AffineFeature2D_create_PtrLFeature2DG(keypoint_detector: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_xfeatures2d_AffineFeature2D_detect_const__InputArrayR_vectorLElliptic_KeyPointGR_const__InputArrayR(instance: *mut c_void, image: *const c_void, keypoints: *mut c_void, mask: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_xfeatures2d_AffineFeature2D_detect_const__InputArrayR_vectorLElliptic_KeyPointGR(instance: *mut c_void, image: *const c_void, keypoints: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_xfeatures2d_AffineFeature2D_detectAndCompute_const__InputArrayR_const__InputArrayR_vectorLElliptic_KeyPointGR_const__OutputArrayR_bool(instance: *mut c_void, image: *const c_void, mask: *const c_void, keypoints: *mut c_void, descriptors: *const c_void, use_provided_keypoints: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_xfeatures2d_AffineFeature2D_detectAndCompute_const__InputArrayR_const__InputArrayR_vectorLElliptic_KeyPointGR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, mask: *const c_void, keypoints: *mut c_void, descriptors: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_AffineFeature2D_detect_const__InputArrayR_vectorLElliptic_KeyPointGR_const__InputArrayR(instance: *mut c_void, image: *const c_void, keypoints: *mut c_void, mask: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_xfeatures2d_AffineFeature2D_detect_const__InputArrayR_vectorLElliptic_KeyPointGR(instance: *mut c_void, image: *const c_void, keypoints: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_xfeatures2d_AffineFeature2D_detectAndCompute_const__InputArrayR_const__InputArrayR_vectorLElliptic_KeyPointGR_const__OutputArrayR_bool(instance: *mut c_void, image: *const c_void, mask: *const c_void, keypoints: *mut c_void, descriptors: *const c_void, use_provided_keypoints: bool, ocvrs_return: *mut Result<()>); + pub fn cv_xfeatures2d_AffineFeature2D_detectAndCompute_const__InputArrayR_const__InputArrayR_vectorLElliptic_KeyPointGR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, mask: *const c_void, keypoints: *mut c_void, descriptors: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_AffineFeature2D_to_TBMR(instance: *mut c_void) -> *mut c_void; pub fn cv_xfeatures2d_AffineFeature2D_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_xfeatures2d_AffineFeature2D_to_Feature2D(instance: *mut c_void) -> *mut c_void; pub fn cv_xfeatures2d_AffineFeature2D_delete(instance: *mut c_void); pub fn cv_xfeatures2d_BEBLID_create_float_int(scale_factor: f32, n_bits: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_xfeatures2d_BEBLID_create_float(scale_factor: f32, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_xfeatures2d_BEBLID_setScaleFactor_float(instance: *mut c_void, scale_factor: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_BEBLID_setScaleFactor_float(instance: *mut c_void, scale_factor: f32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_BEBLID_getScaleFactor_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_xfeatures2d_BEBLID_getDefaultName_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_xfeatures2d_BEBLID_to_Algorithm(instance: *mut c_void) -> *mut c_void; @@ -17062,18 +17051,18 @@ mod xfeatures2d_sys { pub fn cv_xfeatures2d_BoostDesc_create_int_bool_float(desc: i32, use_scale_orientation: bool, scale_factor: f32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_xfeatures2d_BoostDesc_create(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_xfeatures2d_BoostDesc_getDefaultName_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_xfeatures2d_BoostDesc_setUseScaleOrientation_const_bool(instance: *mut c_void, use_scale_orientation: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_BoostDesc_setUseScaleOrientation_const_bool(instance: *mut c_void, use_scale_orientation: bool, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_BoostDesc_getUseScaleOrientation_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_BoostDesc_setScaleFactor_const_float(instance: *mut c_void, scale_factor: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_BoostDesc_setScaleFactor_const_float(instance: *mut c_void, scale_factor: f32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_BoostDesc_getScaleFactor_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_xfeatures2d_BoostDesc_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_xfeatures2d_BoostDesc_to_Feature2D(instance: *mut c_void) -> *mut c_void; pub fn cv_xfeatures2d_BoostDesc_delete(instance: *mut c_void); pub fn cv_xfeatures2d_BriefDescriptorExtractor_create_int_bool(bytes: i32, use_orientation: bool, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_xfeatures2d_BriefDescriptorExtractor_create(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_xfeatures2d_BriefDescriptorExtractor_setDescriptorSize_int(instance: *mut c_void, bytes: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_BriefDescriptorExtractor_setDescriptorSize_int(instance: *mut c_void, bytes: i32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_BriefDescriptorExtractor_getDescriptorSize_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_BriefDescriptorExtractor_setUseOrientation_bool(instance: *mut c_void, use_orientation: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_BriefDescriptorExtractor_setUseOrientation_bool(instance: *mut c_void, use_orientation: bool, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_BriefDescriptorExtractor_getUseOrientation_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_xfeatures2d_BriefDescriptorExtractor_getDefaultName_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_xfeatures2d_BriefDescriptorExtractor_to_Algorithm(instance: *mut c_void) -> *mut c_void; @@ -17081,30 +17070,30 @@ mod xfeatures2d_sys { pub fn cv_xfeatures2d_BriefDescriptorExtractor_delete(instance: *mut c_void); pub fn cv_xfeatures2d_DAISY_create_float_int_int_int_NormalizationType_const__InputArrayR_bool_bool(radius: f32, q_radius: i32, q_theta: i32, q_hist: i32, norm: crate::xfeatures2d::DAISY_NormalizationType, h: *const c_void, interpolation: bool, use_orientation: bool, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_xfeatures2d_DAISY_create(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_xfeatures2d_DAISY_setRadius_float(instance: *mut c_void, radius: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_DAISY_setRadius_float(instance: *mut c_void, radius: f32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_DAISY_getRadius_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_DAISY_setQRadius_int(instance: *mut c_void, q_radius: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_DAISY_setQRadius_int(instance: *mut c_void, q_radius: i32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_DAISY_getQRadius_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_DAISY_setQTheta_int(instance: *mut c_void, q_theta: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_DAISY_setQTheta_int(instance: *mut c_void, q_theta: i32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_DAISY_getQTheta_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_DAISY_setQHist_int(instance: *mut c_void, q_hist: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_DAISY_setQHist_int(instance: *mut c_void, q_hist: i32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_DAISY_getQHist_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_DAISY_setNorm_int(instance: *mut c_void, norm: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_DAISY_setNorm_int(instance: *mut c_void, norm: i32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_DAISY_getNorm_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_DAISY_setH_const__InputArrayR(instance: *mut c_void, h: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_DAISY_setH_const__InputArrayR(instance: *mut c_void, h: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_DAISY_getH_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_xfeatures2d_DAISY_setInterpolation_bool(instance: *mut c_void, interpolation: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_DAISY_setInterpolation_bool(instance: *mut c_void, interpolation: bool, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_DAISY_getInterpolation_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_DAISY_setUseOrientation_bool(instance: *mut c_void, use_orientation: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_DAISY_setUseOrientation_bool(instance: *mut c_void, use_orientation: bool, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_DAISY_getUseOrientation_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_xfeatures2d_DAISY_getDefaultName_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_xfeatures2d_DAISY_compute_const__InputArrayR_vectorLKeyPointGR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, keypoints: *mut c_void, descriptors: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_xfeatures2d_DAISY_compute_const__InputArrayR_vectorLvectorLKeyPointGGR_const__OutputArrayR(instance: *mut c_void, images: *const c_void, keypoints: *mut c_void, descriptors: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_xfeatures2d_DAISY_compute_const__InputArrayR_Rect_const__OutputArrayR(instance: *mut c_void, image: *const c_void, roi: *const core::Rect, descriptors: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_xfeatures2d_DAISY_compute_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, descriptors: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_xfeatures2d_DAISY_GetDescriptor_const_double_double_int_floatX(instance: *const c_void, y: f64, x: f64, orientation: i32, descriptor: *mut f32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_DAISY_compute_const__InputArrayR_vectorLKeyPointGR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, keypoints: *mut c_void, descriptors: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_xfeatures2d_DAISY_compute_const__InputArrayR_vectorLvectorLKeyPointGGR_const__OutputArrayR(instance: *mut c_void, images: *const c_void, keypoints: *mut c_void, descriptors: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_xfeatures2d_DAISY_compute_const__InputArrayR_Rect_const__OutputArrayR(instance: *mut c_void, image: *const c_void, roi: *const core::Rect, descriptors: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_xfeatures2d_DAISY_compute_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, descriptors: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_xfeatures2d_DAISY_GetDescriptor_const_double_double_int_floatX(instance: *const c_void, y: f64, x: f64, orientation: i32, descriptor: *mut f32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_DAISY_GetDescriptor_const_double_double_int_floatX_doubleX(instance: *const c_void, y: f64, x: f64, orientation: i32, descriptor: *mut f32, h: *mut f64, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_DAISY_GetUnnormalizedDescriptor_const_double_double_int_floatX(instance: *const c_void, y: f64, x: f64, orientation: i32, descriptor: *mut f32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_DAISY_GetUnnormalizedDescriptor_const_double_double_int_floatX(instance: *const c_void, y: f64, x: f64, orientation: i32, descriptor: *mut f32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_DAISY_GetUnnormalizedDescriptor_const_double_double_int_floatX_doubleX(instance: *const c_void, y: f64, x: f64, orientation: i32, descriptor: *mut f32, h: *mut f64, ocvrs_return: *mut Result); pub fn cv_xfeatures2d_DAISY_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_xfeatures2d_DAISY_to_Feature2D(instance: *mut c_void) -> *mut c_void; @@ -17121,13 +17110,13 @@ mod xfeatures2d_sys { pub fn cv_xfeatures2d_Elliptic_KeyPoint_delete(instance: *mut c_void); pub fn cv_xfeatures2d_FREAK_create_bool_bool_float_int_const_vectorLintGR(orientation_normalized: bool, scale_normalized: bool, pattern_scale: f32, n_octaves: i32, selected_pairs: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_xfeatures2d_FREAK_create(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_xfeatures2d_FREAK_setOrientationNormalized_bool(instance: *mut c_void, orientation_normalized: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_FREAK_setOrientationNormalized_bool(instance: *mut c_void, orientation_normalized: bool, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_FREAK_getOrientationNormalized_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_FREAK_setScaleNormalized_bool(instance: *mut c_void, scale_normalized: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_FREAK_setScaleNormalized_bool(instance: *mut c_void, scale_normalized: bool, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_FREAK_getScaleNormalized_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_FREAK_setPatternScale_double(instance: *mut c_void, pattern_scale: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_FREAK_setPatternScale_double(instance: *mut c_void, pattern_scale: f64, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_FREAK_getPatternScale_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_FREAK_setNOctaves_int(instance: *mut c_void, n_octaves: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_FREAK_setNOctaves_int(instance: *mut c_void, n_octaves: i32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_FREAK_getNOctaves_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_xfeatures2d_FREAK_getDefaultName_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_xfeatures2d_FREAK_to_Algorithm(instance: *mut c_void) -> *mut c_void; @@ -17135,15 +17124,15 @@ mod xfeatures2d_sys { pub fn cv_xfeatures2d_FREAK_delete(instance: *mut c_void); pub fn cv_xfeatures2d_HarrisLaplaceFeatureDetector_create_int_float_float_int_int(num_octaves: i32, corn_thresh: f32, dog_thresh: f32, max_corners: i32, num_layers: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_xfeatures2d_HarrisLaplaceFeatureDetector_create(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_xfeatures2d_HarrisLaplaceFeatureDetector_setNumOctaves_int(instance: *mut c_void, num_octaves_: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_HarrisLaplaceFeatureDetector_setNumOctaves_int(instance: *mut c_void, num_octaves_: i32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_HarrisLaplaceFeatureDetector_getNumOctaves_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_HarrisLaplaceFeatureDetector_setCornThresh_float(instance: *mut c_void, corn_thresh_: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_HarrisLaplaceFeatureDetector_setCornThresh_float(instance: *mut c_void, corn_thresh_: f32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_HarrisLaplaceFeatureDetector_getCornThresh_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_HarrisLaplaceFeatureDetector_setDOGThresh_float(instance: *mut c_void, dog_thresh_: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_HarrisLaplaceFeatureDetector_setDOGThresh_float(instance: *mut c_void, dog_thresh_: f32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_HarrisLaplaceFeatureDetector_getDOGThresh_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_HarrisLaplaceFeatureDetector_setMaxCorners_int(instance: *mut c_void, max_corners_: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_HarrisLaplaceFeatureDetector_setMaxCorners_int(instance: *mut c_void, max_corners_: i32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_HarrisLaplaceFeatureDetector_getMaxCorners_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_HarrisLaplaceFeatureDetector_setNumLayers_int(instance: *mut c_void, num_layers_: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_HarrisLaplaceFeatureDetector_setNumLayers_int(instance: *mut c_void, num_layers_: i32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_HarrisLaplaceFeatureDetector_getNumLayers_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_xfeatures2d_HarrisLaplaceFeatureDetector_getDefaultName_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_xfeatures2d_HarrisLaplaceFeatureDetector_to_Algorithm(instance: *mut c_void) -> *mut c_void; @@ -17151,13 +17140,13 @@ mod xfeatures2d_sys { pub fn cv_xfeatures2d_HarrisLaplaceFeatureDetector_delete(instance: *mut c_void); pub fn cv_xfeatures2d_LATCH_create_int_bool_int_double(bytes: i32, rotation_invariance: bool, half_ssd_size: i32, sigma: f64, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_xfeatures2d_LATCH_create(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_xfeatures2d_LATCH_setBytes_int(instance: *mut c_void, bytes: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_LATCH_setBytes_int(instance: *mut c_void, bytes: i32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_LATCH_getBytes_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_LATCH_setRotationInvariance_bool(instance: *mut c_void, rotation_invariance: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_LATCH_setRotationInvariance_bool(instance: *mut c_void, rotation_invariance: bool, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_LATCH_getRotationInvariance_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_LATCH_setHalfSSDsize_int(instance: *mut c_void, half_ssd_size: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_LATCH_setHalfSSDsize_int(instance: *mut c_void, half_ssd_size: i32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_LATCH_getHalfSSDsize_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_LATCH_setSigma_double(instance: *mut c_void, sigma: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_LATCH_setSigma_double(instance: *mut c_void, sigma: f64, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_LATCH_getSigma_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_xfeatures2d_LATCH_getDefaultName_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_xfeatures2d_LATCH_to_Algorithm(instance: *mut c_void) -> *mut c_void; @@ -17165,9 +17154,9 @@ mod xfeatures2d_sys { pub fn cv_xfeatures2d_LATCH_delete(instance: *mut c_void); pub fn cv_xfeatures2d_LUCID_create_const_int_const_int(lucid_kernel: i32, blur_kernel: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_xfeatures2d_LUCID_create(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_xfeatures2d_LUCID_setLucidKernel_int(instance: *mut c_void, lucid_kernel: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_LUCID_setLucidKernel_int(instance: *mut c_void, lucid_kernel: i32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_LUCID_getLucidKernel_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_LUCID_setBlurKernel_int(instance: *mut c_void, blur_kernel: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_LUCID_setBlurKernel_int(instance: *mut c_void, blur_kernel: i32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_LUCID_getBlurKernel_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_xfeatures2d_LUCID_getDefaultName_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_xfeatures2d_LUCID_to_Algorithm(instance: *mut c_void) -> *mut c_void; @@ -17175,23 +17164,23 @@ mod xfeatures2d_sys { pub fn cv_xfeatures2d_LUCID_delete(instance: *mut c_void); pub fn cv_xfeatures2d_MSDDetector_create_int_int_int_int_float_int_float_int_bool(m_patch_radius: i32, m_search_area_radius: i32, m_nms_radius: i32, m_nms_scale_radius: i32, m_th_saliency: f32, m_k_nn: i32, m_scale_factor: f32, m_n_scales: i32, m_compute_orientation: bool, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_xfeatures2d_MSDDetector_create(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_xfeatures2d_MSDDetector_setPatchRadius_int(instance: *mut c_void, patch_radius: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_MSDDetector_setPatchRadius_int(instance: *mut c_void, patch_radius: i32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_MSDDetector_getPatchRadius_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_MSDDetector_setSearchAreaRadius_int(instance: *mut c_void, use_orientation: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_MSDDetector_setSearchAreaRadius_int(instance: *mut c_void, use_orientation: i32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_MSDDetector_getSearchAreaRadius_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_MSDDetector_setNmsRadius_int(instance: *mut c_void, nms_radius: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_MSDDetector_setNmsRadius_int(instance: *mut c_void, nms_radius: i32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_MSDDetector_getNmsRadius_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_MSDDetector_setNmsScaleRadius_int(instance: *mut c_void, nms_scale_radius: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_MSDDetector_setNmsScaleRadius_int(instance: *mut c_void, nms_scale_radius: i32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_MSDDetector_getNmsScaleRadius_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_MSDDetector_setThSaliency_float(instance: *mut c_void, th_saliency: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_MSDDetector_setThSaliency_float(instance: *mut c_void, th_saliency: f32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_MSDDetector_getThSaliency_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_MSDDetector_setKNN_int(instance: *mut c_void, k_nn: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_MSDDetector_setKNN_int(instance: *mut c_void, k_nn: i32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_MSDDetector_getKNN_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_MSDDetector_setScaleFactor_float(instance: *mut c_void, scale_factor: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_MSDDetector_setScaleFactor_float(instance: *mut c_void, scale_factor: f32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_MSDDetector_getScaleFactor_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_MSDDetector_setNScales_int(instance: *mut c_void, use_orientation: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_MSDDetector_setNScales_int(instance: *mut c_void, use_orientation: i32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_MSDDetector_getNScales_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_MSDDetector_setComputeOrientation_bool(instance: *mut c_void, compute_orientation: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_MSDDetector_setComputeOrientation_bool(instance: *mut c_void, compute_orientation: bool, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_MSDDetector_getComputeOrientation_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_xfeatures2d_MSDDetector_getDefaultName_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_xfeatures2d_MSDDetector_to_Algorithm(instance: *mut c_void) -> *mut c_void; @@ -17201,70 +17190,70 @@ mod xfeatures2d_sys { pub fn cv_xfeatures2d_PCTSignatures_create(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_xfeatures2d_PCTSignatures_create_const_vectorLPoint2fGR_const_int(init_sampling_points: *const c_void, init_seed_count: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_xfeatures2d_PCTSignatures_create_const_vectorLPoint2fGR_const_vectorLintGR(init_sampling_points: *const c_void, init_cluster_seed_indexes: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_xfeatures2d_PCTSignatures_computeSignature_const_const__InputArrayR_const__OutputArrayR(instance: *const c_void, image: *const c_void, signature: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_xfeatures2d_PCTSignatures_computeSignatures_const_const_vectorLMatGR_vectorLMatGR(instance: *const c_void, images: *const c_void, signatures: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_xfeatures2d_PCTSignatures_drawSignature_const__InputArrayR_const__InputArrayR_const__OutputArrayR_float_int(source: *const c_void, signature: *const c_void, result: *const c_void, radius_to_shorter_side_ratio: f32, border_thickness: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_xfeatures2d_PCTSignatures_drawSignature_const__InputArrayR_const__InputArrayR_const__OutputArrayR(source: *const c_void, signature: *const c_void, result: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_xfeatures2d_PCTSignatures_generateInitPoints_vectorLPoint2fGR_const_int_int(init_points: *mut c_void, count: i32, point_distribution: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_PCTSignatures_computeSignature_const_const__InputArrayR_const__OutputArrayR(instance: *const c_void, image: *const c_void, signature: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_xfeatures2d_PCTSignatures_computeSignatures_const_const_vectorLMatGR_vectorLMatGR(instance: *const c_void, images: *const c_void, signatures: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_xfeatures2d_PCTSignatures_drawSignature_const__InputArrayR_const__InputArrayR_const__OutputArrayR_float_int(source: *const c_void, signature: *const c_void, result: *const c_void, radius_to_shorter_side_ratio: f32, border_thickness: i32, ocvrs_return: *mut Result<()>); + pub fn cv_xfeatures2d_PCTSignatures_drawSignature_const__InputArrayR_const__InputArrayR_const__OutputArrayR(source: *const c_void, signature: *const c_void, result: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_xfeatures2d_PCTSignatures_generateInitPoints_vectorLPoint2fGR_const_int_int(init_points: *mut c_void, count: i32, point_distribution: i32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_PCTSignatures_getSampleCount_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_xfeatures2d_PCTSignatures_getGrayscaleBits_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_PCTSignatures_setGrayscaleBits_int(instance: *mut c_void, grayscale_bits: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_PCTSignatures_setGrayscaleBits_int(instance: *mut c_void, grayscale_bits: i32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_PCTSignatures_getWindowRadius_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_PCTSignatures_setWindowRadius_int(instance: *mut c_void, radius: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_PCTSignatures_setWindowRadius_int(instance: *mut c_void, radius: i32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_PCTSignatures_getWeightX_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_PCTSignatures_setWeightX_float(instance: *mut c_void, weight: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_PCTSignatures_setWeightX_float(instance: *mut c_void, weight: f32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_PCTSignatures_getWeightY_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_PCTSignatures_setWeightY_float(instance: *mut c_void, weight: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_PCTSignatures_setWeightY_float(instance: *mut c_void, weight: f32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_PCTSignatures_getWeightL_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_PCTSignatures_setWeightL_float(instance: *mut c_void, weight: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_PCTSignatures_setWeightL_float(instance: *mut c_void, weight: f32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_PCTSignatures_getWeightA_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_PCTSignatures_setWeightA_float(instance: *mut c_void, weight: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_PCTSignatures_setWeightA_float(instance: *mut c_void, weight: f32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_PCTSignatures_getWeightB_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_PCTSignatures_setWeightB_float(instance: *mut c_void, weight: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_PCTSignatures_setWeightB_float(instance: *mut c_void, weight: f32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_PCTSignatures_getWeightContrast_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_PCTSignatures_setWeightContrast_float(instance: *mut c_void, weight: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_PCTSignatures_setWeightContrast_float(instance: *mut c_void, weight: f32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_PCTSignatures_getWeightEntropy_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_PCTSignatures_setWeightEntropy_float(instance: *mut c_void, weight: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_PCTSignatures_setWeightEntropy_float(instance: *mut c_void, weight: f32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_PCTSignatures_getSamplingPoints_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_xfeatures2d_PCTSignatures_setWeight_int_float(instance: *mut c_void, idx: i32, value: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_xfeatures2d_PCTSignatures_setWeights_const_vectorLfloatGR(instance: *mut c_void, weights: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_xfeatures2d_PCTSignatures_setTranslation_int_float(instance: *mut c_void, idx: i32, value: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_xfeatures2d_PCTSignatures_setTranslations_const_vectorLfloatGR(instance: *mut c_void, translations: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_xfeatures2d_PCTSignatures_setSamplingPoints_vectorLPoint2fG(instance: *mut c_void, sampling_points: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_PCTSignatures_setWeight_int_float(instance: *mut c_void, idx: i32, value: f32, ocvrs_return: *mut Result<()>); + pub fn cv_xfeatures2d_PCTSignatures_setWeights_const_vectorLfloatGR(instance: *mut c_void, weights: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_xfeatures2d_PCTSignatures_setTranslation_int_float(instance: *mut c_void, idx: i32, value: f32, ocvrs_return: *mut Result<()>); + pub fn cv_xfeatures2d_PCTSignatures_setTranslations_const_vectorLfloatGR(instance: *mut c_void, translations: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_xfeatures2d_PCTSignatures_setSamplingPoints_vectorLPoint2fG(instance: *mut c_void, sampling_points: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_PCTSignatures_getInitSeedIndexes_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_xfeatures2d_PCTSignatures_setInitSeedIndexes_vectorLintG(instance: *mut c_void, init_seed_indexes: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_PCTSignatures_setInitSeedIndexes_vectorLintG(instance: *mut c_void, init_seed_indexes: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_PCTSignatures_getInitSeedCount_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_xfeatures2d_PCTSignatures_getIterationCount_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_PCTSignatures_setIterationCount_int(instance: *mut c_void, iteration_count: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_PCTSignatures_setIterationCount_int(instance: *mut c_void, iteration_count: i32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_PCTSignatures_getMaxClustersCount_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_PCTSignatures_setMaxClustersCount_int(instance: *mut c_void, max_clusters_count: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_PCTSignatures_setMaxClustersCount_int(instance: *mut c_void, max_clusters_count: i32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_PCTSignatures_getClusterMinSize_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_PCTSignatures_setClusterMinSize_int(instance: *mut c_void, cluster_min_size: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_PCTSignatures_setClusterMinSize_int(instance: *mut c_void, cluster_min_size: i32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_PCTSignatures_getJoiningDistance_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_PCTSignatures_setJoiningDistance_float(instance: *mut c_void, joining_distance: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_PCTSignatures_setJoiningDistance_float(instance: *mut c_void, joining_distance: f32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_PCTSignatures_getDropThreshold_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_PCTSignatures_setDropThreshold_float(instance: *mut c_void, drop_threshold: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_PCTSignatures_setDropThreshold_float(instance: *mut c_void, drop_threshold: f32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_PCTSignatures_getDistanceFunction_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_PCTSignatures_setDistanceFunction_int(instance: *mut c_void, distance_function: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_PCTSignatures_setDistanceFunction_int(instance: *mut c_void, distance_function: i32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_PCTSignatures_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_xfeatures2d_PCTSignatures_delete(instance: *mut c_void); pub fn cv_xfeatures2d_PCTSignaturesSQFD_create_const_int_const_int_const_float(distance_function: i32, similarity_function: i32, similarity_parameter: f32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_xfeatures2d_PCTSignaturesSQFD_create(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_xfeatures2d_PCTSignaturesSQFD_computeQuadraticFormDistance_const_const__InputArrayR_const__InputArrayR(instance: *const c_void, _signature0: *const c_void, _signature1: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_PCTSignaturesSQFD_computeQuadraticFormDistances_const_const_MatR_const_vectorLMatGR_vectorLfloatGR(instance: *const c_void, source_signature: *const c_void, image_signatures: *const c_void, distances: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_PCTSignaturesSQFD_computeQuadraticFormDistances_const_const_MatR_const_vectorLMatGR_vectorLfloatGR(instance: *const c_void, source_signature: *const c_void, image_signatures: *const c_void, distances: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_PCTSignaturesSQFD_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_xfeatures2d_PCTSignaturesSQFD_delete(instance: *mut c_void); pub fn cv_xfeatures2d_SURF_create_double_int_int_bool_bool(hessian_threshold: f64, n_octaves: i32, n_octave_layers: i32, extended: bool, upright: bool, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_xfeatures2d_SURF_create(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_xfeatures2d_SURF_setHessianThreshold_double(instance: *mut c_void, hessian_threshold: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_SURF_setHessianThreshold_double(instance: *mut c_void, hessian_threshold: f64, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_SURF_getHessianThreshold_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_SURF_setNOctaves_int(instance: *mut c_void, n_octaves: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_SURF_setNOctaves_int(instance: *mut c_void, n_octaves: i32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_SURF_getNOctaves_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_SURF_setNOctaveLayers_int(instance: *mut c_void, n_octave_layers: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_SURF_setNOctaveLayers_int(instance: *mut c_void, n_octave_layers: i32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_SURF_getNOctaveLayers_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_SURF_setExtended_bool(instance: *mut c_void, extended: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_SURF_setExtended_bool(instance: *mut c_void, extended: bool, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_SURF_getExtended_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_SURF_setUpright_bool(instance: *mut c_void, upright: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_SURF_setUpright_bool(instance: *mut c_void, upright: bool, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_SURF_getUpright_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_xfeatures2d_SURF_getDefaultName_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_xfeatures2d_SURF_to_Algorithm(instance: *mut c_void) -> *mut c_void; @@ -17272,15 +17261,15 @@ mod xfeatures2d_sys { pub fn cv_xfeatures2d_SURF_delete(instance: *mut c_void); pub fn cv_xfeatures2d_StarDetector_create_int_int_int_int_int(max_size: i32, response_threshold: i32, line_threshold_projected: i32, line_threshold_binarized: i32, suppress_nonmax_size: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_xfeatures2d_StarDetector_create(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_xfeatures2d_StarDetector_setMaxSize_int(instance: *mut c_void, _max_size: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_StarDetector_setMaxSize_int(instance: *mut c_void, _max_size: i32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_StarDetector_getMaxSize_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_StarDetector_setResponseThreshold_int(instance: *mut c_void, _response_threshold: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_StarDetector_setResponseThreshold_int(instance: *mut c_void, _response_threshold: i32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_StarDetector_getResponseThreshold_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_StarDetector_setLineThresholdProjected_int(instance: *mut c_void, _line_threshold_projected: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_StarDetector_setLineThresholdProjected_int(instance: *mut c_void, _line_threshold_projected: i32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_StarDetector_getLineThresholdProjected_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_StarDetector_setLineThresholdBinarized_int(instance: *mut c_void, _line_threshold_binarized: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_StarDetector_setLineThresholdBinarized_int(instance: *mut c_void, _line_threshold_binarized: i32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_StarDetector_getLineThresholdBinarized_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_StarDetector_setSuppressNonmaxSize_int(instance: *mut c_void, _suppress_nonmax_size: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_StarDetector_setSuppressNonmaxSize_int(instance: *mut c_void, _suppress_nonmax_size: i32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_StarDetector_getSuppressNonmaxSize_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_xfeatures2d_StarDetector_getDefaultName_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_xfeatures2d_StarDetector_to_Algorithm(instance: *mut c_void) -> *mut c_void; @@ -17288,13 +17277,13 @@ mod xfeatures2d_sys { pub fn cv_xfeatures2d_StarDetector_delete(instance: *mut c_void); pub fn cv_xfeatures2d_TBMR_create_int_float_float_int(min_area: i32, max_area_relative: f32, scale_factor: f32, n_scales: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_xfeatures2d_TBMR_create(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_xfeatures2d_TBMR_setMinArea_int(instance: *mut c_void, min_area: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_TBMR_setMinArea_int(instance: *mut c_void, min_area: i32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_TBMR_getMinArea_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_TBMR_setMaxAreaRelative_float(instance: *mut c_void, max_area: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_TBMR_setMaxAreaRelative_float(instance: *mut c_void, max_area: f32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_TBMR_getMaxAreaRelative_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_TBMR_setScaleFactor_float(instance: *mut c_void, scale_factor: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_TBMR_setScaleFactor_float(instance: *mut c_void, scale_factor: f32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_TBMR_getScaleFactor_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_TBMR_setNScales_int(instance: *mut c_void, n_scales: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_TBMR_setNScales_int(instance: *mut c_void, n_scales: i32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_TBMR_getNScales_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_xfeatures2d_TBMR_getDefaultName_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_xfeatures2d_TBMR_to_AffineFeature2D(instance: *mut c_void) -> *mut c_void; @@ -17311,15 +17300,15 @@ mod xfeatures2d_sys { pub fn cv_xfeatures2d_VGG_create_int_float_bool_bool_float_bool(desc: i32, isigma: f32, img_normalize: bool, use_scale_orientation: bool, scale_factor: f32, dsc_normalize: bool, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_xfeatures2d_VGG_create(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_xfeatures2d_VGG_getDefaultName_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_xfeatures2d_VGG_setSigma_const_float(instance: *mut c_void, isigma: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_VGG_setSigma_const_float(instance: *mut c_void, isigma: f32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_VGG_getSigma_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_VGG_setUseNormalizeImage_const_bool(instance: *mut c_void, img_normalize: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_VGG_setUseNormalizeImage_const_bool(instance: *mut c_void, img_normalize: bool, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_VGG_getUseNormalizeImage_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_VGG_setUseScaleOrientation_const_bool(instance: *mut c_void, use_scale_orientation: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_VGG_setUseScaleOrientation_const_bool(instance: *mut c_void, use_scale_orientation: bool, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_VGG_getUseScaleOrientation_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_VGG_setScaleFactor_const_float(instance: *mut c_void, scale_factor: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_VGG_setScaleFactor_const_float(instance: *mut c_void, scale_factor: f32, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_VGG_getScaleFactor_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xfeatures2d_VGG_setUseNormalizeDescriptor_const_bool(instance: *mut c_void, dsc_normalize: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_xfeatures2d_VGG_setUseNormalizeDescriptor_const_bool(instance: *mut c_void, dsc_normalize: bool, ocvrs_return: *mut Result<()>); pub fn cv_xfeatures2d_VGG_getUseNormalizeDescriptor_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_xfeatures2d_VGG_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_xfeatures2d_VGG_to_Feature2D(instance: *mut c_void) -> *mut c_void; @@ -17447,39 +17436,37 @@ mod xfeatures2d_sys { pub fn std_vectorLcv_xfeatures2d_Elliptic_KeyPointG_set_size_t_const_Elliptic_KeyPoint(instance: *mut c_void, index: size_t, val: *const c_void); } } -#[cfg(ocvrs_has_module_xfeatures2d)] pub use xfeatures2d_sys::*; -#[cfg(ocvrs_has_module_ximgproc)] mod ximgproc_sys { use super::*; extern "C" { - pub fn cv_ximgproc_BrightEdges_MatR_MatR(_original: *mut c_void, _edgeview: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_BrightEdges_MatR_MatR_int_int_int(_original: *mut c_void, _edgeview: *mut c_void, contrast: i32, shortrange: i32, longrange: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_FastHoughTransform_const__InputArrayR_const__OutputArrayR_int(src: *const c_void, dst: *const c_void, dst_mat_depth: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_FastHoughTransform_const__InputArrayR_const__OutputArrayR_int_int_int_int(src: *const c_void, dst: *const c_void, dst_mat_depth: i32, angle_range: i32, op: i32, make_skew: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_GradientDericheX_const__InputArrayR_const__OutputArrayR_double_double(op: *const c_void, dst: *const c_void, alpha: f64, omega: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_GradientDericheY_const__InputArrayR_const__OutputArrayR_double_double(op: *const c_void, dst: *const c_void, alpha: f64, omega: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_GradientPaillouX_const__InputArrayR_const__OutputArrayR_double_double(op: *const c_void, _dst: *const c_void, alpha: f64, omega: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_GradientPaillouY_const__InputArrayR_const__OutputArrayR_double_double(op: *const c_void, _dst: *const c_void, alpha: f64, omega: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_BrightEdges_MatR_MatR(_original: *mut c_void, _edgeview: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_BrightEdges_MatR_MatR_int_int_int(_original: *mut c_void, _edgeview: *mut c_void, contrast: i32, shortrange: i32, longrange: i32, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_FastHoughTransform_const__InputArrayR_const__OutputArrayR_int(src: *const c_void, dst: *const c_void, dst_mat_depth: i32, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_FastHoughTransform_const__InputArrayR_const__OutputArrayR_int_int_int_int(src: *const c_void, dst: *const c_void, dst_mat_depth: i32, angle_range: i32, op: i32, make_skew: i32, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_GradientDericheX_const__InputArrayR_const__OutputArrayR_double_double(op: *const c_void, dst: *const c_void, alpha: f64, omega: f64, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_GradientDericheY_const__InputArrayR_const__OutputArrayR_double_double(op: *const c_void, dst: *const c_void, alpha: f64, omega: f64, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_GradientPaillouX_const__InputArrayR_const__OutputArrayR_double_double(op: *const c_void, _dst: *const c_void, alpha: f64, omega: f64, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_GradientPaillouY_const__InputArrayR_const__OutputArrayR_double_double(op: *const c_void, _dst: *const c_void, alpha: f64, omega: f64, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_HoughPoint2Line_const_PointR_const__InputArrayR(hough_point: *const core::Point, src_img_info: *const c_void, ocvrs_return: *mut Result); pub fn cv_ximgproc_HoughPoint2Line_const_PointR_const__InputArrayR_int_int_int(hough_point: *const core::Point, src_img_info: *const c_void, angle_range: i32, make_skew: i32, rules: i32, ocvrs_return: *mut Result); pub fn cv_ximgproc_PeiLinNormalization_const__InputArrayR(i: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ximgproc_PeiLinNormalization_const__InputArrayR_const__OutputArrayR(i: *const c_void, t: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_RadonTransform_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_RadonTransform_const__InputArrayR_const__OutputArrayR_double_double_double_bool_bool(src: *const c_void, dst: *const c_void, theta: f64, start_angle: f64, end_angle: f64, crop: bool, norm: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_amFilter_const__InputArrayR_const__InputArrayR_const__OutputArrayR_double_double(joint: *const c_void, src: *const c_void, dst: *const c_void, sigma_s: f64, sigma_r: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_amFilter_const__InputArrayR_const__InputArrayR_const__OutputArrayR_double_double_bool(joint: *const c_void, src: *const c_void, dst: *const c_void, sigma_s: f64, sigma_r: f64, adjust_outliers: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_anisotropicDiffusion_const__InputArrayR_const__OutputArrayR_float_float_int(src: *const c_void, dst: *const c_void, alpha: f32, k: f32, niters: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_bilateralTextureFilter_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_bilateralTextureFilter_const__InputArrayR_const__OutputArrayR_int_int_double_double(src: *const c_void, dst: *const c_void, fr: i32, num_iter: i32, sigma_alpha: f64, sigma_avg: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_colorMatchTemplate_const__InputArrayR_const__InputArrayR_const__OutputArrayR(img: *const c_void, templ: *const c_void, result: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_PeiLinNormalization_const__InputArrayR_const__OutputArrayR(i: *const c_void, t: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_RadonTransform_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_RadonTransform_const__InputArrayR_const__OutputArrayR_double_double_double_bool_bool(src: *const c_void, dst: *const c_void, theta: f64, start_angle: f64, end_angle: f64, crop: bool, norm: bool, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_amFilter_const__InputArrayR_const__InputArrayR_const__OutputArrayR_double_double(joint: *const c_void, src: *const c_void, dst: *const c_void, sigma_s: f64, sigma_r: f64, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_amFilter_const__InputArrayR_const__InputArrayR_const__OutputArrayR_double_double_bool(joint: *const c_void, src: *const c_void, dst: *const c_void, sigma_s: f64, sigma_r: f64, adjust_outliers: bool, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_anisotropicDiffusion_const__InputArrayR_const__OutputArrayR_float_float_int(src: *const c_void, dst: *const c_void, alpha: f32, k: f32, niters: i32, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_bilateralTextureFilter_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_bilateralTextureFilter_const__InputArrayR_const__OutputArrayR_int_int_double_double(src: *const c_void, dst: *const c_void, fr: i32, num_iter: i32, sigma_alpha: f64, sigma_avg: f64, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_colorMatchTemplate_const__InputArrayR_const__InputArrayR_const__OutputArrayR(img: *const c_void, templ: *const c_void, result: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_computeBadPixelPercent_const__InputArrayR_const__InputArrayR_Rect(gt: *const c_void, src: *const c_void, roi: *const core::Rect, ocvrs_return: *mut Result); pub fn cv_ximgproc_computeBadPixelPercent_const__InputArrayR_const__InputArrayR_Rect_int(gt: *const c_void, src: *const c_void, roi: *const core::Rect, thresh: i32, ocvrs_return: *mut Result); pub fn cv_ximgproc_computeMSE_const__InputArrayR_const__InputArrayR_Rect(gt: *const c_void, src: *const c_void, roi: *const core::Rect, ocvrs_return: *mut Result); - pub fn cv_ximgproc_contourSampling_const__InputArrayR_const__OutputArrayR_int(src: *const c_void, out: *const c_void, nb_elt: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_covarianceEstimation_const__InputArrayR_const__OutputArrayR_int_int(src: *const c_void, dst: *const c_void, window_rows: i32, window_cols: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_contourSampling_const__InputArrayR_const__OutputArrayR_int(src: *const c_void, out: *const c_void, nb_elt: i32, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_covarianceEstimation_const__InputArrayR_const__OutputArrayR_int_int(src: *const c_void, dst: *const c_void, window_rows: i32, window_cols: i32, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_createAMFilter_double_double(sigma_s: f64, sigma_r: f64, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ximgproc_createAMFilter_double_double_bool(sigma_s: f64, sigma_r: f64, adjust_outliers: bool, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ximgproc_createContourFitting(ocvrs_return: *mut Result<*mut c_void>); @@ -17500,7 +17487,7 @@ mod ximgproc_sys { pub fn cv_ximgproc_createFastLineDetector_int_float_double_double_int_bool(length_threshold: i32, distance_threshold: f32, canny_th1: f64, canny_th2: f64, canny_aperture_size: i32, do_merge: bool, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ximgproc_createGuidedFilter_const__InputArrayR_int_double(guide: *const c_void, radius: i32, eps: f64, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ximgproc_createGuidedFilter_const__InputArrayR_int_double_double(guide: *const c_void, radius: i32, eps: f64, scale: f64, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_ximgproc_createQuaternionImage_const__InputArrayR_const__OutputArrayR(img: *const c_void, qimg: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_createQuaternionImage_const__InputArrayR_const__OutputArrayR(img: *const c_void, qimg: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_createRFFeatureGetter(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ximgproc_createRICInterpolator(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ximgproc_createRightMatcher_PtrLStereoMatcherG(matcher_left: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); @@ -17514,46 +17501,46 @@ mod ximgproc_sys { pub fn cv_ximgproc_createSuperpixelSEEDS_int_int_int_int_int_int_int_bool(image_width: i32, image_height: i32, image_channels: i32, num_superpixels: i32, num_levels: i32, prior: i32, histogram_bins: i32, double_step: bool, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ximgproc_createSuperpixelSLIC_const__InputArrayR(image: *const c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ximgproc_createSuperpixelSLIC_const__InputArrayR_int_int_float(image: *const c_void, algorithm: i32, region_size: i32, ruler: f32, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_ximgproc_dtFilter_const__InputArrayR_const__InputArrayR_const__OutputArrayR_double_double(guide: *const c_void, src: *const c_void, dst: *const c_void, sigma_spatial: f64, sigma_color: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_dtFilter_const__InputArrayR_const__InputArrayR_const__OutputArrayR_double_double_int_int(guide: *const c_void, src: *const c_void, dst: *const c_void, sigma_spatial: f64, sigma_color: f64, mode: i32, num_iters: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_edgePreservingFilter_const__InputArrayR_const__OutputArrayR_int_double(src: *const c_void, dst: *const c_void, d: i32, threshold: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_fastBilateralSolverFilter_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR(guide: *const c_void, src: *const c_void, confidence: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_fastBilateralSolverFilter_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR_double_double_double_double_int_double(guide: *const c_void, src: *const c_void, confidence: *const c_void, dst: *const c_void, sigma_spatial: f64, sigma_luma: f64, sigma_chroma: f64, lambda: f64, num_iter: i32, max_tol: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_fastGlobalSmootherFilter_const__InputArrayR_const__InputArrayR_const__OutputArrayR_double_double(guide: *const c_void, src: *const c_void, dst: *const c_void, lambda: f64, sigma_color: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_fastGlobalSmootherFilter_const__InputArrayR_const__InputArrayR_const__OutputArrayR_double_double_double_int(guide: *const c_void, src: *const c_void, dst: *const c_void, lambda: f64, sigma_color: f64, lambda_attenuation: f64, num_iter: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_findEllipses_const__InputArrayR_const__OutputArrayR(image: *const c_void, ellipses: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_findEllipses_const__InputArrayR_const__OutputArrayR_float_float_float(image: *const c_void, ellipses: *const c_void, score_threshold: f32, reliability_threshold: f32, center_distance_threshold: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_fourierDescriptor_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_fourierDescriptor_const__InputArrayR_const__OutputArrayR_int_int(src: *const c_void, dst: *const c_void, nb_elt: i32, nb_fd: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_getDisparityVis_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_getDisparityVis_const__InputArrayR_const__OutputArrayR_double(src: *const c_void, dst: *const c_void, scale: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_guidedFilter_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int_double(guide: *const c_void, src: *const c_void, dst: *const c_void, radius: i32, eps: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_guidedFilter_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int_double_int_double(guide: *const c_void, src: *const c_void, dst: *const c_void, radius: i32, eps: f64, d_depth: i32, scale: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_jointBilateralFilter_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int_double_double(joint: *const c_void, src: *const c_void, dst: *const c_void, d: i32, sigma_color: f64, sigma_space: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_jointBilateralFilter_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int_double_double_int(joint: *const c_void, src: *const c_void, dst: *const c_void, d: i32, sigma_color: f64, sigma_space: f64, border_type: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_l0Smooth_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_l0Smooth_const__InputArrayR_const__OutputArrayR_double_double(src: *const c_void, dst: *const c_void, lambda: f64, kappa: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_niBlackThreshold_const__InputArrayR_const__OutputArrayR_double_int_int_double(_src: *const c_void, _dst: *const c_void, max_value: f64, typ: i32, block_size: i32, k: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_niBlackThreshold_const__InputArrayR_const__OutputArrayR_double_int_int_double_int_double(_src: *const c_void, _dst: *const c_void, max_value: f64, typ: i32, block_size: i32, k: f64, binarization_method: i32, r: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_qconj_const__InputArrayR_const__OutputArrayR(qimg: *const c_void, qcimg: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_qdft_const__InputArrayR_const__OutputArrayR_int_bool(img: *const c_void, qimg: *const c_void, flags: i32, side_left: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_qmultiply_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_qunitary_const__InputArrayR_const__OutputArrayR(qimg: *const c_void, qnimg: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_dtFilter_const__InputArrayR_const__InputArrayR_const__OutputArrayR_double_double(guide: *const c_void, src: *const c_void, dst: *const c_void, sigma_spatial: f64, sigma_color: f64, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_dtFilter_const__InputArrayR_const__InputArrayR_const__OutputArrayR_double_double_int_int(guide: *const c_void, src: *const c_void, dst: *const c_void, sigma_spatial: f64, sigma_color: f64, mode: i32, num_iters: i32, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_edgePreservingFilter_const__InputArrayR_const__OutputArrayR_int_double(src: *const c_void, dst: *const c_void, d: i32, threshold: f64, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_fastBilateralSolverFilter_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR(guide: *const c_void, src: *const c_void, confidence: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_fastBilateralSolverFilter_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR_double_double_double_double_int_double(guide: *const c_void, src: *const c_void, confidence: *const c_void, dst: *const c_void, sigma_spatial: f64, sigma_luma: f64, sigma_chroma: f64, lambda: f64, num_iter: i32, max_tol: f64, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_fastGlobalSmootherFilter_const__InputArrayR_const__InputArrayR_const__OutputArrayR_double_double(guide: *const c_void, src: *const c_void, dst: *const c_void, lambda: f64, sigma_color: f64, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_fastGlobalSmootherFilter_const__InputArrayR_const__InputArrayR_const__OutputArrayR_double_double_double_int(guide: *const c_void, src: *const c_void, dst: *const c_void, lambda: f64, sigma_color: f64, lambda_attenuation: f64, num_iter: i32, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_findEllipses_const__InputArrayR_const__OutputArrayR(image: *const c_void, ellipses: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_findEllipses_const__InputArrayR_const__OutputArrayR_float_float_float(image: *const c_void, ellipses: *const c_void, score_threshold: f32, reliability_threshold: f32, center_distance_threshold: f32, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_fourierDescriptor_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_fourierDescriptor_const__InputArrayR_const__OutputArrayR_int_int(src: *const c_void, dst: *const c_void, nb_elt: i32, nb_fd: i32, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_getDisparityVis_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_getDisparityVis_const__InputArrayR_const__OutputArrayR_double(src: *const c_void, dst: *const c_void, scale: f64, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_guidedFilter_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int_double(guide: *const c_void, src: *const c_void, dst: *const c_void, radius: i32, eps: f64, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_guidedFilter_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int_double_int_double(guide: *const c_void, src: *const c_void, dst: *const c_void, radius: i32, eps: f64, d_depth: i32, scale: f64, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_jointBilateralFilter_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int_double_double(joint: *const c_void, src: *const c_void, dst: *const c_void, d: i32, sigma_color: f64, sigma_space: f64, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_jointBilateralFilter_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int_double_double_int(joint: *const c_void, src: *const c_void, dst: *const c_void, d: i32, sigma_color: f64, sigma_space: f64, border_type: i32, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_l0Smooth_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_l0Smooth_const__InputArrayR_const__OutputArrayR_double_double(src: *const c_void, dst: *const c_void, lambda: f64, kappa: f64, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_niBlackThreshold_const__InputArrayR_const__OutputArrayR_double_int_int_double(_src: *const c_void, _dst: *const c_void, max_value: f64, typ: i32, block_size: i32, k: f64, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_niBlackThreshold_const__InputArrayR_const__OutputArrayR_double_int_int_double_int_double(_src: *const c_void, _dst: *const c_void, max_value: f64, typ: i32, block_size: i32, k: f64, binarization_method: i32, r: f64, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_qconj_const__InputArrayR_const__OutputArrayR(qimg: *const c_void, qcimg: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_qdft_const__InputArrayR_const__OutputArrayR_int_bool(img: *const c_void, qimg: *const c_void, flags: i32, side_left: bool, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_qmultiply_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src1: *const c_void, src2: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_qunitary_const__InputArrayR_const__OutputArrayR(qimg: *const c_void, qnimg: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_readGT_String_const__OutputArrayR(src_path: *const c_char, dst: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ximgproc_rl_createRLEImage_const_vectorLPoint3iGR_const__OutputArrayR(runs: *const c_void, res: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_rl_createRLEImage_const_vectorLPoint3iGR_const__OutputArrayR_Size(runs: *const c_void, res: *const c_void, size: *const core::Size, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_rl_dilate_const__InputArrayR_const__OutputArrayR_const__InputArrayR(rl_src: *const c_void, rl_dest: *const c_void, rl_kernel: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_rl_dilate_const__InputArrayR_const__OutputArrayR_const__InputArrayR_Point(rl_src: *const c_void, rl_dest: *const c_void, rl_kernel: *const c_void, anchor: *const core::Point, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_rl_erode_const__InputArrayR_const__OutputArrayR_const__InputArrayR(rl_src: *const c_void, rl_dest: *const c_void, rl_kernel: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_rl_erode_const__InputArrayR_const__OutputArrayR_const__InputArrayR_bool_Point(rl_src: *const c_void, rl_dest: *const c_void, rl_kernel: *const c_void, b_boundary_on: bool, anchor: *const core::Point, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_rl_createRLEImage_const_vectorLPoint3iGR_const__OutputArrayR(runs: *const c_void, res: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_rl_createRLEImage_const_vectorLPoint3iGR_const__OutputArrayR_Size(runs: *const c_void, res: *const c_void, size: *const core::Size, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_rl_dilate_const__InputArrayR_const__OutputArrayR_const__InputArrayR(rl_src: *const c_void, rl_dest: *const c_void, rl_kernel: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_rl_dilate_const__InputArrayR_const__OutputArrayR_const__InputArrayR_Point(rl_src: *const c_void, rl_dest: *const c_void, rl_kernel: *const c_void, anchor: *const core::Point, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_rl_erode_const__InputArrayR_const__OutputArrayR_const__InputArrayR(rl_src: *const c_void, rl_dest: *const c_void, rl_kernel: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_rl_erode_const__InputArrayR_const__OutputArrayR_const__InputArrayR_bool_Point(rl_src: *const c_void, rl_dest: *const c_void, rl_kernel: *const c_void, b_boundary_on: bool, anchor: *const core::Point, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_rl_getStructuringElement_int_Size(shape: i32, ksize: *const core::Size, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ximgproc_rl_isRLMorphologyPossible_const__InputArrayR(rl_structuring_element: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ximgproc_rl_morphologyEx_const__InputArrayR_const__OutputArrayR_int_const__InputArrayR(rl_src: *const c_void, rl_dest: *const c_void, op: i32, rl_kernel: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_rl_morphologyEx_const__InputArrayR_const__OutputArrayR_int_const__InputArrayR_bool_Point(rl_src: *const c_void, rl_dest: *const c_void, op: i32, rl_kernel: *const c_void, b_boundary_on_for_erosion: bool, anchor: *const core::Point, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_rl_paint_const__InputOutputArrayR_const__InputArrayR_const_ScalarR(image: *const c_void, rl_src: *const c_void, value: *const core::Scalar, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_rl_threshold_const__InputArrayR_const__OutputArrayR_double_int(src: *const c_void, rl_dest: *const c_void, thresh: f64, typ: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_rollingGuidanceFilter_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_rollingGuidanceFilter_const__InputArrayR_const__OutputArrayR_int_double_double_int_int(src: *const c_void, dst: *const c_void, d: i32, sigma_color: f64, sigma_space: f64, num_of_iter: i32, border_type: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_rl_morphologyEx_const__InputArrayR_const__OutputArrayR_int_const__InputArrayR(rl_src: *const c_void, rl_dest: *const c_void, op: i32, rl_kernel: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_rl_morphologyEx_const__InputArrayR_const__OutputArrayR_int_const__InputArrayR_bool_Point(rl_src: *const c_void, rl_dest: *const c_void, op: i32, rl_kernel: *const c_void, b_boundary_on_for_erosion: bool, anchor: *const core::Point, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_rl_paint_const__InputOutputArrayR_const__InputArrayR_const_ScalarR(image: *const c_void, rl_src: *const c_void, value: *const core::Scalar, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_rl_threshold_const__InputArrayR_const__OutputArrayR_double_int(src: *const c_void, rl_dest: *const c_void, thresh: f64, typ: i32, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_rollingGuidanceFilter_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_rollingGuidanceFilter_const__InputArrayR_const__OutputArrayR_int_double_double_int_int(src: *const c_void, dst: *const c_void, d: i32, sigma_color: f64, sigma_space: f64, num_of_iter: i32, border_type: i32, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_segmentation_createGraphSegmentation(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ximgproc_segmentation_createGraphSegmentation_double_float_int(sigma: f64, k: f32, min_size: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ximgproc_segmentation_createSelectiveSearchSegmentation(ocvrs_return: *mut Result<*mut c_void>); @@ -17566,264 +17553,264 @@ mod ximgproc_sys { pub fn cv_ximgproc_segmentation_createSelectiveSearchSegmentationStrategyMultiple_PtrLSelectiveSearchSegmentationStrategyG_PtrLSelectiveSearchSegmentationStrategyG_PtrLSelectiveSearchSegmentationStrategyG_PtrLSelectiveSearchSegmentationStrategyG(s1: *mut c_void, s2: *mut c_void, s3: *mut c_void, s4: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ximgproc_segmentation_createSelectiveSearchSegmentationStrategySize(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ximgproc_segmentation_createSelectiveSearchSegmentationStrategyTexture(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_ximgproc_thinning_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_thinning_const__InputArrayR_const__OutputArrayR_int(src: *const c_void, dst: *const c_void, thinning_type: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_transformFD_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src: *const c_void, t: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_transformFD_const__InputArrayR_const__InputArrayR_const__OutputArrayR_bool(src: *const c_void, t: *const c_void, dst: *const c_void, fd_contour: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_weightedMedianFilter_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int(joint: *const c_void, src: *const c_void, dst: *const c_void, r: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_weightedMedianFilter_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int_double_int_const__InputArrayR(joint: *const c_void, src: *const c_void, dst: *const c_void, r: i32, sigma: f64, weight_type: i32, mask: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_AdaptiveManifoldFilter_filter_const__InputArrayR_const__OutputArrayR_const__InputArrayR(instance: *mut c_void, src: *const c_void, dst: *const c_void, joint: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_AdaptiveManifoldFilter_filter_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_AdaptiveManifoldFilter_collectGarbage(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_thinning_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_thinning_const__InputArrayR_const__OutputArrayR_int(src: *const c_void, dst: *const c_void, thinning_type: i32, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_transformFD_const__InputArrayR_const__InputArrayR_const__OutputArrayR(src: *const c_void, t: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_transformFD_const__InputArrayR_const__InputArrayR_const__OutputArrayR_bool(src: *const c_void, t: *const c_void, dst: *const c_void, fd_contour: bool, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_weightedMedianFilter_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int(joint: *const c_void, src: *const c_void, dst: *const c_void, r: i32, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_weightedMedianFilter_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int_double_int_const__InputArrayR(joint: *const c_void, src: *const c_void, dst: *const c_void, r: i32, sigma: f64, weight_type: i32, mask: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_AdaptiveManifoldFilter_filter_const__InputArrayR_const__OutputArrayR_const__InputArrayR(instance: *mut c_void, src: *const c_void, dst: *const c_void, joint: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_AdaptiveManifoldFilter_filter_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_AdaptiveManifoldFilter_collectGarbage(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_AdaptiveManifoldFilter_create(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ximgproc_AdaptiveManifoldFilter_getSigmaS_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ximgproc_AdaptiveManifoldFilter_setSigmaS_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_AdaptiveManifoldFilter_setSigmaS_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_AdaptiveManifoldFilter_getSigmaR_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ximgproc_AdaptiveManifoldFilter_setSigmaR_double(instance: *mut c_void, val: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_AdaptiveManifoldFilter_setSigmaR_double(instance: *mut c_void, val: f64, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_AdaptiveManifoldFilter_getTreeHeight_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ximgproc_AdaptiveManifoldFilter_setTreeHeight_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_AdaptiveManifoldFilter_setTreeHeight_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_AdaptiveManifoldFilter_getPCAIterations_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ximgproc_AdaptiveManifoldFilter_setPCAIterations_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_AdaptiveManifoldFilter_setPCAIterations_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_AdaptiveManifoldFilter_getAdjustOutliers_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ximgproc_AdaptiveManifoldFilter_setAdjustOutliers_bool(instance: *mut c_void, val: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_AdaptiveManifoldFilter_setAdjustOutliers_bool(instance: *mut c_void, val: bool, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_AdaptiveManifoldFilter_getUseRNG_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ximgproc_AdaptiveManifoldFilter_setUseRNG_bool(instance: *mut c_void, val: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_AdaptiveManifoldFilter_setUseRNG_bool(instance: *mut c_void, val: bool, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_AdaptiveManifoldFilter_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_ximgproc_AdaptiveManifoldFilter_delete(instance: *mut c_void); pub fn cv_ximgproc_ContourFitting_ContourFitting_int_int(ctr: i32, fd: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ximgproc_ContourFitting_ContourFitting(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_ximgproc_ContourFitting_estimateTransformation_const__InputArrayR_const__InputArrayR_const__OutputArrayR_doubleX_bool(instance: *mut c_void, src: *const c_void, dst: *const c_void, alpha_phi_st: *const c_void, dist: *mut f64, fd_contour: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_ContourFitting_estimateTransformation_const__InputArrayR_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, src: *const c_void, dst: *const c_void, alpha_phi_st: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_ContourFitting_estimateTransformation_const__InputArrayR_const__InputArrayR_const__OutputArrayR_doubleR_bool(instance: *mut c_void, src: *const c_void, dst: *const c_void, alpha_phi_st: *const c_void, dist: *mut f64, fd_contour: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_ContourFitting_estimateTransformation_const__InputArrayR_const__InputArrayR_const__OutputArrayR_doubleR(instance: *mut c_void, src: *const c_void, dst: *const c_void, alpha_phi_st: *const c_void, dist: *mut f64, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_ContourFitting_setCtrSize_int(instance: *mut c_void, n: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_ContourFitting_setFDSize_int(instance: *mut c_void, n: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_ContourFitting_estimateTransformation_const__InputArrayR_const__InputArrayR_const__OutputArrayR_doubleX_bool(instance: *mut c_void, src: *const c_void, dst: *const c_void, alpha_phi_st: *const c_void, dist: *mut f64, fd_contour: bool, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_ContourFitting_estimateTransformation_const__InputArrayR_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, src: *const c_void, dst: *const c_void, alpha_phi_st: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_ContourFitting_estimateTransformation_const__InputArrayR_const__InputArrayR_const__OutputArrayR_doubleR_bool(instance: *mut c_void, src: *const c_void, dst: *const c_void, alpha_phi_st: *const c_void, dist: *mut f64, fd_contour: bool, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_ContourFitting_estimateTransformation_const__InputArrayR_const__InputArrayR_const__OutputArrayR_doubleR(instance: *mut c_void, src: *const c_void, dst: *const c_void, alpha_phi_st: *const c_void, dist: *mut f64, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_ContourFitting_setCtrSize_int(instance: *mut c_void, n: i32, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_ContourFitting_setFDSize_int(instance: *mut c_void, n: i32, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_ContourFitting_getCtrSize(instance: *mut c_void, ocvrs_return: *mut Result); pub fn cv_ximgproc_ContourFitting_getFDSize(instance: *mut c_void, ocvrs_return: *mut Result); pub fn cv_ximgproc_ContourFitting_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_ximgproc_ContourFitting_delete(instance: *mut c_void); - pub fn cv_ximgproc_DTFilter_filter_const__InputArrayR_const__OutputArrayR_int(instance: *mut c_void, src: *const c_void, dst: *const c_void, d_depth: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_DTFilter_filter_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_DTFilter_filter_const__InputArrayR_const__OutputArrayR_int(instance: *mut c_void, src: *const c_void, dst: *const c_void, d_depth: i32, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_DTFilter_filter_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_DTFilter_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_ximgproc_DTFilter_delete(instance: *mut c_void); - pub fn cv_ximgproc_DisparityFilter_filter_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__InputArrayR_Rect_const__InputArrayR(instance: *mut c_void, disparity_map_left: *const c_void, left_view: *const c_void, filtered_disparity_map: *const c_void, disparity_map_right: *const c_void, roi: *const core::Rect, right_view: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_DisparityFilter_filter_const__InputArrayR_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, disparity_map_left: *const c_void, left_view: *const c_void, filtered_disparity_map: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_DisparityFilter_filter_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__InputArrayR_Rect_const__InputArrayR(instance: *mut c_void, disparity_map_left: *const c_void, left_view: *const c_void, filtered_disparity_map: *const c_void, disparity_map_right: *const c_void, roi: *const core::Rect, right_view: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_DisparityFilter_filter_const__InputArrayR_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, disparity_map_left: *const c_void, left_view: *const c_void, filtered_disparity_map: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_DisparityFilter_to_DisparityWLSFilter(instance: *mut c_void) -> *mut c_void; pub fn cv_ximgproc_DisparityFilter_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_ximgproc_DisparityFilter_delete(instance: *mut c_void); pub fn cv_ximgproc_DisparityWLSFilter_getLambda(instance: *mut c_void, ocvrs_return: *mut Result); - pub fn cv_ximgproc_DisparityWLSFilter_setLambda_double(instance: *mut c_void, _lambda: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_DisparityWLSFilter_setLambda_double(instance: *mut c_void, _lambda: f64, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_DisparityWLSFilter_getSigmaColor(instance: *mut c_void, ocvrs_return: *mut Result); - pub fn cv_ximgproc_DisparityWLSFilter_setSigmaColor_double(instance: *mut c_void, _sigma_color: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_DisparityWLSFilter_setSigmaColor_double(instance: *mut c_void, _sigma_color: f64, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_DisparityWLSFilter_getLRCthresh(instance: *mut c_void, ocvrs_return: *mut Result); - pub fn cv_ximgproc_DisparityWLSFilter_setLRCthresh_int(instance: *mut c_void, _lrc_thresh: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_DisparityWLSFilter_setLRCthresh_int(instance: *mut c_void, _lrc_thresh: i32, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_DisparityWLSFilter_getDepthDiscontinuityRadius(instance: *mut c_void, ocvrs_return: *mut Result); - pub fn cv_ximgproc_DisparityWLSFilter_setDepthDiscontinuityRadius_int(instance: *mut c_void, _disc_radius: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_DisparityWLSFilter_setDepthDiscontinuityRadius_int(instance: *mut c_void, _disc_radius: i32, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_DisparityWLSFilter_getConfidenceMap(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ximgproc_DisparityWLSFilter_getROI(instance: *mut c_void, ocvrs_return: *mut Result); pub fn cv_ximgproc_DisparityWLSFilter_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_ximgproc_DisparityWLSFilter_to_DisparityFilter(instance: *mut c_void) -> *mut c_void; pub fn cv_ximgproc_DisparityWLSFilter_delete(instance: *mut c_void); - pub fn cv_ximgproc_EdgeAwareInterpolator_setCostMap_const_MatR(instance: *mut c_void, _cost_map: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_EdgeAwareInterpolator_setK_int(instance: *mut c_void, _k: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_EdgeAwareInterpolator_setCostMap_const_MatR(instance: *mut c_void, _cost_map: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_EdgeAwareInterpolator_setK_int(instance: *mut c_void, _k: i32, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_EdgeAwareInterpolator_getK(instance: *mut c_void, ocvrs_return: *mut Result); - pub fn cv_ximgproc_EdgeAwareInterpolator_setSigma_float(instance: *mut c_void, _sigma: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_EdgeAwareInterpolator_setSigma_float(instance: *mut c_void, _sigma: f32, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_EdgeAwareInterpolator_getSigma(instance: *mut c_void, ocvrs_return: *mut Result); - pub fn cv_ximgproc_EdgeAwareInterpolator_setLambda_float(instance: *mut c_void, _lambda: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_EdgeAwareInterpolator_setLambda_float(instance: *mut c_void, _lambda: f32, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_EdgeAwareInterpolator_getLambda(instance: *mut c_void, ocvrs_return: *mut Result); - pub fn cv_ximgproc_EdgeAwareInterpolator_setUsePostProcessing_bool(instance: *mut c_void, _use_post_proc: bool, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_EdgeAwareInterpolator_setUsePostProcessing_bool(instance: *mut c_void, _use_post_proc: bool, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_EdgeAwareInterpolator_getUsePostProcessing(instance: *mut c_void, ocvrs_return: *mut Result); - pub fn cv_ximgproc_EdgeAwareInterpolator_setFGSLambda_float(instance: *mut c_void, _lambda: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_EdgeAwareInterpolator_setFGSLambda_float(instance: *mut c_void, _lambda: f32, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_EdgeAwareInterpolator_getFGSLambda(instance: *mut c_void, ocvrs_return: *mut Result); - pub fn cv_ximgproc_EdgeAwareInterpolator_setFGSSigma_float(instance: *mut c_void, _sigma: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_EdgeAwareInterpolator_setFGSSigma_float(instance: *mut c_void, _sigma: f32, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_EdgeAwareInterpolator_getFGSSigma(instance: *mut c_void, ocvrs_return: *mut Result); pub fn cv_ximgproc_EdgeAwareInterpolator_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_ximgproc_EdgeAwareInterpolator_to_SparseMatchInterpolator(instance: *mut c_void) -> *mut c_void; pub fn cv_ximgproc_EdgeAwareInterpolator_delete(instance: *mut c_void); - pub fn cv_ximgproc_EdgeBoxes_getBoundingBoxes_const__InputArrayR_const__InputArrayR_vectorLRectGR_const__OutputArrayR(instance: *mut c_void, edge_map: *const c_void, orientation_map: *const c_void, boxes: *mut c_void, scores: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_EdgeBoxes_getBoundingBoxes_const__InputArrayR_const__InputArrayR_vectorLRectGR(instance: *mut c_void, edge_map: *const c_void, orientation_map: *const c_void, boxes: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_EdgeBoxes_getBoundingBoxes_const__InputArrayR_const__InputArrayR_vectorLRectGR_const__OutputArrayR(instance: *mut c_void, edge_map: *const c_void, orientation_map: *const c_void, boxes: *mut c_void, scores: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_EdgeBoxes_getBoundingBoxes_const__InputArrayR_const__InputArrayR_vectorLRectGR(instance: *mut c_void, edge_map: *const c_void, orientation_map: *const c_void, boxes: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_EdgeBoxes_getAlpha_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ximgproc_EdgeBoxes_setAlpha_float(instance: *mut c_void, value: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_EdgeBoxes_setAlpha_float(instance: *mut c_void, value: f32, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_EdgeBoxes_getBeta_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ximgproc_EdgeBoxes_setBeta_float(instance: *mut c_void, value: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_EdgeBoxes_setBeta_float(instance: *mut c_void, value: f32, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_EdgeBoxes_getEta_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ximgproc_EdgeBoxes_setEta_float(instance: *mut c_void, value: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_EdgeBoxes_setEta_float(instance: *mut c_void, value: f32, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_EdgeBoxes_getMinScore_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ximgproc_EdgeBoxes_setMinScore_float(instance: *mut c_void, value: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_EdgeBoxes_setMinScore_float(instance: *mut c_void, value: f32, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_EdgeBoxes_getMaxBoxes_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ximgproc_EdgeBoxes_setMaxBoxes_int(instance: *mut c_void, value: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_EdgeBoxes_setMaxBoxes_int(instance: *mut c_void, value: i32, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_EdgeBoxes_getEdgeMinMag_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ximgproc_EdgeBoxes_setEdgeMinMag_float(instance: *mut c_void, value: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_EdgeBoxes_setEdgeMinMag_float(instance: *mut c_void, value: f32, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_EdgeBoxes_getEdgeMergeThr_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ximgproc_EdgeBoxes_setEdgeMergeThr_float(instance: *mut c_void, value: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_EdgeBoxes_setEdgeMergeThr_float(instance: *mut c_void, value: f32, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_EdgeBoxes_getClusterMinMag_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ximgproc_EdgeBoxes_setClusterMinMag_float(instance: *mut c_void, value: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_EdgeBoxes_setClusterMinMag_float(instance: *mut c_void, value: f32, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_EdgeBoxes_getMaxAspectRatio_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ximgproc_EdgeBoxes_setMaxAspectRatio_float(instance: *mut c_void, value: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_EdgeBoxes_setMaxAspectRatio_float(instance: *mut c_void, value: f32, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_EdgeBoxes_getMinBoxArea_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ximgproc_EdgeBoxes_setMinBoxArea_float(instance: *mut c_void, value: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_EdgeBoxes_setMinBoxArea_float(instance: *mut c_void, value: f32, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_EdgeBoxes_getGamma_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ximgproc_EdgeBoxes_setGamma_float(instance: *mut c_void, value: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_EdgeBoxes_setGamma_float(instance: *mut c_void, value: f32, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_EdgeBoxes_getKappa_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ximgproc_EdgeBoxes_setKappa_float(instance: *mut c_void, value: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_EdgeBoxes_setKappa_float(instance: *mut c_void, value: f32, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_EdgeBoxes_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_ximgproc_EdgeBoxes_delete(instance: *mut c_void); - pub fn cv_ximgproc_EdgeDrawing_detectEdges_const__InputArrayR(instance: *mut c_void, src: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_EdgeDrawing_getEdgeImage_const__OutputArrayR(instance: *mut c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_EdgeDrawing_getGradientImage_const__OutputArrayR(instance: *mut c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_EdgeDrawing_detectEdges_const__InputArrayR(instance: *mut c_void, src: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_EdgeDrawing_getEdgeImage_const__OutputArrayR(instance: *mut c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_EdgeDrawing_getGradientImage_const__OutputArrayR(instance: *mut c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_EdgeDrawing_getSegments(instance: *mut c_void, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ximgproc_EdgeDrawing_getSegmentIndicesOfLines_const(instance: *const c_void, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_ximgproc_EdgeDrawing_detectLines_const__OutputArrayR(instance: *mut c_void, lines: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_EdgeDrawing_detectEllipses_const__OutputArrayR(instance: *mut c_void, ellipses: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_EdgeDrawing_setParams_const_ParamsR(instance: *mut c_void, parameters: *const crate::ximgproc::EdgeDrawing_Params, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_EdgeDrawing_detectLines_const__OutputArrayR(instance: *mut c_void, lines: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_EdgeDrawing_detectEllipses_const__OutputArrayR(instance: *mut c_void, ellipses: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_EdgeDrawing_setParams_const_ParamsR(instance: *mut c_void, parameters: *const crate::ximgproc::EdgeDrawing_Params, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_EdgeDrawing_propParams_const(instance: *const c_void, ocvrs_return: *mut crate::ximgproc::EdgeDrawing_Params); pub fn cv_ximgproc_EdgeDrawing_propParams_const_Params(instance: *mut c_void, val: *const crate::ximgproc::EdgeDrawing_Params); pub fn cv_ximgproc_EdgeDrawing_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_ximgproc_EdgeDrawing_delete(instance: *mut c_void); pub fn cv_ximgproc_EdgeDrawing_Params_Params(ocvrs_return: *mut Result); - pub fn cv_ximgproc_EdgeDrawing_Params_read_const_FileNodeR(instance: *const crate::ximgproc::EdgeDrawing_Params, fn_: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_EdgeDrawing_Params_write_const_FileStorageR(instance: *const crate::ximgproc::EdgeDrawing_Params, fs: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_FastBilateralSolverFilter_filter_const__InputArrayR_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, src: *const c_void, confidence: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_EdgeDrawing_Params_read_const_FileNodeR(instance: *const crate::ximgproc::EdgeDrawing_Params, fn_: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_EdgeDrawing_Params_write_const_FileStorageR(instance: *const crate::ximgproc::EdgeDrawing_Params, fs: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_FastBilateralSolverFilter_filter_const__InputArrayR_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, src: *const c_void, confidence: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_FastBilateralSolverFilter_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_ximgproc_FastBilateralSolverFilter_delete(instance: *mut c_void); - pub fn cv_ximgproc_FastGlobalSmootherFilter_filter_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_FastGlobalSmootherFilter_filter_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_FastGlobalSmootherFilter_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_ximgproc_FastGlobalSmootherFilter_delete(instance: *mut c_void); - pub fn cv_ximgproc_FastLineDetector_detect_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, lines: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_FastLineDetector_drawSegments_const__InputOutputArrayR_const__InputArrayR_bool_Scalar_int(instance: *mut c_void, image: *const c_void, lines: *const c_void, draw_arrow: bool, linecolor: *const core::Scalar, linethickness: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_FastLineDetector_drawSegments_const__InputOutputArrayR_const__InputArrayR(instance: *mut c_void, image: *const c_void, lines: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_FastLineDetector_detect_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, image: *const c_void, lines: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_FastLineDetector_drawSegments_const__InputOutputArrayR_const__InputArrayR_bool_Scalar_int(instance: *mut c_void, image: *const c_void, lines: *const c_void, draw_arrow: bool, linecolor: *const core::Scalar, linethickness: i32, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_FastLineDetector_drawSegments_const__InputOutputArrayR_const__InputArrayR(instance: *mut c_void, image: *const c_void, lines: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_FastLineDetector_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_ximgproc_FastLineDetector_delete(instance: *mut c_void); - pub fn cv_ximgproc_GuidedFilter_filter_const__InputArrayR_const__OutputArrayR_int(instance: *mut c_void, src: *const c_void, dst: *const c_void, d_depth: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_GuidedFilter_filter_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_GuidedFilter_filter_const__InputArrayR_const__OutputArrayR_int(instance: *mut c_void, src: *const c_void, dst: *const c_void, d_depth: i32, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_GuidedFilter_filter_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_GuidedFilter_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_ximgproc_GuidedFilter_delete(instance: *mut c_void); - pub fn cv_ximgproc_RFFeatureGetter_getFeatures_const_const_MatR_MatR_const_int_const_int_const_int_const_int_const_int(instance: *const c_void, src: *const c_void, features: *mut c_void, gnrm_rad: i32, gsmth_rad: i32, shrink: i32, out_num: i32, grad_num: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_RFFeatureGetter_getFeatures_const_const_MatR_MatR_const_int_const_int_const_int_const_int_const_int(instance: *const c_void, src: *const c_void, features: *mut c_void, gnrm_rad: i32, gsmth_rad: i32, shrink: i32, out_num: i32, grad_num: i32, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_RFFeatureGetter_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_ximgproc_RFFeatureGetter_delete(instance: *mut c_void); - pub fn cv_ximgproc_RICInterpolator_setK_int(instance: *mut c_void, k: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_RICInterpolator_setK(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_RICInterpolator_setK_int(instance: *mut c_void, k: i32, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_RICInterpolator_setK(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_RICInterpolator_getK_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ximgproc_RICInterpolator_setCostMap_const_MatR(instance: *mut c_void, cost_map: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_RICInterpolator_setSuperpixelSize_int(instance: *mut c_void, sp_size: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_RICInterpolator_setSuperpixelSize(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_RICInterpolator_setCostMap_const_MatR(instance: *mut c_void, cost_map: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_RICInterpolator_setSuperpixelSize_int(instance: *mut c_void, sp_size: i32, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_RICInterpolator_setSuperpixelSize(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_RICInterpolator_getSuperpixelSize_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ximgproc_RICInterpolator_setSuperpixelNNCnt_int(instance: *mut c_void, sp_nn: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_RICInterpolator_setSuperpixelNNCnt(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_RICInterpolator_setSuperpixelNNCnt_int(instance: *mut c_void, sp_nn: i32, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_RICInterpolator_setSuperpixelNNCnt(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_RICInterpolator_getSuperpixelNNCnt_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ximgproc_RICInterpolator_setSuperpixelRuler_float(instance: *mut c_void, ruler: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_RICInterpolator_setSuperpixelRuler(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_RICInterpolator_setSuperpixelRuler_float(instance: *mut c_void, ruler: f32, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_RICInterpolator_setSuperpixelRuler(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_RICInterpolator_getSuperpixelRuler_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ximgproc_RICInterpolator_setSuperpixelMode_int(instance: *mut c_void, mode: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_RICInterpolator_setSuperpixelMode(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_RICInterpolator_setSuperpixelMode_int(instance: *mut c_void, mode: i32, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_RICInterpolator_setSuperpixelMode(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_RICInterpolator_getSuperpixelMode_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ximgproc_RICInterpolator_setAlpha_float(instance: *mut c_void, alpha: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_RICInterpolator_setAlpha(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_RICInterpolator_setAlpha_float(instance: *mut c_void, alpha: f32, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_RICInterpolator_setAlpha(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_RICInterpolator_getAlpha_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ximgproc_RICInterpolator_setModelIter_int(instance: *mut c_void, model_iter: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_RICInterpolator_setModelIter(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_RICInterpolator_setModelIter_int(instance: *mut c_void, model_iter: i32, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_RICInterpolator_setModelIter(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_RICInterpolator_getModelIter_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ximgproc_RICInterpolator_setRefineModels_bool(instance: *mut c_void, refine_modles: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_RICInterpolator_setRefineModels(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_RICInterpolator_setRefineModels_bool(instance: *mut c_void, refine_modles: bool, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_RICInterpolator_setRefineModels(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_RICInterpolator_getRefineModels_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ximgproc_RICInterpolator_setMaxFlow_float(instance: *mut c_void, max_flow: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_RICInterpolator_setMaxFlow(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_RICInterpolator_setMaxFlow_float(instance: *mut c_void, max_flow: f32, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_RICInterpolator_setMaxFlow(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_RICInterpolator_getMaxFlow_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ximgproc_RICInterpolator_setUseVariationalRefinement_bool(instance: *mut c_void, use_variational_refinement: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_RICInterpolator_setUseVariationalRefinement(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_RICInterpolator_setUseVariationalRefinement_bool(instance: *mut c_void, use_variational_refinement: bool, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_RICInterpolator_setUseVariationalRefinement(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_RICInterpolator_getUseVariationalRefinement_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ximgproc_RICInterpolator_setUseGlobalSmootherFilter_bool(instance: *mut c_void, use_fgs: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_RICInterpolator_setUseGlobalSmootherFilter(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_RICInterpolator_setUseGlobalSmootherFilter_bool(instance: *mut c_void, use_fgs: bool, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_RICInterpolator_setUseGlobalSmootherFilter(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_RICInterpolator_getUseGlobalSmootherFilter_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ximgproc_RICInterpolator_setFGSLambda_float(instance: *mut c_void, lambda: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_RICInterpolator_setFGSLambda(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_RICInterpolator_setFGSLambda_float(instance: *mut c_void, lambda: f32, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_RICInterpolator_setFGSLambda(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_RICInterpolator_getFGSLambda_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ximgproc_RICInterpolator_setFGSSigma_float(instance: *mut c_void, sigma: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_RICInterpolator_setFGSSigma(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_RICInterpolator_setFGSSigma_float(instance: *mut c_void, sigma: f32, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_RICInterpolator_setFGSSigma(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_RICInterpolator_getFGSSigma_const(instance: *const c_void, ocvrs_return: *mut Result); pub fn cv_ximgproc_RICInterpolator_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_ximgproc_RICInterpolator_to_SparseMatchInterpolator(instance: *mut c_void) -> *mut c_void; pub fn cv_ximgproc_RICInterpolator_delete(instance: *mut c_void); pub fn cv_ximgproc_RidgeDetectionFilter_create_int_int_int_int_int_double_double_int(ddepth: i32, dx: i32, dy: i32, ksize: i32, out_dtype: i32, scale: f64, delta: f64, border_type: i32, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_ximgproc_RidgeDetectionFilter_create(ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_ximgproc_RidgeDetectionFilter_getRidgeFilteredImage_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, _img: *const c_void, out: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_RidgeDetectionFilter_getRidgeFilteredImage_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, _img: *const c_void, out: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_RidgeDetectionFilter_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_ximgproc_RidgeDetectionFilter_delete(instance: *mut c_void); pub fn cv_ximgproc_ScanSegment_getNumberOfSuperpixels(instance: *mut c_void, ocvrs_return: *mut Result); - pub fn cv_ximgproc_ScanSegment_iterate_const__InputArrayR(instance: *mut c_void, img: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_ScanSegment_getLabels_const__OutputArrayR(instance: *mut c_void, labels_out: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_ScanSegment_getLabelContourMask_const__OutputArrayR_bool(instance: *mut c_void, image: *const c_void, thick_line: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_ScanSegment_getLabelContourMask_const__OutputArrayR(instance: *mut c_void, image: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_ScanSegment_iterate_const__InputArrayR(instance: *mut c_void, img: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_ScanSegment_getLabels_const__OutputArrayR(instance: *mut c_void, labels_out: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_ScanSegment_getLabelContourMask_const__OutputArrayR_bool(instance: *mut c_void, image: *const c_void, thick_line: bool, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_ScanSegment_getLabelContourMask_const__OutputArrayR(instance: *mut c_void, image: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_ScanSegment_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_ximgproc_ScanSegment_delete(instance: *mut c_void); - pub fn cv_ximgproc_SparseMatchInterpolator_interpolate_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, from_image: *const c_void, from_points: *const c_void, to_image: *const c_void, to_points: *const c_void, dense_flow: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_SparseMatchInterpolator_interpolate_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, from_image: *const c_void, from_points: *const c_void, to_image: *const c_void, to_points: *const c_void, dense_flow: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_SparseMatchInterpolator_to_EdgeAwareInterpolator(instance: *mut c_void) -> *mut c_void; pub fn cv_ximgproc_SparseMatchInterpolator_to_RICInterpolator(instance: *mut c_void) -> *mut c_void; pub fn cv_ximgproc_SparseMatchInterpolator_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_ximgproc_SparseMatchInterpolator_delete(instance: *mut c_void); - pub fn cv_ximgproc_StructuredEdgeDetection_detectEdges_const_const__InputArrayR_const__OutputArrayR(instance: *const c_void, src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_StructuredEdgeDetection_computeOrientation_const_const__InputArrayR_const__OutputArrayR(instance: *const c_void, src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_StructuredEdgeDetection_edgesNms_const_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int_int_float_bool(instance: *const c_void, edge_image: *const c_void, orientation_image: *const c_void, dst: *const c_void, r: i32, s: i32, m: f32, is_parallel: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_StructuredEdgeDetection_edgesNms_const_const__InputArrayR_const__InputArrayR_const__OutputArrayR(instance: *const c_void, edge_image: *const c_void, orientation_image: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_StructuredEdgeDetection_detectEdges_const_const__InputArrayR_const__OutputArrayR(instance: *const c_void, src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_StructuredEdgeDetection_computeOrientation_const_const__InputArrayR_const__OutputArrayR(instance: *const c_void, src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_StructuredEdgeDetection_edgesNms_const_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int_int_float_bool(instance: *const c_void, edge_image: *const c_void, orientation_image: *const c_void, dst: *const c_void, r: i32, s: i32, m: f32, is_parallel: bool, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_StructuredEdgeDetection_edgesNms_const_const__InputArrayR_const__InputArrayR_const__OutputArrayR(instance: *const c_void, edge_image: *const c_void, orientation_image: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_StructuredEdgeDetection_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_ximgproc_StructuredEdgeDetection_delete(instance: *mut c_void); pub fn cv_ximgproc_SuperpixelLSC_getNumberOfSuperpixels_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ximgproc_SuperpixelLSC_iterate_int(instance: *mut c_void, num_iterations: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_SuperpixelLSC_iterate(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_SuperpixelLSC_getLabels_const_const__OutputArrayR(instance: *const c_void, labels_out: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_SuperpixelLSC_getLabelContourMask_const_const__OutputArrayR_bool(instance: *const c_void, image: *const c_void, thick_line: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_SuperpixelLSC_getLabelContourMask_const_const__OutputArrayR(instance: *const c_void, image: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_SuperpixelLSC_enforceLabelConnectivity_int(instance: *mut c_void, min_element_size: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_SuperpixelLSC_enforceLabelConnectivity(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_SuperpixelLSC_iterate_int(instance: *mut c_void, num_iterations: i32, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_SuperpixelLSC_iterate(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_SuperpixelLSC_getLabels_const_const__OutputArrayR(instance: *const c_void, labels_out: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_SuperpixelLSC_getLabelContourMask_const_const__OutputArrayR_bool(instance: *const c_void, image: *const c_void, thick_line: bool, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_SuperpixelLSC_getLabelContourMask_const_const__OutputArrayR(instance: *const c_void, image: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_SuperpixelLSC_enforceLabelConnectivity_int(instance: *mut c_void, min_element_size: i32, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_SuperpixelLSC_enforceLabelConnectivity(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_SuperpixelLSC_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_ximgproc_SuperpixelLSC_delete(instance: *mut c_void); pub fn cv_ximgproc_SuperpixelSEEDS_getNumberOfSuperpixels(instance: *mut c_void, ocvrs_return: *mut Result); - pub fn cv_ximgproc_SuperpixelSEEDS_iterate_const__InputArrayR_int(instance: *mut c_void, img: *const c_void, num_iterations: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_SuperpixelSEEDS_iterate_const__InputArrayR(instance: *mut c_void, img: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_SuperpixelSEEDS_getLabels_const__OutputArrayR(instance: *mut c_void, labels_out: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_SuperpixelSEEDS_getLabelContourMask_const__OutputArrayR_bool(instance: *mut c_void, image: *const c_void, thick_line: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_SuperpixelSEEDS_getLabelContourMask_const__OutputArrayR(instance: *mut c_void, image: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_SuperpixelSEEDS_iterate_const__InputArrayR_int(instance: *mut c_void, img: *const c_void, num_iterations: i32, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_SuperpixelSEEDS_iterate_const__InputArrayR(instance: *mut c_void, img: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_SuperpixelSEEDS_getLabels_const__OutputArrayR(instance: *mut c_void, labels_out: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_SuperpixelSEEDS_getLabelContourMask_const__OutputArrayR_bool(instance: *mut c_void, image: *const c_void, thick_line: bool, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_SuperpixelSEEDS_getLabelContourMask_const__OutputArrayR(instance: *mut c_void, image: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_SuperpixelSEEDS_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_ximgproc_SuperpixelSEEDS_delete(instance: *mut c_void); pub fn cv_ximgproc_SuperpixelSLIC_getNumberOfSuperpixels_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_ximgproc_SuperpixelSLIC_iterate_int(instance: *mut c_void, num_iterations: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_SuperpixelSLIC_iterate(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_SuperpixelSLIC_getLabels_const_const__OutputArrayR(instance: *const c_void, labels_out: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_SuperpixelSLIC_getLabelContourMask_const_const__OutputArrayR_bool(instance: *const c_void, image: *const c_void, thick_line: bool, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_SuperpixelSLIC_getLabelContourMask_const_const__OutputArrayR(instance: *const c_void, image: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_SuperpixelSLIC_enforceLabelConnectivity_int(instance: *mut c_void, min_element_size: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_SuperpixelSLIC_enforceLabelConnectivity(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_SuperpixelSLIC_iterate_int(instance: *mut c_void, num_iterations: i32, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_SuperpixelSLIC_iterate(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_SuperpixelSLIC_getLabels_const_const__OutputArrayR(instance: *const c_void, labels_out: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_SuperpixelSLIC_getLabelContourMask_const_const__OutputArrayR_bool(instance: *const c_void, image: *const c_void, thick_line: bool, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_SuperpixelSLIC_getLabelContourMask_const_const__OutputArrayR(instance: *const c_void, image: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_SuperpixelSLIC_enforceLabelConnectivity_int(instance: *mut c_void, min_element_size: i32, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_SuperpixelSLIC_enforceLabelConnectivity(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_SuperpixelSLIC_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_ximgproc_SuperpixelSLIC_delete(instance: *mut c_void); - pub fn cv_ximgproc_segmentation_GraphSegmentation_processImage_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_segmentation_GraphSegmentation_setSigma_double(instance: *mut c_void, sigma: f64, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_segmentation_GraphSegmentation_processImage_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_segmentation_GraphSegmentation_setSigma_double(instance: *mut c_void, sigma: f64, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_segmentation_GraphSegmentation_getSigma(instance: *mut c_void, ocvrs_return: *mut Result); - pub fn cv_ximgproc_segmentation_GraphSegmentation_setK_float(instance: *mut c_void, k: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_segmentation_GraphSegmentation_setK_float(instance: *mut c_void, k: f32, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_segmentation_GraphSegmentation_getK(instance: *mut c_void, ocvrs_return: *mut Result); - pub fn cv_ximgproc_segmentation_GraphSegmentation_setMinSize_int(instance: *mut c_void, min_size: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_segmentation_GraphSegmentation_setMinSize_int(instance: *mut c_void, min_size: i32, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_segmentation_GraphSegmentation_getMinSize(instance: *mut c_void, ocvrs_return: *mut Result); pub fn cv_ximgproc_segmentation_GraphSegmentation_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_ximgproc_segmentation_GraphSegmentation_delete(instance: *mut c_void); - pub fn cv_ximgproc_segmentation_SelectiveSearchSegmentation_setBaseImage_const__InputArrayR(instance: *mut c_void, img: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_segmentation_SelectiveSearchSegmentation_switchToSingleStrategy_int_float(instance: *mut c_void, k: i32, sigma: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_segmentation_SelectiveSearchSegmentation_switchToSingleStrategy(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_segmentation_SelectiveSearchSegmentation_switchToSelectiveSearchFast_int_int_float(instance: *mut c_void, base_k: i32, inc_k: i32, sigma: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_segmentation_SelectiveSearchSegmentation_switchToSelectiveSearchFast(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_segmentation_SelectiveSearchSegmentation_switchToSelectiveSearchQuality_int_int_float(instance: *mut c_void, base_k: i32, inc_k: i32, sigma: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_segmentation_SelectiveSearchSegmentation_switchToSelectiveSearchQuality(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_segmentation_SelectiveSearchSegmentation_addImage_const__InputArrayR(instance: *mut c_void, img: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_segmentation_SelectiveSearchSegmentation_clearImages(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_segmentation_SelectiveSearchSegmentation_addGraphSegmentation_PtrLGraphSegmentationG(instance: *mut c_void, g: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_segmentation_SelectiveSearchSegmentation_clearGraphSegmentations(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_segmentation_SelectiveSearchSegmentation_addStrategy_PtrLSelectiveSearchSegmentationStrategyG(instance: *mut c_void, s: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_segmentation_SelectiveSearchSegmentation_clearStrategies(instance: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_segmentation_SelectiveSearchSegmentation_process_vectorLRectGR(instance: *mut c_void, rects: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_segmentation_SelectiveSearchSegmentation_setBaseImage_const__InputArrayR(instance: *mut c_void, img: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_segmentation_SelectiveSearchSegmentation_switchToSingleStrategy_int_float(instance: *mut c_void, k: i32, sigma: f32, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_segmentation_SelectiveSearchSegmentation_switchToSingleStrategy(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_segmentation_SelectiveSearchSegmentation_switchToSelectiveSearchFast_int_int_float(instance: *mut c_void, base_k: i32, inc_k: i32, sigma: f32, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_segmentation_SelectiveSearchSegmentation_switchToSelectiveSearchFast(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_segmentation_SelectiveSearchSegmentation_switchToSelectiveSearchQuality_int_int_float(instance: *mut c_void, base_k: i32, inc_k: i32, sigma: f32, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_segmentation_SelectiveSearchSegmentation_switchToSelectiveSearchQuality(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_segmentation_SelectiveSearchSegmentation_addImage_const__InputArrayR(instance: *mut c_void, img: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_segmentation_SelectiveSearchSegmentation_clearImages(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_segmentation_SelectiveSearchSegmentation_addGraphSegmentation_PtrLGraphSegmentationG(instance: *mut c_void, g: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_segmentation_SelectiveSearchSegmentation_clearGraphSegmentations(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_segmentation_SelectiveSearchSegmentation_addStrategy_PtrLSelectiveSearchSegmentationStrategyG(instance: *mut c_void, s: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_segmentation_SelectiveSearchSegmentation_clearStrategies(instance: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_segmentation_SelectiveSearchSegmentation_process_vectorLRectGR(instance: *mut c_void, rects: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_segmentation_SelectiveSearchSegmentation_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_ximgproc_segmentation_SelectiveSearchSegmentation_delete(instance: *mut c_void); - pub fn cv_ximgproc_segmentation_SelectiveSearchSegmentationStrategy_setImage_const__InputArrayR_const__InputArrayR_const__InputArrayR_int(instance: *mut c_void, img: *const c_void, regions: *const c_void, sizes: *const c_void, image_id: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_segmentation_SelectiveSearchSegmentationStrategy_setImage_const__InputArrayR_const__InputArrayR_const__InputArrayR(instance: *mut c_void, img: *const c_void, regions: *const c_void, sizes: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_segmentation_SelectiveSearchSegmentationStrategy_setImage_const__InputArrayR_const__InputArrayR_const__InputArrayR_int(instance: *mut c_void, img: *const c_void, regions: *const c_void, sizes: *const c_void, image_id: i32, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_segmentation_SelectiveSearchSegmentationStrategy_setImage_const__InputArrayR_const__InputArrayR_const__InputArrayR(instance: *mut c_void, img: *const c_void, regions: *const c_void, sizes: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_segmentation_SelectiveSearchSegmentationStrategy_get_int_int(instance: *mut c_void, r1: i32, r2: i32, ocvrs_return: *mut Result); - pub fn cv_ximgproc_segmentation_SelectiveSearchSegmentationStrategy_merge_int_int(instance: *mut c_void, r1: i32, r2: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_segmentation_SelectiveSearchSegmentationStrategy_merge_int_int(instance: *mut c_void, r1: i32, r2: i32, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_segmentation_SelectiveSearchSegmentationStrategy_to_SelectiveSearchSegmentationStrategyColor(instance: *mut c_void) -> *mut c_void; pub fn cv_ximgproc_segmentation_SelectiveSearchSegmentationStrategy_to_SelectiveSearchSegmentationStrategyFill(instance: *mut c_void) -> *mut c_void; pub fn cv_ximgproc_segmentation_SelectiveSearchSegmentationStrategy_to_SelectiveSearchSegmentationStrategyMultiple(instance: *mut c_void) -> *mut c_void; @@ -17837,8 +17824,8 @@ mod ximgproc_sys { pub fn cv_ximgproc_segmentation_SelectiveSearchSegmentationStrategyFill_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_ximgproc_segmentation_SelectiveSearchSegmentationStrategyFill_to_SelectiveSearchSegmentationStrategy(instance: *mut c_void) -> *mut c_void; pub fn cv_ximgproc_segmentation_SelectiveSearchSegmentationStrategyFill_delete(instance: *mut c_void); - pub fn cv_ximgproc_segmentation_SelectiveSearchSegmentationStrategyMultiple_addStrategy_PtrLSelectiveSearchSegmentationStrategyG_float(instance: *mut c_void, g: *mut c_void, weight: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_ximgproc_segmentation_SelectiveSearchSegmentationStrategyMultiple_clearStrategies(instance: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_ximgproc_segmentation_SelectiveSearchSegmentationStrategyMultiple_addStrategy_PtrLSelectiveSearchSegmentationStrategyG_float(instance: *mut c_void, g: *mut c_void, weight: f32, ocvrs_return: *mut Result<()>); + pub fn cv_ximgproc_segmentation_SelectiveSearchSegmentationStrategyMultiple_clearStrategies(instance: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_ximgproc_segmentation_SelectiveSearchSegmentationStrategyMultiple_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_ximgproc_segmentation_SelectiveSearchSegmentationStrategyMultiple_to_SelectiveSearchSegmentationStrategy(instance: *mut c_void) -> *mut c_void; pub fn cv_ximgproc_segmentation_SelectiveSearchSegmentationStrategyMultiple_delete(instance: *mut c_void); @@ -18022,18 +18009,16 @@ mod ximgproc_sys { pub fn cv_fromSlice_const_const_BoxX_size_t(data: *const crate::ximgproc::Box, len: size_t) -> *mut c_void; } } -#[cfg(ocvrs_has_module_ximgproc)] pub use ximgproc_sys::*; -#[cfg(ocvrs_has_module_xobjdetect)] mod xobjdetect_sys { use super::*; extern "C" { - pub fn cv_xobjdetect_WBDetector_read_const_FileNodeR(instance: *mut c_void, node: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_xobjdetect_WBDetector_write_const_FileStorageR(instance: *const c_void, fs: *mut c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_xobjdetect_WBDetector_train_const_stringR_const_stringR(instance: *mut c_void, pos_samples: *const c_char, neg_imgs: *const c_char, ocvrs_return: *mut ResultVoid); - pub fn cv_xobjdetect_WBDetector_detect_const_MatR_vectorLRectGR_vectorLdoubleGR(instance: *mut c_void, img: *const c_void, bboxes: *mut c_void, confidences: *mut c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_xobjdetect_WBDetector_read_const_FileNodeR(instance: *mut c_void, node: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_xobjdetect_WBDetector_write_const_FileStorageR(instance: *const c_void, fs: *mut c_void, ocvrs_return: *mut Result<()>); + pub fn cv_xobjdetect_WBDetector_train_const_stringR_const_stringR(instance: *mut c_void, pos_samples: *const c_char, neg_imgs: *const c_char, ocvrs_return: *mut Result<()>); + pub fn cv_xobjdetect_WBDetector_detect_const_MatR_vectorLRectGR_vectorLdoubleGR(instance: *mut c_void, img: *const c_void, bboxes: *mut c_void, confidences: *mut c_void, ocvrs_return: *mut Result<()>); pub fn cv_xobjdetect_WBDetector_create(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_xobjdetect_WBDetector_delete(instance: *mut c_void); pub fn cv_PtrLcv_xobjdetect_WBDetectorG_getInnerPtr_const(instance: *const c_void) -> *mut c_void; @@ -18042,70 +18027,68 @@ mod xobjdetect_sys { pub fn cv_PtrLcv_xobjdetect_WBDetectorG_delete(instance: *mut c_void); } } -#[cfg(ocvrs_has_module_xobjdetect)] pub use xobjdetect_sys::*; -#[cfg(ocvrs_has_module_xphoto)] mod xphoto_sys { use super::*; extern "C" { - pub fn cv_xphoto_applyChannelGains_const__InputArrayR_const__OutputArrayR_float_float_float(src: *const c_void, dst: *const c_void, gain_b: f32, gain_g: f32, gain_r: f32, ocvrs_return: *mut ResultVoid); - pub fn cv_xphoto_bm3dDenoising_const__InputArrayR_const__InputOutputArrayR_const__OutputArrayR(src: *const c_void, dst_step1: *const c_void, dst_step2: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_xphoto_bm3dDenoising_const__InputArrayR_const__InputOutputArrayR_const__OutputArrayR_float_int_int_int_int_int_int_float_int_int_int(src: *const c_void, dst_step1: *const c_void, dst_step2: *const c_void, h: f32, template_window_size: i32, search_window_size: i32, block_matching_step1: i32, block_matching_step2: i32, group_size: i32, sliding_step: i32, beta: f32, norm_type: i32, step: i32, transform_type: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_xphoto_bm3dDenoising_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); - pub fn cv_xphoto_bm3dDenoising_const__InputArrayR_const__OutputArrayR_float_int_int_int_int_int_int_float_int_int_int(src: *const c_void, dst: *const c_void, h: f32, template_window_size: i32, search_window_size: i32, block_matching_step1: i32, block_matching_step2: i32, group_size: i32, sliding_step: i32, beta: f32, norm_type: i32, step: i32, transform_type: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_xphoto_applyChannelGains_const__InputArrayR_const__OutputArrayR_float_float_float(src: *const c_void, dst: *const c_void, gain_b: f32, gain_g: f32, gain_r: f32, ocvrs_return: *mut Result<()>); + pub fn cv_xphoto_bm3dDenoising_const__InputArrayR_const__InputOutputArrayR_const__OutputArrayR(src: *const c_void, dst_step1: *const c_void, dst_step2: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_xphoto_bm3dDenoising_const__InputArrayR_const__InputOutputArrayR_const__OutputArrayR_float_int_int_int_int_int_int_float_int_int_int(src: *const c_void, dst_step1: *const c_void, dst_step2: *const c_void, h: f32, template_window_size: i32, search_window_size: i32, block_matching_step1: i32, block_matching_step2: i32, group_size: i32, sliding_step: i32, beta: f32, norm_type: i32, step: i32, transform_type: i32, ocvrs_return: *mut Result<()>); + pub fn cv_xphoto_bm3dDenoising_const__InputArrayR_const__OutputArrayR(src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); + pub fn cv_xphoto_bm3dDenoising_const__InputArrayR_const__OutputArrayR_float_int_int_int_int_int_int_float_int_int_int(src: *const c_void, dst: *const c_void, h: f32, template_window_size: i32, search_window_size: i32, block_matching_step1: i32, block_matching_step2: i32, group_size: i32, sliding_step: i32, beta: f32, norm_type: i32, step: i32, transform_type: i32, ocvrs_return: *mut Result<()>); pub fn cv_xphoto_createGrayworldWB(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_xphoto_createLearningBasedWB(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_xphoto_createLearningBasedWB_const_StringR(path_to_model: *const c_char, ocvrs_return: *mut Result<*mut c_void>); pub fn cv_xphoto_createSimpleWB(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_xphoto_createTonemapDurand(ocvrs_return: *mut Result<*mut c_void>); pub fn cv_xphoto_createTonemapDurand_float_float_float_float_float(gamma: f32, contrast: f32, saturation: f32, sigma_color: f32, sigma_space: f32, ocvrs_return: *mut Result<*mut c_void>); - pub fn cv_xphoto_dctDenoising_const_MatR_MatR_const_double(src: *const c_void, dst: *mut c_void, sigma: f64, ocvrs_return: *mut ResultVoid); - pub fn cv_xphoto_dctDenoising_const_MatR_MatR_const_double_const_int(src: *const c_void, dst: *mut c_void, sigma: f64, psize: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_xphoto_inpaint_const_MatR_const_MatR_MatR_const_int(src: *const c_void, mask: *const c_void, dst: *mut c_void, algorithm_type: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_xphoto_oilPainting_const__InputArrayR_const__OutputArrayR_int_int(src: *const c_void, dst: *const c_void, size: i32, dyn_ratio: i32, ocvrs_return: *mut ResultVoid); - pub fn cv_xphoto_oilPainting_const__InputArrayR_const__OutputArrayR_int_int_int(src: *const c_void, dst: *const c_void, size: i32, dyn_ratio: i32, code: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_xphoto_dctDenoising_const_MatR_MatR_const_double(src: *const c_void, dst: *mut c_void, sigma: f64, ocvrs_return: *mut Result<()>); + pub fn cv_xphoto_dctDenoising_const_MatR_MatR_const_double_const_int(src: *const c_void, dst: *mut c_void, sigma: f64, psize: i32, ocvrs_return: *mut Result<()>); + pub fn cv_xphoto_inpaint_const_MatR_const_MatR_MatR_const_int(src: *const c_void, mask: *const c_void, dst: *mut c_void, algorithm_type: i32, ocvrs_return: *mut Result<()>); + pub fn cv_xphoto_oilPainting_const__InputArrayR_const__OutputArrayR_int_int(src: *const c_void, dst: *const c_void, size: i32, dyn_ratio: i32, ocvrs_return: *mut Result<()>); + pub fn cv_xphoto_oilPainting_const__InputArrayR_const__OutputArrayR_int_int_int(src: *const c_void, dst: *const c_void, size: i32, dyn_ratio: i32, code: i32, ocvrs_return: *mut Result<()>); pub fn cv_xphoto_GrayworldWB_getSaturationThreshold_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xphoto_GrayworldWB_setSaturationThreshold_float(instance: *mut c_void, val: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_xphoto_GrayworldWB_setSaturationThreshold_float(instance: *mut c_void, val: f32, ocvrs_return: *mut Result<()>); pub fn cv_xphoto_GrayworldWB_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_xphoto_GrayworldWB_to_WhiteBalancer(instance: *mut c_void) -> *mut c_void; pub fn cv_xphoto_GrayworldWB_delete(instance: *mut c_void); - pub fn cv_xphoto_LearningBasedWB_extractSimpleFeatures_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_xphoto_LearningBasedWB_extractSimpleFeatures_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_xphoto_LearningBasedWB_getRangeMaxVal_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xphoto_LearningBasedWB_setRangeMaxVal_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_xphoto_LearningBasedWB_setRangeMaxVal_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_xphoto_LearningBasedWB_getSaturationThreshold_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xphoto_LearningBasedWB_setSaturationThreshold_float(instance: *mut c_void, val: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_xphoto_LearningBasedWB_setSaturationThreshold_float(instance: *mut c_void, val: f32, ocvrs_return: *mut Result<()>); pub fn cv_xphoto_LearningBasedWB_getHistBinNum_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xphoto_LearningBasedWB_setHistBinNum_int(instance: *mut c_void, val: i32, ocvrs_return: *mut ResultVoid); + pub fn cv_xphoto_LearningBasedWB_setHistBinNum_int(instance: *mut c_void, val: i32, ocvrs_return: *mut Result<()>); pub fn cv_xphoto_LearningBasedWB_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_xphoto_LearningBasedWB_to_WhiteBalancer(instance: *mut c_void) -> *mut c_void; pub fn cv_xphoto_LearningBasedWB_delete(instance: *mut c_void); pub fn cv_xphoto_SimpleWB_getInputMin_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xphoto_SimpleWB_setInputMin_float(instance: *mut c_void, val: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_xphoto_SimpleWB_setInputMin_float(instance: *mut c_void, val: f32, ocvrs_return: *mut Result<()>); pub fn cv_xphoto_SimpleWB_getInputMax_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xphoto_SimpleWB_setInputMax_float(instance: *mut c_void, val: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_xphoto_SimpleWB_setInputMax_float(instance: *mut c_void, val: f32, ocvrs_return: *mut Result<()>); pub fn cv_xphoto_SimpleWB_getOutputMin_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xphoto_SimpleWB_setOutputMin_float(instance: *mut c_void, val: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_xphoto_SimpleWB_setOutputMin_float(instance: *mut c_void, val: f32, ocvrs_return: *mut Result<()>); pub fn cv_xphoto_SimpleWB_getOutputMax_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xphoto_SimpleWB_setOutputMax_float(instance: *mut c_void, val: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_xphoto_SimpleWB_setOutputMax_float(instance: *mut c_void, val: f32, ocvrs_return: *mut Result<()>); pub fn cv_xphoto_SimpleWB_getP_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xphoto_SimpleWB_setP_float(instance: *mut c_void, val: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_xphoto_SimpleWB_setP_float(instance: *mut c_void, val: f32, ocvrs_return: *mut Result<()>); pub fn cv_xphoto_SimpleWB_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_xphoto_SimpleWB_to_WhiteBalancer(instance: *mut c_void) -> *mut c_void; pub fn cv_xphoto_SimpleWB_delete(instance: *mut c_void); pub fn cv_xphoto_TonemapDurand_getSaturation_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xphoto_TonemapDurand_setSaturation_float(instance: *mut c_void, saturation: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_xphoto_TonemapDurand_setSaturation_float(instance: *mut c_void, saturation: f32, ocvrs_return: *mut Result<()>); pub fn cv_xphoto_TonemapDurand_getContrast_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xphoto_TonemapDurand_setContrast_float(instance: *mut c_void, contrast: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_xphoto_TonemapDurand_setContrast_float(instance: *mut c_void, contrast: f32, ocvrs_return: *mut Result<()>); pub fn cv_xphoto_TonemapDurand_getSigmaSpace_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xphoto_TonemapDurand_setSigmaSpace_float(instance: *mut c_void, sigma_space: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_xphoto_TonemapDurand_setSigmaSpace_float(instance: *mut c_void, sigma_space: f32, ocvrs_return: *mut Result<()>); pub fn cv_xphoto_TonemapDurand_getSigmaColor_const(instance: *const c_void, ocvrs_return: *mut Result); - pub fn cv_xphoto_TonemapDurand_setSigmaColor_float(instance: *mut c_void, sigma_color: f32, ocvrs_return: *mut ResultVoid); + pub fn cv_xphoto_TonemapDurand_setSigmaColor_float(instance: *mut c_void, sigma_color: f32, ocvrs_return: *mut Result<()>); pub fn cv_xphoto_TonemapDurand_to_Algorithm(instance: *mut c_void) -> *mut c_void; pub fn cv_xphoto_TonemapDurand_to_Tonemap(instance: *mut c_void) -> *mut c_void; pub fn cv_xphoto_TonemapDurand_delete(instance: *mut c_void); - pub fn cv_xphoto_WhiteBalancer_balanceWhite_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, src: *const c_void, dst: *const c_void, ocvrs_return: *mut ResultVoid); + pub fn cv_xphoto_WhiteBalancer_balanceWhite_const__InputArrayR_const__OutputArrayR(instance: *mut c_void, src: *const c_void, dst: *const c_void, ocvrs_return: *mut Result<()>); pub fn cv_xphoto_WhiteBalancer_to_GrayworldWB(instance: *mut c_void) -> *mut c_void; pub fn cv_xphoto_WhiteBalancer_to_LearningBasedWB(instance: *mut c_void) -> *mut c_void; pub fn cv_xphoto_WhiteBalancer_to_SimpleWB(instance: *mut c_void) -> *mut c_void; @@ -18142,7 +18125,6 @@ mod xphoto_sys { pub fn cv_PtrLcv_xphoto_WhiteBalancerG_to_PtrOfAlgorithm(instance: *mut c_void) -> *mut c_void; } } -#[cfg(ocvrs_has_module_xphoto)] pub use xphoto_sys::*; pub use crate::manual::sys::*; diff --git a/docs/types.rs b/docs/types.rs index e830354a..67bb265b 100644 --- a/docs/types.rs +++ b/docs/types.rs @@ -1,11 +1,7 @@ -#[cfg(ocvrs_has_module_aruco)] mod aruco_types { use crate::{mod_prelude::*, core, types, sys}; - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfEstimateParameters = core::Ptr; - ptr_extern! { crate::aruco::EstimateParameters, cv_PtrLcv_aruco_EstimateParametersG_new_null_const, cv_PtrLcv_aruco_EstimateParametersG_delete, cv_PtrLcv_aruco_EstimateParametersG_getInnerPtr_const, cv_PtrLcv_aruco_EstimateParametersG_getInnerPtrMut } @@ -36,16 +32,11 @@ mod aruco_types { } } -#[cfg(ocvrs_has_module_aruco)] pub use aruco_types::*; -#[cfg(ocvrs_has_module_bgsegm)] mod bgsegm_types { use crate::{mod_prelude::*, core, types, sys}; - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfBackgroundSubtractorCNT = core::Ptr; - ptr_extern! { crate::bgsegm::BackgroundSubtractorCNT, cv_PtrLcv_bgsegm_BackgroundSubtractorCNTG_new_null_const, cv_PtrLcv_bgsegm_BackgroundSubtractorCNTG_delete, cv_PtrLcv_bgsegm_BackgroundSubtractorCNTG_getInnerPtr_const, cv_PtrLcv_bgsegm_BackgroundSubtractorCNTG_getInnerPtrMut } @@ -91,9 +82,6 @@ mod bgsegm_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfBackgroundSubtractorGMG = core::Ptr; - ptr_extern! { crate::bgsegm::BackgroundSubtractorGMG, cv_PtrLcv_bgsegm_BackgroundSubtractorGMGG_new_null_const, cv_PtrLcv_bgsegm_BackgroundSubtractorGMGG_delete, cv_PtrLcv_bgsegm_BackgroundSubtractorGMGG_getInnerPtr_const, cv_PtrLcv_bgsegm_BackgroundSubtractorGMGG_getInnerPtrMut } @@ -139,9 +127,6 @@ mod bgsegm_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfBackgroundSubtractorGSOC = core::Ptr; - ptr_extern! { crate::bgsegm::BackgroundSubtractorGSOC, cv_PtrLcv_bgsegm_BackgroundSubtractorGSOCG_new_null_const, cv_PtrLcv_bgsegm_BackgroundSubtractorGSOCG_delete, cv_PtrLcv_bgsegm_BackgroundSubtractorGSOCG_getInnerPtr_const, cv_PtrLcv_bgsegm_BackgroundSubtractorGSOCG_getInnerPtrMut } @@ -187,9 +172,6 @@ mod bgsegm_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfBackgroundSubtractorLSBP = core::Ptr; - ptr_extern! { crate::bgsegm::BackgroundSubtractorLSBP, cv_PtrLcv_bgsegm_BackgroundSubtractorLSBPG_new_null_const, cv_PtrLcv_bgsegm_BackgroundSubtractorLSBPG_delete, cv_PtrLcv_bgsegm_BackgroundSubtractorLSBPG_getInnerPtr_const, cv_PtrLcv_bgsegm_BackgroundSubtractorLSBPG_getInnerPtrMut } @@ -235,9 +217,6 @@ mod bgsegm_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfBackgroundSubtractorMOG = core::Ptr; - ptr_extern! { crate::bgsegm::BackgroundSubtractorMOG, cv_PtrLcv_bgsegm_BackgroundSubtractorMOGG_new_null_const, cv_PtrLcv_bgsegm_BackgroundSubtractorMOGG_delete, cv_PtrLcv_bgsegm_BackgroundSubtractorMOGG_getInnerPtr_const, cv_PtrLcv_bgsegm_BackgroundSubtractorMOGG_getInnerPtrMut } @@ -283,9 +262,6 @@ mod bgsegm_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfSyntheticSequenceGenerator = core::Ptr; - ptr_extern! { crate::bgsegm::SyntheticSequenceGenerator, cv_PtrLcv_bgsegm_SyntheticSequenceGeneratorG_new_null_const, cv_PtrLcv_bgsegm_SyntheticSequenceGeneratorG_delete, cv_PtrLcv_bgsegm_SyntheticSequenceGeneratorG_getInnerPtr_const, cv_PtrLcv_bgsegm_SyntheticSequenceGeneratorG_getInnerPtrMut } @@ -323,16 +299,11 @@ mod bgsegm_types { } } -#[cfg(ocvrs_has_module_bgsegm)] pub use bgsegm_types::*; -#[cfg(ocvrs_has_module_bioinspired)] mod bioinspired_types { use crate::{mod_prelude::*, core, types, sys}; - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfRetina = core::Ptr; - ptr_extern! { crate::bioinspired::Retina, cv_PtrLcv_bioinspired_RetinaG_new_null_const, cv_PtrLcv_bioinspired_RetinaG_delete, cv_PtrLcv_bioinspired_RetinaG_getInnerPtr_const, cv_PtrLcv_bioinspired_RetinaG_getInnerPtrMut } @@ -368,9 +339,6 @@ mod bioinspired_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfRetinaFastToneMapping = core::Ptr; - ptr_extern! { crate::bioinspired::RetinaFastToneMapping, cv_PtrLcv_bioinspired_RetinaFastToneMappingG_new_null_const, cv_PtrLcv_bioinspired_RetinaFastToneMappingG_delete, cv_PtrLcv_bioinspired_RetinaFastToneMappingG_getInnerPtr_const, cv_PtrLcv_bioinspired_RetinaFastToneMappingG_getInnerPtrMut } @@ -406,9 +374,6 @@ mod bioinspired_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfTransientAreasSegmentationModule = core::Ptr; - ptr_extern! { crate::bioinspired::TransientAreasSegmentationModule, cv_PtrLcv_bioinspired_TransientAreasSegmentationModuleG_new_null_const, cv_PtrLcv_bioinspired_TransientAreasSegmentationModuleG_delete, cv_PtrLcv_bioinspired_TransientAreasSegmentationModuleG_getInnerPtr_const, cv_PtrLcv_bioinspired_TransientAreasSegmentationModuleG_getInnerPtrMut } @@ -445,16 +410,11 @@ mod bioinspired_types { } } -#[cfg(ocvrs_has_module_bioinspired)] pub use bioinspired_types::*; -#[cfg(ocvrs_has_module_calib3d)] mod calib3d_types { use crate::{mod_prelude::*, core, types, sys}; - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfLMSolver = core::Ptr; - ptr_extern! { crate::calib3d::LMSolver, cv_PtrLcv_LMSolverG_new_null_const, cv_PtrLcv_LMSolverG_delete, cv_PtrLcv_LMSolverG_getInnerPtr_const, cv_PtrLcv_LMSolverG_getInnerPtrMut } @@ -490,9 +450,6 @@ mod calib3d_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfLMSolver_Callback = core::Ptr; - ptr_extern! { crate::calib3d::LMSolver_Callback, cv_PtrLcv_LMSolver_CallbackG_new_null_const, cv_PtrLcv_LMSolver_CallbackG_delete, cv_PtrLcv_LMSolver_CallbackG_getInnerPtr_const, cv_PtrLcv_LMSolver_CallbackG_getInnerPtrMut } @@ -518,9 +475,6 @@ mod calib3d_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfStereoBM = core::Ptr; - ptr_extern! { crate::calib3d::StereoBM, cv_PtrLcv_StereoBMG_new_null_const, cv_PtrLcv_StereoBMG_delete, cv_PtrLcv_StereoBMG_getInnerPtr_const, cv_PtrLcv_StereoBMG_getInnerPtrMut } @@ -566,9 +520,6 @@ mod calib3d_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfStereoMatcher = core::Ptr; - ptr_extern! { crate::calib3d::StereoMatcher, cv_PtrLcv_StereoMatcherG_new_null_const, cv_PtrLcv_StereoMatcherG_delete, cv_PtrLcv_StereoMatcherG_getInnerPtr_const, cv_PtrLcv_StereoMatcherG_getInnerPtrMut } @@ -604,9 +555,6 @@ mod calib3d_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfStereoSGBM = core::Ptr; - ptr_extern! { crate::calib3d::StereoSGBM, cv_PtrLcv_StereoSGBMG_new_null_const, cv_PtrLcv_StereoSGBMG_delete, cv_PtrLcv_StereoSGBMG_getInnerPtr_const, cv_PtrLcv_StereoSGBMG_getInnerPtrMut } @@ -653,16 +601,11 @@ mod calib3d_types { } } -#[cfg(ocvrs_has_module_calib3d)] pub use calib3d_types::*; -#[cfg(ocvrs_has_module_ccalib)] mod ccalib_types { use crate::{mod_prelude::*, core, types, sys}; - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCustomPattern = core::Ptr; - ptr_extern! { crate::ccalib::CustomPattern, cv_PtrLcv_ccalib_CustomPatternG_new_null_const, cv_PtrLcv_ccalib_CustomPatternG_delete, cv_PtrLcv_ccalib_CustomPatternG_getInnerPtr_const, cv_PtrLcv_ccalib_CustomPatternG_getInnerPtrMut } @@ -700,10 +643,8 @@ mod ccalib_types { } } -#[cfg(ocvrs_has_module_ccalib)] pub use ccalib_types::*; -#[cfg(ocvrs_has_module_core)] mod core_types { use crate::{mod_prelude::*, core, types, sys}; @@ -723,9 +664,6 @@ mod core_types { #[inline] fn as_raw_mut_MatOp(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfAlgorithm = core::Ptr; - ptr_extern! { core::Algorithm, cv_PtrLcv_AlgorithmG_new_null_const, cv_PtrLcv_AlgorithmG_delete, cv_PtrLcv_AlgorithmG_getInnerPtr_const, cv_PtrLcv_AlgorithmG_getInnerPtrMut } @@ -752,9 +690,6 @@ mod core_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfConjGradSolver = core::Ptr; - ptr_extern! { core::ConjGradSolver, cv_PtrLcv_ConjGradSolverG_new_null_const, cv_PtrLcv_ConjGradSolverG_delete, cv_PtrLcv_ConjGradSolverG_getInnerPtr_const, cv_PtrLcv_ConjGradSolverG_getInnerPtrMut } @@ -800,9 +735,6 @@ mod core_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDownhillSolver = core::Ptr; - ptr_extern! { core::DownhillSolver, cv_PtrLcv_DownhillSolverG_new_null_const, cv_PtrLcv_DownhillSolverG_delete, cv_PtrLcv_DownhillSolverG_getInnerPtr_const, cv_PtrLcv_DownhillSolverG_getInnerPtrMut } @@ -848,9 +780,6 @@ mod core_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfFileStorage = core::Ptr; - ptr_extern! { core::FileStorage, cv_PtrLcv_FileStorageG_new_null_const, cv_PtrLcv_FileStorageG_delete, cv_PtrLcv_FileStorageG_getInnerPtr_const, cv_PtrLcv_FileStorageG_getInnerPtrMut } @@ -879,9 +808,6 @@ mod core_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfFormatted = core::Ptr; - ptr_extern! { core::Formatted, cv_PtrLcv_FormattedG_new_null_const, cv_PtrLcv_FormattedG_delete, cv_PtrLcv_FormattedG_getInnerPtr_const, cv_PtrLcv_FormattedG_getInnerPtrMut } @@ -907,9 +833,6 @@ mod core_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfFormatter = core::Ptr; - ptr_extern! { core::Formatter, cv_PtrLcv_FormatterG_new_null_const, cv_PtrLcv_FormatterG_delete, cv_PtrLcv_FormatterG_getInnerPtr_const, cv_PtrLcv_FormatterG_getInnerPtrMut } @@ -935,9 +858,6 @@ mod core_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfGpuMat_Allocator = core::Ptr; - ptr_extern! { core::GpuMat_Allocator, cv_PtrLcv_cuda_GpuMat_AllocatorG_new_null_const, cv_PtrLcv_cuda_GpuMat_AllocatorG_delete, cv_PtrLcv_cuda_GpuMat_AllocatorG_getInnerPtr_const, cv_PtrLcv_cuda_GpuMat_AllocatorG_getInnerPtrMut } @@ -963,8 +883,31 @@ mod core_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfMinProblemSolver = core::Ptr; + ptr_extern! { core::KeyPoint, + cv_PtrLcv_KeyPointG_new_null_const, cv_PtrLcv_KeyPointG_delete, cv_PtrLcv_KeyPointG_getInnerPtr_const, cv_PtrLcv_KeyPointG_getInnerPtrMut + } + + ptr_extern_ctor! { core::KeyPoint, cv_PtrLcv_KeyPointG_new_const_KeyPoint } + impl core::Ptr { + #[inline] pub fn as_raw_PtrOfKeyPoint(&self) -> extern_send!(Self) { self.as_raw() } + #[inline] pub fn as_raw_mut_PtrOfKeyPoint(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } + } + + impl core::KeyPointTraitConst for core::Ptr { + #[inline] fn as_raw_KeyPoint(&self) -> *const c_void { self.inner_as_raw() } + } + + impl core::KeyPointTrait for core::Ptr { + #[inline] fn as_raw_mut_KeyPoint(&mut self) -> *mut c_void { self.inner_as_raw_mut() } + } + + impl std::fmt::Debug for core::Ptr { + #[inline] + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + f.debug_struct("PtrOfKeyPoint") + .finish() + } + } ptr_extern! { core::MinProblemSolver, cv_PtrLcv_MinProblemSolverG_new_null_const, cv_PtrLcv_MinProblemSolverG_delete, cv_PtrLcv_MinProblemSolverG_getInnerPtr_const, cv_PtrLcv_MinProblemSolverG_getInnerPtrMut @@ -1001,9 +944,6 @@ mod core_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfMinProblemSolver_Function = core::Ptr; - ptr_extern! { core::MinProblemSolver_Function, cv_PtrLcv_MinProblemSolver_FunctionG_new_null_const, cv_PtrLcv_MinProblemSolver_FunctionG_delete, cv_PtrLcv_MinProblemSolver_FunctionG_getInnerPtr_const, cv_PtrLcv_MinProblemSolver_FunctionG_getInnerPtrMut } @@ -1029,9 +969,6 @@ mod core_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfOriginalClassName = core::Ptr; - ptr_extern! { core::OriginalClassName, cv_PtrLcv_utils_nested_OriginalClassNameG_new_null_const, cv_PtrLcv_utils_nested_OriginalClassNameG_delete, cv_PtrLcv_utils_nested_OriginalClassNameG_getInnerPtr_const, cv_PtrLcv_utils_nested_OriginalClassNameG_getInnerPtrMut } @@ -1058,9 +995,6 @@ mod core_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOff32 = core::Ptr; - ptr_extern! { f32, cv_PtrLfloatG_new_null_const, cv_PtrLfloatG_delete, cv_PtrLfloatG_getInnerPtr_const, cv_PtrLfloatG_getInnerPtrMut } @@ -1071,9 +1005,6 @@ mod core_types { #[inline] pub fn as_raw_mut_PtrOff32(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } } - #[deprecated = "Use the the non-alias form `core::Tuple<(core::Point2i, core::Point2i)>` instead, removal in Nov 2024"] - pub type TupleOfPoint2i_Point2i = core::Tuple<(core::Point2i, core::Point2i)>; - impl core::Tuple<(core::Point2i, core::Point2i)> { pub fn as_raw_TupleOfPoint2i_Point2i(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_TupleOfPoint2i_Point2i(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -1085,9 +1016,6 @@ mod core_types { 1 = arg_1: core::Point2i, get_1 via std_pairLcv_Point2i__cv_Point2iG_get_1_const } - #[deprecated = "Use the the non-alias form `core::Tuple<(core::Rect, i32)>` instead, removal in Nov 2024"] - pub type TupleOfRect_i32 = core::Tuple<(core::Rect, i32)>; - impl core::Tuple<(core::Rect, i32)> { pub fn as_raw_TupleOfRect_i32(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_TupleOfRect_i32(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -1099,9 +1027,6 @@ mod core_types { 1 = arg_1: i32, get_1 via std_pairLcv_Rect__intG_get_1_const } - #[deprecated = "Use the the non-alias form `core::Tuple<(core::UMat, u8)>` instead, removal in Nov 2024"] - pub type TupleOfUMat_u8 = core::Tuple<(core::UMat, u8)>; - impl core::Tuple<(core::UMat, u8)> { pub fn as_raw_TupleOfUMat_u8(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_TupleOfUMat_u8(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -1113,9 +1038,6 @@ mod core_types { 1 = arg_1: u8, get_1 via std_pairLcv_UMat__unsigned_charG_get_1_const } - #[deprecated = "Use the the non-alias form `core::Tuple<(i32, f32)>` instead, removal in Nov 2024"] - pub type TupleOfi32_f32 = core::Tuple<(i32, f32)>; - impl core::Tuple<(i32, f32)> { pub fn as_raw_TupleOfi32_f32(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_TupleOfi32_f32(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -1127,9 +1049,6 @@ mod core_types { 1 = arg_1: f32, get_1 via std_pairLint__floatG_get_1_const } - #[deprecated = "Use the the non-alias form `core::Tuple<(i32, f64)>` instead, removal in Nov 2024"] - pub type TupleOfi32_f64 = core::Tuple<(i32, f64)>; - impl core::Tuple<(i32, f64)> { pub fn as_raw_TupleOfi32_f64(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_TupleOfi32_f64(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -1141,9 +1060,6 @@ mod core_types { 1 = arg_1: f64, get_1 via std_pairLint__doubleG_get_1_const } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfDMatch = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfDMatch(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfDMatch(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -1165,9 +1081,6 @@ mod core_types { } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfGpuMat = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfGpuMat(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfGpuMat(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -1198,9 +1111,6 @@ mod core_types { } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfKeyPoint = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfKeyPoint(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfKeyPoint(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -1231,9 +1141,6 @@ mod core_types { } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfMat = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfMat(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfMat(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -1264,9 +1171,6 @@ mod core_types { } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfPlatformInfo = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfPlatformInfo(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfPlatformInfo(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -1297,9 +1201,6 @@ mod core_types { } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfPoint = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfPoint(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfPoint(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -1363,9 +1264,6 @@ mod core_types { output_array_ref_forward! { core::Vector } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfPoint2d = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfPoint2d(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfPoint2d(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -1429,9 +1327,6 @@ mod core_types { output_array_ref_forward! { core::Vector } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfPoint2f = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfPoint2f(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfPoint2f(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -1495,9 +1390,6 @@ mod core_types { output_array_ref_forward! { core::Vector } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfPoint3d = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfPoint3d(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfPoint3d(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -1561,9 +1453,6 @@ mod core_types { output_array_ref_forward! { core::Vector } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfPoint3f = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfPoint3f(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfPoint3f(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -1627,9 +1516,6 @@ mod core_types { output_array_ref_forward! { core::Vector } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfPoint3i = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfPoint3i(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfPoint3i(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -1693,9 +1579,6 @@ mod core_types { output_array_ref_forward! { core::Vector } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfRange = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfRange(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfRange(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -1726,9 +1609,6 @@ mod core_types { } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfRect = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfRect(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfRect(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -1792,9 +1672,6 @@ mod core_types { output_array_ref_forward! { core::Vector } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfRect2d = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfRect2d(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfRect2d(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -1858,9 +1735,6 @@ mod core_types { output_array_ref_forward! { core::Vector } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfRotatedRect = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfRotatedRect(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfRotatedRect(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -1882,9 +1756,6 @@ mod core_types { } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfScalar = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfScalar(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfScalar(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -1948,9 +1819,6 @@ mod core_types { output_array_ref_forward! { core::Vector } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfSize = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfSize(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfSize(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -2014,9 +1882,6 @@ mod core_types { output_array_ref_forward! { core::Vector } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfString = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfString(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfString(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -2035,9 +1900,6 @@ mod core_types { vector_non_copy_or_bool! { String } - #[deprecated = "Use the the non-alias form `core::Vector>` instead, removal in Nov 2024"] - pub type VectorOfTupleOfPoint2i_Point2i = core::Vector>; - impl core::Vector> { pub fn as_raw_VectorOfTupleOfPoint2i_Point2i(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfTupleOfPoint2i_Point2i(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -2056,9 +1918,6 @@ mod core_types { vector_non_copy_or_bool! { core::Tuple<(core::Point2i, core::Point2i)> } - #[deprecated = "Use the the non-alias form `core::Vector>` instead, removal in Nov 2024"] - pub type VectorOfTupleOfUMat_u8 = core::Vector>; - impl core::Vector> { pub fn as_raw_VectorOfTupleOfUMat_u8(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfTupleOfUMat_u8(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -2077,9 +1936,6 @@ mod core_types { vector_non_copy_or_bool! { core::Tuple<(core::UMat, u8)> } - #[deprecated = "Use the the non-alias form `core::Vector>` instead, removal in Nov 2024"] - pub type VectorOfTupleOfi32_f64 = core::Vector>; - impl core::Vector> { pub fn as_raw_VectorOfTupleOfi32_f64(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfTupleOfi32_f64(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -2098,9 +1954,6 @@ mod core_types { vector_non_copy_or_bool! { core::Tuple<(i32, f64)> } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfUMat = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfUMat(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfUMat(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -2131,9 +1984,6 @@ mod core_types { } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfVec2d = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfVec2d(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfVec2d(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -2197,9 +2047,6 @@ mod core_types { output_array_ref_forward! { core::Vector } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfVec2f = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfVec2f(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfVec2f(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -2263,9 +2110,6 @@ mod core_types { output_array_ref_forward! { core::Vector } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfVec2i = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfVec2i(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfVec2i(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -2329,9 +2173,6 @@ mod core_types { output_array_ref_forward! { core::Vector } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfVec3d = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfVec3d(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfVec3d(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -2395,9 +2236,6 @@ mod core_types { output_array_ref_forward! { core::Vector } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfVec3f = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfVec3f(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfVec3f(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -2461,9 +2299,6 @@ mod core_types { output_array_ref_forward! { core::Vector } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfVec3i = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfVec3i(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfVec3i(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -2527,9 +2362,6 @@ mod core_types { output_array_ref_forward! { core::Vector } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfVec4f = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfVec4f(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfVec4f(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -2593,9 +2425,6 @@ mod core_types { output_array_ref_forward! { core::Vector } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfVec4i = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfVec4i(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfVec4i(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -2659,9 +2488,6 @@ mod core_types { output_array_ref_forward! { core::Vector } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfVec6f = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfVec6f(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfVec6f(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -2725,9 +2551,6 @@ mod core_types { output_array_ref_forward! { core::Vector } - #[deprecated = "Use the the non-alias form `core::Vector>` instead, removal in Nov 2024"] - pub type VectorOfVectorOfDMatch = core::Vector>; - impl core::Vector> { pub fn as_raw_VectorOfVectorOfDMatch(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfVectorOfDMatch(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -2746,9 +2569,6 @@ mod core_types { vector_non_copy_or_bool! { clone core::Vector } - #[deprecated = "Use the the non-alias form `core::Vector>` instead, removal in Nov 2024"] - pub type VectorOfVectorOfKeyPoint = core::Vector>; - impl core::Vector> { pub fn as_raw_VectorOfVectorOfKeyPoint(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfVectorOfKeyPoint(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -2767,9 +2587,6 @@ mod core_types { vector_non_copy_or_bool! { clone core::Vector } - #[deprecated = "Use the the non-alias form `core::Vector>` instead, removal in Nov 2024"] - pub type VectorOfVectorOfMat = core::Vector>; - impl core::Vector> { pub fn as_raw_VectorOfVectorOfMat(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfVectorOfMat(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -2788,9 +2605,6 @@ mod core_types { vector_non_copy_or_bool! { clone core::Vector } - #[deprecated = "Use the the non-alias form `core::Vector>` instead, removal in Nov 2024"] - pub type VectorOfVectorOfPoint = core::Vector>; - impl core::Vector> { pub fn as_raw_VectorOfVectorOfPoint(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfVectorOfPoint(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -2851,9 +2665,6 @@ mod core_types { output_array_ref_forward! { core::Vector> } - #[deprecated = "Use the the non-alias form `core::Vector>` instead, removal in Nov 2024"] - pub type VectorOfVectorOfPoint2d = core::Vector>; - impl core::Vector> { pub fn as_raw_VectorOfVectorOfPoint2d(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfVectorOfPoint2d(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -2914,9 +2725,6 @@ mod core_types { output_array_ref_forward! { core::Vector> } - #[deprecated = "Use the the non-alias form `core::Vector>` instead, removal in Nov 2024"] - pub type VectorOfVectorOfPoint2f = core::Vector>; - impl core::Vector> { pub fn as_raw_VectorOfVectorOfPoint2f(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfVectorOfPoint2f(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -2977,9 +2785,6 @@ mod core_types { output_array_ref_forward! { core::Vector> } - #[deprecated = "Use the the non-alias form `core::Vector>` instead, removal in Nov 2024"] - pub type VectorOfVectorOfPoint3d = core::Vector>; - impl core::Vector> { pub fn as_raw_VectorOfVectorOfPoint3d(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfVectorOfPoint3d(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -3040,9 +2845,6 @@ mod core_types { output_array_ref_forward! { core::Vector> } - #[deprecated = "Use the the non-alias form `core::Vector>` instead, removal in Nov 2024"] - pub type VectorOfVectorOfPoint3f = core::Vector>; - impl core::Vector> { pub fn as_raw_VectorOfVectorOfPoint3f(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfVectorOfPoint3f(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -3103,9 +2905,6 @@ mod core_types { output_array_ref_forward! { core::Vector> } - #[deprecated = "Use the the non-alias form `core::Vector>` instead, removal in Nov 2024"] - pub type VectorOfVectorOfPoint3i = core::Vector>; - impl core::Vector> { pub fn as_raw_VectorOfVectorOfPoint3i(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfVectorOfPoint3i(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -3166,9 +2965,6 @@ mod core_types { output_array_ref_forward! { core::Vector> } - #[deprecated = "Use the the non-alias form `core::Vector>` instead, removal in Nov 2024"] - pub type VectorOfVectorOfRange = core::Vector>; - impl core::Vector> { pub fn as_raw_VectorOfVectorOfRange(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfVectorOfRange(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -3187,9 +2983,6 @@ mod core_types { vector_non_copy_or_bool! { core::Vector } - #[deprecated = "Use the the non-alias form `core::Vector>` instead, removal in Nov 2024"] - pub type VectorOfVectorOfVec2d = core::Vector>; - impl core::Vector> { pub fn as_raw_VectorOfVectorOfVec2d(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfVectorOfVec2d(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -3250,9 +3043,6 @@ mod core_types { output_array_ref_forward! { core::Vector> } - #[deprecated = "Use the the non-alias form `core::Vector>` instead, removal in Nov 2024"] - pub type VectorOfVectorOfVec2f = core::Vector>; - impl core::Vector> { pub fn as_raw_VectorOfVectorOfVec2f(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfVectorOfVec2f(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -3313,9 +3103,6 @@ mod core_types { output_array_ref_forward! { core::Vector> } - #[deprecated = "Use the the non-alias form `core::Vector>` instead, removal in Nov 2024"] - pub type VectorOfVectorOfVec2i = core::Vector>; - impl core::Vector> { pub fn as_raw_VectorOfVectorOfVec2i(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfVectorOfVec2i(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -3376,9 +3163,6 @@ mod core_types { output_array_ref_forward! { core::Vector> } - #[deprecated = "Use the the non-alias form `core::Vector>` instead, removal in Nov 2024"] - pub type VectorOfVectorOfVec3d = core::Vector>; - impl core::Vector> { pub fn as_raw_VectorOfVectorOfVec3d(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfVectorOfVec3d(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -3439,9 +3223,6 @@ mod core_types { output_array_ref_forward! { core::Vector> } - #[deprecated = "Use the the non-alias form `core::Vector>` instead, removal in Nov 2024"] - pub type VectorOfVectorOfVec3f = core::Vector>; - impl core::Vector> { pub fn as_raw_VectorOfVectorOfVec3f(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfVectorOfVec3f(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -3502,17 +3283,11 @@ mod core_types { output_array_ref_forward! { core::Vector> } - #[deprecated = "Use the the non-alias form `core::Vector>` instead, removal in Nov 2024"] - pub type VectorOfVectorOfc_char = core::Vector>; - impl core::Vector> { pub fn as_raw_VectorOfVectorOfc_char(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfVectorOfc_char(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } } - #[deprecated = "Use the the non-alias form `core::Vector>` instead, removal in Nov 2024"] - pub type VectorOfVectorOff32 = core::Vector>; - impl core::Vector> { pub fn as_raw_VectorOfVectorOff32(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfVectorOff32(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -3573,9 +3348,6 @@ mod core_types { output_array_ref_forward! { core::Vector> } - #[deprecated = "Use the the non-alias form `core::Vector>` instead, removal in Nov 2024"] - pub type VectorOfVectorOff64 = core::Vector>; - impl core::Vector> { pub fn as_raw_VectorOfVectorOff64(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfVectorOff64(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -3636,9 +3408,6 @@ mod core_types { output_array_ref_forward! { core::Vector> } - #[deprecated = "Use the the non-alias form `core::Vector>` instead, removal in Nov 2024"] - pub type VectorOfVectorOfi32 = core::Vector>; - impl core::Vector> { pub fn as_raw_VectorOfVectorOfi32(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfVectorOfi32(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -3699,9 +3468,6 @@ mod core_types { output_array_ref_forward! { core::Vector> } - #[deprecated = "Use the the non-alias form `core::Vector>` instead, removal in Nov 2024"] - pub type VectorOfVectorOfi8 = core::Vector>; - impl core::Vector> { pub fn as_raw_VectorOfVectorOfi8(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfVectorOfi8(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -3720,9 +3486,6 @@ mod core_types { vector_non_copy_or_bool! { clone core::Vector } - #[deprecated = "Use the the non-alias form `core::Vector>` instead, removal in Nov 2024"] - pub type VectorOfVectorOfu8 = core::Vector>; - impl core::Vector> { pub fn as_raw_VectorOfVectorOfu8(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfVectorOfu8(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -3783,9 +3546,6 @@ mod core_types { output_array_ref_forward! { core::Vector> } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfbool = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfbool(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfbool(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -3818,17 +3578,11 @@ mod core_types { input_array_ref_forward! { core::Vector } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfc_char = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfc_char(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfc_char(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOff32 = core::Vector; - impl core::Vector { pub fn as_raw_VectorOff32(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOff32(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -3892,9 +3646,6 @@ mod core_types { output_array_ref_forward! { core::Vector } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOff64 = core::Vector; - impl core::Vector { pub fn as_raw_VectorOff64(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOff64(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -3958,9 +3709,6 @@ mod core_types { output_array_ref_forward! { core::Vector } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfi32 = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfi32(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfi32(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -4024,9 +3772,6 @@ mod core_types { output_array_ref_forward! { core::Vector } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfi8 = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfi8(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfi8(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -4048,9 +3793,6 @@ mod core_types { } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfsize_t = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfsize_t(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfsize_t(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -4072,9 +3814,6 @@ mod core_types { } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfu64 = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfu64(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfu64(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -4096,9 +3835,6 @@ mod core_types { } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfu8 = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfu8(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfu8(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -4163,16 +3899,11 @@ mod core_types { output_array_ref_forward! { core::Vector } } -#[cfg(ocvrs_has_module_core)] pub use core_types::*; -#[cfg(ocvrs_has_module_cudaarithm)] mod cudaarithm_types { use crate::{mod_prelude::*, core, types, sys}; - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfConvolution = core::Ptr; - ptr_extern! { crate::cudaarithm::Convolution, cv_PtrLcv_cuda_ConvolutionG_new_null_const, cv_PtrLcv_cuda_ConvolutionG_delete, cv_PtrLcv_cuda_ConvolutionG_getInnerPtr_const, cv_PtrLcv_cuda_ConvolutionG_getInnerPtrMut } @@ -4208,9 +3939,6 @@ mod cudaarithm_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDFT = core::Ptr; - ptr_extern! { crate::cudaarithm::DFT, cv_PtrLcv_cuda_DFTG_new_null_const, cv_PtrLcv_cuda_DFTG_delete, cv_PtrLcv_cuda_DFTG_getInnerPtr_const, cv_PtrLcv_cuda_DFTG_getInnerPtrMut } @@ -4246,9 +3974,6 @@ mod cudaarithm_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfLookUpTable = core::Ptr; - ptr_extern! { crate::cudaarithm::LookUpTable, cv_PtrLcv_cuda_LookUpTableG_new_null_const, cv_PtrLcv_cuda_LookUpTableG_delete, cv_PtrLcv_cuda_LookUpTableG_getInnerPtr_const, cv_PtrLcv_cuda_LookUpTableG_getInnerPtrMut } @@ -4285,16 +4010,11 @@ mod cudaarithm_types { } } -#[cfg(ocvrs_has_module_cudaarithm)] pub use cudaarithm_types::*; -#[cfg(ocvrs_has_module_cudabgsegm)] mod cudabgsegm_types { use crate::{mod_prelude::*, core, types, sys}; - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCUDA_BackgroundSubtractorMOG = core::Ptr; - ptr_extern! { crate::cudabgsegm::CUDA_BackgroundSubtractorMOG, cv_PtrLcv_cuda_BackgroundSubtractorMOGG_new_null_const, cv_PtrLcv_cuda_BackgroundSubtractorMOGG_delete, cv_PtrLcv_cuda_BackgroundSubtractorMOGG_getInnerPtr_const, cv_PtrLcv_cuda_BackgroundSubtractorMOGG_getInnerPtrMut } @@ -4340,9 +4060,6 @@ mod cudabgsegm_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCUDA_BackgroundSubtractorMOG2 = core::Ptr; - ptr_extern! { crate::cudabgsegm::CUDA_BackgroundSubtractorMOG2, cv_PtrLcv_cuda_BackgroundSubtractorMOG2G_new_null_const, cv_PtrLcv_cuda_BackgroundSubtractorMOG2G_delete, cv_PtrLcv_cuda_BackgroundSubtractorMOG2G_getInnerPtr_const, cv_PtrLcv_cuda_BackgroundSubtractorMOG2G_getInnerPtrMut } @@ -4399,16 +4116,11 @@ mod cudabgsegm_types { } } -#[cfg(ocvrs_has_module_cudabgsegm)] pub use cudabgsegm_types::*; -#[cfg(ocvrs_has_module_cudacodec)] mod cudacodec_types { use crate::{mod_prelude::*, core, types, sys}; - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCUDA_EncoderCallback = core::Ptr; - ptr_extern! { crate::cudacodec::CUDA_EncoderCallback, cv_PtrLcv_cudacodec_EncoderCallbackG_new_null_const, cv_PtrLcv_cudacodec_EncoderCallbackG_delete, cv_PtrLcv_cudacodec_EncoderCallbackG_getInnerPtr_const, cv_PtrLcv_cudacodec_EncoderCallbackG_getInnerPtrMut } @@ -4434,9 +4146,6 @@ mod cudacodec_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCUDA_NVSurfaceToColorConverter = core::Ptr; - ptr_extern! { crate::cudacodec::CUDA_NVSurfaceToColorConverter, cv_PtrLcv_cudacodec_NVSurfaceToColorConverterG_new_null_const, cv_PtrLcv_cudacodec_NVSurfaceToColorConverterG_delete, cv_PtrLcv_cudacodec_NVSurfaceToColorConverterG_getInnerPtr_const, cv_PtrLcv_cudacodec_NVSurfaceToColorConverterG_getInnerPtrMut } @@ -4462,9 +4171,6 @@ mod cudacodec_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCUDA_RawVideoSource = core::Ptr; - ptr_extern! { crate::cudacodec::CUDA_RawVideoSource, cv_PtrLcv_cudacodec_RawVideoSourceG_new_null_const, cv_PtrLcv_cudacodec_RawVideoSourceG_delete, cv_PtrLcv_cudacodec_RawVideoSourceG_getInnerPtr_const, cv_PtrLcv_cudacodec_RawVideoSourceG_getInnerPtrMut } @@ -4490,9 +4196,6 @@ mod cudacodec_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCUDA_VideoReader = core::Ptr; - ptr_extern! { crate::cudacodec::CUDA_VideoReader, cv_PtrLcv_cudacodec_VideoReaderG_new_null_const, cv_PtrLcv_cudacodec_VideoReaderG_delete, cv_PtrLcv_cudacodec_VideoReaderG_getInnerPtr_const, cv_PtrLcv_cudacodec_VideoReaderG_getInnerPtrMut } @@ -4518,9 +4221,6 @@ mod cudacodec_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCUDA_VideoWriter = core::Ptr; - ptr_extern! { crate::cudacodec::CUDA_VideoWriter, cv_PtrLcv_cudacodec_VideoWriterG_new_null_const, cv_PtrLcv_cudacodec_VideoWriterG_delete, cv_PtrLcv_cudacodec_VideoWriterG_getInnerPtr_const, cv_PtrLcv_cudacodec_VideoWriterG_getInnerPtrMut } @@ -4547,16 +4247,11 @@ mod cudacodec_types { } } -#[cfg(ocvrs_has_module_cudacodec)] pub use cudacodec_types::*; -#[cfg(ocvrs_has_module_cudafeatures2d)] mod cudafeatures2d_types { use crate::{mod_prelude::*, core, types, sys}; - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCUDA_DescriptorMatcher = core::Ptr; - ptr_extern! { crate::cudafeatures2d::CUDA_DescriptorMatcher, cv_PtrLcv_cuda_DescriptorMatcherG_new_null_const, cv_PtrLcv_cuda_DescriptorMatcherG_delete, cv_PtrLcv_cuda_DescriptorMatcherG_getInnerPtr_const, cv_PtrLcv_cuda_DescriptorMatcherG_getInnerPtrMut } @@ -4592,9 +4287,6 @@ mod cudafeatures2d_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCUDA_FastFeatureDetector = core::Ptr; - ptr_extern! { crate::cudafeatures2d::CUDA_FastFeatureDetector, cv_PtrLcv_cuda_FastFeatureDetectorG_new_null_const, cv_PtrLcv_cuda_FastFeatureDetectorG_delete, cv_PtrLcv_cuda_FastFeatureDetectorG_getInnerPtr_const, cv_PtrLcv_cuda_FastFeatureDetectorG_getInnerPtrMut } @@ -4650,9 +4342,6 @@ mod cudafeatures2d_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCUDA_Feature2DAsync = core::Ptr; - ptr_extern! { crate::cudafeatures2d::CUDA_Feature2DAsync, cv_PtrLcv_cuda_Feature2DAsyncG_new_null_const, cv_PtrLcv_cuda_Feature2DAsyncG_delete, cv_PtrLcv_cuda_Feature2DAsyncG_getInnerPtr_const, cv_PtrLcv_cuda_Feature2DAsyncG_getInnerPtrMut } @@ -4698,9 +4387,6 @@ mod cudafeatures2d_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCUDA_ORB = core::Ptr; - ptr_extern! { crate::cudafeatures2d::CUDA_ORB, cv_PtrLcv_cuda_ORBG_new_null_const, cv_PtrLcv_cuda_ORBG_delete, cv_PtrLcv_cuda_ORBG_getInnerPtr_const, cv_PtrLcv_cuda_ORBG_getInnerPtrMut } @@ -4757,16 +4443,11 @@ mod cudafeatures2d_types { } } -#[cfg(ocvrs_has_module_cudafeatures2d)] pub use cudafeatures2d_types::*; -#[cfg(ocvrs_has_module_cudafilters)] mod cudafilters_types { use crate::{mod_prelude::*, core, types, sys}; - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfFilter = core::Ptr; - ptr_extern! { crate::cudafilters::Filter, cv_PtrLcv_cuda_FilterG_new_null_const, cv_PtrLcv_cuda_FilterG_delete, cv_PtrLcv_cuda_FilterG_getInnerPtr_const, cv_PtrLcv_cuda_FilterG_getInnerPtrMut } @@ -4803,16 +4484,11 @@ mod cudafilters_types { } } -#[cfg(ocvrs_has_module_cudafilters)] pub use cudafilters_types::*; -#[cfg(ocvrs_has_module_cudaimgproc)] mod cudaimgproc_types { use crate::{mod_prelude::*, core, types, sys}; - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCUDA_CLAHE = core::Ptr; - ptr_extern! { crate::cudaimgproc::CUDA_CLAHE, cv_PtrLcv_cuda_CLAHEG_new_null_const, cv_PtrLcv_cuda_CLAHEG_delete, cv_PtrLcv_cuda_CLAHEG_getInnerPtr_const, cv_PtrLcv_cuda_CLAHEG_getInnerPtrMut } @@ -4858,9 +4534,6 @@ mod cudaimgproc_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCUDA_CannyEdgeDetector = core::Ptr; - ptr_extern! { crate::cudaimgproc::CUDA_CannyEdgeDetector, cv_PtrLcv_cuda_CannyEdgeDetectorG_new_null_const, cv_PtrLcv_cuda_CannyEdgeDetectorG_delete, cv_PtrLcv_cuda_CannyEdgeDetectorG_getInnerPtr_const, cv_PtrLcv_cuda_CannyEdgeDetectorG_getInnerPtrMut } @@ -4896,9 +4569,6 @@ mod cudaimgproc_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCUDA_CornernessCriteria = core::Ptr; - ptr_extern! { crate::cudaimgproc::CUDA_CornernessCriteria, cv_PtrLcv_cuda_CornernessCriteriaG_new_null_const, cv_PtrLcv_cuda_CornernessCriteriaG_delete, cv_PtrLcv_cuda_CornernessCriteriaG_getInnerPtr_const, cv_PtrLcv_cuda_CornernessCriteriaG_getInnerPtrMut } @@ -4934,9 +4604,6 @@ mod cudaimgproc_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCUDA_CornersDetector = core::Ptr; - ptr_extern! { crate::cudaimgproc::CUDA_CornersDetector, cv_PtrLcv_cuda_CornersDetectorG_new_null_const, cv_PtrLcv_cuda_CornersDetectorG_delete, cv_PtrLcv_cuda_CornersDetectorG_getInnerPtr_const, cv_PtrLcv_cuda_CornersDetectorG_getInnerPtrMut } @@ -4972,9 +4639,6 @@ mod cudaimgproc_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCUDA_HoughCirclesDetector = core::Ptr; - ptr_extern! { crate::cudaimgproc::CUDA_HoughCirclesDetector, cv_PtrLcv_cuda_HoughCirclesDetectorG_new_null_const, cv_PtrLcv_cuda_HoughCirclesDetectorG_delete, cv_PtrLcv_cuda_HoughCirclesDetectorG_getInnerPtr_const, cv_PtrLcv_cuda_HoughCirclesDetectorG_getInnerPtrMut } @@ -5010,9 +4674,6 @@ mod cudaimgproc_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCUDA_HoughLinesDetector = core::Ptr; - ptr_extern! { crate::cudaimgproc::CUDA_HoughLinesDetector, cv_PtrLcv_cuda_HoughLinesDetectorG_new_null_const, cv_PtrLcv_cuda_HoughLinesDetectorG_delete, cv_PtrLcv_cuda_HoughLinesDetectorG_getInnerPtr_const, cv_PtrLcv_cuda_HoughLinesDetectorG_getInnerPtrMut } @@ -5048,9 +4709,6 @@ mod cudaimgproc_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCUDA_HoughSegmentDetector = core::Ptr; - ptr_extern! { crate::cudaimgproc::CUDA_HoughSegmentDetector, cv_PtrLcv_cuda_HoughSegmentDetectorG_new_null_const, cv_PtrLcv_cuda_HoughSegmentDetectorG_delete, cv_PtrLcv_cuda_HoughSegmentDetectorG_getInnerPtr_const, cv_PtrLcv_cuda_HoughSegmentDetectorG_getInnerPtrMut } @@ -5086,9 +4744,6 @@ mod cudaimgproc_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCUDA_TemplateMatching = core::Ptr; - ptr_extern! { crate::cudaimgproc::CUDA_TemplateMatching, cv_PtrLcv_cuda_TemplateMatchingG_new_null_const, cv_PtrLcv_cuda_TemplateMatchingG_delete, cv_PtrLcv_cuda_TemplateMatchingG_getInnerPtr_const, cv_PtrLcv_cuda_TemplateMatchingG_getInnerPtrMut } @@ -5125,15 +4780,141 @@ mod cudaimgproc_types { } } -#[cfg(ocvrs_has_module_cudaimgproc)] pub use cudaimgproc_types::*; -#[cfg(ocvrs_has_module_cudaobjdetect)] -mod cudaobjdetect_types { +mod cudalegacy_types { use crate::{mod_prelude::*, core, types, sys}; - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCUDA_CascadeClassifier = core::Ptr; + ptr_extern! { crate::cudalegacy::CUDA_BackgroundSubtractorFGD, + cv_PtrLcv_cuda_BackgroundSubtractorFGDG_new_null_const, cv_PtrLcv_cuda_BackgroundSubtractorFGDG_delete, cv_PtrLcv_cuda_BackgroundSubtractorFGDG_getInnerPtr_const, cv_PtrLcv_cuda_BackgroundSubtractorFGDG_getInnerPtrMut + } + + impl core::Ptr { + #[inline] pub fn as_raw_PtrOfCUDA_BackgroundSubtractorFGD(&self) -> extern_send!(Self) { self.as_raw() } + #[inline] pub fn as_raw_mut_PtrOfCUDA_BackgroundSubtractorFGD(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } + } + + impl crate::cudalegacy::CUDA_BackgroundSubtractorFGDTraitConst for core::Ptr { + #[inline] fn as_raw_CUDA_BackgroundSubtractorFGD(&self) -> *const c_void { self.inner_as_raw() } + } + + impl crate::cudalegacy::CUDA_BackgroundSubtractorFGDTrait for core::Ptr { + #[inline] fn as_raw_mut_CUDA_BackgroundSubtractorFGD(&mut self) -> *mut c_void { self.inner_as_raw_mut() } + } + + impl core::AlgorithmTraitConst for core::Ptr { + #[inline] fn as_raw_Algorithm(&self) -> *const c_void { self.inner_as_raw() } + } + + impl core::AlgorithmTrait for core::Ptr { + #[inline] fn as_raw_mut_Algorithm(&mut self) -> *mut c_void { self.inner_as_raw_mut() } + } + + ptr_cast_base! { core::Ptr, core::Ptr, cv_PtrLcv_cuda_BackgroundSubtractorFGDG_to_PtrOfAlgorithm } + + impl crate::video::BackgroundSubtractorTraitConst for core::Ptr { + #[inline] fn as_raw_BackgroundSubtractor(&self) -> *const c_void { self.inner_as_raw() } + } + + impl crate::video::BackgroundSubtractorTrait for core::Ptr { + #[inline] fn as_raw_mut_BackgroundSubtractor(&mut self) -> *mut c_void { self.inner_as_raw_mut() } + } + + ptr_cast_base! { core::Ptr, core::Ptr, cv_PtrLcv_cuda_BackgroundSubtractorFGDG_to_PtrOfBackgroundSubtractor } + + impl std::fmt::Debug for core::Ptr { + #[inline] + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + f.debug_struct("PtrOfCUDA_BackgroundSubtractorFGD") + .finish() + } + } + + ptr_extern! { crate::cudalegacy::CUDA_BackgroundSubtractorGMG, + cv_PtrLcv_cuda_BackgroundSubtractorGMGG_new_null_const, cv_PtrLcv_cuda_BackgroundSubtractorGMGG_delete, cv_PtrLcv_cuda_BackgroundSubtractorGMGG_getInnerPtr_const, cv_PtrLcv_cuda_BackgroundSubtractorGMGG_getInnerPtrMut + } + + impl core::Ptr { + #[inline] pub fn as_raw_PtrOfCUDA_BackgroundSubtractorGMG(&self) -> extern_send!(Self) { self.as_raw() } + #[inline] pub fn as_raw_mut_PtrOfCUDA_BackgroundSubtractorGMG(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } + } + + impl crate::cudalegacy::CUDA_BackgroundSubtractorGMGTraitConst for core::Ptr { + #[inline] fn as_raw_CUDA_BackgroundSubtractorGMG(&self) -> *const c_void { self.inner_as_raw() } + } + + impl crate::cudalegacy::CUDA_BackgroundSubtractorGMGTrait for core::Ptr { + #[inline] fn as_raw_mut_CUDA_BackgroundSubtractorGMG(&mut self) -> *mut c_void { self.inner_as_raw_mut() } + } + + impl core::AlgorithmTraitConst for core::Ptr { + #[inline] fn as_raw_Algorithm(&self) -> *const c_void { self.inner_as_raw() } + } + + impl core::AlgorithmTrait for core::Ptr { + #[inline] fn as_raw_mut_Algorithm(&mut self) -> *mut c_void { self.inner_as_raw_mut() } + } + + ptr_cast_base! { core::Ptr, core::Ptr, cv_PtrLcv_cuda_BackgroundSubtractorGMGG_to_PtrOfAlgorithm } + + impl crate::video::BackgroundSubtractorTraitConst for core::Ptr { + #[inline] fn as_raw_BackgroundSubtractor(&self) -> *const c_void { self.inner_as_raw() } + } + + impl crate::video::BackgroundSubtractorTrait for core::Ptr { + #[inline] fn as_raw_mut_BackgroundSubtractor(&mut self) -> *mut c_void { self.inner_as_raw_mut() } + } + + ptr_cast_base! { core::Ptr, core::Ptr, cv_PtrLcv_cuda_BackgroundSubtractorGMGG_to_PtrOfBackgroundSubtractor } + + impl std::fmt::Debug for core::Ptr { + #[inline] + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + f.debug_struct("PtrOfCUDA_BackgroundSubtractorGMG") + .finish() + } + } + + ptr_extern! { crate::cudalegacy::CUDA_ImagePyramid, + cv_PtrLcv_cuda_ImagePyramidG_new_null_const, cv_PtrLcv_cuda_ImagePyramidG_delete, cv_PtrLcv_cuda_ImagePyramidG_getInnerPtr_const, cv_PtrLcv_cuda_ImagePyramidG_getInnerPtrMut + } + + impl core::Ptr { + #[inline] pub fn as_raw_PtrOfCUDA_ImagePyramid(&self) -> extern_send!(Self) { self.as_raw() } + #[inline] pub fn as_raw_mut_PtrOfCUDA_ImagePyramid(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } + } + + impl crate::cudalegacy::CUDA_ImagePyramidTraitConst for core::Ptr { + #[inline] fn as_raw_CUDA_ImagePyramid(&self) -> *const c_void { self.inner_as_raw() } + } + + impl crate::cudalegacy::CUDA_ImagePyramidTrait for core::Ptr { + #[inline] fn as_raw_mut_CUDA_ImagePyramid(&mut self) -> *mut c_void { self.inner_as_raw_mut() } + } + + impl core::AlgorithmTraitConst for core::Ptr { + #[inline] fn as_raw_Algorithm(&self) -> *const c_void { self.inner_as_raw() } + } + + impl core::AlgorithmTrait for core::Ptr { + #[inline] fn as_raw_mut_Algorithm(&mut self) -> *mut c_void { self.inner_as_raw_mut() } + } + + ptr_cast_base! { core::Ptr, core::Ptr, cv_PtrLcv_cuda_ImagePyramidG_to_PtrOfAlgorithm } + + impl std::fmt::Debug for core::Ptr { + #[inline] + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + f.debug_struct("PtrOfCUDA_ImagePyramid") + .finish() + } + } + +} +pub use cudalegacy_types::*; + +mod cudaobjdetect_types { + use crate::{mod_prelude::*, core, types, sys}; ptr_extern! { crate::cudaobjdetect::CUDA_CascadeClassifier, cv_PtrLcv_cuda_CascadeClassifierG_new_null_const, cv_PtrLcv_cuda_CascadeClassifierG_delete, cv_PtrLcv_cuda_CascadeClassifierG_getInnerPtr_const, cv_PtrLcv_cuda_CascadeClassifierG_getInnerPtrMut @@ -5170,9 +4951,6 @@ mod cudaobjdetect_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCUDA_HOG = core::Ptr; - ptr_extern! { crate::cudaobjdetect::CUDA_HOG, cv_PtrLcv_cuda_HOGG_new_null_const, cv_PtrLcv_cuda_HOGG_delete, cv_PtrLcv_cuda_HOGG_getInnerPtr_const, cv_PtrLcv_cuda_HOGG_getInnerPtrMut } @@ -5209,16 +4987,11 @@ mod cudaobjdetect_types { } } -#[cfg(ocvrs_has_module_cudaobjdetect)] pub use cudaobjdetect_types::*; -#[cfg(ocvrs_has_module_cudaoptflow)] mod cudaoptflow_types { use crate::{mod_prelude::*, core, types, sys}; - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCUDA_BroxOpticalFlow = core::Ptr; - ptr_extern! { crate::cudaoptflow::CUDA_BroxOpticalFlow, cv_PtrLcv_cuda_BroxOpticalFlowG_new_null_const, cv_PtrLcv_cuda_BroxOpticalFlowG_delete, cv_PtrLcv_cuda_BroxOpticalFlowG_getInnerPtr_const, cv_PtrLcv_cuda_BroxOpticalFlowG_getInnerPtrMut } @@ -5264,9 +5037,6 @@ mod cudaoptflow_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCUDA_DenseOpticalFlow = core::Ptr; - ptr_extern! { crate::cudaoptflow::CUDA_DenseOpticalFlow, cv_PtrLcv_cuda_DenseOpticalFlowG_new_null_const, cv_PtrLcv_cuda_DenseOpticalFlowG_delete, cv_PtrLcv_cuda_DenseOpticalFlowG_getInnerPtr_const, cv_PtrLcv_cuda_DenseOpticalFlowG_getInnerPtrMut } @@ -5302,9 +5072,6 @@ mod cudaoptflow_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCUDA_DensePyrLKOpticalFlow = core::Ptr; - ptr_extern! { crate::cudaoptflow::CUDA_DensePyrLKOpticalFlow, cv_PtrLcv_cuda_DensePyrLKOpticalFlowG_new_null_const, cv_PtrLcv_cuda_DensePyrLKOpticalFlowG_delete, cv_PtrLcv_cuda_DensePyrLKOpticalFlowG_getInnerPtr_const, cv_PtrLcv_cuda_DensePyrLKOpticalFlowG_getInnerPtrMut } @@ -5350,9 +5117,6 @@ mod cudaoptflow_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCUDA_FarnebackOpticalFlow = core::Ptr; - ptr_extern! { crate::cudaoptflow::CUDA_FarnebackOpticalFlow, cv_PtrLcv_cuda_FarnebackOpticalFlowG_new_null_const, cv_PtrLcv_cuda_FarnebackOpticalFlowG_delete, cv_PtrLcv_cuda_FarnebackOpticalFlowG_getInnerPtr_const, cv_PtrLcv_cuda_FarnebackOpticalFlowG_getInnerPtrMut } @@ -5398,9 +5162,6 @@ mod cudaoptflow_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCUDA_NvidiaHWOpticalFlow = core::Ptr; - ptr_extern! { crate::cudaoptflow::CUDA_NvidiaHWOpticalFlow, cv_PtrLcv_cuda_NvidiaHWOpticalFlowG_new_null_const, cv_PtrLcv_cuda_NvidiaHWOpticalFlowG_delete, cv_PtrLcv_cuda_NvidiaHWOpticalFlowG_getInnerPtr_const, cv_PtrLcv_cuda_NvidiaHWOpticalFlowG_getInnerPtrMut } @@ -5436,9 +5197,6 @@ mod cudaoptflow_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCUDA_NvidiaOpticalFlow_1_0 = core::Ptr; - ptr_extern! { crate::cudaoptflow::CUDA_NvidiaOpticalFlow_1_0, cv_PtrLcv_cuda_NvidiaOpticalFlow_1_0G_new_null_const, cv_PtrLcv_cuda_NvidiaOpticalFlow_1_0G_delete, cv_PtrLcv_cuda_NvidiaOpticalFlow_1_0G_getInnerPtr_const, cv_PtrLcv_cuda_NvidiaOpticalFlow_1_0G_getInnerPtrMut } @@ -5484,9 +5242,6 @@ mod cudaoptflow_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCUDA_NvidiaOpticalFlow_2_0 = core::Ptr; - ptr_extern! { crate::cudaoptflow::CUDA_NvidiaOpticalFlow_2_0, cv_PtrLcv_cuda_NvidiaOpticalFlow_2_0G_new_null_const, cv_PtrLcv_cuda_NvidiaOpticalFlow_2_0G_delete, cv_PtrLcv_cuda_NvidiaOpticalFlow_2_0G_getInnerPtr_const, cv_PtrLcv_cuda_NvidiaOpticalFlow_2_0G_getInnerPtrMut } @@ -5532,9 +5287,6 @@ mod cudaoptflow_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCUDA_OpticalFlowDual_TVL1 = core::Ptr; - ptr_extern! { crate::cudaoptflow::CUDA_OpticalFlowDual_TVL1, cv_PtrLcv_cuda_OpticalFlowDual_TVL1G_new_null_const, cv_PtrLcv_cuda_OpticalFlowDual_TVL1G_delete, cv_PtrLcv_cuda_OpticalFlowDual_TVL1G_getInnerPtr_const, cv_PtrLcv_cuda_OpticalFlowDual_TVL1G_getInnerPtrMut } @@ -5580,9 +5332,6 @@ mod cudaoptflow_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCUDA_SparseOpticalFlow = core::Ptr; - ptr_extern! { crate::cudaoptflow::CUDA_SparseOpticalFlow, cv_PtrLcv_cuda_SparseOpticalFlowG_new_null_const, cv_PtrLcv_cuda_SparseOpticalFlowG_delete, cv_PtrLcv_cuda_SparseOpticalFlowG_getInnerPtr_const, cv_PtrLcv_cuda_SparseOpticalFlowG_getInnerPtrMut } @@ -5618,9 +5367,6 @@ mod cudaoptflow_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCUDA_SparsePyrLKOpticalFlow = core::Ptr; - ptr_extern! { crate::cudaoptflow::CUDA_SparsePyrLKOpticalFlow, cv_PtrLcv_cuda_SparsePyrLKOpticalFlowG_new_null_const, cv_PtrLcv_cuda_SparsePyrLKOpticalFlowG_delete, cv_PtrLcv_cuda_SparsePyrLKOpticalFlowG_getInnerPtr_const, cv_PtrLcv_cuda_SparsePyrLKOpticalFlowG_getInnerPtrMut } @@ -5667,16 +5413,11 @@ mod cudaoptflow_types { } } -#[cfg(ocvrs_has_module_cudaoptflow)] pub use cudaoptflow_types::*; -#[cfg(ocvrs_has_module_cudastereo)] mod cudastereo_types { use crate::{mod_prelude::*, core, types, sys}; - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCUDA_DisparityBilateralFilter = core::Ptr; - ptr_extern! { crate::cudastereo::CUDA_DisparityBilateralFilter, cv_PtrLcv_cuda_DisparityBilateralFilterG_new_null_const, cv_PtrLcv_cuda_DisparityBilateralFilterG_delete, cv_PtrLcv_cuda_DisparityBilateralFilterG_getInnerPtr_const, cv_PtrLcv_cuda_DisparityBilateralFilterG_getInnerPtrMut } @@ -5712,9 +5453,6 @@ mod cudastereo_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCUDA_StereoBM = core::Ptr; - ptr_extern! { crate::cudastereo::CUDA_StereoBM, cv_PtrLcv_cuda_StereoBMG_new_null_const, cv_PtrLcv_cuda_StereoBMG_delete, cv_PtrLcv_cuda_StereoBMG_getInnerPtr_const, cv_PtrLcv_cuda_StereoBMG_getInnerPtrMut } @@ -5770,9 +5508,6 @@ mod cudastereo_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCUDA_StereoBeliefPropagation = core::Ptr; - ptr_extern! { crate::cudastereo::CUDA_StereoBeliefPropagation, cv_PtrLcv_cuda_StereoBeliefPropagationG_new_null_const, cv_PtrLcv_cuda_StereoBeliefPropagationG_delete, cv_PtrLcv_cuda_StereoBeliefPropagationG_getInnerPtr_const, cv_PtrLcv_cuda_StereoBeliefPropagationG_getInnerPtrMut } @@ -5818,9 +5553,6 @@ mod cudastereo_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCUDA_StereoConstantSpaceBP = core::Ptr; - ptr_extern! { crate::cudastereo::CUDA_StereoConstantSpaceBP, cv_PtrLcv_cuda_StereoConstantSpaceBPG_new_null_const, cv_PtrLcv_cuda_StereoConstantSpaceBPG_delete, cv_PtrLcv_cuda_StereoConstantSpaceBPG_getInnerPtr_const, cv_PtrLcv_cuda_StereoConstantSpaceBPG_getInnerPtrMut } @@ -5876,9 +5608,6 @@ mod cudastereo_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCUDA_StereoSGM = core::Ptr; - ptr_extern! { crate::cudastereo::CUDA_StereoSGM, cv_PtrLcv_cuda_StereoSGMG_new_null_const, cv_PtrLcv_cuda_StereoSGMG_delete, cv_PtrLcv_cuda_StereoSGMG_getInnerPtr_const, cv_PtrLcv_cuda_StereoSGMG_getInnerPtrMut } @@ -5935,16 +5664,11 @@ mod cudastereo_types { } } -#[cfg(ocvrs_has_module_cudastereo)] pub use cudastereo_types::*; -#[cfg(ocvrs_has_module_dnn)] mod dnn_types { use crate::{mod_prelude::*, core, types, sys}; - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfAbsLayer = core::Ptr; - ptr_extern! { crate::dnn::AbsLayer, cv_PtrLcv_dnn_AbsLayerG_new_null_const, cv_PtrLcv_dnn_AbsLayerG_delete, cv_PtrLcv_dnn_AbsLayerG_getInnerPtr_const, cv_PtrLcv_dnn_AbsLayerG_getInnerPtrMut } @@ -6005,9 +5729,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfAccumLayer = core::Ptr; - ptr_extern! { crate::dnn::AccumLayer, cv_PtrLcv_dnn_AccumLayerG_new_null_const, cv_PtrLcv_dnn_AccumLayerG_delete, cv_PtrLcv_dnn_AccumLayerG_getInnerPtr_const, cv_PtrLcv_dnn_AccumLayerG_getInnerPtrMut } @@ -6058,9 +5779,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfAcosLayer = core::Ptr; - ptr_extern! { crate::dnn::AcosLayer, cv_PtrLcv_dnn_AcosLayerG_new_null_const, cv_PtrLcv_dnn_AcosLayerG_delete, cv_PtrLcv_dnn_AcosLayerG_getInnerPtr_const, cv_PtrLcv_dnn_AcosLayerG_getInnerPtrMut } @@ -6121,9 +5839,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfAcoshLayer = core::Ptr; - ptr_extern! { crate::dnn::AcoshLayer, cv_PtrLcv_dnn_AcoshLayerG_new_null_const, cv_PtrLcv_dnn_AcoshLayerG_delete, cv_PtrLcv_dnn_AcoshLayerG_getInnerPtr_const, cv_PtrLcv_dnn_AcoshLayerG_getInnerPtrMut } @@ -6184,9 +5899,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfActivationLayer = core::Ptr; - ptr_extern! { crate::dnn::ActivationLayer, cv_PtrLcv_dnn_ActivationLayerG_new_null_const, cv_PtrLcv_dnn_ActivationLayerG_delete, cv_PtrLcv_dnn_ActivationLayerG_getInnerPtr_const, cv_PtrLcv_dnn_ActivationLayerG_getInnerPtrMut } @@ -6237,9 +5949,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfActivationLayerInt8 = core::Ptr; - ptr_extern! { crate::dnn::ActivationLayerInt8, cv_PtrLcv_dnn_ActivationLayerInt8G_new_null_const, cv_PtrLcv_dnn_ActivationLayerInt8G_delete, cv_PtrLcv_dnn_ActivationLayerInt8G_getInnerPtr_const, cv_PtrLcv_dnn_ActivationLayerInt8G_getInnerPtrMut } @@ -6300,9 +6009,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfArgLayer = core::Ptr; - ptr_extern! { crate::dnn::ArgLayer, cv_PtrLcv_dnn_ArgLayerG_new_null_const, cv_PtrLcv_dnn_ArgLayerG_delete, cv_PtrLcv_dnn_ArgLayerG_getInnerPtr_const, cv_PtrLcv_dnn_ArgLayerG_getInnerPtrMut } @@ -6353,9 +6059,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfAsinLayer = core::Ptr; - ptr_extern! { crate::dnn::AsinLayer, cv_PtrLcv_dnn_AsinLayerG_new_null_const, cv_PtrLcv_dnn_AsinLayerG_delete, cv_PtrLcv_dnn_AsinLayerG_getInnerPtr_const, cv_PtrLcv_dnn_AsinLayerG_getInnerPtrMut } @@ -6416,9 +6119,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfAsinhLayer = core::Ptr; - ptr_extern! { crate::dnn::AsinhLayer, cv_PtrLcv_dnn_AsinhLayerG_new_null_const, cv_PtrLcv_dnn_AsinhLayerG_delete, cv_PtrLcv_dnn_AsinhLayerG_getInnerPtr_const, cv_PtrLcv_dnn_AsinhLayerG_getInnerPtrMut } @@ -6479,9 +6179,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfAtanLayer = core::Ptr; - ptr_extern! { crate::dnn::AtanLayer, cv_PtrLcv_dnn_AtanLayerG_new_null_const, cv_PtrLcv_dnn_AtanLayerG_delete, cv_PtrLcv_dnn_AtanLayerG_getInnerPtr_const, cv_PtrLcv_dnn_AtanLayerG_getInnerPtrMut } @@ -6542,9 +6239,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfAtanhLayer = core::Ptr; - ptr_extern! { crate::dnn::AtanhLayer, cv_PtrLcv_dnn_AtanhLayerG_new_null_const, cv_PtrLcv_dnn_AtanhLayerG_delete, cv_PtrLcv_dnn_AtanhLayerG_getInnerPtr_const, cv_PtrLcv_dnn_AtanhLayerG_getInnerPtrMut } @@ -6605,9 +6299,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfAttentionLayer = core::Ptr; - ptr_extern! { crate::dnn::AttentionLayer, cv_PtrLcv_dnn_AttentionLayerG_new_null_const, cv_PtrLcv_dnn_AttentionLayerG_delete, cv_PtrLcv_dnn_AttentionLayerG_getInnerPtr_const, cv_PtrLcv_dnn_AttentionLayerG_getInnerPtrMut } @@ -6658,9 +6349,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfBNLLLayer = core::Ptr; - ptr_extern! { crate::dnn::BNLLLayer, cv_PtrLcv_dnn_BNLLLayerG_new_null_const, cv_PtrLcv_dnn_BNLLLayerG_delete, cv_PtrLcv_dnn_BNLLLayerG_getInnerPtr_const, cv_PtrLcv_dnn_BNLLLayerG_getInnerPtrMut } @@ -6721,9 +6409,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfBackendNode = core::Ptr; - ptr_extern! { crate::dnn::BackendNode, cv_PtrLcv_dnn_BackendNodeG_new_null_const, cv_PtrLcv_dnn_BackendNodeG_delete, cv_PtrLcv_dnn_BackendNodeG_getInnerPtr_const, cv_PtrLcv_dnn_BackendNodeG_getInnerPtrMut } @@ -6751,9 +6436,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfBackendWrapper = core::Ptr; - ptr_extern! { crate::dnn::BackendWrapper, cv_PtrLcv_dnn_BackendWrapperG_new_null_const, cv_PtrLcv_dnn_BackendWrapperG_delete, cv_PtrLcv_dnn_BackendWrapperG_getInnerPtr_const, cv_PtrLcv_dnn_BackendWrapperG_getInnerPtrMut } @@ -6781,9 +6463,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfBaseConvolutionLayer = core::Ptr; - ptr_extern! { crate::dnn::BaseConvolutionLayer, cv_PtrLcv_dnn_BaseConvolutionLayerG_new_null_const, cv_PtrLcv_dnn_BaseConvolutionLayerG_delete, cv_PtrLcv_dnn_BaseConvolutionLayerG_getInnerPtr_const, cv_PtrLcv_dnn_BaseConvolutionLayerG_getInnerPtrMut } @@ -6847,9 +6526,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfBatchNormLayer = core::Ptr; - ptr_extern! { crate::dnn::BatchNormLayer, cv_PtrLcv_dnn_BatchNormLayerG_new_null_const, cv_PtrLcv_dnn_BatchNormLayerG_delete, cv_PtrLcv_dnn_BatchNormLayerG_getInnerPtr_const, cv_PtrLcv_dnn_BatchNormLayerG_getInnerPtrMut } @@ -6913,9 +6589,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfBatchNormLayerInt8 = core::Ptr; - ptr_extern! { crate::dnn::BatchNormLayerInt8, cv_PtrLcv_dnn_BatchNormLayerInt8G_new_null_const, cv_PtrLcv_dnn_BatchNormLayerInt8G_delete, cv_PtrLcv_dnn_BatchNormLayerInt8G_getInnerPtr_const, cv_PtrLcv_dnn_BatchNormLayerInt8G_getInnerPtrMut } @@ -6993,9 +6666,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfBlankLayer = core::Ptr; - ptr_extern! { crate::dnn::BlankLayer, cv_PtrLcv_dnn_BlankLayerG_new_null_const, cv_PtrLcv_dnn_BlankLayerG_delete, cv_PtrLcv_dnn_BlankLayerG_getInnerPtr_const, cv_PtrLcv_dnn_BlankLayerG_getInnerPtrMut } @@ -7046,9 +6716,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCeilLayer = core::Ptr; - ptr_extern! { crate::dnn::CeilLayer, cv_PtrLcv_dnn_CeilLayerG_new_null_const, cv_PtrLcv_dnn_CeilLayerG_delete, cv_PtrLcv_dnn_CeilLayerG_getInnerPtr_const, cv_PtrLcv_dnn_CeilLayerG_getInnerPtrMut } @@ -7109,9 +6776,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCeluLayer = core::Ptr; - ptr_extern! { crate::dnn::CeluLayer, cv_PtrLcv_dnn_CeluLayerG_new_null_const, cv_PtrLcv_dnn_CeluLayerG_delete, cv_PtrLcv_dnn_CeluLayerG_getInnerPtr_const, cv_PtrLcv_dnn_CeluLayerG_getInnerPtrMut } @@ -7173,9 +6837,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfChannelsPReLULayer = core::Ptr; - ptr_extern! { crate::dnn::ChannelsPReLULayer, cv_PtrLcv_dnn_ChannelsPReLULayerG_new_null_const, cv_PtrLcv_dnn_ChannelsPReLULayerG_delete, cv_PtrLcv_dnn_ChannelsPReLULayerG_getInnerPtr_const, cv_PtrLcv_dnn_ChannelsPReLULayerG_getInnerPtrMut } @@ -7236,9 +6897,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCompareLayer = core::Ptr; - ptr_extern! { crate::dnn::CompareLayer, cv_PtrLcv_dnn_CompareLayerG_new_null_const, cv_PtrLcv_dnn_CompareLayerG_delete, cv_PtrLcv_dnn_CompareLayerG_getInnerPtr_const, cv_PtrLcv_dnn_CompareLayerG_getInnerPtrMut } @@ -7289,9 +6947,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfConcatLayer = core::Ptr; - ptr_extern! { crate::dnn::ConcatLayer, cv_PtrLcv_dnn_ConcatLayerG_new_null_const, cv_PtrLcv_dnn_ConcatLayerG_delete, cv_PtrLcv_dnn_ConcatLayerG_getInnerPtr_const, cv_PtrLcv_dnn_ConcatLayerG_getInnerPtrMut } @@ -7345,9 +7000,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfConstLayer = core::Ptr; - ptr_extern! { crate::dnn::ConstLayer, cv_PtrLcv_dnn_ConstLayerG_new_null_const, cv_PtrLcv_dnn_ConstLayerG_delete, cv_PtrLcv_dnn_ConstLayerG_getInnerPtr_const, cv_PtrLcv_dnn_ConstLayerG_getInnerPtrMut } @@ -7398,9 +7050,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfConvolutionLayer = core::Ptr; - ptr_extern! { crate::dnn::ConvolutionLayer, cv_PtrLcv_dnn_ConvolutionLayerG_new_null_const, cv_PtrLcv_dnn_ConvolutionLayerG_delete, cv_PtrLcv_dnn_ConvolutionLayerG_getInnerPtr_const, cv_PtrLcv_dnn_ConvolutionLayerG_getInnerPtrMut } @@ -7477,9 +7126,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfConvolutionLayerInt8 = core::Ptr; - ptr_extern! { crate::dnn::ConvolutionLayerInt8, cv_PtrLcv_dnn_ConvolutionLayerInt8G_new_null_const, cv_PtrLcv_dnn_ConvolutionLayerInt8G_delete, cv_PtrLcv_dnn_ConvolutionLayerInt8G_getInnerPtr_const, cv_PtrLcv_dnn_ConvolutionLayerInt8G_getInnerPtrMut } @@ -7559,9 +7205,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCorrelationLayer = core::Ptr; - ptr_extern! { crate::dnn::CorrelationLayer, cv_PtrLcv_dnn_CorrelationLayerG_new_null_const, cv_PtrLcv_dnn_CorrelationLayerG_delete, cv_PtrLcv_dnn_CorrelationLayerG_getInnerPtr_const, cv_PtrLcv_dnn_CorrelationLayerG_getInnerPtrMut } @@ -7612,9 +7255,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCosLayer = core::Ptr; - ptr_extern! { crate::dnn::CosLayer, cv_PtrLcv_dnn_CosLayerG_new_null_const, cv_PtrLcv_dnn_CosLayerG_delete, cv_PtrLcv_dnn_CosLayerG_getInnerPtr_const, cv_PtrLcv_dnn_CosLayerG_getInnerPtrMut } @@ -7675,9 +7315,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCoshLayer = core::Ptr; - ptr_extern! { crate::dnn::CoshLayer, cv_PtrLcv_dnn_CoshLayerG_new_null_const, cv_PtrLcv_dnn_CoshLayerG_delete, cv_PtrLcv_dnn_CoshLayerG_getInnerPtr_const, cv_PtrLcv_dnn_CoshLayerG_getInnerPtrMut } @@ -7738,9 +7375,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCropAndResizeLayer = core::Ptr; - ptr_extern! { crate::dnn::CropAndResizeLayer, cv_PtrLcv_dnn_CropAndResizeLayerG_new_null_const, cv_PtrLcv_dnn_CropAndResizeLayerG_delete, cv_PtrLcv_dnn_CropAndResizeLayerG_getInnerPtr_const, cv_PtrLcv_dnn_CropAndResizeLayerG_getInnerPtrMut } @@ -7791,9 +7425,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCropLayer = core::Ptr; - ptr_extern! { crate::dnn::CropLayer, cv_PtrLcv_dnn_CropLayerG_new_null_const, cv_PtrLcv_dnn_CropLayerG_delete, cv_PtrLcv_dnn_CropLayerG_getInnerPtr_const, cv_PtrLcv_dnn_CropLayerG_getInnerPtrMut } @@ -7844,9 +7475,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCumSumLayer = core::Ptr; - ptr_extern! { crate::dnn::CumSumLayer, cv_PtrLcv_dnn_CumSumLayerG_new_null_const, cv_PtrLcv_dnn_CumSumLayerG_delete, cv_PtrLcv_dnn_CumSumLayerG_getInnerPtr_const, cv_PtrLcv_dnn_CumSumLayerG_getInnerPtrMut } @@ -7899,9 +7527,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDataAugmentationLayer = core::Ptr; - ptr_extern! { crate::dnn::DataAugmentationLayer, cv_PtrLcv_dnn_DataAugmentationLayerG_new_null_const, cv_PtrLcv_dnn_DataAugmentationLayerG_delete, cv_PtrLcv_dnn_DataAugmentationLayerG_getInnerPtr_const, cv_PtrLcv_dnn_DataAugmentationLayerG_getInnerPtrMut } @@ -7952,9 +7577,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDeconvolutionLayer = core::Ptr; - ptr_extern! { crate::dnn::DeconvolutionLayer, cv_PtrLcv_dnn_DeconvolutionLayerG_new_null_const, cv_PtrLcv_dnn_DeconvolutionLayerG_delete, cv_PtrLcv_dnn_DeconvolutionLayerG_getInnerPtr_const, cv_PtrLcv_dnn_DeconvolutionLayerG_getInnerPtrMut } @@ -8028,9 +7650,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDepthToSpaceLayer = core::Ptr; - ptr_extern! { crate::dnn::DepthToSpaceLayer, cv_PtrLcv_dnn_DepthToSpaceLayerG_new_null_const, cv_PtrLcv_dnn_DepthToSpaceLayerG_delete, cv_PtrLcv_dnn_DepthToSpaceLayerG_getInnerPtr_const, cv_PtrLcv_dnn_DepthToSpaceLayerG_getInnerPtrMut } @@ -8081,9 +7700,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDequantizeLayer = core::Ptr; - ptr_extern! { crate::dnn::DequantizeLayer, cv_PtrLcv_dnn_DequantizeLayerG_new_null_const, cv_PtrLcv_dnn_DequantizeLayerG_delete, cv_PtrLcv_dnn_DequantizeLayerG_getInnerPtr_const, cv_PtrLcv_dnn_DequantizeLayerG_getInnerPtrMut } @@ -8136,9 +7752,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDetectionOutputLayer = core::Ptr; - ptr_extern! { crate::dnn::DetectionOutputLayer, cv_PtrLcv_dnn_DetectionOutputLayerG_new_null_const, cv_PtrLcv_dnn_DetectionOutputLayerG_delete, cv_PtrLcv_dnn_DetectionOutputLayerG_getInnerPtr_const, cv_PtrLcv_dnn_DetectionOutputLayerG_getInnerPtrMut } @@ -8189,9 +7802,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfELULayer = core::Ptr; - ptr_extern! { crate::dnn::ELULayer, cv_PtrLcv_dnn_ELULayerG_new_null_const, cv_PtrLcv_dnn_ELULayerG_delete, cv_PtrLcv_dnn_ELULayerG_getInnerPtr_const, cv_PtrLcv_dnn_ELULayerG_getInnerPtrMut } @@ -8253,9 +7863,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfEinsumLayer = core::Ptr; - ptr_extern! { crate::dnn::EinsumLayer, cv_PtrLcv_dnn_EinsumLayerG_new_null_const, cv_PtrLcv_dnn_EinsumLayerG_delete, cv_PtrLcv_dnn_EinsumLayerG_getInnerPtr_const, cv_PtrLcv_dnn_EinsumLayerG_getInnerPtrMut } @@ -8306,9 +7913,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfEltwiseLayer = core::Ptr; - ptr_extern! { crate::dnn::EltwiseLayer, cv_PtrLcv_dnn_EltwiseLayerG_new_null_const, cv_PtrLcv_dnn_EltwiseLayerG_delete, cv_PtrLcv_dnn_EltwiseLayerG_getInnerPtr_const, cv_PtrLcv_dnn_EltwiseLayerG_getInnerPtrMut } @@ -8359,9 +7963,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfEltwiseLayerInt8 = core::Ptr; - ptr_extern! { crate::dnn::EltwiseLayerInt8, cv_PtrLcv_dnn_EltwiseLayerInt8G_new_null_const, cv_PtrLcv_dnn_EltwiseLayerInt8G_delete, cv_PtrLcv_dnn_EltwiseLayerInt8G_getInnerPtr_const, cv_PtrLcv_dnn_EltwiseLayerInt8G_getInnerPtrMut } @@ -8412,9 +8013,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfErfLayer = core::Ptr; - ptr_extern! { crate::dnn::ErfLayer, cv_PtrLcv_dnn_ErfLayerG_new_null_const, cv_PtrLcv_dnn_ErfLayerG_delete, cv_PtrLcv_dnn_ErfLayerG_getInnerPtr_const, cv_PtrLcv_dnn_ErfLayerG_getInnerPtrMut } @@ -8475,9 +8073,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfExpLayer = core::Ptr; - ptr_extern! { crate::dnn::ExpLayer, cv_PtrLcv_dnn_ExpLayerG_new_null_const, cv_PtrLcv_dnn_ExpLayerG_delete, cv_PtrLcv_dnn_ExpLayerG_getInnerPtr_const, cv_PtrLcv_dnn_ExpLayerG_getInnerPtrMut } @@ -8541,9 +8136,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfExpandLayer = core::Ptr; - ptr_extern! { crate::dnn::ExpandLayer, cv_PtrLcv_dnn_ExpandLayerG_new_null_const, cv_PtrLcv_dnn_ExpandLayerG_delete, cv_PtrLcv_dnn_ExpandLayerG_getInnerPtr_const, cv_PtrLcv_dnn_ExpandLayerG_getInnerPtrMut } @@ -8594,9 +8186,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfFlattenLayer = core::Ptr; - ptr_extern! { crate::dnn::FlattenLayer, cv_PtrLcv_dnn_FlattenLayerG_new_null_const, cv_PtrLcv_dnn_FlattenLayerG_delete, cv_PtrLcv_dnn_FlattenLayerG_getInnerPtr_const, cv_PtrLcv_dnn_FlattenLayerG_getInnerPtrMut } @@ -8647,9 +8236,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfFloorLayer = core::Ptr; - ptr_extern! { crate::dnn::FloorLayer, cv_PtrLcv_dnn_FloorLayerG_new_null_const, cv_PtrLcv_dnn_FloorLayerG_delete, cv_PtrLcv_dnn_FloorLayerG_getInnerPtr_const, cv_PtrLcv_dnn_FloorLayerG_getInnerPtrMut } @@ -8710,9 +8296,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfFlowWarpLayer = core::Ptr; - ptr_extern! { crate::dnn::FlowWarpLayer, cv_PtrLcv_dnn_FlowWarpLayerG_new_null_const, cv_PtrLcv_dnn_FlowWarpLayerG_delete, cv_PtrLcv_dnn_FlowWarpLayerG_getInnerPtr_const, cv_PtrLcv_dnn_FlowWarpLayerG_getInnerPtrMut } @@ -8763,9 +8346,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfGRULayer = core::Ptr; - ptr_extern! { crate::dnn::GRULayer, cv_PtrLcv_dnn_GRULayerG_new_null_const, cv_PtrLcv_dnn_GRULayerG_delete, cv_PtrLcv_dnn_GRULayerG_getInnerPtr_const, cv_PtrLcv_dnn_GRULayerG_getInnerPtrMut } @@ -8816,9 +8396,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfGatherElementsLayer = core::Ptr; - ptr_extern! { crate::dnn::GatherElementsLayer, cv_PtrLcv_dnn_GatherElementsLayerG_new_null_const, cv_PtrLcv_dnn_GatherElementsLayerG_delete, cv_PtrLcv_dnn_GatherElementsLayerG_getInnerPtr_const, cv_PtrLcv_dnn_GatherElementsLayerG_getInnerPtrMut } @@ -8869,9 +8446,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfGatherLayer = core::Ptr; - ptr_extern! { crate::dnn::GatherLayer, cv_PtrLcv_dnn_GatherLayerG_new_null_const, cv_PtrLcv_dnn_GatherLayerG_delete, cv_PtrLcv_dnn_GatherLayerG_getInnerPtr_const, cv_PtrLcv_dnn_GatherLayerG_getInnerPtrMut } @@ -8922,9 +8496,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfGeluApproximationLayer = core::Ptr; - ptr_extern! { crate::dnn::GeluApproximationLayer, cv_PtrLcv_dnn_GeluApproximationLayerG_new_null_const, cv_PtrLcv_dnn_GeluApproximationLayerG_delete, cv_PtrLcv_dnn_GeluApproximationLayerG_getInnerPtr_const, cv_PtrLcv_dnn_GeluApproximationLayerG_getInnerPtrMut } @@ -8985,9 +8556,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfGeluLayer = core::Ptr; - ptr_extern! { crate::dnn::GeluLayer, cv_PtrLcv_dnn_GeluLayerG_new_null_const, cv_PtrLcv_dnn_GeluLayerG_delete, cv_PtrLcv_dnn_GeluLayerG_getInnerPtr_const, cv_PtrLcv_dnn_GeluLayerG_getInnerPtrMut } @@ -9048,9 +8616,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfGemmLayer = core::Ptr; - ptr_extern! { crate::dnn::GemmLayer, cv_PtrLcv_dnn_GemmLayerG_new_null_const, cv_PtrLcv_dnn_GemmLayerG_delete, cv_PtrLcv_dnn_GemmLayerG_getInnerPtr_const, cv_PtrLcv_dnn_GemmLayerG_getInnerPtrMut } @@ -9105,9 +8670,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfGroupNormLayer = core::Ptr; - ptr_extern! { crate::dnn::GroupNormLayer, cv_PtrLcv_dnn_GroupNormLayerG_new_null_const, cv_PtrLcv_dnn_GroupNormLayerG_delete, cv_PtrLcv_dnn_GroupNormLayerG_getInnerPtr_const, cv_PtrLcv_dnn_GroupNormLayerG_getInnerPtrMut } @@ -9158,9 +8720,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfHardSigmoidLayer = core::Ptr; - ptr_extern! { crate::dnn::HardSigmoidLayer, cv_PtrLcv_dnn_HardSigmoidLayerG_new_null_const, cv_PtrLcv_dnn_HardSigmoidLayerG_delete, cv_PtrLcv_dnn_HardSigmoidLayerG_getInnerPtr_const, cv_PtrLcv_dnn_HardSigmoidLayerG_getInnerPtrMut } @@ -9223,9 +8782,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfHardSwishLayer = core::Ptr; - ptr_extern! { crate::dnn::HardSwishLayer, cv_PtrLcv_dnn_HardSwishLayerG_new_null_const, cv_PtrLcv_dnn_HardSwishLayerG_delete, cv_PtrLcv_dnn_HardSwishLayerG_getInnerPtr_const, cv_PtrLcv_dnn_HardSwishLayerG_getInnerPtrMut } @@ -9286,9 +8842,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfInnerProductLayer = core::Ptr; - ptr_extern! { crate::dnn::InnerProductLayer, cv_PtrLcv_dnn_InnerProductLayerG_new_null_const, cv_PtrLcv_dnn_InnerProductLayerG_delete, cv_PtrLcv_dnn_InnerProductLayerG_getInnerPtr_const, cv_PtrLcv_dnn_InnerProductLayerG_getInnerPtrMut } @@ -9340,9 +8893,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfInnerProductLayerInt8 = core::Ptr; - ptr_extern! { crate::dnn::InnerProductLayerInt8, cv_PtrLcv_dnn_InnerProductLayerInt8G_new_null_const, cv_PtrLcv_dnn_InnerProductLayerInt8G_delete, cv_PtrLcv_dnn_InnerProductLayerInt8G_getInnerPtr_const, cv_PtrLcv_dnn_InnerProductLayerInt8G_getInnerPtrMut } @@ -9409,9 +8959,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfInstanceNormLayer = core::Ptr; - ptr_extern! { crate::dnn::InstanceNormLayer, cv_PtrLcv_dnn_InstanceNormLayerG_new_null_const, cv_PtrLcv_dnn_InstanceNormLayerG_delete, cv_PtrLcv_dnn_InstanceNormLayerG_getInnerPtr_const, cv_PtrLcv_dnn_InstanceNormLayerG_getInnerPtrMut } @@ -9463,9 +9010,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfInterpLayer = core::Ptr; - ptr_extern! { crate::dnn::InterpLayer, cv_PtrLcv_dnn_InterpLayerG_new_null_const, cv_PtrLcv_dnn_InterpLayerG_delete, cv_PtrLcv_dnn_InterpLayerG_getInnerPtr_const, cv_PtrLcv_dnn_InterpLayerG_getInnerPtrMut } @@ -9516,9 +9060,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfLRNLayer = core::Ptr; - ptr_extern! { crate::dnn::LRNLayer, cv_PtrLcv_dnn_LRNLayerG_new_null_const, cv_PtrLcv_dnn_LRNLayerG_delete, cv_PtrLcv_dnn_LRNLayerG_getInnerPtr_const, cv_PtrLcv_dnn_LRNLayerG_getInnerPtrMut } @@ -9575,9 +9116,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfLSTMLayer = core::Ptr; - ptr_extern! { crate::dnn::LSTMLayer, cv_PtrLcv_dnn_LSTMLayerG_new_null_const, cv_PtrLcv_dnn_LSTMLayerG_delete, cv_PtrLcv_dnn_LSTMLayerG_getInnerPtr_const, cv_PtrLcv_dnn_LSTMLayerG_getInnerPtrMut } @@ -9627,9 +9165,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfLayer = core::Ptr; - ptr_extern! { crate::dnn::Layer, cv_PtrLcv_dnn_LayerG_new_null_const, cv_PtrLcv_dnn_LayerG_delete, cv_PtrLcv_dnn_LayerG_getInnerPtr_const, cv_PtrLcv_dnn_LayerG_getInnerPtrMut } @@ -9670,9 +9205,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfLayerNormLayer = core::Ptr; - ptr_extern! { crate::dnn::LayerNormLayer, cv_PtrLcv_dnn_LayerNormLayerG_new_null_const, cv_PtrLcv_dnn_LayerNormLayerG_delete, cv_PtrLcv_dnn_LayerNormLayerG_getInnerPtr_const, cv_PtrLcv_dnn_LayerNormLayerG_getInnerPtrMut } @@ -9726,9 +9258,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfLogLayer = core::Ptr; - ptr_extern! { crate::dnn::LogLayer, cv_PtrLcv_dnn_LogLayerG_new_null_const, cv_PtrLcv_dnn_LogLayerG_delete, cv_PtrLcv_dnn_LogLayerG_getInnerPtr_const, cv_PtrLcv_dnn_LogLayerG_getInnerPtrMut } @@ -9789,9 +9318,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfMVNLayer = core::Ptr; - ptr_extern! { crate::dnn::MVNLayer, cv_PtrLcv_dnn_MVNLayerG_new_null_const, cv_PtrLcv_dnn_MVNLayerG_delete, cv_PtrLcv_dnn_MVNLayerG_getInnerPtr_const, cv_PtrLcv_dnn_MVNLayerG_getInnerPtrMut } @@ -9845,9 +9371,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfMatMulLayer = core::Ptr; - ptr_extern! { crate::dnn::MatMulLayer, cv_PtrLcv_dnn_MatMulLayerG_new_null_const, cv_PtrLcv_dnn_MatMulLayerG_delete, cv_PtrLcv_dnn_MatMulLayerG_getInnerPtr_const, cv_PtrLcv_dnn_MatMulLayerG_getInnerPtrMut } @@ -9898,9 +9421,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfMaxUnpoolLayer = core::Ptr; - ptr_extern! { crate::dnn::MaxUnpoolLayer, cv_PtrLcv_dnn_MaxUnpoolLayerG_new_null_const, cv_PtrLcv_dnn_MaxUnpoolLayerG_delete, cv_PtrLcv_dnn_MaxUnpoolLayerG_getInnerPtr_const, cv_PtrLcv_dnn_MaxUnpoolLayerG_getInnerPtrMut } @@ -9954,9 +9474,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfMishLayer = core::Ptr; - ptr_extern! { crate::dnn::MishLayer, cv_PtrLcv_dnn_MishLayerG_new_null_const, cv_PtrLcv_dnn_MishLayerG_delete, cv_PtrLcv_dnn_MishLayerG_getInnerPtr_const, cv_PtrLcv_dnn_MishLayerG_getInnerPtrMut } @@ -10017,9 +9534,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfNaryEltwiseLayer = core::Ptr; - ptr_extern! { crate::dnn::NaryEltwiseLayer, cv_PtrLcv_dnn_NaryEltwiseLayerG_new_null_const, cv_PtrLcv_dnn_NaryEltwiseLayerG_delete, cv_PtrLcv_dnn_NaryEltwiseLayerG_getInnerPtr_const, cv_PtrLcv_dnn_NaryEltwiseLayerG_getInnerPtrMut } @@ -10070,9 +9584,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfNormalizeBBoxLayer = core::Ptr; - ptr_extern! { crate::dnn::NormalizeBBoxLayer, cv_PtrLcv_dnn_NormalizeBBoxLayerG_new_null_const, cv_PtrLcv_dnn_NormalizeBBoxLayerG_delete, cv_PtrLcv_dnn_NormalizeBBoxLayerG_getInnerPtr_const, cv_PtrLcv_dnn_NormalizeBBoxLayerG_getInnerPtrMut } @@ -10126,9 +9637,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfNotLayer = core::Ptr; - ptr_extern! { crate::dnn::NotLayer, cv_PtrLcv_dnn_NotLayerG_new_null_const, cv_PtrLcv_dnn_NotLayerG_delete, cv_PtrLcv_dnn_NotLayerG_getInnerPtr_const, cv_PtrLcv_dnn_NotLayerG_getInnerPtrMut } @@ -10189,9 +9697,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfPaddingLayer = core::Ptr; - ptr_extern! { crate::dnn::PaddingLayer, cv_PtrLcv_dnn_PaddingLayerG_new_null_const, cv_PtrLcv_dnn_PaddingLayerG_delete, cv_PtrLcv_dnn_PaddingLayerG_getInnerPtr_const, cv_PtrLcv_dnn_PaddingLayerG_getInnerPtrMut } @@ -10242,9 +9747,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfPermuteLayer = core::Ptr; - ptr_extern! { crate::dnn::PermuteLayer, cv_PtrLcv_dnn_PermuteLayerG_new_null_const, cv_PtrLcv_dnn_PermuteLayerG_delete, cv_PtrLcv_dnn_PermuteLayerG_getInnerPtr_const, cv_PtrLcv_dnn_PermuteLayerG_getInnerPtrMut } @@ -10295,9 +9797,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfPoolingLayer = core::Ptr; - ptr_extern! { crate::dnn::PoolingLayer, cv_PtrLcv_dnn_PoolingLayerG_new_null_const, cv_PtrLcv_dnn_PoolingLayerG_delete, cv_PtrLcv_dnn_PoolingLayerG_getInnerPtr_const, cv_PtrLcv_dnn_PoolingLayerG_getInnerPtrMut } @@ -10362,9 +9861,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfPoolingLayerInt8 = core::Ptr; - ptr_extern! { crate::dnn::PoolingLayerInt8, cv_PtrLcv_dnn_PoolingLayerInt8G_new_null_const, cv_PtrLcv_dnn_PoolingLayerInt8G_delete, cv_PtrLcv_dnn_PoolingLayerInt8G_getInnerPtr_const, cv_PtrLcv_dnn_PoolingLayerInt8G_getInnerPtrMut } @@ -10443,9 +9939,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfPowerLayer = core::Ptr; - ptr_extern! { crate::dnn::PowerLayer, cv_PtrLcv_dnn_PowerLayerG_new_null_const, cv_PtrLcv_dnn_PowerLayerG_delete, cv_PtrLcv_dnn_PowerLayerG_getInnerPtr_const, cv_PtrLcv_dnn_PowerLayerG_getInnerPtrMut } @@ -10509,9 +10002,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfPriorBoxLayer = core::Ptr; - ptr_extern! { crate::dnn::PriorBoxLayer, cv_PtrLcv_dnn_PriorBoxLayerG_new_null_const, cv_PtrLcv_dnn_PriorBoxLayerG_delete, cv_PtrLcv_dnn_PriorBoxLayerG_getInnerPtr_const, cv_PtrLcv_dnn_PriorBoxLayerG_getInnerPtrMut } @@ -10562,9 +10052,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfProposalLayer = core::Ptr; - ptr_extern! { crate::dnn::ProposalLayer, cv_PtrLcv_dnn_ProposalLayerG_new_null_const, cv_PtrLcv_dnn_ProposalLayerG_delete, cv_PtrLcv_dnn_ProposalLayerG_getInnerPtr_const, cv_PtrLcv_dnn_ProposalLayerG_getInnerPtrMut } @@ -10615,9 +10102,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfQuantizeLayer = core::Ptr; - ptr_extern! { crate::dnn::QuantizeLayer, cv_PtrLcv_dnn_QuantizeLayerG_new_null_const, cv_PtrLcv_dnn_QuantizeLayerG_delete, cv_PtrLcv_dnn_QuantizeLayerG_getInnerPtr_const, cv_PtrLcv_dnn_QuantizeLayerG_getInnerPtrMut } @@ -10670,9 +10154,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfRNNLayer = core::Ptr; - ptr_extern! { crate::dnn::RNNLayer, cv_PtrLcv_dnn_RNNLayerG_new_null_const, cv_PtrLcv_dnn_RNNLayerG_delete, cv_PtrLcv_dnn_RNNLayerG_getInnerPtr_const, cv_PtrLcv_dnn_RNNLayerG_getInnerPtrMut } @@ -10722,9 +10203,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfReLU6Layer = core::Ptr; - ptr_extern! { crate::dnn::ReLU6Layer, cv_PtrLcv_dnn_ReLU6LayerG_new_null_const, cv_PtrLcv_dnn_ReLU6LayerG_delete, cv_PtrLcv_dnn_ReLU6LayerG_getInnerPtr_const, cv_PtrLcv_dnn_ReLU6LayerG_getInnerPtrMut } @@ -10787,9 +10265,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfReLULayer = core::Ptr; - ptr_extern! { crate::dnn::ReLULayer, cv_PtrLcv_dnn_ReLULayerG_new_null_const, cv_PtrLcv_dnn_ReLULayerG_delete, cv_PtrLcv_dnn_ReLULayerG_getInnerPtr_const, cv_PtrLcv_dnn_ReLULayerG_getInnerPtrMut } @@ -10851,9 +10326,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfReciprocalLayer = core::Ptr; - ptr_extern! { crate::dnn::ReciprocalLayer, cv_PtrLcv_dnn_ReciprocalLayerG_new_null_const, cv_PtrLcv_dnn_ReciprocalLayerG_delete, cv_PtrLcv_dnn_ReciprocalLayerG_getInnerPtr_const, cv_PtrLcv_dnn_ReciprocalLayerG_getInnerPtrMut } @@ -10914,9 +10386,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfReduceLayer = core::Ptr; - ptr_extern! { crate::dnn::ReduceLayer, cv_PtrLcv_dnn_ReduceLayerG_new_null_const, cv_PtrLcv_dnn_ReduceLayerG_delete, cv_PtrLcv_dnn_ReduceLayerG_getInnerPtr_const, cv_PtrLcv_dnn_ReduceLayerG_getInnerPtrMut } @@ -10967,9 +10436,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfRegionLayer = core::Ptr; - ptr_extern! { crate::dnn::RegionLayer, cv_PtrLcv_dnn_RegionLayerG_new_null_const, cv_PtrLcv_dnn_RegionLayerG_delete, cv_PtrLcv_dnn_RegionLayerG_getInnerPtr_const, cv_PtrLcv_dnn_RegionLayerG_getInnerPtrMut } @@ -11021,9 +10487,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfReorgLayer = core::Ptr; - ptr_extern! { crate::dnn::ReorgLayer, cv_PtrLcv_dnn_ReorgLayerG_new_null_const, cv_PtrLcv_dnn_ReorgLayerG_delete, cv_PtrLcv_dnn_ReorgLayerG_getInnerPtr_const, cv_PtrLcv_dnn_ReorgLayerG_getInnerPtrMut } @@ -11074,9 +10537,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfRequantizeLayer = core::Ptr; - ptr_extern! { crate::dnn::RequantizeLayer, cv_PtrLcv_dnn_RequantizeLayerG_new_null_const, cv_PtrLcv_dnn_RequantizeLayerG_delete, cv_PtrLcv_dnn_RequantizeLayerG_getInnerPtr_const, cv_PtrLcv_dnn_RequantizeLayerG_getInnerPtrMut } @@ -11129,9 +10589,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfReshapeLayer = core::Ptr; - ptr_extern! { crate::dnn::ReshapeLayer, cv_PtrLcv_dnn_ReshapeLayerG_new_null_const, cv_PtrLcv_dnn_ReshapeLayerG_delete, cv_PtrLcv_dnn_ReshapeLayerG_getInnerPtr_const, cv_PtrLcv_dnn_ReshapeLayerG_getInnerPtrMut } @@ -11184,9 +10641,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfResizeLayer = core::Ptr; - ptr_extern! { crate::dnn::ResizeLayer, cv_PtrLcv_dnn_ResizeLayerG_new_null_const, cv_PtrLcv_dnn_ResizeLayerG_delete, cv_PtrLcv_dnn_ResizeLayerG_getInnerPtr_const, cv_PtrLcv_dnn_ResizeLayerG_getInnerPtrMut } @@ -11237,9 +10691,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfRoundLayer = core::Ptr; - ptr_extern! { crate::dnn::RoundLayer, cv_PtrLcv_dnn_RoundLayerG_new_null_const, cv_PtrLcv_dnn_RoundLayerG_delete, cv_PtrLcv_dnn_RoundLayerG_getInnerPtr_const, cv_PtrLcv_dnn_RoundLayerG_getInnerPtrMut } @@ -11300,9 +10751,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfScaleLayer = core::Ptr; - ptr_extern! { crate::dnn::ScaleLayer, cv_PtrLcv_dnn_ScaleLayerG_new_null_const, cv_PtrLcv_dnn_ScaleLayerG_delete, cv_PtrLcv_dnn_ScaleLayerG_getInnerPtr_const, cv_PtrLcv_dnn_ScaleLayerG_getInnerPtrMut } @@ -11356,9 +10804,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfScaleLayerInt8 = core::Ptr; - ptr_extern! { crate::dnn::ScaleLayerInt8, cv_PtrLcv_dnn_ScaleLayerInt8G_new_null_const, cv_PtrLcv_dnn_ScaleLayerInt8G_delete, cv_PtrLcv_dnn_ScaleLayerInt8G_getInnerPtr_const, cv_PtrLcv_dnn_ScaleLayerInt8G_getInnerPtrMut } @@ -11424,9 +10869,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfScatterLayer = core::Ptr; - ptr_extern! { crate::dnn::ScatterLayer, cv_PtrLcv_dnn_ScatterLayerG_new_null_const, cv_PtrLcv_dnn_ScatterLayerG_delete, cv_PtrLcv_dnn_ScatterLayerG_getInnerPtr_const, cv_PtrLcv_dnn_ScatterLayerG_getInnerPtrMut } @@ -11477,9 +10919,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfScatterNDLayer = core::Ptr; - ptr_extern! { crate::dnn::ScatterNDLayer, cv_PtrLcv_dnn_ScatterNDLayerG_new_null_const, cv_PtrLcv_dnn_ScatterNDLayerG_delete, cv_PtrLcv_dnn_ScatterNDLayerG_getInnerPtr_const, cv_PtrLcv_dnn_ScatterNDLayerG_getInnerPtrMut } @@ -11530,9 +10969,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfSeluLayer = core::Ptr; - ptr_extern! { crate::dnn::SeluLayer, cv_PtrLcv_dnn_SeluLayerG_new_null_const, cv_PtrLcv_dnn_SeluLayerG_delete, cv_PtrLcv_dnn_SeluLayerG_getInnerPtr_const, cv_PtrLcv_dnn_SeluLayerG_getInnerPtrMut } @@ -11595,9 +11031,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfShiftLayer = core::Ptr; - ptr_extern! { crate::dnn::ShiftLayer, cv_PtrLcv_dnn_ShiftLayerG_new_null_const, cv_PtrLcv_dnn_ShiftLayerG_delete, cv_PtrLcv_dnn_ShiftLayerG_getInnerPtr_const, cv_PtrLcv_dnn_ShiftLayerG_getInnerPtrMut } @@ -11648,9 +11081,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfShiftLayerInt8 = core::Ptr; - ptr_extern! { crate::dnn::ShiftLayerInt8, cv_PtrLcv_dnn_ShiftLayerInt8G_new_null_const, cv_PtrLcv_dnn_ShiftLayerInt8G_delete, cv_PtrLcv_dnn_ShiftLayerInt8G_getInnerPtr_const, cv_PtrLcv_dnn_ShiftLayerInt8G_getInnerPtrMut } @@ -11701,9 +11131,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfShrinkLayer = core::Ptr; - ptr_extern! { crate::dnn::ShrinkLayer, cv_PtrLcv_dnn_ShrinkLayerG_new_null_const, cv_PtrLcv_dnn_ShrinkLayerG_delete, cv_PtrLcv_dnn_ShrinkLayerG_getInnerPtr_const, cv_PtrLcv_dnn_ShrinkLayerG_getInnerPtrMut } @@ -11766,9 +11193,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfShuffleChannelLayer = core::Ptr; - ptr_extern! { crate::dnn::ShuffleChannelLayer, cv_PtrLcv_dnn_ShuffleChannelLayerG_new_null_const, cv_PtrLcv_dnn_ShuffleChannelLayerG_delete, cv_PtrLcv_dnn_ShuffleChannelLayerG_getInnerPtr_const, cv_PtrLcv_dnn_ShuffleChannelLayerG_getInnerPtrMut } @@ -11820,9 +11244,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfSigmoidLayer = core::Ptr; - ptr_extern! { crate::dnn::SigmoidLayer, cv_PtrLcv_dnn_SigmoidLayerG_new_null_const, cv_PtrLcv_dnn_SigmoidLayerG_delete, cv_PtrLcv_dnn_SigmoidLayerG_getInnerPtr_const, cv_PtrLcv_dnn_SigmoidLayerG_getInnerPtrMut } @@ -11883,9 +11304,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfSignLayer = core::Ptr; - ptr_extern! { crate::dnn::SignLayer, cv_PtrLcv_dnn_SignLayerG_new_null_const, cv_PtrLcv_dnn_SignLayerG_delete, cv_PtrLcv_dnn_SignLayerG_getInnerPtr_const, cv_PtrLcv_dnn_SignLayerG_getInnerPtrMut } @@ -11946,9 +11364,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfSinLayer = core::Ptr; - ptr_extern! { crate::dnn::SinLayer, cv_PtrLcv_dnn_SinLayerG_new_null_const, cv_PtrLcv_dnn_SinLayerG_delete, cv_PtrLcv_dnn_SinLayerG_getInnerPtr_const, cv_PtrLcv_dnn_SinLayerG_getInnerPtrMut } @@ -12009,9 +11424,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfSinhLayer = core::Ptr; - ptr_extern! { crate::dnn::SinhLayer, cv_PtrLcv_dnn_SinhLayerG_new_null_const, cv_PtrLcv_dnn_SinhLayerG_delete, cv_PtrLcv_dnn_SinhLayerG_getInnerPtr_const, cv_PtrLcv_dnn_SinhLayerG_getInnerPtrMut } @@ -12072,9 +11484,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfSliceLayer = core::Ptr; - ptr_extern! { crate::dnn::SliceLayer, cv_PtrLcv_dnn_SliceLayerG_new_null_const, cv_PtrLcv_dnn_SliceLayerG_delete, cv_PtrLcv_dnn_SliceLayerG_getInnerPtr_const, cv_PtrLcv_dnn_SliceLayerG_getInnerPtrMut } @@ -12129,9 +11538,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfSoftmaxLayer = core::Ptr; - ptr_extern! { crate::dnn::SoftmaxLayer, cv_PtrLcv_dnn_SoftmaxLayerG_new_null_const, cv_PtrLcv_dnn_SoftmaxLayerG_delete, cv_PtrLcv_dnn_SoftmaxLayerG_getInnerPtr_const, cv_PtrLcv_dnn_SoftmaxLayerG_getInnerPtrMut } @@ -12183,9 +11589,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfSoftmaxLayerInt8 = core::Ptr; - ptr_extern! { crate::dnn::SoftmaxLayerInt8, cv_PtrLcv_dnn_SoftmaxLayerInt8G_new_null_const, cv_PtrLcv_dnn_SoftmaxLayerInt8G_delete, cv_PtrLcv_dnn_SoftmaxLayerInt8G_getInnerPtr_const, cv_PtrLcv_dnn_SoftmaxLayerInt8G_getInnerPtrMut } @@ -12249,9 +11652,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfSoftplusLayer = core::Ptr; - ptr_extern! { crate::dnn::SoftplusLayer, cv_PtrLcv_dnn_SoftplusLayerG_new_null_const, cv_PtrLcv_dnn_SoftplusLayerG_delete, cv_PtrLcv_dnn_SoftplusLayerG_getInnerPtr_const, cv_PtrLcv_dnn_SoftplusLayerG_getInnerPtrMut } @@ -12312,9 +11712,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfSoftsignLayer = core::Ptr; - ptr_extern! { crate::dnn::SoftsignLayer, cv_PtrLcv_dnn_SoftsignLayerG_new_null_const, cv_PtrLcv_dnn_SoftsignLayerG_delete, cv_PtrLcv_dnn_SoftsignLayerG_getInnerPtr_const, cv_PtrLcv_dnn_SoftsignLayerG_getInnerPtrMut } @@ -12375,9 +11772,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfSpaceToDepthLayer = core::Ptr; - ptr_extern! { crate::dnn::SpaceToDepthLayer, cv_PtrLcv_dnn_SpaceToDepthLayerG_new_null_const, cv_PtrLcv_dnn_SpaceToDepthLayerG_delete, cv_PtrLcv_dnn_SpaceToDepthLayerG_getInnerPtr_const, cv_PtrLcv_dnn_SpaceToDepthLayerG_getInnerPtrMut } @@ -12428,9 +11822,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfSplitLayer = core::Ptr; - ptr_extern! { crate::dnn::SplitLayer, cv_PtrLcv_dnn_SplitLayerG_new_null_const, cv_PtrLcv_dnn_SplitLayerG_delete, cv_PtrLcv_dnn_SplitLayerG_getInnerPtr_const, cv_PtrLcv_dnn_SplitLayerG_getInnerPtrMut } @@ -12482,9 +11873,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfSqrtLayer = core::Ptr; - ptr_extern! { crate::dnn::SqrtLayer, cv_PtrLcv_dnn_SqrtLayerG_new_null_const, cv_PtrLcv_dnn_SqrtLayerG_delete, cv_PtrLcv_dnn_SqrtLayerG_getInnerPtr_const, cv_PtrLcv_dnn_SqrtLayerG_getInnerPtrMut } @@ -12545,9 +11933,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfSwishLayer = core::Ptr; - ptr_extern! { crate::dnn::SwishLayer, cv_PtrLcv_dnn_SwishLayerG_new_null_const, cv_PtrLcv_dnn_SwishLayerG_delete, cv_PtrLcv_dnn_SwishLayerG_getInnerPtr_const, cv_PtrLcv_dnn_SwishLayerG_getInnerPtrMut } @@ -12608,9 +11993,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfTanHLayer = core::Ptr; - ptr_extern! { crate::dnn::TanHLayer, cv_PtrLcv_dnn_TanHLayerG_new_null_const, cv_PtrLcv_dnn_TanHLayerG_delete, cv_PtrLcv_dnn_TanHLayerG_getInnerPtr_const, cv_PtrLcv_dnn_TanHLayerG_getInnerPtrMut } @@ -12671,9 +12053,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfTanLayer = core::Ptr; - ptr_extern! { crate::dnn::TanLayer, cv_PtrLcv_dnn_TanLayerG_new_null_const, cv_PtrLcv_dnn_TanLayerG_delete, cv_PtrLcv_dnn_TanLayerG_getInnerPtr_const, cv_PtrLcv_dnn_TanLayerG_getInnerPtrMut } @@ -12734,9 +12113,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfThresholdedReluLayer = core::Ptr; - ptr_extern! { crate::dnn::ThresholdedReluLayer, cv_PtrLcv_dnn_ThresholdedReluLayerG_new_null_const, cv_PtrLcv_dnn_ThresholdedReluLayerG_delete, cv_PtrLcv_dnn_ThresholdedReluLayerG_getInnerPtr_const, cv_PtrLcv_dnn_ThresholdedReluLayerG_getInnerPtrMut } @@ -12798,9 +12174,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfTileLayer = core::Ptr; - ptr_extern! { crate::dnn::TileLayer, cv_PtrLcv_dnn_TileLayerG_new_null_const, cv_PtrLcv_dnn_TileLayerG_delete, cv_PtrLcv_dnn_TileLayerG_getInnerPtr_const, cv_PtrLcv_dnn_TileLayerG_getInnerPtrMut } @@ -12851,9 +12224,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfTopKLayer = core::Ptr; - ptr_extern! { crate::dnn::TopKLayer, cv_PtrLcv_dnn_TopKLayerG_new_null_const, cv_PtrLcv_dnn_TopKLayerG_delete, cv_PtrLcv_dnn_TopKLayerG_getInnerPtr_const, cv_PtrLcv_dnn_TopKLayerG_getInnerPtrMut } @@ -12904,9 +12274,6 @@ mod dnn_types { } } - #[deprecated = "Use the the non-alias form `core::Tuple<(crate::dnn::Backend, crate::dnn::Target)>` instead, removal in Nov 2024"] - pub type TupleOfBackend_Target = core::Tuple<(crate::dnn::Backend, crate::dnn::Target)>; - impl core::Tuple<(crate::dnn::Backend, crate::dnn::Target)> { pub fn as_raw_TupleOfBackend_Target(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_TupleOfBackend_Target(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -12918,17 +12285,11 @@ mod dnn_types { 1 = arg_1: crate::dnn::Target, get_1 via std_pairLcv_dnn_Backend__cv_dnn_TargetG_get_1_const } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfMatShape = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfMatShape(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfMatShape(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } } - #[deprecated = "Use the the non-alias form `core::Vector>` instead, removal in Nov 2024"] - pub type VectorOfPtrOfBackendNode = core::Vector>; - impl core::Vector> { pub fn as_raw_VectorOfPtrOfBackendNode(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfPtrOfBackendNode(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -12947,9 +12308,6 @@ mod dnn_types { vector_non_copy_or_bool! { core::Ptr } - #[deprecated = "Use the the non-alias form `core::Vector>` instead, removal in Nov 2024"] - pub type VectorOfPtrOfBackendWrapper = core::Vector>; - impl core::Vector> { pub fn as_raw_VectorOfPtrOfBackendWrapper(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfPtrOfBackendWrapper(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -12968,9 +12326,6 @@ mod dnn_types { vector_non_copy_or_bool! { core::Ptr } - #[deprecated = "Use the the non-alias form `core::Vector>` instead, removal in Nov 2024"] - pub type VectorOfPtrOfLayer = core::Vector>; - impl core::Vector> { pub fn as_raw_VectorOfPtrOfLayer(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfPtrOfLayer(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -12989,9 +12344,6 @@ mod dnn_types { vector_non_copy_or_bool! { core::Ptr } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfTarget = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfTarget(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfTarget(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -13013,9 +12365,6 @@ mod dnn_types { } - #[deprecated = "Use the the non-alias form `core::Vector>` instead, removal in Nov 2024"] - pub type VectorOfTupleOfBackend_Target = core::Vector>; - impl core::Vector> { pub fn as_raw_VectorOfTupleOfBackend_Target(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfTupleOfBackend_Target(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -13034,9 +12383,6 @@ mod dnn_types { vector_non_copy_or_bool! { core::Tuple<(crate::dnn::Backend, crate::dnn::Target)> } - #[deprecated = "Use the the non-alias form `core::Vector>` instead, removal in Nov 2024"] - pub type VectorOfVectorOfMatShape = core::Vector>; - impl core::Vector> { pub fn as_raw_VectorOfVectorOfMatShape(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfVectorOfMatShape(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -13056,16 +12402,11 @@ mod dnn_types { } -#[cfg(ocvrs_has_module_dnn)] pub use dnn_types::*; -#[cfg(ocvrs_has_module_dnn_superres)] mod dnn_superres_types { use crate::{mod_prelude::*, core, types, sys}; - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDnnSuperResImpl = core::Ptr; - ptr_extern! { crate::dnn_superres::DnnSuperResImpl, cv_PtrLcv_dnn_superres_DnnSuperResImplG_new_null_const, cv_PtrLcv_dnn_superres_DnnSuperResImplG_delete, cv_PtrLcv_dnn_superres_DnnSuperResImplG_getInnerPtr_const, cv_PtrLcv_dnn_superres_DnnSuperResImplG_getInnerPtrMut } @@ -13093,16 +12434,11 @@ mod dnn_superres_types { } } -#[cfg(ocvrs_has_module_dnn_superres)] pub use dnn_superres_types::*; -#[cfg(ocvrs_has_module_dpm)] mod dpm_types { use crate::{mod_prelude::*, core, types, sys}; - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDPMDetector = core::Ptr; - ptr_extern! { crate::dpm::DPMDetector, cv_PtrLcv_dpm_DPMDetectorG_new_null_const, cv_PtrLcv_dpm_DPMDetectorG_delete, cv_PtrLcv_dpm_DPMDetectorG_getInnerPtr_const, cv_PtrLcv_dpm_DPMDetectorG_getInnerPtrMut } @@ -13128,9 +12464,6 @@ mod dpm_types { } } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfDPMDetector_ObjectDetection = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfDPMDetector_ObjectDetection(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfDPMDetector_ObjectDetection(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -13162,16 +12495,11 @@ mod dpm_types { } -#[cfg(ocvrs_has_module_dpm)] pub use dpm_types::*; -#[cfg(ocvrs_has_module_face)] mod face_types { use crate::{mod_prelude::*, core, types, sys}; - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfBIF = core::Ptr; - ptr_extern! { crate::face::BIF, cv_PtrLcv_face_BIFG_new_null_const, cv_PtrLcv_face_BIFG_delete, cv_PtrLcv_face_BIFG_getInnerPtr_const, cv_PtrLcv_face_BIFG_getInnerPtrMut } @@ -13207,9 +12535,6 @@ mod face_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfBasicFaceRecognizer = core::Ptr; - ptr_extern! { crate::face::BasicFaceRecognizer, cv_PtrLcv_face_BasicFaceRecognizerG_new_null_const, cv_PtrLcv_face_BasicFaceRecognizerG_delete, cv_PtrLcv_face_BasicFaceRecognizerG_getInnerPtr_const, cv_PtrLcv_face_BasicFaceRecognizerG_getInnerPtrMut } @@ -13255,9 +12580,6 @@ mod face_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfEigenFaceRecognizer = core::Ptr; - ptr_extern! { crate::face::EigenFaceRecognizer, cv_PtrLcv_face_EigenFaceRecognizerG_new_null_const, cv_PtrLcv_face_EigenFaceRecognizerG_delete, cv_PtrLcv_face_EigenFaceRecognizerG_getInnerPtr_const, cv_PtrLcv_face_EigenFaceRecognizerG_getInnerPtrMut } @@ -13313,9 +12635,6 @@ mod face_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfFaceRecognizer = core::Ptr; - ptr_extern! { crate::face::FaceRecognizer, cv_PtrLcv_face_FaceRecognizerG_new_null_const, cv_PtrLcv_face_FaceRecognizerG_delete, cv_PtrLcv_face_FaceRecognizerG_getInnerPtr_const, cv_PtrLcv_face_FaceRecognizerG_getInnerPtrMut } @@ -13351,9 +12670,6 @@ mod face_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfFacemark = core::Ptr; - ptr_extern! { crate::face::Facemark, cv_PtrLcv_face_FacemarkG_new_null_const, cv_PtrLcv_face_FacemarkG_delete, cv_PtrLcv_face_FacemarkG_getInnerPtr_const, cv_PtrLcv_face_FacemarkG_getInnerPtrMut } @@ -13389,9 +12705,6 @@ mod face_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfFacemarkAAM = core::Ptr; - ptr_extern! { crate::face::FacemarkAAM, cv_PtrLcv_face_FacemarkAAMG_new_null_const, cv_PtrLcv_face_FacemarkAAMG_delete, cv_PtrLcv_face_FacemarkAAMG_getInnerPtr_const, cv_PtrLcv_face_FacemarkAAMG_getInnerPtrMut } @@ -13447,9 +12760,6 @@ mod face_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfFacemarkKazemi = core::Ptr; - ptr_extern! { crate::face::FacemarkKazemi, cv_PtrLcv_face_FacemarkKazemiG_new_null_const, cv_PtrLcv_face_FacemarkKazemiG_delete, cv_PtrLcv_face_FacemarkKazemiG_getInnerPtr_const, cv_PtrLcv_face_FacemarkKazemiG_getInnerPtrMut } @@ -13495,9 +12805,6 @@ mod face_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfFacemarkLBF = core::Ptr; - ptr_extern! { crate::face::FacemarkLBF, cv_PtrLcv_face_FacemarkLBFG_new_null_const, cv_PtrLcv_face_FacemarkLBFG_delete, cv_PtrLcv_face_FacemarkLBFG_getInnerPtr_const, cv_PtrLcv_face_FacemarkLBFG_getInnerPtrMut } @@ -13553,9 +12860,6 @@ mod face_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfFacemarkTrain = core::Ptr; - ptr_extern! { crate::face::FacemarkTrain, cv_PtrLcv_face_FacemarkTrainG_new_null_const, cv_PtrLcv_face_FacemarkTrainG_delete, cv_PtrLcv_face_FacemarkTrainG_getInnerPtr_const, cv_PtrLcv_face_FacemarkTrainG_getInnerPtrMut } @@ -13601,9 +12905,6 @@ mod face_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfFisherFaceRecognizer = core::Ptr; - ptr_extern! { crate::face::FisherFaceRecognizer, cv_PtrLcv_face_FisherFaceRecognizerG_new_null_const, cv_PtrLcv_face_FisherFaceRecognizerG_delete, cv_PtrLcv_face_FisherFaceRecognizerG_getInnerPtr_const, cv_PtrLcv_face_FisherFaceRecognizerG_getInnerPtrMut } @@ -13659,9 +12960,6 @@ mod face_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfLBPHFaceRecognizer = core::Ptr; - ptr_extern! { crate::face::LBPHFaceRecognizer, cv_PtrLcv_face_LBPHFaceRecognizerG_new_null_const, cv_PtrLcv_face_LBPHFaceRecognizerG_delete, cv_PtrLcv_face_LBPHFaceRecognizerG_getInnerPtr_const, cv_PtrLcv_face_LBPHFaceRecognizerG_getInnerPtrMut } @@ -13707,9 +13005,6 @@ mod face_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfMACE = core::Ptr; - ptr_extern! { crate::face::MACE, cv_PtrLcv_face_MACEG_new_null_const, cv_PtrLcv_face_MACEG_delete, cv_PtrLcv_face_MACEG_getInnerPtr_const, cv_PtrLcv_face_MACEG_getInnerPtrMut } @@ -13745,9 +13040,6 @@ mod face_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfPredictCollector = core::Ptr; - ptr_extern! { crate::face::PredictCollector, cv_PtrLcv_face_PredictCollectorG_new_null_const, cv_PtrLcv_face_PredictCollectorG_delete, cv_PtrLcv_face_PredictCollectorG_getInnerPtr_const, cv_PtrLcv_face_PredictCollectorG_getInnerPtrMut } @@ -13773,9 +13065,6 @@ mod face_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfStandardCollector = core::Ptr; - ptr_extern! { crate::face::StandardCollector, cv_PtrLcv_face_StandardCollectorG_new_null_const, cv_PtrLcv_face_StandardCollectorG_delete, cv_PtrLcv_face_StandardCollectorG_getInnerPtr_const, cv_PtrLcv_face_StandardCollectorG_getInnerPtrMut } @@ -13812,9 +13101,6 @@ mod face_types { } } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfFacemarkAAM_Config = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfFacemarkAAM_Config(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfFacemarkAAM_Config(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -13845,9 +13131,6 @@ mod face_types { } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfFacemarkAAM_Model_Texture = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfFacemarkAAM_Model_Texture(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfFacemarkAAM_Model_Texture(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -13879,16 +13162,11 @@ mod face_types { } -#[cfg(ocvrs_has_module_face)] pub use face_types::*; -#[cfg(ocvrs_has_module_features2d)] mod features2d_types { use crate::{mod_prelude::*, core, types, sys}; - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfAKAZE = core::Ptr; - ptr_extern! { crate::features2d::AKAZE, cv_PtrLcv_AKAZEG_new_null_const, cv_PtrLcv_AKAZEG_delete, cv_PtrLcv_AKAZEG_getInnerPtr_const, cv_PtrLcv_AKAZEG_getInnerPtrMut } @@ -13934,9 +13212,6 @@ mod features2d_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfAffineFeature = core::Ptr; - ptr_extern! { crate::features2d::AffineFeature, cv_PtrLcv_AffineFeatureG_new_null_const, cv_PtrLcv_AffineFeatureG_delete, cv_PtrLcv_AffineFeatureG_getInnerPtr_const, cv_PtrLcv_AffineFeatureG_getInnerPtrMut } @@ -13982,9 +13257,6 @@ mod features2d_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfAgastFeatureDetector = core::Ptr; - ptr_extern! { crate::features2d::AgastFeatureDetector, cv_PtrLcv_AgastFeatureDetectorG_new_null_const, cv_PtrLcv_AgastFeatureDetectorG_delete, cv_PtrLcv_AgastFeatureDetectorG_getInnerPtr_const, cv_PtrLcv_AgastFeatureDetectorG_getInnerPtrMut } @@ -14030,9 +13302,6 @@ mod features2d_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfBFMatcher = core::Ptr; - ptr_extern! { crate::features2d::BFMatcher, cv_PtrLcv_BFMatcherG_new_null_const, cv_PtrLcv_BFMatcherG_delete, cv_PtrLcv_BFMatcherG_getInnerPtr_const, cv_PtrLcv_BFMatcherG_getInnerPtrMut } @@ -14079,9 +13348,6 @@ mod features2d_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfBRISK = core::Ptr; - ptr_extern! { crate::features2d::BRISK, cv_PtrLcv_BRISKG_new_null_const, cv_PtrLcv_BRISKG_delete, cv_PtrLcv_BRISKG_getInnerPtr_const, cv_PtrLcv_BRISKG_getInnerPtrMut } @@ -14127,9 +13393,6 @@ mod features2d_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDescriptorMatcher = core::Ptr; - ptr_extern! { crate::features2d::DescriptorMatcher, cv_PtrLcv_DescriptorMatcherG_new_null_const, cv_PtrLcv_DescriptorMatcherG_delete, cv_PtrLcv_DescriptorMatcherG_getInnerPtr_const, cv_PtrLcv_DescriptorMatcherG_getInnerPtrMut } @@ -14165,9 +13428,6 @@ mod features2d_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfFastFeatureDetector = core::Ptr; - ptr_extern! { crate::features2d::FastFeatureDetector, cv_PtrLcv_FastFeatureDetectorG_new_null_const, cv_PtrLcv_FastFeatureDetectorG_delete, cv_PtrLcv_FastFeatureDetectorG_getInnerPtr_const, cv_PtrLcv_FastFeatureDetectorG_getInnerPtrMut } @@ -14213,9 +13473,6 @@ mod features2d_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfFeature2D = core::Ptr; - ptr_extern! { crate::features2d::Feature2D, cv_PtrLcv_Feature2DG_new_null_const, cv_PtrLcv_Feature2DG_delete, cv_PtrLcv_Feature2DG_getInnerPtr_const, cv_PtrLcv_Feature2DG_getInnerPtrMut } @@ -14252,9 +13509,6 @@ mod features2d_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfFlannBasedMatcher = core::Ptr; - ptr_extern! { crate::features2d::FlannBasedMatcher, cv_PtrLcv_FlannBasedMatcherG_new_null_const, cv_PtrLcv_FlannBasedMatcherG_delete, cv_PtrLcv_FlannBasedMatcherG_getInnerPtr_const, cv_PtrLcv_FlannBasedMatcherG_getInnerPtrMut } @@ -14301,9 +13555,6 @@ mod features2d_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfGFTTDetector = core::Ptr; - ptr_extern! { crate::features2d::GFTTDetector, cv_PtrLcv_GFTTDetectorG_new_null_const, cv_PtrLcv_GFTTDetectorG_delete, cv_PtrLcv_GFTTDetectorG_getInnerPtr_const, cv_PtrLcv_GFTTDetectorG_getInnerPtrMut } @@ -14349,9 +13600,6 @@ mod features2d_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfKAZE = core::Ptr; - ptr_extern! { crate::features2d::KAZE, cv_PtrLcv_KAZEG_new_null_const, cv_PtrLcv_KAZEG_delete, cv_PtrLcv_KAZEG_getInnerPtr_const, cv_PtrLcv_KAZEG_getInnerPtrMut } @@ -14397,9 +13645,6 @@ mod features2d_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfMSER = core::Ptr; - ptr_extern! { crate::features2d::MSER, cv_PtrLcv_MSERG_new_null_const, cv_PtrLcv_MSERG_delete, cv_PtrLcv_MSERG_getInnerPtr_const, cv_PtrLcv_MSERG_getInnerPtrMut } @@ -14445,9 +13690,6 @@ mod features2d_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfORB = core::Ptr; - ptr_extern! { crate::features2d::ORB, cv_PtrLcv_ORBG_new_null_const, cv_PtrLcv_ORBG_delete, cv_PtrLcv_ORBG_getInnerPtr_const, cv_PtrLcv_ORBG_getInnerPtrMut } @@ -14493,9 +13735,6 @@ mod features2d_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfSIFT = core::Ptr; - ptr_extern! { crate::features2d::SIFT, cv_PtrLcv_SIFTG_new_null_const, cv_PtrLcv_SIFTG_delete, cv_PtrLcv_SIFTG_getInnerPtr_const, cv_PtrLcv_SIFTG_getInnerPtrMut } @@ -14541,9 +13780,6 @@ mod features2d_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfSimpleBlobDetector = core::Ptr; - ptr_extern! { crate::features2d::SimpleBlobDetector, cv_PtrLcv_SimpleBlobDetectorG_new_null_const, cv_PtrLcv_SimpleBlobDetectorG_delete, cv_PtrLcv_SimpleBlobDetectorG_getInnerPtr_const, cv_PtrLcv_SimpleBlobDetectorG_getInnerPtrMut } @@ -14590,16 +13826,11 @@ mod features2d_types { } } -#[cfg(ocvrs_has_module_features2d)] pub use features2d_types::*; -#[cfg(ocvrs_has_module_flann)] mod flann_types { use crate::{mod_prelude::*, core, types, sys}; - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfAutotunedIndexParams = core::Ptr; - ptr_extern! { crate::flann::AutotunedIndexParams, cv_PtrLcv_flann_AutotunedIndexParamsG_new_null_const, cv_PtrLcv_flann_AutotunedIndexParamsG_delete, cv_PtrLcv_flann_AutotunedIndexParamsG_getInnerPtr_const, cv_PtrLcv_flann_AutotunedIndexParamsG_getInnerPtrMut } @@ -14636,9 +13867,6 @@ mod flann_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCompositeIndexParams = core::Ptr; - ptr_extern! { crate::flann::CompositeIndexParams, cv_PtrLcv_flann_CompositeIndexParamsG_new_null_const, cv_PtrLcv_flann_CompositeIndexParamsG_delete, cv_PtrLcv_flann_CompositeIndexParamsG_getInnerPtr_const, cv_PtrLcv_flann_CompositeIndexParamsG_getInnerPtrMut } @@ -14675,9 +13903,6 @@ mod flann_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfHierarchicalClusteringIndexParams = core::Ptr; - ptr_extern! { crate::flann::HierarchicalClusteringIndexParams, cv_PtrLcv_flann_HierarchicalClusteringIndexParamsG_new_null_const, cv_PtrLcv_flann_HierarchicalClusteringIndexParamsG_delete, cv_PtrLcv_flann_HierarchicalClusteringIndexParamsG_getInnerPtr_const, cv_PtrLcv_flann_HierarchicalClusteringIndexParamsG_getInnerPtrMut } @@ -14714,9 +13939,6 @@ mod flann_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfIndexParams = core::Ptr; - ptr_extern! { crate::flann::IndexParams, cv_PtrLcv_flann_IndexParamsG_new_null_const, cv_PtrLcv_flann_IndexParamsG_delete, cv_PtrLcv_flann_IndexParamsG_getInnerPtr_const, cv_PtrLcv_flann_IndexParamsG_getInnerPtrMut } @@ -14743,9 +13965,6 @@ mod flann_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfKDTreeIndexParams = core::Ptr; - ptr_extern! { crate::flann::KDTreeIndexParams, cv_PtrLcv_flann_KDTreeIndexParamsG_new_null_const, cv_PtrLcv_flann_KDTreeIndexParamsG_delete, cv_PtrLcv_flann_KDTreeIndexParamsG_getInnerPtr_const, cv_PtrLcv_flann_KDTreeIndexParamsG_getInnerPtrMut } @@ -14782,9 +14001,6 @@ mod flann_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfKMeansIndexParams = core::Ptr; - ptr_extern! { crate::flann::KMeansIndexParams, cv_PtrLcv_flann_KMeansIndexParamsG_new_null_const, cv_PtrLcv_flann_KMeansIndexParamsG_delete, cv_PtrLcv_flann_KMeansIndexParamsG_getInnerPtr_const, cv_PtrLcv_flann_KMeansIndexParamsG_getInnerPtrMut } @@ -14821,9 +14037,6 @@ mod flann_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfLinearIndexParams = core::Ptr; - ptr_extern! { crate::flann::LinearIndexParams, cv_PtrLcv_flann_LinearIndexParamsG_new_null_const, cv_PtrLcv_flann_LinearIndexParamsG_delete, cv_PtrLcv_flann_LinearIndexParamsG_getInnerPtr_const, cv_PtrLcv_flann_LinearIndexParamsG_getInnerPtrMut } @@ -14860,9 +14073,6 @@ mod flann_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfLshIndexParams = core::Ptr; - ptr_extern! { crate::flann::LshIndexParams, cv_PtrLcv_flann_LshIndexParamsG_new_null_const, cv_PtrLcv_flann_LshIndexParamsG_delete, cv_PtrLcv_flann_LshIndexParamsG_getInnerPtr_const, cv_PtrLcv_flann_LshIndexParamsG_getInnerPtrMut } @@ -14899,9 +14109,6 @@ mod flann_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfSavedIndexParams = core::Ptr; - ptr_extern! { crate::flann::SavedIndexParams, cv_PtrLcv_flann_SavedIndexParamsG_new_null_const, cv_PtrLcv_flann_SavedIndexParamsG_delete, cv_PtrLcv_flann_SavedIndexParamsG_getInnerPtr_const, cv_PtrLcv_flann_SavedIndexParamsG_getInnerPtrMut } @@ -14938,9 +14145,6 @@ mod flann_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfSearchParams = core::Ptr; - ptr_extern! { crate::flann::SearchParams, cv_PtrLcv_flann_SearchParamsG_new_null_const, cv_PtrLcv_flann_SearchParamsG_delete, cv_PtrLcv_flann_SearchParamsG_getInnerPtr_const, cv_PtrLcv_flann_SearchParamsG_getInnerPtrMut } @@ -14977,9 +14181,6 @@ mod flann_types { } } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfFeatureIndex = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfFeatureIndex(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfFeatureIndex(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -15001,9 +14202,6 @@ mod flann_types { } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfFlannIndexType = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfFlannIndexType(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfFlannIndexType(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -15026,16 +14224,11 @@ mod flann_types { } -#[cfg(ocvrs_has_module_flann)] pub use flann_types::*; -#[cfg(ocvrs_has_module_freetype)] mod freetype_types { use crate::{mod_prelude::*, core, types, sys}; - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfFreeType2 = core::Ptr; - ptr_extern! { crate::freetype::FreeType2, cv_PtrLcv_freetype_FreeType2G_new_null_const, cv_PtrLcv_freetype_FreeType2G_delete, cv_PtrLcv_freetype_FreeType2G_getInnerPtr_const, cv_PtrLcv_freetype_FreeType2G_getInnerPtrMut } @@ -15072,16 +14265,11 @@ mod freetype_types { } } -#[cfg(ocvrs_has_module_freetype)] pub use freetype_types::*; -#[cfg(ocvrs_has_module_gapi)] mod gapi_types { use crate::{mod_prelude::*, core, types, sys}; - #[deprecated = "Use the the non-alias form `core::Tuple<(crate::gapi::GBackend, crate::gapi::GKernelImpl)>` instead, removal in Nov 2024"] - pub type TupleOfGBackend_GKernelImpl = core::Tuple<(crate::gapi::GBackend, crate::gapi::GKernelImpl)>; - impl core::Tuple<(crate::gapi::GBackend, crate::gapi::GKernelImpl)> { pub fn as_raw_TupleOfGBackend_GKernelImpl(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_TupleOfGBackend_GKernelImpl(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -15093,9 +14281,6 @@ mod gapi_types { 1 = arg_1: crate::gapi::GKernelImpl, get_1 via std_pairLcv_gapi_GBackend__cv_GKernelImplG_get_1_const } - #[deprecated = "Use the the non-alias form `core::Tuple<(crate::gapi::GMat, crate::gapi::GMat)>` instead, removal in Nov 2024"] - pub type TupleOfGMat_GMat = core::Tuple<(crate::gapi::GMat, crate::gapi::GMat)>; - impl core::Tuple<(crate::gapi::GMat, crate::gapi::GMat)> { pub fn as_raw_TupleOfGMat_GMat(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_TupleOfGMat_GMat(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -15107,9 +14292,6 @@ mod gapi_types { 1 = arg_1: crate::gapi::GMat, get_1 via std_tupleLcv_GMat__cv_GMatG_get_1_const } - #[deprecated = "Use the the non-alias form `core::Tuple<(crate::gapi::GMat, crate::gapi::GMat, crate::gapi::GMat)>` instead, removal in Nov 2024"] - pub type TupleOfGMat_GMat_GMat = core::Tuple<(crate::gapi::GMat, crate::gapi::GMat, crate::gapi::GMat)>; - impl core::Tuple<(crate::gapi::GMat, crate::gapi::GMat, crate::gapi::GMat)> { pub fn as_raw_TupleOfGMat_GMat_GMat(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_TupleOfGMat_GMat_GMat(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -15122,9 +14304,6 @@ mod gapi_types { 2 = arg_2: crate::gapi::GMat, get_2 via std_tupleLcv_GMat__cv_GMat__cv_GMatG_get_2_const } - #[deprecated = "Use the the non-alias form `core::Tuple<(crate::gapi::GMat, crate::gapi::GMat, crate::gapi::GMat, crate::gapi::GMat)>` instead, removal in Nov 2024"] - pub type TupleOfGMat_GMat_GMat_GMat = core::Tuple<(crate::gapi::GMat, crate::gapi::GMat, crate::gapi::GMat, crate::gapi::GMat)>; - impl core::Tuple<(crate::gapi::GMat, crate::gapi::GMat, crate::gapi::GMat, crate::gapi::GMat)> { pub fn as_raw_TupleOfGMat_GMat_GMat_GMat(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_TupleOfGMat_GMat_GMat_GMat(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -15138,9 +14317,6 @@ mod gapi_types { 3 = arg_3: crate::gapi::GMat, get_3 via std_tupleLcv_GMat__cv_GMat__cv_GMat__cv_GMatG_get_3_const } - #[deprecated = "Use the the non-alias form `core::Tuple<(crate::gapi::GMat, crate::gapi::GScalar)>` instead, removal in Nov 2024"] - pub type TupleOfGMat_GScalar = core::Tuple<(crate::gapi::GMat, crate::gapi::GScalar)>; - impl core::Tuple<(crate::gapi::GMat, crate::gapi::GScalar)> { pub fn as_raw_TupleOfGMat_GScalar(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_TupleOfGMat_GScalar(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -15152,9 +14328,6 @@ mod gapi_types { 1 = arg_1: crate::gapi::GScalar, get_1 via std_tupleLcv_GMat__cv_GScalarG_get_1_const } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfDetail_OpaqueKind = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfDetail_OpaqueKind(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfDetail_OpaqueKind(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -15176,9 +14349,6 @@ mod gapi_types { } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfGArg = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfGArg(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfGArg(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -15209,9 +14379,6 @@ mod gapi_types { } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfGBackend = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfGBackend(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfGBackend(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -15242,9 +14409,6 @@ mod gapi_types { } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfGCompileArg = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfGCompileArg(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfGCompileArg(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -15275,9 +14439,6 @@ mod gapi_types { } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfGMat = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfGMat(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfGMat(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -15308,9 +14469,6 @@ mod gapi_types { } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfGRunArg = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfGRunArg(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfGRunArg(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -15341,9 +14499,6 @@ mod gapi_types { } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfGShape = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfGShape(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfGShape(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -15365,9 +14520,6 @@ mod gapi_types { } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfGTransform = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfGTransform(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfGTransform(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -15398,9 +14550,6 @@ mod gapi_types { } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfGTypeInfo = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfGTypeInfo(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfGTypeInfo(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -15432,16 +14581,11 @@ mod gapi_types { } -#[cfg(ocvrs_has_module_gapi)] pub use gapi_types::*; -#[cfg(ocvrs_has_module_hdf)] mod hdf_types { use crate::{mod_prelude::*, core, types, sys}; - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfHDF5 = core::Ptr; - ptr_extern! { crate::hdf::HDF5, cv_PtrLcv_hdf_HDF5G_new_null_const, cv_PtrLcv_hdf_HDF5G_delete, cv_PtrLcv_hdf_HDF5G_getInnerPtr_const, cv_PtrLcv_hdf_HDF5G_getInnerPtrMut } @@ -15468,16 +14612,11 @@ mod hdf_types { } } -#[cfg(ocvrs_has_module_hdf)] pub use hdf_types::*; -#[cfg(ocvrs_has_module_hfs)] mod hfs_types { use crate::{mod_prelude::*, core, types, sys}; - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfHfsSegment = core::Ptr; - ptr_extern! { crate::hfs::HfsSegment, cv_PtrLcv_hfs_HfsSegmentG_new_null_const, cv_PtrLcv_hfs_HfsSegmentG_delete, cv_PtrLcv_hfs_HfsSegmentG_getInnerPtr_const, cv_PtrLcv_hfs_HfsSegmentG_getInnerPtrMut } @@ -15514,16 +14653,11 @@ mod hfs_types { } } -#[cfg(ocvrs_has_module_hfs)] pub use hfs_types::*; -#[cfg(ocvrs_has_module_img_hash)] mod img_hash_types { use crate::{mod_prelude::*, core, types, sys}; - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfAverageHash = core::Ptr; - ptr_extern! { crate::img_hash::AverageHash, cv_PtrLcv_img_hash_AverageHashG_new_null_const, cv_PtrLcv_img_hash_AverageHashG_delete, cv_PtrLcv_img_hash_AverageHashG_getInnerPtr_const, cv_PtrLcv_img_hash_AverageHashG_getInnerPtrMut } @@ -15570,9 +14704,6 @@ mod img_hash_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfBlockMeanHash = core::Ptr; - ptr_extern! { crate::img_hash::BlockMeanHash, cv_PtrLcv_img_hash_BlockMeanHashG_new_null_const, cv_PtrLcv_img_hash_BlockMeanHashG_delete, cv_PtrLcv_img_hash_BlockMeanHashG_getInnerPtr_const, cv_PtrLcv_img_hash_BlockMeanHashG_getInnerPtrMut } @@ -15619,9 +14750,6 @@ mod img_hash_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfColorMomentHash = core::Ptr; - ptr_extern! { crate::img_hash::ColorMomentHash, cv_PtrLcv_img_hash_ColorMomentHashG_new_null_const, cv_PtrLcv_img_hash_ColorMomentHashG_delete, cv_PtrLcv_img_hash_ColorMomentHashG_getInnerPtr_const, cv_PtrLcv_img_hash_ColorMomentHashG_getInnerPtrMut } @@ -15668,9 +14796,6 @@ mod img_hash_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfImgHashBase = core::Ptr; - ptr_extern! { crate::img_hash::ImgHashBase, cv_PtrLcv_img_hash_ImgHashBaseG_new_null_const, cv_PtrLcv_img_hash_ImgHashBaseG_delete, cv_PtrLcv_img_hash_ImgHashBaseG_getInnerPtr_const, cv_PtrLcv_img_hash_ImgHashBaseG_getInnerPtrMut } @@ -15707,9 +14832,6 @@ mod img_hash_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfMarrHildrethHash = core::Ptr; - ptr_extern! { crate::img_hash::MarrHildrethHash, cv_PtrLcv_img_hash_MarrHildrethHashG_new_null_const, cv_PtrLcv_img_hash_MarrHildrethHashG_delete, cv_PtrLcv_img_hash_MarrHildrethHashG_getInnerPtr_const, cv_PtrLcv_img_hash_MarrHildrethHashG_getInnerPtrMut } @@ -15756,9 +14878,6 @@ mod img_hash_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfPHash = core::Ptr; - ptr_extern! { crate::img_hash::PHash, cv_PtrLcv_img_hash_PHashG_new_null_const, cv_PtrLcv_img_hash_PHashG_delete, cv_PtrLcv_img_hash_PHashG_getInnerPtr_const, cv_PtrLcv_img_hash_PHashG_getInnerPtrMut } @@ -15805,9 +14924,6 @@ mod img_hash_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfRadialVarianceHash = core::Ptr; - ptr_extern! { crate::img_hash::RadialVarianceHash, cv_PtrLcv_img_hash_RadialVarianceHashG_new_null_const, cv_PtrLcv_img_hash_RadialVarianceHashG_delete, cv_PtrLcv_img_hash_RadialVarianceHashG_getInnerPtr_const, cv_PtrLcv_img_hash_RadialVarianceHashG_getInnerPtrMut } @@ -15855,16 +14971,11 @@ mod img_hash_types { } } -#[cfg(ocvrs_has_module_img_hash)] pub use img_hash_types::*; -#[cfg(ocvrs_has_module_imgproc)] mod imgproc_types { use crate::{mod_prelude::*, core, types, sys}; - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCLAHE = core::Ptr; - ptr_extern! { crate::imgproc::CLAHE, cv_PtrLcv_CLAHEG_new_null_const, cv_PtrLcv_CLAHEG_delete, cv_PtrLcv_CLAHEG_getInnerPtr_const, cv_PtrLcv_CLAHEG_getInnerPtrMut } @@ -15900,9 +15011,6 @@ mod imgproc_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfGeneralizedHough = core::Ptr; - ptr_extern! { crate::imgproc::GeneralizedHough, cv_PtrLcv_GeneralizedHoughG_new_null_const, cv_PtrLcv_GeneralizedHoughG_delete, cv_PtrLcv_GeneralizedHoughG_getInnerPtr_const, cv_PtrLcv_GeneralizedHoughG_getInnerPtrMut } @@ -15938,9 +15046,6 @@ mod imgproc_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfGeneralizedHoughBallard = core::Ptr; - ptr_extern! { crate::imgproc::GeneralizedHoughBallard, cv_PtrLcv_GeneralizedHoughBallardG_new_null_const, cv_PtrLcv_GeneralizedHoughBallardG_delete, cv_PtrLcv_GeneralizedHoughBallardG_getInnerPtr_const, cv_PtrLcv_GeneralizedHoughBallardG_getInnerPtrMut } @@ -15986,9 +15091,6 @@ mod imgproc_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfGeneralizedHoughGuil = core::Ptr; - ptr_extern! { crate::imgproc::GeneralizedHoughGuil, cv_PtrLcv_GeneralizedHoughGuilG_new_null_const, cv_PtrLcv_GeneralizedHoughGuilG_delete, cv_PtrLcv_GeneralizedHoughGuilG_getInnerPtr_const, cv_PtrLcv_GeneralizedHoughGuilG_getInnerPtrMut } @@ -16034,9 +15136,6 @@ mod imgproc_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfLineSegmentDetector = core::Ptr; - ptr_extern! { crate::imgproc::LineSegmentDetector, cv_PtrLcv_LineSegmentDetectorG_new_null_const, cv_PtrLcv_LineSegmentDetectorG_delete, cv_PtrLcv_LineSegmentDetectorG_getInnerPtr_const, cv_PtrLcv_LineSegmentDetectorG_getInnerPtrMut } @@ -16073,16 +15172,11 @@ mod imgproc_types { } } -#[cfg(ocvrs_has_module_imgproc)] pub use imgproc_types::*; -#[cfg(ocvrs_has_module_line_descriptor)] mod line_descriptor_types { use crate::{mod_prelude::*, core, types, sys}; - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfBinaryDescriptor = core::Ptr; - ptr_extern! { crate::line_descriptor::BinaryDescriptor, cv_PtrLcv_line_descriptor_BinaryDescriptorG_new_null_const, cv_PtrLcv_line_descriptor_BinaryDescriptorG_delete, cv_PtrLcv_line_descriptor_BinaryDescriptorG_getInnerPtr_const, cv_PtrLcv_line_descriptor_BinaryDescriptorG_getInnerPtrMut } @@ -16119,9 +15213,6 @@ mod line_descriptor_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfBinaryDescriptorMatcher = core::Ptr; - ptr_extern! { crate::line_descriptor::BinaryDescriptorMatcher, cv_PtrLcv_line_descriptor_BinaryDescriptorMatcherG_new_null_const, cv_PtrLcv_line_descriptor_BinaryDescriptorMatcherG_delete, cv_PtrLcv_line_descriptor_BinaryDescriptorMatcherG_getInnerPtr_const, cv_PtrLcv_line_descriptor_BinaryDescriptorMatcherG_getInnerPtrMut } @@ -16158,9 +15249,6 @@ mod line_descriptor_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfLSDDetector = core::Ptr; - ptr_extern! { crate::line_descriptor::LSDDetector, cv_PtrLcv_line_descriptor_LSDDetectorG_new_null_const, cv_PtrLcv_line_descriptor_LSDDetectorG_delete, cv_PtrLcv_line_descriptor_LSDDetectorG_getInnerPtr_const, cv_PtrLcv_line_descriptor_LSDDetectorG_getInnerPtrMut } @@ -16197,9 +15285,6 @@ mod line_descriptor_types { } } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfKeyLine = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfKeyLine(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfKeyLine(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -16221,9 +15306,6 @@ mod line_descriptor_types { } - #[deprecated = "Use the the non-alias form `core::Vector>` instead, removal in Nov 2024"] - pub type VectorOfVectorOfKeyLine = core::Vector>; - impl core::Vector> { pub fn as_raw_VectorOfVectorOfKeyLine(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfVectorOfKeyLine(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -16243,16 +15325,11 @@ mod line_descriptor_types { } -#[cfg(ocvrs_has_module_line_descriptor)] pub use line_descriptor_types::*; -#[cfg(ocvrs_has_module_mcc)] mod mcc_types { use crate::{mod_prelude::*, core, types, sys}; - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfMCC_CChecker = core::Ptr; - ptr_extern! { crate::mcc::MCC_CChecker, cv_PtrLcv_mcc_CCheckerG_new_null_const, cv_PtrLcv_mcc_CCheckerG_delete, cv_PtrLcv_mcc_CCheckerG_getInnerPtr_const, cv_PtrLcv_mcc_CCheckerG_getInnerPtrMut } @@ -16278,9 +15355,6 @@ mod mcc_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfMCC_CCheckerDetector = core::Ptr; - ptr_extern! { crate::mcc::MCC_CCheckerDetector, cv_PtrLcv_mcc_CCheckerDetectorG_new_null_const, cv_PtrLcv_mcc_CCheckerDetectorG_delete, cv_PtrLcv_mcc_CCheckerDetectorG_getInnerPtr_const, cv_PtrLcv_mcc_CCheckerDetectorG_getInnerPtrMut } @@ -16316,9 +15390,6 @@ mod mcc_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfMCC_CCheckerDraw = core::Ptr; - ptr_extern! { crate::mcc::MCC_CCheckerDraw, cv_PtrLcv_mcc_CCheckerDrawG_new_null_const, cv_PtrLcv_mcc_CCheckerDrawG_delete, cv_PtrLcv_mcc_CCheckerDrawG_getInnerPtr_const, cv_PtrLcv_mcc_CCheckerDrawG_getInnerPtrMut } @@ -16344,9 +15415,6 @@ mod mcc_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfMCC_DetectorParameters = core::Ptr; - ptr_extern! { crate::mcc::MCC_DetectorParameters, cv_PtrLcv_mcc_DetectorParametersG_new_null_const, cv_PtrLcv_mcc_DetectorParametersG_delete, cv_PtrLcv_mcc_DetectorParametersG_getInnerPtr_const, cv_PtrLcv_mcc_DetectorParametersG_getInnerPtrMut } @@ -16391,9 +15459,6 @@ mod mcc_types { } } - #[deprecated = "Use the the non-alias form `core::Vector>` instead, removal in Nov 2024"] - pub type VectorOfPtrOfMCC_CChecker = core::Vector>; - impl core::Vector> { pub fn as_raw_VectorOfPtrOfMCC_CChecker(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfPtrOfMCC_CChecker(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -16413,16 +15478,11 @@ mod mcc_types { } -#[cfg(ocvrs_has_module_mcc)] pub use mcc_types::*; -#[cfg(ocvrs_has_module_ml)] mod ml_types { use crate::{mod_prelude::*, core, types, sys}; - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfANN_MLP = core::Ptr; - ptr_extern! { crate::ml::ANN_MLP, cv_PtrLcv_ml_ANN_MLPG_new_null_const, cv_PtrLcv_ml_ANN_MLPG_delete, cv_PtrLcv_ml_ANN_MLPG_getInnerPtr_const, cv_PtrLcv_ml_ANN_MLPG_getInnerPtrMut } @@ -16468,9 +15528,6 @@ mod ml_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfBoost = core::Ptr; - ptr_extern! { crate::ml::Boost, cv_PtrLcv_ml_BoostG_new_null_const, cv_PtrLcv_ml_BoostG_delete, cv_PtrLcv_ml_BoostG_getInnerPtr_const, cv_PtrLcv_ml_BoostG_getInnerPtrMut } @@ -16526,9 +15583,6 @@ mod ml_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDTrees = core::Ptr; - ptr_extern! { crate::ml::DTrees, cv_PtrLcv_ml_DTreesG_new_null_const, cv_PtrLcv_ml_DTreesG_delete, cv_PtrLcv_ml_DTreesG_getInnerPtr_const, cv_PtrLcv_ml_DTreesG_getInnerPtrMut } @@ -16574,9 +15628,6 @@ mod ml_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfEM = core::Ptr; - ptr_extern! { crate::ml::EM, cv_PtrLcv_ml_EMG_new_null_const, cv_PtrLcv_ml_EMG_delete, cv_PtrLcv_ml_EMG_getInnerPtr_const, cv_PtrLcv_ml_EMG_getInnerPtrMut } @@ -16622,9 +15673,6 @@ mod ml_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfKNearest = core::Ptr; - ptr_extern! { crate::ml::KNearest, cv_PtrLcv_ml_KNearestG_new_null_const, cv_PtrLcv_ml_KNearestG_delete, cv_PtrLcv_ml_KNearestG_getInnerPtr_const, cv_PtrLcv_ml_KNearestG_getInnerPtrMut } @@ -16670,9 +15718,6 @@ mod ml_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfLogisticRegression = core::Ptr; - ptr_extern! { crate::ml::LogisticRegression, cv_PtrLcv_ml_LogisticRegressionG_new_null_const, cv_PtrLcv_ml_LogisticRegressionG_delete, cv_PtrLcv_ml_LogisticRegressionG_getInnerPtr_const, cv_PtrLcv_ml_LogisticRegressionG_getInnerPtrMut } @@ -16718,9 +15763,6 @@ mod ml_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfNormalBayesClassifier = core::Ptr; - ptr_extern! { crate::ml::NormalBayesClassifier, cv_PtrLcv_ml_NormalBayesClassifierG_new_null_const, cv_PtrLcv_ml_NormalBayesClassifierG_delete, cv_PtrLcv_ml_NormalBayesClassifierG_getInnerPtr_const, cv_PtrLcv_ml_NormalBayesClassifierG_getInnerPtrMut } @@ -16766,9 +15808,6 @@ mod ml_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfParamGrid = core::Ptr; - ptr_extern! { crate::ml::ParamGrid, cv_PtrLcv_ml_ParamGridG_new_null_const, cv_PtrLcv_ml_ParamGridG_delete, cv_PtrLcv_ml_ParamGridG_getInnerPtr_const, cv_PtrLcv_ml_ParamGridG_getInnerPtrMut } @@ -16798,9 +15837,6 @@ mod ml_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfRTrees = core::Ptr; - ptr_extern! { crate::ml::RTrees, cv_PtrLcv_ml_RTreesG_new_null_const, cv_PtrLcv_ml_RTreesG_delete, cv_PtrLcv_ml_RTreesG_getInnerPtr_const, cv_PtrLcv_ml_RTreesG_getInnerPtrMut } @@ -16856,9 +15892,6 @@ mod ml_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfSVM = core::Ptr; - ptr_extern! { crate::ml::SVM, cv_PtrLcv_ml_SVMG_new_null_const, cv_PtrLcv_ml_SVMG_delete, cv_PtrLcv_ml_SVMG_getInnerPtr_const, cv_PtrLcv_ml_SVMG_getInnerPtrMut } @@ -16904,9 +15937,6 @@ mod ml_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfSVMSGD = core::Ptr; - ptr_extern! { crate::ml::SVMSGD, cv_PtrLcv_ml_SVMSGDG_new_null_const, cv_PtrLcv_ml_SVMSGDG_delete, cv_PtrLcv_ml_SVMSGDG_getInnerPtr_const, cv_PtrLcv_ml_SVMSGDG_getInnerPtrMut } @@ -16952,9 +15982,6 @@ mod ml_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfSVM_Kernel = core::Ptr; - ptr_extern! { crate::ml::SVM_Kernel, cv_PtrLcv_ml_SVM_KernelG_new_null_const, cv_PtrLcv_ml_SVM_KernelG_delete, cv_PtrLcv_ml_SVM_KernelG_getInnerPtr_const, cv_PtrLcv_ml_SVM_KernelG_getInnerPtrMut } @@ -16990,9 +16017,6 @@ mod ml_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfStatModel = core::Ptr; - ptr_extern! { crate::ml::StatModel, cv_PtrLcv_ml_StatModelG_new_null_const, cv_PtrLcv_ml_StatModelG_delete, cv_PtrLcv_ml_StatModelG_getInnerPtr_const, cv_PtrLcv_ml_StatModelG_getInnerPtrMut } @@ -17028,9 +16052,6 @@ mod ml_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfTrainData = core::Ptr; - ptr_extern! { crate::ml::TrainData, cv_PtrLcv_ml_TrainDataG_new_null_const, cv_PtrLcv_ml_TrainDataG_delete, cv_PtrLcv_ml_TrainDataG_getInnerPtr_const, cv_PtrLcv_ml_TrainDataG_getInnerPtrMut } @@ -17056,9 +16077,6 @@ mod ml_types { } } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfDTrees_Node = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfDTrees_Node(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfDTrees_Node(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -17089,9 +16107,6 @@ mod ml_types { } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfDTrees_Split = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfDTrees_Split(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfDTrees_Split(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -17123,16 +16138,11 @@ mod ml_types { } -#[cfg(ocvrs_has_module_ml)] pub use ml_types::*; -#[cfg(ocvrs_has_module_objdetect)] mod objdetect_types { use crate::{mod_prelude::*, core, types, sys}; - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfArucoDetector = core::Ptr; - ptr_extern! { crate::objdetect::ArucoDetector, cv_PtrLcv_aruco_ArucoDetectorG_new_null_const, cv_PtrLcv_aruco_ArucoDetectorG_delete, cv_PtrLcv_aruco_ArucoDetectorG_getInnerPtr_const, cv_PtrLcv_aruco_ArucoDetectorG_getInnerPtrMut } @@ -17169,9 +16179,6 @@ mod objdetect_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfBaseCascadeClassifier = core::Ptr; - ptr_extern! { crate::objdetect::BaseCascadeClassifier, cv_PtrLcv_BaseCascadeClassifierG_new_null_const, cv_PtrLcv_BaseCascadeClassifierG_delete, cv_PtrLcv_BaseCascadeClassifierG_getInnerPtr_const, cv_PtrLcv_BaseCascadeClassifierG_getInnerPtrMut } @@ -17207,9 +16214,6 @@ mod objdetect_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfBaseCascadeClassifier_MaskGenerator = core::Ptr; - ptr_extern! { crate::objdetect::BaseCascadeClassifier_MaskGenerator, cv_PtrLcv_BaseCascadeClassifier_MaskGeneratorG_new_null_const, cv_PtrLcv_BaseCascadeClassifier_MaskGeneratorG_delete, cv_PtrLcv_BaseCascadeClassifier_MaskGeneratorG_getInnerPtr_const, cv_PtrLcv_BaseCascadeClassifier_MaskGeneratorG_getInnerPtrMut } @@ -17235,9 +16239,6 @@ mod objdetect_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfBoard = core::Ptr; - ptr_extern! { crate::objdetect::Board, cv_PtrLcv_aruco_BoardG_new_null_const, cv_PtrLcv_aruco_BoardG_delete, cv_PtrLcv_aruco_BoardG_getInnerPtr_const, cv_PtrLcv_aruco_BoardG_getInnerPtrMut } @@ -17264,9 +16265,6 @@ mod objdetect_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCharucoBoard = core::Ptr; - ptr_extern! { crate::objdetect::CharucoBoard, cv_PtrLcv_aruco_CharucoBoardG_new_null_const, cv_PtrLcv_aruco_CharucoBoardG_delete, cv_PtrLcv_aruco_CharucoBoardG_getInnerPtr_const, cv_PtrLcv_aruco_CharucoBoardG_getInnerPtrMut } @@ -17303,9 +16301,6 @@ mod objdetect_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCharucoDetector = core::Ptr; - ptr_extern! { crate::objdetect::CharucoDetector, cv_PtrLcv_aruco_CharucoDetectorG_new_null_const, cv_PtrLcv_aruco_CharucoDetectorG_delete, cv_PtrLcv_aruco_CharucoDetectorG_getInnerPtr_const, cv_PtrLcv_aruco_CharucoDetectorG_getInnerPtrMut } @@ -17342,9 +16337,6 @@ mod objdetect_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDetectionBasedTracker_IDetector = core::Ptr; - ptr_extern! { crate::objdetect::DetectionBasedTracker_IDetector, cv_PtrLcv_DetectionBasedTracker_IDetectorG_new_null_const, cv_PtrLcv_DetectionBasedTracker_IDetectorG_delete, cv_PtrLcv_DetectionBasedTracker_IDetectorG_getInnerPtr_const, cv_PtrLcv_DetectionBasedTracker_IDetectorG_getInnerPtrMut } @@ -17370,9 +16362,6 @@ mod objdetect_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDetectorParameters = core::Ptr; - ptr_extern! { crate::objdetect::DetectorParameters, cv_PtrLcv_aruco_DetectorParametersG_new_null_const, cv_PtrLcv_aruco_DetectorParametersG_delete, cv_PtrLcv_aruco_DetectorParametersG_getInnerPtr_const, cv_PtrLcv_aruco_DetectorParametersG_getInnerPtrMut } @@ -17433,9 +16422,6 @@ mod objdetect_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDictionary = core::Ptr; - ptr_extern! { crate::objdetect::Dictionary, cv_PtrLcv_aruco_DictionaryG_new_null_const, cv_PtrLcv_aruco_DictionaryG_delete, cv_PtrLcv_aruco_DictionaryG_getInnerPtr_const, cv_PtrLcv_aruco_DictionaryG_getInnerPtrMut } @@ -17465,9 +16451,6 @@ mod objdetect_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfFaceDetectorYN = core::Ptr; - ptr_extern! { crate::objdetect::FaceDetectorYN, cv_PtrLcv_FaceDetectorYNG_new_null_const, cv_PtrLcv_FaceDetectorYNG_delete, cv_PtrLcv_FaceDetectorYNG_getInnerPtr_const, cv_PtrLcv_FaceDetectorYNG_getInnerPtrMut } @@ -17493,9 +16476,6 @@ mod objdetect_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfFaceRecognizerSF = core::Ptr; - ptr_extern! { crate::objdetect::FaceRecognizerSF, cv_PtrLcv_FaceRecognizerSFG_new_null_const, cv_PtrLcv_FaceRecognizerSFG_delete, cv_PtrLcv_FaceRecognizerSFG_getInnerPtr_const, cv_PtrLcv_FaceRecognizerSFG_getInnerPtrMut } @@ -17521,9 +16501,6 @@ mod objdetect_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfGridBoard = core::Ptr; - ptr_extern! { crate::objdetect::GridBoard, cv_PtrLcv_aruco_GridBoardG_new_null_const, cv_PtrLcv_aruco_GridBoardG_delete, cv_PtrLcv_aruco_GridBoardG_getInnerPtr_const, cv_PtrLcv_aruco_GridBoardG_getInnerPtrMut } @@ -17560,9 +16537,6 @@ mod objdetect_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfQRCodeEncoder = core::Ptr; - ptr_extern! { crate::objdetect::QRCodeEncoder, cv_PtrLcv_QRCodeEncoderG_new_null_const, cv_PtrLcv_QRCodeEncoderG_delete, cv_PtrLcv_QRCodeEncoderG_getInnerPtr_const, cv_PtrLcv_QRCodeEncoderG_getInnerPtrMut } @@ -17588,9 +16562,6 @@ mod objdetect_types { } } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfDetectionBasedTracker_ExtObject = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfDetectionBasedTracker_ExtObject(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfDetectionBasedTracker_ExtObject(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -17621,9 +16592,6 @@ mod objdetect_types { } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfDetectionBasedTracker_Object = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfDetectionBasedTracker_Object(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfDetectionBasedTracker_Object(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -17642,9 +16610,6 @@ mod objdetect_types { vector_non_copy_or_bool! { crate::objdetect::DetectionBasedTracker_Object } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfDetectionROI = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfDetectionROI(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfDetectionROI(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -17676,16 +16641,11 @@ mod objdetect_types { } -#[cfg(ocvrs_has_module_objdetect)] pub use objdetect_types::*; -#[cfg(ocvrs_has_module_optflow)] mod optflow_types { use crate::{mod_prelude::*, core, types, sys}; - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDenseRLOFOpticalFlow = core::Ptr; - ptr_extern! { crate::optflow::DenseRLOFOpticalFlow, cv_PtrLcv_optflow_DenseRLOFOpticalFlowG_new_null_const, cv_PtrLcv_optflow_DenseRLOFOpticalFlowG_delete, cv_PtrLcv_optflow_DenseRLOFOpticalFlowG_getInnerPtr_const, cv_PtrLcv_optflow_DenseRLOFOpticalFlowG_getInnerPtrMut } @@ -17731,9 +16691,6 @@ mod optflow_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDualTVL1OpticalFlow = core::Ptr; - ptr_extern! { crate::optflow::DualTVL1OpticalFlow, cv_PtrLcv_optflow_DualTVL1OpticalFlowG_new_null_const, cv_PtrLcv_optflow_DualTVL1OpticalFlowG_delete, cv_PtrLcv_optflow_DualTVL1OpticalFlowG_getInnerPtr_const, cv_PtrLcv_optflow_DualTVL1OpticalFlowG_getInnerPtrMut } @@ -17779,9 +16736,6 @@ mod optflow_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfGPCTrainingSamples = core::Ptr; - ptr_extern! { crate::optflow::GPCTrainingSamples, cv_PtrLcv_optflow_GPCTrainingSamplesG_new_null_const, cv_PtrLcv_optflow_GPCTrainingSamplesG_delete, cv_PtrLcv_optflow_GPCTrainingSamplesG_getInnerPtr_const, cv_PtrLcv_optflow_GPCTrainingSamplesG_getInnerPtrMut } @@ -17808,9 +16762,6 @@ mod optflow_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfGPCTree = core::Ptr; - ptr_extern! { crate::optflow::GPCTree, cv_PtrLcv_optflow_GPCTreeG_new_null_const, cv_PtrLcv_optflow_GPCTreeG_delete, cv_PtrLcv_optflow_GPCTreeG_getInnerPtr_const, cv_PtrLcv_optflow_GPCTreeG_getInnerPtrMut } @@ -17847,9 +16798,6 @@ mod optflow_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfOpticalFlowPCAFlow = core::Ptr; - ptr_extern! { crate::optflow::OpticalFlowPCAFlow, cv_PtrLcv_optflow_OpticalFlowPCAFlowG_new_null_const, cv_PtrLcv_optflow_OpticalFlowPCAFlowG_delete, cv_PtrLcv_optflow_OpticalFlowPCAFlowG_getInnerPtr_const, cv_PtrLcv_optflow_OpticalFlowPCAFlowG_getInnerPtrMut } @@ -17896,9 +16844,6 @@ mod optflow_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfPCAPrior = core::Ptr; - ptr_extern! { crate::optflow::PCAPrior, cv_PtrLcv_optflow_PCAPriorG_new_null_const, cv_PtrLcv_optflow_PCAPriorG_delete, cv_PtrLcv_optflow_PCAPriorG_getInnerPtr_const, cv_PtrLcv_optflow_PCAPriorG_getInnerPtrMut } @@ -17925,9 +16870,6 @@ mod optflow_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfRLOFOpticalFlowParameter = core::Ptr; - ptr_extern! { crate::optflow::RLOFOpticalFlowParameter, cv_PtrLcv_optflow_RLOFOpticalFlowParameterG_new_null_const, cv_PtrLcv_optflow_RLOFOpticalFlowParameterG_delete, cv_PtrLcv_optflow_RLOFOpticalFlowParameterG_getInnerPtr_const, cv_PtrLcv_optflow_RLOFOpticalFlowParameterG_getInnerPtrMut } @@ -17968,9 +16910,6 @@ mod optflow_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfSparseRLOFOpticalFlow = core::Ptr; - ptr_extern! { crate::optflow::SparseRLOFOpticalFlow, cv_PtrLcv_optflow_SparseRLOFOpticalFlowG_new_null_const, cv_PtrLcv_optflow_SparseRLOFOpticalFlowG_delete, cv_PtrLcv_optflow_SparseRLOFOpticalFlowG_getInnerPtr_const, cv_PtrLcv_optflow_SparseRLOFOpticalFlowG_getInnerPtrMut } @@ -18016,9 +16955,6 @@ mod optflow_types { } } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfGPCPatchDescriptor = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfGPCPatchDescriptor(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfGPCPatchDescriptor(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -18049,9 +16985,6 @@ mod optflow_types { } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfGPCPatchSample = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfGPCPatchSample(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfGPCPatchSample(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -18083,16 +17016,11 @@ mod optflow_types { } -#[cfg(ocvrs_has_module_optflow)] pub use optflow_types::*; -#[cfg(ocvrs_has_module_ovis)] mod ovis_types { use crate::{mod_prelude::*, core, types, sys}; - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfWindowScene = core::Ptr; - ptr_extern! { crate::ovis::WindowScene, cv_PtrLcv_ovis_WindowSceneG_new_null_const, cv_PtrLcv_ovis_WindowSceneG_delete, cv_PtrLcv_ovis_WindowSceneG_getInnerPtr_const, cv_PtrLcv_ovis_WindowSceneG_getInnerPtrMut } @@ -18119,16 +17047,11 @@ mod ovis_types { } } -#[cfg(ocvrs_has_module_ovis)] pub use ovis_types::*; -#[cfg(ocvrs_has_module_phase_unwrapping)] mod phase_unwrapping_types { use crate::{mod_prelude::*, core, types, sys}; - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfHistogramPhaseUnwrapping = core::Ptr; - ptr_extern! { crate::phase_unwrapping::HistogramPhaseUnwrapping, cv_PtrLcv_phase_unwrapping_HistogramPhaseUnwrappingG_new_null_const, cv_PtrLcv_phase_unwrapping_HistogramPhaseUnwrappingG_delete, cv_PtrLcv_phase_unwrapping_HistogramPhaseUnwrappingG_getInnerPtr_const, cv_PtrLcv_phase_unwrapping_HistogramPhaseUnwrappingG_getInnerPtrMut } @@ -18174,9 +17097,6 @@ mod phase_unwrapping_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfPhaseUnwrapping = core::Ptr; - ptr_extern! { crate::phase_unwrapping::PhaseUnwrapping, cv_PtrLcv_phase_unwrapping_PhaseUnwrappingG_new_null_const, cv_PtrLcv_phase_unwrapping_PhaseUnwrappingG_delete, cv_PtrLcv_phase_unwrapping_PhaseUnwrappingG_getInnerPtr_const, cv_PtrLcv_phase_unwrapping_PhaseUnwrappingG_getInnerPtrMut } @@ -18213,16 +17133,11 @@ mod phase_unwrapping_types { } } -#[cfg(ocvrs_has_module_phase_unwrapping)] pub use phase_unwrapping_types::*; -#[cfg(ocvrs_has_module_photo)] mod photo_types { use crate::{mod_prelude::*, core, types, sys}; - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfAlignExposures = core::Ptr; - ptr_extern! { crate::photo::AlignExposures, cv_PtrLcv_AlignExposuresG_new_null_const, cv_PtrLcv_AlignExposuresG_delete, cv_PtrLcv_AlignExposuresG_getInnerPtr_const, cv_PtrLcv_AlignExposuresG_getInnerPtrMut } @@ -18258,9 +17173,6 @@ mod photo_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfAlignMTB = core::Ptr; - ptr_extern! { crate::photo::AlignMTB, cv_PtrLcv_AlignMTBG_new_null_const, cv_PtrLcv_AlignMTBG_delete, cv_PtrLcv_AlignMTBG_getInnerPtr_const, cv_PtrLcv_AlignMTBG_getInnerPtrMut } @@ -18306,9 +17218,6 @@ mod photo_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCalibrateCRF = core::Ptr; - ptr_extern! { crate::photo::CalibrateCRF, cv_PtrLcv_CalibrateCRFG_new_null_const, cv_PtrLcv_CalibrateCRFG_delete, cv_PtrLcv_CalibrateCRFG_getInnerPtr_const, cv_PtrLcv_CalibrateCRFG_getInnerPtrMut } @@ -18344,9 +17253,6 @@ mod photo_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCalibrateDebevec = core::Ptr; - ptr_extern! { crate::photo::CalibrateDebevec, cv_PtrLcv_CalibrateDebevecG_new_null_const, cv_PtrLcv_CalibrateDebevecG_delete, cv_PtrLcv_CalibrateDebevecG_getInnerPtr_const, cv_PtrLcv_CalibrateDebevecG_getInnerPtrMut } @@ -18392,9 +17298,6 @@ mod photo_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCalibrateRobertson = core::Ptr; - ptr_extern! { crate::photo::CalibrateRobertson, cv_PtrLcv_CalibrateRobertsonG_new_null_const, cv_PtrLcv_CalibrateRobertsonG_delete, cv_PtrLcv_CalibrateRobertsonG_getInnerPtr_const, cv_PtrLcv_CalibrateRobertsonG_getInnerPtrMut } @@ -18440,9 +17343,6 @@ mod photo_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfMergeDebevec = core::Ptr; - ptr_extern! { crate::photo::MergeDebevec, cv_PtrLcv_MergeDebevecG_new_null_const, cv_PtrLcv_MergeDebevecG_delete, cv_PtrLcv_MergeDebevecG_getInnerPtr_const, cv_PtrLcv_MergeDebevecG_getInnerPtrMut } @@ -18488,9 +17388,6 @@ mod photo_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfMergeExposures = core::Ptr; - ptr_extern! { crate::photo::MergeExposures, cv_PtrLcv_MergeExposuresG_new_null_const, cv_PtrLcv_MergeExposuresG_delete, cv_PtrLcv_MergeExposuresG_getInnerPtr_const, cv_PtrLcv_MergeExposuresG_getInnerPtrMut } @@ -18526,9 +17423,6 @@ mod photo_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfMergeMertens = core::Ptr; - ptr_extern! { crate::photo::MergeMertens, cv_PtrLcv_MergeMertensG_new_null_const, cv_PtrLcv_MergeMertensG_delete, cv_PtrLcv_MergeMertensG_getInnerPtr_const, cv_PtrLcv_MergeMertensG_getInnerPtrMut } @@ -18574,9 +17468,6 @@ mod photo_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfMergeRobertson = core::Ptr; - ptr_extern! { crate::photo::MergeRobertson, cv_PtrLcv_MergeRobertsonG_new_null_const, cv_PtrLcv_MergeRobertsonG_delete, cv_PtrLcv_MergeRobertsonG_getInnerPtr_const, cv_PtrLcv_MergeRobertsonG_getInnerPtrMut } @@ -18622,9 +17513,6 @@ mod photo_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfTonemap = core::Ptr; - ptr_extern! { crate::photo::Tonemap, cv_PtrLcv_TonemapG_new_null_const, cv_PtrLcv_TonemapG_delete, cv_PtrLcv_TonemapG_getInnerPtr_const, cv_PtrLcv_TonemapG_getInnerPtrMut } @@ -18660,9 +17548,6 @@ mod photo_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfTonemapDrago = core::Ptr; - ptr_extern! { crate::photo::TonemapDrago, cv_PtrLcv_TonemapDragoG_new_null_const, cv_PtrLcv_TonemapDragoG_delete, cv_PtrLcv_TonemapDragoG_getInnerPtr_const, cv_PtrLcv_TonemapDragoG_getInnerPtrMut } @@ -18708,9 +17593,6 @@ mod photo_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfTonemapMantiuk = core::Ptr; - ptr_extern! { crate::photo::TonemapMantiuk, cv_PtrLcv_TonemapMantiukG_new_null_const, cv_PtrLcv_TonemapMantiukG_delete, cv_PtrLcv_TonemapMantiukG_getInnerPtr_const, cv_PtrLcv_TonemapMantiukG_getInnerPtrMut } @@ -18756,9 +17638,6 @@ mod photo_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfTonemapReinhard = core::Ptr; - ptr_extern! { crate::photo::TonemapReinhard, cv_PtrLcv_TonemapReinhardG_new_null_const, cv_PtrLcv_TonemapReinhardG_delete, cv_PtrLcv_TonemapReinhardG_getInnerPtr_const, cv_PtrLcv_TonemapReinhardG_getInnerPtrMut } @@ -18805,16 +17684,11 @@ mod photo_types { } } -#[cfg(ocvrs_has_module_photo)] pub use photo_types::*; -#[cfg(ocvrs_has_module_plot)] mod plot_types { use crate::{mod_prelude::*, core, types, sys}; - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfPlot2d = core::Ptr; - ptr_extern! { crate::plot::Plot2d, cv_PtrLcv_plot_Plot2dG_new_null_const, cv_PtrLcv_plot_Plot2dG_delete, cv_PtrLcv_plot_Plot2dG_getInnerPtr_const, cv_PtrLcv_plot_Plot2dG_getInnerPtrMut } @@ -18851,16 +17725,11 @@ mod plot_types { } } -#[cfg(ocvrs_has_module_plot)] pub use plot_types::*; -#[cfg(ocvrs_has_module_quality)] mod quality_types { use crate::{mod_prelude::*, core, types, sys}; - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfQualityBRISQUE = core::Ptr; - ptr_extern! { crate::quality::QualityBRISQUE, cv_PtrLcv_quality_QualityBRISQUEG_new_null_const, cv_PtrLcv_quality_QualityBRISQUEG_delete, cv_PtrLcv_quality_QualityBRISQUEG_getInnerPtr_const, cv_PtrLcv_quality_QualityBRISQUEG_getInnerPtrMut } @@ -18907,9 +17776,6 @@ mod quality_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfQualityBase = core::Ptr; - ptr_extern! { crate::quality::QualityBase, cv_PtrLcv_quality_QualityBaseG_new_null_const, cv_PtrLcv_quality_QualityBaseG_delete, cv_PtrLcv_quality_QualityBaseG_getInnerPtr_const, cv_PtrLcv_quality_QualityBaseG_getInnerPtrMut } @@ -18945,9 +17811,6 @@ mod quality_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfQualityGMSD = core::Ptr; - ptr_extern! { crate::quality::QualityGMSD, cv_PtrLcv_quality_QualityGMSDG_new_null_const, cv_PtrLcv_quality_QualityGMSDG_delete, cv_PtrLcv_quality_QualityGMSDG_getInnerPtr_const, cv_PtrLcv_quality_QualityGMSDG_getInnerPtrMut } @@ -18994,9 +17857,6 @@ mod quality_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfQualityMSE = core::Ptr; - ptr_extern! { crate::quality::QualityMSE, cv_PtrLcv_quality_QualityMSEG_new_null_const, cv_PtrLcv_quality_QualityMSEG_delete, cv_PtrLcv_quality_QualityMSEG_getInnerPtr_const, cv_PtrLcv_quality_QualityMSEG_getInnerPtrMut } @@ -19043,9 +17903,6 @@ mod quality_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfQualityPSNR = core::Ptr; - ptr_extern! { crate::quality::QualityPSNR, cv_PtrLcv_quality_QualityPSNRG_new_null_const, cv_PtrLcv_quality_QualityPSNRG_delete, cv_PtrLcv_quality_QualityPSNRG_getInnerPtr_const, cv_PtrLcv_quality_QualityPSNRG_getInnerPtrMut } @@ -19092,9 +17949,6 @@ mod quality_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfQualitySSIM = core::Ptr; - ptr_extern! { crate::quality::QualitySSIM, cv_PtrLcv_quality_QualitySSIMG_new_null_const, cv_PtrLcv_quality_QualitySSIMG_delete, cv_PtrLcv_quality_QualitySSIMG_getInnerPtr_const, cv_PtrLcv_quality_QualitySSIMG_getInnerPtrMut } @@ -19142,16 +17996,11 @@ mod quality_types { } } -#[cfg(ocvrs_has_module_quality)] pub use quality_types::*; -#[cfg(ocvrs_has_module_rapid)] mod rapid_types { use crate::{mod_prelude::*, core, types, sys}; - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfRapid_GOSTracker = core::Ptr; - ptr_extern! { crate::rapid::Rapid_GOSTracker, cv_PtrLcv_rapid_GOSTrackerG_new_null_const, cv_PtrLcv_rapid_GOSTrackerG_delete, cv_PtrLcv_rapid_GOSTrackerG_getInnerPtr_const, cv_PtrLcv_rapid_GOSTrackerG_getInnerPtrMut } @@ -19197,9 +18046,6 @@ mod rapid_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfRapid_OLSTracker = core::Ptr; - ptr_extern! { crate::rapid::Rapid_OLSTracker, cv_PtrLcv_rapid_OLSTrackerG_new_null_const, cv_PtrLcv_rapid_OLSTrackerG_delete, cv_PtrLcv_rapid_OLSTrackerG_getInnerPtr_const, cv_PtrLcv_rapid_OLSTrackerG_getInnerPtrMut } @@ -19245,9 +18091,6 @@ mod rapid_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfRapid_Rapid = core::Ptr; - ptr_extern! { crate::rapid::Rapid_Rapid, cv_PtrLcv_rapid_RapidG_new_null_const, cv_PtrLcv_rapid_RapidG_delete, cv_PtrLcv_rapid_RapidG_getInnerPtr_const, cv_PtrLcv_rapid_RapidG_getInnerPtrMut } @@ -19293,9 +18136,6 @@ mod rapid_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfRapid_Tracker = core::Ptr; - ptr_extern! { crate::rapid::Rapid_Tracker, cv_PtrLcv_rapid_TrackerG_new_null_const, cv_PtrLcv_rapid_TrackerG_delete, cv_PtrLcv_rapid_TrackerG_getInnerPtr_const, cv_PtrLcv_rapid_TrackerG_getInnerPtrMut } @@ -19332,16 +18172,11 @@ mod rapid_types { } } -#[cfg(ocvrs_has_module_rapid)] pub use rapid_types::*; -#[cfg(ocvrs_has_module_rgbd)] mod rgbd_types { use crate::{mod_prelude::*, core, types, sys}; - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfColoredKinfu_ColoredKinFu = core::Ptr; - ptr_extern! { crate::rgbd::ColoredKinfu_ColoredKinFu, cv_PtrLcv_colored_kinfu_ColoredKinFuG_new_null_const, cv_PtrLcv_colored_kinfu_ColoredKinFuG_delete, cv_PtrLcv_colored_kinfu_ColoredKinFuG_getInnerPtr_const, cv_PtrLcv_colored_kinfu_ColoredKinFuG_getInnerPtrMut } @@ -19367,9 +18202,6 @@ mod rgbd_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfColoredKinfu_Params = core::Ptr; - ptr_extern! { crate::rgbd::ColoredKinfu_Params, cv_PtrLcv_colored_kinfu_ParamsG_new_null_const, cv_PtrLcv_colored_kinfu_ParamsG_delete, cv_PtrLcv_colored_kinfu_ParamsG_getInnerPtr_const, cv_PtrLcv_colored_kinfu_ParamsG_getInnerPtrMut } @@ -19418,9 +18250,6 @@ mod rgbd_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDepthCleaner = core::Ptr; - ptr_extern! { crate::rgbd::DepthCleaner, cv_PtrLcv_rgbd_DepthCleanerG_new_null_const, cv_PtrLcv_rgbd_DepthCleanerG_delete, cv_PtrLcv_rgbd_DepthCleanerG_getInnerPtr_const, cv_PtrLcv_rgbd_DepthCleanerG_getInnerPtrMut } @@ -19457,9 +18286,6 @@ mod rgbd_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDynafu_DynaFu = core::Ptr; - ptr_extern! { crate::rgbd::Dynafu_DynaFu, cv_PtrLcv_dynafu_DynaFuG_new_null_const, cv_PtrLcv_dynafu_DynaFuG_delete, cv_PtrLcv_dynafu_DynaFuG_getInnerPtr_const, cv_PtrLcv_dynafu_DynaFuG_getInnerPtrMut } @@ -19485,9 +18311,6 @@ mod rgbd_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfFastICPOdometry = core::Ptr; - ptr_extern! { crate::rgbd::FastICPOdometry, cv_PtrLcv_rgbd_FastICPOdometryG_new_null_const, cv_PtrLcv_rgbd_FastICPOdometryG_delete, cv_PtrLcv_rgbd_FastICPOdometryG_getInnerPtr_const, cv_PtrLcv_rgbd_FastICPOdometryG_getInnerPtrMut } @@ -19534,9 +18357,6 @@ mod rgbd_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfICPOdometry = core::Ptr; - ptr_extern! { crate::rgbd::ICPOdometry, cv_PtrLcv_rgbd_ICPOdometryG_new_null_const, cv_PtrLcv_rgbd_ICPOdometryG_delete, cv_PtrLcv_rgbd_ICPOdometryG_getInnerPtr_const, cv_PtrLcv_rgbd_ICPOdometryG_getInnerPtrMut } @@ -19583,9 +18403,6 @@ mod rgbd_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfKinfu_Detail_PoseGraph = core::Ptr; - ptr_extern! { crate::rgbd::Kinfu_Detail_PoseGraph, cv_PtrLcv_kinfu_detail_PoseGraphG_new_null_const, cv_PtrLcv_kinfu_detail_PoseGraphG_delete, cv_PtrLcv_kinfu_detail_PoseGraphG_getInnerPtr_const, cv_PtrLcv_kinfu_detail_PoseGraphG_getInnerPtrMut } @@ -19611,9 +18428,6 @@ mod rgbd_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfKinfu_KinFu = core::Ptr; - ptr_extern! { crate::rgbd::Kinfu_KinFu, cv_PtrLcv_kinfu_KinFuG_new_null_const, cv_PtrLcv_kinfu_KinFuG_delete, cv_PtrLcv_kinfu_KinFuG_getInnerPtr_const, cv_PtrLcv_kinfu_KinFuG_getInnerPtrMut } @@ -19639,9 +18453,6 @@ mod rgbd_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfKinfu_Params = core::Ptr; - ptr_extern! { crate::rgbd::Kinfu_Params, cv_PtrLcv_kinfu_ParamsG_new_null_const, cv_PtrLcv_kinfu_ParamsG_delete, cv_PtrLcv_kinfu_ParamsG_getInnerPtr_const, cv_PtrLcv_kinfu_ParamsG_getInnerPtrMut } @@ -19689,9 +18500,6 @@ mod rgbd_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfKinfu_Volume = core::Ptr; - ptr_extern! { crate::rgbd::Kinfu_Volume, cv_PtrLcv_kinfu_VolumeG_new_null_const, cv_PtrLcv_kinfu_VolumeG_delete, cv_PtrLcv_kinfu_VolumeG_getInnerPtr_const, cv_PtrLcv_kinfu_VolumeG_getInnerPtrMut } @@ -19721,9 +18529,6 @@ mod rgbd_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfKinfu_VolumeParams = core::Ptr; - ptr_extern! { crate::rgbd::Kinfu_VolumeParams, cv_PtrLcv_kinfu_VolumeParamsG_new_null_const, cv_PtrLcv_kinfu_VolumeParamsG_delete, cv_PtrLcv_kinfu_VolumeParamsG_getInnerPtr_const, cv_PtrLcv_kinfu_VolumeParamsG_getInnerPtrMut } @@ -19759,9 +18564,6 @@ mod rgbd_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfLargeKinfu = core::Ptr; - ptr_extern! { crate::rgbd::LargeKinfu, cv_PtrLcv_large_kinfu_LargeKinfuG_new_null_const, cv_PtrLcv_large_kinfu_LargeKinfuG_delete, cv_PtrLcv_large_kinfu_LargeKinfuG_getInnerPtr_const, cv_PtrLcv_large_kinfu_LargeKinfuG_getInnerPtrMut } @@ -19787,9 +18589,6 @@ mod rgbd_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfLineMod_ColorGradient = core::Ptr; - ptr_extern! { crate::rgbd::LineMod_ColorGradient, cv_PtrLcv_linemod_ColorGradientG_new_null_const, cv_PtrLcv_linemod_ColorGradientG_delete, cv_PtrLcv_linemod_ColorGradientG_getInnerPtr_const, cv_PtrLcv_linemod_ColorGradientG_getInnerPtrMut } @@ -19829,9 +18628,6 @@ mod rgbd_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfLineMod_DepthNormal = core::Ptr; - ptr_extern! { crate::rgbd::LineMod_DepthNormal, cv_PtrLcv_linemod_DepthNormalG_new_null_const, cv_PtrLcv_linemod_DepthNormalG_delete, cv_PtrLcv_linemod_DepthNormalG_getInnerPtr_const, cv_PtrLcv_linemod_DepthNormalG_getInnerPtrMut } @@ -19872,9 +18668,6 @@ mod rgbd_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfLineMod_Detector = core::Ptr; - ptr_extern! { crate::rgbd::LineMod_Detector, cv_PtrLcv_linemod_DetectorG_new_null_const, cv_PtrLcv_linemod_DetectorG_delete, cv_PtrLcv_linemod_DetectorG_getInnerPtr_const, cv_PtrLcv_linemod_DetectorG_getInnerPtrMut } @@ -19901,9 +18694,6 @@ mod rgbd_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfLineMod_Modality = core::Ptr; - ptr_extern! { crate::rgbd::LineMod_Modality, cv_PtrLcv_linemod_ModalityG_new_null_const, cv_PtrLcv_linemod_ModalityG_delete, cv_PtrLcv_linemod_ModalityG_getInnerPtr_const, cv_PtrLcv_linemod_ModalityG_getInnerPtrMut } @@ -19929,9 +18719,6 @@ mod rgbd_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfLineMod_QuantizedPyramid = core::Ptr; - ptr_extern! { crate::rgbd::LineMod_QuantizedPyramid, cv_PtrLcv_linemod_QuantizedPyramidG_new_null_const, cv_PtrLcv_linemod_QuantizedPyramidG_delete, cv_PtrLcv_linemod_QuantizedPyramidG_getInnerPtr_const, cv_PtrLcv_linemod_QuantizedPyramidG_getInnerPtrMut } @@ -19957,9 +18744,6 @@ mod rgbd_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfOdometry = core::Ptr; - ptr_extern! { crate::rgbd::Odometry, cv_PtrLcv_rgbd_OdometryG_new_null_const, cv_PtrLcv_rgbd_OdometryG_delete, cv_PtrLcv_rgbd_OdometryG_getInnerPtr_const, cv_PtrLcv_rgbd_OdometryG_getInnerPtrMut } @@ -19995,9 +18779,6 @@ mod rgbd_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfOdometryFrame = core::Ptr; - ptr_extern! { crate::rgbd::OdometryFrame, cv_PtrLcv_rgbd_OdometryFrameG_new_null_const, cv_PtrLcv_rgbd_OdometryFrameG_delete, cv_PtrLcv_rgbd_OdometryFrameG_getInnerPtr_const, cv_PtrLcv_rgbd_OdometryFrameG_getInnerPtrMut } @@ -20048,9 +18829,6 @@ mod rgbd_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfParams = core::Ptr; - ptr_extern! { crate::rgbd::Params, cv_PtrLcv_large_kinfu_ParamsG_new_null_const, cv_PtrLcv_large_kinfu_ParamsG_delete, cv_PtrLcv_large_kinfu_ParamsG_getInnerPtr_const, cv_PtrLcv_large_kinfu_ParamsG_getInnerPtrMut } @@ -20092,9 +18870,6 @@ mod rgbd_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfRgbdFrame = core::Ptr; - ptr_extern! { crate::rgbd::RgbdFrame, cv_PtrLcv_rgbd_RgbdFrameG_new_null_const, cv_PtrLcv_rgbd_RgbdFrameG_delete, cv_PtrLcv_rgbd_RgbdFrameG_getInnerPtr_const, cv_PtrLcv_rgbd_RgbdFrameG_getInnerPtrMut } @@ -20126,9 +18901,6 @@ mod rgbd_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfRgbdICPOdometry = core::Ptr; - ptr_extern! { crate::rgbd::RgbdICPOdometry, cv_PtrLcv_rgbd_RgbdICPOdometryG_new_null_const, cv_PtrLcv_rgbd_RgbdICPOdometryG_delete, cv_PtrLcv_rgbd_RgbdICPOdometryG_getInnerPtr_const, cv_PtrLcv_rgbd_RgbdICPOdometryG_getInnerPtrMut } @@ -20175,9 +18947,6 @@ mod rgbd_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfRgbdNormals = core::Ptr; - ptr_extern! { crate::rgbd::RgbdNormals, cv_PtrLcv_rgbd_RgbdNormalsG_new_null_const, cv_PtrLcv_rgbd_RgbdNormalsG_delete, cv_PtrLcv_rgbd_RgbdNormalsG_getInnerPtr_const, cv_PtrLcv_rgbd_RgbdNormalsG_getInnerPtrMut } @@ -20214,9 +18983,6 @@ mod rgbd_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfRgbdOdometry = core::Ptr; - ptr_extern! { crate::rgbd::RgbdOdometry, cv_PtrLcv_rgbd_RgbdOdometryG_new_null_const, cv_PtrLcv_rgbd_RgbdOdometryG_delete, cv_PtrLcv_rgbd_RgbdOdometryG_getInnerPtr_const, cv_PtrLcv_rgbd_RgbdOdometryG_getInnerPtrMut } @@ -20263,9 +19029,6 @@ mod rgbd_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfRgbdPlane = core::Ptr; - ptr_extern! { crate::rgbd::RgbdPlane, cv_PtrLcv_rgbd_RgbdPlaneG_new_null_const, cv_PtrLcv_rgbd_RgbdPlaneG_delete, cv_PtrLcv_rgbd_RgbdPlaneG_getInnerPtr_const, cv_PtrLcv_rgbd_RgbdPlaneG_getInnerPtrMut } @@ -20302,9 +19065,6 @@ mod rgbd_types { } } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfLineMod_Feature = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfLineMod_Feature(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfLineMod_Feature(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -20326,9 +19086,6 @@ mod rgbd_types { } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfLineMod_Match = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfLineMod_Match(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfLineMod_Match(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -20359,9 +19116,6 @@ mod rgbd_types { } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfLineMod_Template = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfLineMod_Template(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfLineMod_Template(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -20392,9 +19146,6 @@ mod rgbd_types { } - #[deprecated = "Use the the non-alias form `core::Vector>` instead, removal in Nov 2024"] - pub type VectorOfPtrOfLineMod_Modality = core::Vector>; - impl core::Vector> { pub fn as_raw_VectorOfPtrOfLineMod_Modality(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfPtrOfLineMod_Modality(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -20414,16 +19165,11 @@ mod rgbd_types { } -#[cfg(ocvrs_has_module_rgbd)] pub use rgbd_types::*; -#[cfg(ocvrs_has_module_saliency)] mod saliency_types { use crate::{mod_prelude::*, core, types, sys}; - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfMotionSaliency = core::Ptr; - ptr_extern! { crate::saliency::MotionSaliency, cv_PtrLcv_saliency_MotionSaliencyG_new_null_const, cv_PtrLcv_saliency_MotionSaliencyG_delete, cv_PtrLcv_saliency_MotionSaliencyG_getInnerPtr_const, cv_PtrLcv_saliency_MotionSaliencyG_getInnerPtrMut } @@ -20469,9 +19215,6 @@ mod saliency_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfMotionSaliencyBinWangApr2014 = core::Ptr; - ptr_extern! { crate::saliency::MotionSaliencyBinWangApr2014, cv_PtrLcv_saliency_MotionSaliencyBinWangApr2014G_new_null_const, cv_PtrLcv_saliency_MotionSaliencyBinWangApr2014G_delete, cv_PtrLcv_saliency_MotionSaliencyBinWangApr2014G_getInnerPtr_const, cv_PtrLcv_saliency_MotionSaliencyBinWangApr2014G_getInnerPtrMut } @@ -20528,9 +19271,6 @@ mod saliency_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfObjectness = core::Ptr; - ptr_extern! { crate::saliency::Objectness, cv_PtrLcv_saliency_ObjectnessG_new_null_const, cv_PtrLcv_saliency_ObjectnessG_delete, cv_PtrLcv_saliency_ObjectnessG_getInnerPtr_const, cv_PtrLcv_saliency_ObjectnessG_getInnerPtrMut } @@ -20576,9 +19316,6 @@ mod saliency_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfObjectnessBING = core::Ptr; - ptr_extern! { crate::saliency::ObjectnessBING, cv_PtrLcv_saliency_ObjectnessBINGG_new_null_const, cv_PtrLcv_saliency_ObjectnessBINGG_delete, cv_PtrLcv_saliency_ObjectnessBINGG_getInnerPtr_const, cv_PtrLcv_saliency_ObjectnessBINGG_getInnerPtrMut } @@ -20635,9 +19372,6 @@ mod saliency_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfSaliency = core::Ptr; - ptr_extern! { crate::saliency::Saliency, cv_PtrLcv_saliency_SaliencyG_new_null_const, cv_PtrLcv_saliency_SaliencyG_delete, cv_PtrLcv_saliency_SaliencyG_getInnerPtr_const, cv_PtrLcv_saliency_SaliencyG_getInnerPtrMut } @@ -20673,9 +19407,6 @@ mod saliency_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfStaticSaliency = core::Ptr; - ptr_extern! { crate::saliency::StaticSaliency, cv_PtrLcv_saliency_StaticSaliencyG_new_null_const, cv_PtrLcv_saliency_StaticSaliencyG_delete, cv_PtrLcv_saliency_StaticSaliencyG_getInnerPtr_const, cv_PtrLcv_saliency_StaticSaliencyG_getInnerPtrMut } @@ -20721,9 +19452,6 @@ mod saliency_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfStaticSaliencyFineGrained = core::Ptr; - ptr_extern! { crate::saliency::StaticSaliencyFineGrained, cv_PtrLcv_saliency_StaticSaliencyFineGrainedG_new_null_const, cv_PtrLcv_saliency_StaticSaliencyFineGrainedG_delete, cv_PtrLcv_saliency_StaticSaliencyFineGrainedG_getInnerPtr_const, cv_PtrLcv_saliency_StaticSaliencyFineGrainedG_getInnerPtrMut } @@ -20780,9 +19508,6 @@ mod saliency_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfStaticSaliencySpectralResidual = core::Ptr; - ptr_extern! { crate::saliency::StaticSaliencySpectralResidual, cv_PtrLcv_saliency_StaticSaliencySpectralResidualG_new_null_const, cv_PtrLcv_saliency_StaticSaliencySpectralResidualG_delete, cv_PtrLcv_saliency_StaticSaliencySpectralResidualG_getInnerPtr_const, cv_PtrLcv_saliency_StaticSaliencySpectralResidualG_getInnerPtrMut } @@ -20840,16 +19565,11 @@ mod saliency_types { } } -#[cfg(ocvrs_has_module_saliency)] pub use saliency_types::*; -#[cfg(ocvrs_has_module_sfm)] mod sfm_types { use crate::{mod_prelude::*, core, types, sys}; - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfBaseSFM = core::Ptr; - ptr_extern! { crate::sfm::BaseSFM, cv_PtrLcv_sfm_BaseSFMG_new_null_const, cv_PtrLcv_sfm_BaseSFMG_delete, cv_PtrLcv_sfm_BaseSFMG_getInnerPtr_const, cv_PtrLcv_sfm_BaseSFMG_getInnerPtrMut } @@ -20875,9 +19595,6 @@ mod sfm_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfSFMLibmvEuclideanReconstruction = core::Ptr; - ptr_extern! { crate::sfm::SFMLibmvEuclideanReconstruction, cv_PtrLcv_sfm_SFMLibmvEuclideanReconstructionG_new_null_const, cv_PtrLcv_sfm_SFMLibmvEuclideanReconstructionG_delete, cv_PtrLcv_sfm_SFMLibmvEuclideanReconstructionG_getInnerPtr_const, cv_PtrLcv_sfm_SFMLibmvEuclideanReconstructionG_getInnerPtrMut } @@ -20914,16 +19631,11 @@ mod sfm_types { } } -#[cfg(ocvrs_has_module_sfm)] pub use sfm_types::*; -#[cfg(ocvrs_has_module_shape)] mod shape_types { use crate::{mod_prelude::*, core, types, sys}; - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfAffineTransformer = core::Ptr; - ptr_extern! { crate::shape::AffineTransformer, cv_PtrLcv_AffineTransformerG_new_null_const, cv_PtrLcv_AffineTransformerG_delete, cv_PtrLcv_AffineTransformerG_getInnerPtr_const, cv_PtrLcv_AffineTransformerG_getInnerPtrMut } @@ -20969,9 +19681,6 @@ mod shape_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfChiHistogramCostExtractor = core::Ptr; - ptr_extern! { crate::shape::ChiHistogramCostExtractor, cv_PtrLcv_ChiHistogramCostExtractorG_new_null_const, cv_PtrLcv_ChiHistogramCostExtractorG_delete, cv_PtrLcv_ChiHistogramCostExtractorG_getInnerPtr_const, cv_PtrLcv_ChiHistogramCostExtractorG_getInnerPtrMut } @@ -21017,9 +19726,6 @@ mod shape_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfEMDHistogramCostExtractor = core::Ptr; - ptr_extern! { crate::shape::EMDHistogramCostExtractor, cv_PtrLcv_EMDHistogramCostExtractorG_new_null_const, cv_PtrLcv_EMDHistogramCostExtractorG_delete, cv_PtrLcv_EMDHistogramCostExtractorG_getInnerPtr_const, cv_PtrLcv_EMDHistogramCostExtractorG_getInnerPtrMut } @@ -21065,9 +19771,6 @@ mod shape_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfEMDL1HistogramCostExtractor = core::Ptr; - ptr_extern! { crate::shape::EMDL1HistogramCostExtractor, cv_PtrLcv_EMDL1HistogramCostExtractorG_new_null_const, cv_PtrLcv_EMDL1HistogramCostExtractorG_delete, cv_PtrLcv_EMDL1HistogramCostExtractorG_getInnerPtr_const, cv_PtrLcv_EMDL1HistogramCostExtractorG_getInnerPtrMut } @@ -21113,9 +19816,6 @@ mod shape_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfHausdorffDistanceExtractor = core::Ptr; - ptr_extern! { crate::shape::HausdorffDistanceExtractor, cv_PtrLcv_HausdorffDistanceExtractorG_new_null_const, cv_PtrLcv_HausdorffDistanceExtractorG_delete, cv_PtrLcv_HausdorffDistanceExtractorG_getInnerPtr_const, cv_PtrLcv_HausdorffDistanceExtractorG_getInnerPtrMut } @@ -21161,9 +19861,6 @@ mod shape_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfHistogramCostExtractor = core::Ptr; - ptr_extern! { crate::shape::HistogramCostExtractor, cv_PtrLcv_HistogramCostExtractorG_new_null_const, cv_PtrLcv_HistogramCostExtractorG_delete, cv_PtrLcv_HistogramCostExtractorG_getInnerPtr_const, cv_PtrLcv_HistogramCostExtractorG_getInnerPtrMut } @@ -21199,9 +19896,6 @@ mod shape_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfNormHistogramCostExtractor = core::Ptr; - ptr_extern! { crate::shape::NormHistogramCostExtractor, cv_PtrLcv_NormHistogramCostExtractorG_new_null_const, cv_PtrLcv_NormHistogramCostExtractorG_delete, cv_PtrLcv_NormHistogramCostExtractorG_getInnerPtr_const, cv_PtrLcv_NormHistogramCostExtractorG_getInnerPtrMut } @@ -21247,9 +19941,6 @@ mod shape_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfShapeContextDistanceExtractor = core::Ptr; - ptr_extern! { crate::shape::ShapeContextDistanceExtractor, cv_PtrLcv_ShapeContextDistanceExtractorG_new_null_const, cv_PtrLcv_ShapeContextDistanceExtractorG_delete, cv_PtrLcv_ShapeContextDistanceExtractorG_getInnerPtr_const, cv_PtrLcv_ShapeContextDistanceExtractorG_getInnerPtrMut } @@ -21295,9 +19986,6 @@ mod shape_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfShapeDistanceExtractor = core::Ptr; - ptr_extern! { crate::shape::ShapeDistanceExtractor, cv_PtrLcv_ShapeDistanceExtractorG_new_null_const, cv_PtrLcv_ShapeDistanceExtractorG_delete, cv_PtrLcv_ShapeDistanceExtractorG_getInnerPtr_const, cv_PtrLcv_ShapeDistanceExtractorG_getInnerPtrMut } @@ -21333,9 +20021,6 @@ mod shape_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfShapeTransformer = core::Ptr; - ptr_extern! { crate::shape::ShapeTransformer, cv_PtrLcv_ShapeTransformerG_new_null_const, cv_PtrLcv_ShapeTransformerG_delete, cv_PtrLcv_ShapeTransformerG_getInnerPtr_const, cv_PtrLcv_ShapeTransformerG_getInnerPtrMut } @@ -21371,9 +20056,6 @@ mod shape_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfThinPlateSplineShapeTransformer = core::Ptr; - ptr_extern! { crate::shape::ThinPlateSplineShapeTransformer, cv_PtrLcv_ThinPlateSplineShapeTransformerG_new_null_const, cv_PtrLcv_ThinPlateSplineShapeTransformerG_delete, cv_PtrLcv_ThinPlateSplineShapeTransformerG_getInnerPtr_const, cv_PtrLcv_ThinPlateSplineShapeTransformerG_getInnerPtrMut } @@ -21420,16 +20102,11 @@ mod shape_types { } } -#[cfg(ocvrs_has_module_shape)] pub use shape_types::*; -#[cfg(ocvrs_has_module_stereo)] mod stereo_types { use crate::{mod_prelude::*, core, types, sys}; - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfQuasiDenseStereo = core::Ptr; - ptr_extern! { crate::stereo::QuasiDenseStereo, cv_PtrLcv_stereo_QuasiDenseStereoG_new_null_const, cv_PtrLcv_stereo_QuasiDenseStereoG_delete, cv_PtrLcv_stereo_QuasiDenseStereoG_getInnerPtr_const, cv_PtrLcv_stereo_QuasiDenseStereoG_getInnerPtrMut } @@ -21456,9 +20133,6 @@ mod stereo_types { } } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfMatchQuasiDense = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfMatchQuasiDense(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfMatchQuasiDense(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -21481,16 +20155,11 @@ mod stereo_types { } -#[cfg(ocvrs_has_module_stereo)] pub use stereo_types::*; -#[cfg(ocvrs_has_module_stitching)] mod stitching_types { use crate::{mod_prelude::*, core, types, sys}; - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfAffineWarper = core::Ptr; - ptr_extern! { crate::stitching::AffineWarper, cv_PtrLcv_AffineWarperG_new_null_const, cv_PtrLcv_AffineWarperG_delete, cv_PtrLcv_AffineWarperG_getInnerPtr_const, cv_PtrLcv_AffineWarperG_getInnerPtrMut } @@ -21527,9 +20196,6 @@ mod stitching_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCompressedRectilinearPortraitWarper = core::Ptr; - ptr_extern! { crate::stitching::CompressedRectilinearPortraitWarper, cv_PtrLcv_CompressedRectilinearPortraitWarperG_new_null_const, cv_PtrLcv_CompressedRectilinearPortraitWarperG_delete, cv_PtrLcv_CompressedRectilinearPortraitWarperG_getInnerPtr_const, cv_PtrLcv_CompressedRectilinearPortraitWarperG_getInnerPtrMut } @@ -21566,9 +20232,6 @@ mod stitching_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCompressedRectilinearWarper = core::Ptr; - ptr_extern! { crate::stitching::CompressedRectilinearWarper, cv_PtrLcv_CompressedRectilinearWarperG_new_null_const, cv_PtrLcv_CompressedRectilinearWarperG_delete, cv_PtrLcv_CompressedRectilinearWarperG_getInnerPtr_const, cv_PtrLcv_CompressedRectilinearWarperG_getInnerPtrMut } @@ -21605,9 +20268,6 @@ mod stitching_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCylindricalWarper = core::Ptr; - ptr_extern! { crate::stitching::CylindricalWarper, cv_PtrLcv_CylindricalWarperG_new_null_const, cv_PtrLcv_CylindricalWarperG_delete, cv_PtrLcv_CylindricalWarperG_getInnerPtr_const, cv_PtrLcv_CylindricalWarperG_getInnerPtrMut } @@ -21644,9 +20304,6 @@ mod stitching_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfCylindricalWarperGpu = core::Ptr; - ptr_extern! { crate::stitching::CylindricalWarperGpu, cv_PtrLcv_CylindricalWarperGpuG_new_null_const, cv_PtrLcv_CylindricalWarperGpuG_delete, cv_PtrLcv_CylindricalWarperGpuG_getInnerPtr_const, cv_PtrLcv_CylindricalWarperGpuG_getInnerPtrMut } @@ -21683,9 +20340,6 @@ mod stitching_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDetail_AffineBasedEstimator = core::Ptr; - ptr_extern! { crate::stitching::Detail_AffineBasedEstimator, cv_PtrLcv_detail_AffineBasedEstimatorG_new_null_const, cv_PtrLcv_detail_AffineBasedEstimatorG_delete, cv_PtrLcv_detail_AffineBasedEstimatorG_getInnerPtr_const, cv_PtrLcv_detail_AffineBasedEstimatorG_getInnerPtrMut } @@ -21722,9 +20376,6 @@ mod stitching_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDetail_AffineBestOf2NearestMatcher = core::Ptr; - ptr_extern! { crate::stitching::Detail_AffineBestOf2NearestMatcher, cv_PtrLcv_detail_AffineBestOf2NearestMatcherG_new_null_const, cv_PtrLcv_detail_AffineBestOf2NearestMatcherG_delete, cv_PtrLcv_detail_AffineBestOf2NearestMatcherG_getInnerPtr_const, cv_PtrLcv_detail_AffineBestOf2NearestMatcherG_getInnerPtrMut } @@ -21771,9 +20422,6 @@ mod stitching_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDetail_BestOf2NearestMatcher = core::Ptr; - ptr_extern! { crate::stitching::Detail_BestOf2NearestMatcher, cv_PtrLcv_detail_BestOf2NearestMatcherG_new_null_const, cv_PtrLcv_detail_BestOf2NearestMatcherG_delete, cv_PtrLcv_detail_BestOf2NearestMatcherG_getInnerPtr_const, cv_PtrLcv_detail_BestOf2NearestMatcherG_getInnerPtrMut } @@ -21810,9 +20458,6 @@ mod stitching_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDetail_BestOf2NearestRangeMatcher = core::Ptr; - ptr_extern! { crate::stitching::Detail_BestOf2NearestRangeMatcher, cv_PtrLcv_detail_BestOf2NearestRangeMatcherG_new_null_const, cv_PtrLcv_detail_BestOf2NearestRangeMatcherG_delete, cv_PtrLcv_detail_BestOf2NearestRangeMatcherG_getInnerPtr_const, cv_PtrLcv_detail_BestOf2NearestRangeMatcherG_getInnerPtrMut } @@ -21859,9 +20504,6 @@ mod stitching_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDetail_Blender = core::Ptr; - ptr_extern! { crate::stitching::Detail_Blender, cv_PtrLcv_detail_BlenderG_new_null_const, cv_PtrLcv_detail_BlenderG_delete, cv_PtrLcv_detail_BlenderG_getInnerPtr_const, cv_PtrLcv_detail_BlenderG_getInnerPtrMut } @@ -21888,9 +20530,6 @@ mod stitching_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDetail_BlocksChannelsCompensator = core::Ptr; - ptr_extern! { crate::stitching::Detail_BlocksChannelsCompensator, cv_PtrLcv_detail_BlocksChannelsCompensatorG_new_null_const, cv_PtrLcv_detail_BlocksChannelsCompensatorG_delete, cv_PtrLcv_detail_BlocksChannelsCompensatorG_getInnerPtr_const, cv_PtrLcv_detail_BlocksChannelsCompensatorG_getInnerPtrMut } @@ -21937,9 +20576,6 @@ mod stitching_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDetail_BlocksCompensator = core::Ptr; - ptr_extern! { crate::stitching::Detail_BlocksCompensator, cv_PtrLcv_detail_BlocksCompensatorG_new_null_const, cv_PtrLcv_detail_BlocksCompensatorG_delete, cv_PtrLcv_detail_BlocksCompensatorG_getInnerPtr_const, cv_PtrLcv_detail_BlocksCompensatorG_getInnerPtrMut } @@ -21975,9 +20611,6 @@ mod stitching_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDetail_BlocksGainCompensator = core::Ptr; - ptr_extern! { crate::stitching::Detail_BlocksGainCompensator, cv_PtrLcv_detail_BlocksGainCompensatorG_new_null_const, cv_PtrLcv_detail_BlocksGainCompensatorG_delete, cv_PtrLcv_detail_BlocksGainCompensatorG_getInnerPtr_const, cv_PtrLcv_detail_BlocksGainCompensatorG_getInnerPtrMut } @@ -22024,9 +20657,6 @@ mod stitching_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDetail_BundleAdjusterAffine = core::Ptr; - ptr_extern! { crate::stitching::Detail_BundleAdjusterAffine, cv_PtrLcv_detail_BundleAdjusterAffineG_new_null_const, cv_PtrLcv_detail_BundleAdjusterAffineG_delete, cv_PtrLcv_detail_BundleAdjusterAffineG_getInnerPtr_const, cv_PtrLcv_detail_BundleAdjusterAffineG_getInnerPtrMut } @@ -22073,9 +20703,6 @@ mod stitching_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDetail_BundleAdjusterAffinePartial = core::Ptr; - ptr_extern! { crate::stitching::Detail_BundleAdjusterAffinePartial, cv_PtrLcv_detail_BundleAdjusterAffinePartialG_new_null_const, cv_PtrLcv_detail_BundleAdjusterAffinePartialG_delete, cv_PtrLcv_detail_BundleAdjusterAffinePartialG_getInnerPtr_const, cv_PtrLcv_detail_BundleAdjusterAffinePartialG_getInnerPtrMut } @@ -22122,9 +20749,6 @@ mod stitching_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDetail_BundleAdjusterBase = core::Ptr; - ptr_extern! { crate::stitching::Detail_BundleAdjusterBase, cv_PtrLcv_detail_BundleAdjusterBaseG_new_null_const, cv_PtrLcv_detail_BundleAdjusterBaseG_delete, cv_PtrLcv_detail_BundleAdjusterBaseG_getInnerPtr_const, cv_PtrLcv_detail_BundleAdjusterBaseG_getInnerPtrMut } @@ -22160,9 +20784,6 @@ mod stitching_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDetail_BundleAdjusterRay = core::Ptr; - ptr_extern! { crate::stitching::Detail_BundleAdjusterRay, cv_PtrLcv_detail_BundleAdjusterRayG_new_null_const, cv_PtrLcv_detail_BundleAdjusterRayG_delete, cv_PtrLcv_detail_BundleAdjusterRayG_getInnerPtr_const, cv_PtrLcv_detail_BundleAdjusterRayG_getInnerPtrMut } @@ -22209,9 +20830,6 @@ mod stitching_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDetail_BundleAdjusterReproj = core::Ptr; - ptr_extern! { crate::stitching::Detail_BundleAdjusterReproj, cv_PtrLcv_detail_BundleAdjusterReprojG_new_null_const, cv_PtrLcv_detail_BundleAdjusterReprojG_delete, cv_PtrLcv_detail_BundleAdjusterReprojG_getInnerPtr_const, cv_PtrLcv_detail_BundleAdjusterReprojG_getInnerPtrMut } @@ -22258,9 +20876,6 @@ mod stitching_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDetail_ChannelsCompensator = core::Ptr; - ptr_extern! { crate::stitching::Detail_ChannelsCompensator, cv_PtrLcv_detail_ChannelsCompensatorG_new_null_const, cv_PtrLcv_detail_ChannelsCompensatorG_delete, cv_PtrLcv_detail_ChannelsCompensatorG_getInnerPtr_const, cv_PtrLcv_detail_ChannelsCompensatorG_getInnerPtrMut } @@ -22297,9 +20912,6 @@ mod stitching_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDetail_DpSeamFinder = core::Ptr; - ptr_extern! { crate::stitching::Detail_DpSeamFinder, cv_PtrLcv_detail_DpSeamFinderG_new_null_const, cv_PtrLcv_detail_DpSeamFinderG_delete, cv_PtrLcv_detail_DpSeamFinderG_getInnerPtr_const, cv_PtrLcv_detail_DpSeamFinderG_getInnerPtrMut } @@ -22336,9 +20948,6 @@ mod stitching_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDetail_Estimator = core::Ptr; - ptr_extern! { crate::stitching::Detail_Estimator, cv_PtrLcv_detail_EstimatorG_new_null_const, cv_PtrLcv_detail_EstimatorG_delete, cv_PtrLcv_detail_EstimatorG_getInnerPtr_const, cv_PtrLcv_detail_EstimatorG_getInnerPtrMut } @@ -22364,9 +20973,6 @@ mod stitching_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDetail_ExposureCompensator = core::Ptr; - ptr_extern! { crate::stitching::Detail_ExposureCompensator, cv_PtrLcv_detail_ExposureCompensatorG_new_null_const, cv_PtrLcv_detail_ExposureCompensatorG_delete, cv_PtrLcv_detail_ExposureCompensatorG_getInnerPtr_const, cv_PtrLcv_detail_ExposureCompensatorG_getInnerPtrMut } @@ -22392,9 +20998,6 @@ mod stitching_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDetail_FeatherBlender = core::Ptr; - ptr_extern! { crate::stitching::Detail_FeatherBlender, cv_PtrLcv_detail_FeatherBlenderG_new_null_const, cv_PtrLcv_detail_FeatherBlenderG_delete, cv_PtrLcv_detail_FeatherBlenderG_getInnerPtr_const, cv_PtrLcv_detail_FeatherBlenderG_getInnerPtrMut } @@ -22431,9 +21034,6 @@ mod stitching_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDetail_FeaturesMatcher = core::Ptr; - ptr_extern! { crate::stitching::Detail_FeaturesMatcher, cv_PtrLcv_detail_FeaturesMatcherG_new_null_const, cv_PtrLcv_detail_FeaturesMatcherG_delete, cv_PtrLcv_detail_FeaturesMatcherG_getInnerPtr_const, cv_PtrLcv_detail_FeaturesMatcherG_getInnerPtrMut } @@ -22459,9 +21059,6 @@ mod stitching_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDetail_GainCompensator = core::Ptr; - ptr_extern! { crate::stitching::Detail_GainCompensator, cv_PtrLcv_detail_GainCompensatorG_new_null_const, cv_PtrLcv_detail_GainCompensatorG_delete, cv_PtrLcv_detail_GainCompensatorG_getInnerPtr_const, cv_PtrLcv_detail_GainCompensatorG_getInnerPtrMut } @@ -22498,9 +21095,6 @@ mod stitching_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDetail_GraphCutSeamFinder = core::Ptr; - ptr_extern! { crate::stitching::Detail_GraphCutSeamFinder, cv_PtrLcv_detail_GraphCutSeamFinderG_new_null_const, cv_PtrLcv_detail_GraphCutSeamFinderG_delete, cv_PtrLcv_detail_GraphCutSeamFinderG_getInnerPtr_const, cv_PtrLcv_detail_GraphCutSeamFinderG_getInnerPtrMut } @@ -22547,9 +21141,6 @@ mod stitching_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDetail_GraphCutSeamFinderBase = core::Ptr; - ptr_extern! { crate::stitching::Detail_GraphCutSeamFinderBase, cv_PtrLcv_detail_GraphCutSeamFinderBaseG_new_null_const, cv_PtrLcv_detail_GraphCutSeamFinderBaseG_delete, cv_PtrLcv_detail_GraphCutSeamFinderBaseG_getInnerPtr_const, cv_PtrLcv_detail_GraphCutSeamFinderBaseG_getInnerPtrMut } @@ -22576,9 +21167,6 @@ mod stitching_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDetail_GraphCutSeamFinderGpu = core::Ptr; - ptr_extern! { crate::stitching::Detail_GraphCutSeamFinderGpu, cv_PtrLcv_detail_GraphCutSeamFinderGpuG_new_null_const, cv_PtrLcv_detail_GraphCutSeamFinderGpuG_delete, cv_PtrLcv_detail_GraphCutSeamFinderGpuG_getInnerPtr_const, cv_PtrLcv_detail_GraphCutSeamFinderGpuG_getInnerPtrMut } @@ -22635,9 +21223,6 @@ mod stitching_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDetail_HomographyBasedEstimator = core::Ptr; - ptr_extern! { crate::stitching::Detail_HomographyBasedEstimator, cv_PtrLcv_detail_HomographyBasedEstimatorG_new_null_const, cv_PtrLcv_detail_HomographyBasedEstimatorG_delete, cv_PtrLcv_detail_HomographyBasedEstimatorG_getInnerPtr_const, cv_PtrLcv_detail_HomographyBasedEstimatorG_getInnerPtrMut } @@ -22674,9 +21259,6 @@ mod stitching_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDetail_MultiBandBlender = core::Ptr; - ptr_extern! { crate::stitching::Detail_MultiBandBlender, cv_PtrLcv_detail_MultiBandBlenderG_new_null_const, cv_PtrLcv_detail_MultiBandBlenderG_delete, cv_PtrLcv_detail_MultiBandBlenderG_getInnerPtr_const, cv_PtrLcv_detail_MultiBandBlenderG_getInnerPtrMut } @@ -22713,9 +21295,6 @@ mod stitching_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDetail_NoBundleAdjuster = core::Ptr; - ptr_extern! { crate::stitching::Detail_NoBundleAdjuster, cv_PtrLcv_detail_NoBundleAdjusterG_new_null_const, cv_PtrLcv_detail_NoBundleAdjusterG_delete, cv_PtrLcv_detail_NoBundleAdjusterG_getInnerPtr_const, cv_PtrLcv_detail_NoBundleAdjusterG_getInnerPtrMut } @@ -22762,9 +21341,6 @@ mod stitching_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDetail_NoExposureCompensator = core::Ptr; - ptr_extern! { crate::stitching::Detail_NoExposureCompensator, cv_PtrLcv_detail_NoExposureCompensatorG_new_null_const, cv_PtrLcv_detail_NoExposureCompensatorG_delete, cv_PtrLcv_detail_NoExposureCompensatorG_getInnerPtr_const, cv_PtrLcv_detail_NoExposureCompensatorG_getInnerPtrMut } @@ -22801,9 +21377,6 @@ mod stitching_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDetail_NoSeamFinder = core::Ptr; - ptr_extern! { crate::stitching::Detail_NoSeamFinder, cv_PtrLcv_detail_NoSeamFinderG_new_null_const, cv_PtrLcv_detail_NoSeamFinderG_delete, cv_PtrLcv_detail_NoSeamFinderG_getInnerPtr_const, cv_PtrLcv_detail_NoSeamFinderG_getInnerPtrMut } @@ -22840,9 +21413,6 @@ mod stitching_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDetail_PairwiseSeamFinder = core::Ptr; - ptr_extern! { crate::stitching::Detail_PairwiseSeamFinder, cv_PtrLcv_detail_PairwiseSeamFinderG_new_null_const, cv_PtrLcv_detail_PairwiseSeamFinderG_delete, cv_PtrLcv_detail_PairwiseSeamFinderG_getInnerPtr_const, cv_PtrLcv_detail_PairwiseSeamFinderG_getInnerPtrMut } @@ -22878,9 +21448,6 @@ mod stitching_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDetail_RotationWarper = core::Ptr; - ptr_extern! { crate::stitching::Detail_RotationWarper, cv_PtrLcv_detail_RotationWarperG_new_null_const, cv_PtrLcv_detail_RotationWarperG_delete, cv_PtrLcv_detail_RotationWarperG_getInnerPtr_const, cv_PtrLcv_detail_RotationWarperG_getInnerPtrMut } @@ -22906,9 +21473,6 @@ mod stitching_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDetail_SeamFinder = core::Ptr; - ptr_extern! { crate::stitching::Detail_SeamFinder, cv_PtrLcv_detail_SeamFinderG_new_null_const, cv_PtrLcv_detail_SeamFinderG_delete, cv_PtrLcv_detail_SeamFinderG_getInnerPtr_const, cv_PtrLcv_detail_SeamFinderG_getInnerPtrMut } @@ -22934,9 +21498,6 @@ mod stitching_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDetail_VoronoiSeamFinder = core::Ptr; - ptr_extern! { crate::stitching::Detail_VoronoiSeamFinder, cv_PtrLcv_detail_VoronoiSeamFinderG_new_null_const, cv_PtrLcv_detail_VoronoiSeamFinderG_delete, cv_PtrLcv_detail_VoronoiSeamFinderG_getInnerPtr_const, cv_PtrLcv_detail_VoronoiSeamFinderG_getInnerPtrMut } @@ -22983,9 +21544,6 @@ mod stitching_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfFisheyeWarper = core::Ptr; - ptr_extern! { crate::stitching::FisheyeWarper, cv_PtrLcv_FisheyeWarperG_new_null_const, cv_PtrLcv_FisheyeWarperG_delete, cv_PtrLcv_FisheyeWarperG_getInnerPtr_const, cv_PtrLcv_FisheyeWarperG_getInnerPtrMut } @@ -23022,9 +21580,6 @@ mod stitching_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfMercatorWarper = core::Ptr; - ptr_extern! { crate::stitching::MercatorWarper, cv_PtrLcv_MercatorWarperG_new_null_const, cv_PtrLcv_MercatorWarperG_delete, cv_PtrLcv_MercatorWarperG_getInnerPtr_const, cv_PtrLcv_MercatorWarperG_getInnerPtrMut } @@ -23061,9 +21616,6 @@ mod stitching_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfPaniniPortraitWarper = core::Ptr; - ptr_extern! { crate::stitching::PaniniPortraitWarper, cv_PtrLcv_PaniniPortraitWarperG_new_null_const, cv_PtrLcv_PaniniPortraitWarperG_delete, cv_PtrLcv_PaniniPortraitWarperG_getInnerPtr_const, cv_PtrLcv_PaniniPortraitWarperG_getInnerPtrMut } @@ -23100,9 +21652,6 @@ mod stitching_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfPaniniWarper = core::Ptr; - ptr_extern! { crate::stitching::PaniniWarper, cv_PtrLcv_PaniniWarperG_new_null_const, cv_PtrLcv_PaniniWarperG_delete, cv_PtrLcv_PaniniWarperG_getInnerPtr_const, cv_PtrLcv_PaniniWarperG_getInnerPtrMut } @@ -23139,9 +21688,6 @@ mod stitching_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfPlaneWarper = core::Ptr; - ptr_extern! { crate::stitching::PlaneWarper, cv_PtrLcv_PlaneWarperG_new_null_const, cv_PtrLcv_PlaneWarperG_delete, cv_PtrLcv_PlaneWarperG_getInnerPtr_const, cv_PtrLcv_PlaneWarperG_getInnerPtrMut } @@ -23178,9 +21724,6 @@ mod stitching_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfPlaneWarperGpu = core::Ptr; - ptr_extern! { crate::stitching::PlaneWarperGpu, cv_PtrLcv_PlaneWarperGpuG_new_null_const, cv_PtrLcv_PlaneWarperGpuG_delete, cv_PtrLcv_PlaneWarperGpuG_getInnerPtr_const, cv_PtrLcv_PlaneWarperGpuG_getInnerPtrMut } @@ -23217,9 +21760,6 @@ mod stitching_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfSphericalWarper = core::Ptr; - ptr_extern! { crate::stitching::SphericalWarper, cv_PtrLcv_SphericalWarperG_new_null_const, cv_PtrLcv_SphericalWarperG_delete, cv_PtrLcv_SphericalWarperG_getInnerPtr_const, cv_PtrLcv_SphericalWarperG_getInnerPtrMut } @@ -23256,9 +21796,6 @@ mod stitching_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfSphericalWarperGpu = core::Ptr; - ptr_extern! { crate::stitching::SphericalWarperGpu, cv_PtrLcv_SphericalWarperGpuG_new_null_const, cv_PtrLcv_SphericalWarperGpuG_delete, cv_PtrLcv_SphericalWarperGpuG_getInnerPtr_const, cv_PtrLcv_SphericalWarperGpuG_getInnerPtrMut } @@ -23295,9 +21832,6 @@ mod stitching_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfStereographicWarper = core::Ptr; - ptr_extern! { crate::stitching::StereographicWarper, cv_PtrLcv_StereographicWarperG_new_null_const, cv_PtrLcv_StereographicWarperG_delete, cv_PtrLcv_StereographicWarperG_getInnerPtr_const, cv_PtrLcv_StereographicWarperG_getInnerPtrMut } @@ -23334,9 +21868,6 @@ mod stitching_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfStitcher = core::Ptr; - ptr_extern! { crate::stitching::Stitcher, cv_PtrLcv_StitcherG_new_null_const, cv_PtrLcv_StitcherG_delete, cv_PtrLcv_StitcherG_getInnerPtr_const, cv_PtrLcv_StitcherG_getInnerPtrMut } @@ -23363,9 +21894,6 @@ mod stitching_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfTransverseMercatorWarper = core::Ptr; - ptr_extern! { crate::stitching::TransverseMercatorWarper, cv_PtrLcv_TransverseMercatorWarperG_new_null_const, cv_PtrLcv_TransverseMercatorWarperG_delete, cv_PtrLcv_TransverseMercatorWarperG_getInnerPtr_const, cv_PtrLcv_TransverseMercatorWarperG_getInnerPtrMut } @@ -23402,9 +21930,6 @@ mod stitching_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfWarperCreator = core::Ptr; - ptr_extern! { crate::stitching::WarperCreator, cv_PtrLcv_WarperCreatorG_new_null_const, cv_PtrLcv_WarperCreatorG_delete, cv_PtrLcv_WarperCreatorG_getInnerPtr_const, cv_PtrLcv_WarperCreatorG_getInnerPtrMut } @@ -23430,9 +21955,6 @@ mod stitching_types { } } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfDetail_CameraParams = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfDetail_CameraParams(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfDetail_CameraParams(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -23463,9 +21985,6 @@ mod stitching_types { } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfDetail_ImageFeatures = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfDetail_ImageFeatures(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfDetail_ImageFeatures(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -23496,9 +22015,6 @@ mod stitching_types { } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfDetail_MatchesInfo = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfDetail_MatchesInfo(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfDetail_MatchesInfo(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -23530,16 +22046,11 @@ mod stitching_types { } -#[cfg(ocvrs_has_module_stitching)] pub use stitching_types::*; -#[cfg(ocvrs_has_module_structured_light)] mod structured_light_types { use crate::{mod_prelude::*, core, types, sys}; - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfGrayCodePattern = core::Ptr; - ptr_extern! { crate::structured_light::GrayCodePattern, cv_PtrLcv_structured_light_GrayCodePatternG_new_null_const, cv_PtrLcv_structured_light_GrayCodePatternG_delete, cv_PtrLcv_structured_light_GrayCodePatternG_getInnerPtr_const, cv_PtrLcv_structured_light_GrayCodePatternG_getInnerPtrMut } @@ -23585,9 +22096,6 @@ mod structured_light_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfSinusoidalPattern = core::Ptr; - ptr_extern! { crate::structured_light::SinusoidalPattern, cv_PtrLcv_structured_light_SinusoidalPatternG_new_null_const, cv_PtrLcv_structured_light_SinusoidalPatternG_delete, cv_PtrLcv_structured_light_SinusoidalPatternG_getInnerPtr_const, cv_PtrLcv_structured_light_SinusoidalPatternG_getInnerPtrMut } @@ -23633,9 +22141,6 @@ mod structured_light_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfSinusoidalPattern_Params = core::Ptr; - ptr_extern! { crate::structured_light::SinusoidalPattern_Params, cv_PtrLcv_structured_light_SinusoidalPattern_ParamsG_new_null_const, cv_PtrLcv_structured_light_SinusoidalPattern_ParamsG_delete, cv_PtrLcv_structured_light_SinusoidalPattern_ParamsG_getInnerPtr_const, cv_PtrLcv_structured_light_SinusoidalPattern_ParamsG_getInnerPtrMut } @@ -23671,9 +22176,6 @@ mod structured_light_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfStructuredLightPattern = core::Ptr; - ptr_extern! { crate::structured_light::StructuredLightPattern, cv_PtrLcv_structured_light_StructuredLightPatternG_new_null_const, cv_PtrLcv_structured_light_StructuredLightPatternG_delete, cv_PtrLcv_structured_light_StructuredLightPatternG_getInnerPtr_const, cv_PtrLcv_structured_light_StructuredLightPatternG_getInnerPtrMut } @@ -23710,16 +22212,11 @@ mod structured_light_types { } } -#[cfg(ocvrs_has_module_structured_light)] pub use structured_light_types::*; -#[cfg(ocvrs_has_module_superres)] mod superres_types { use crate::{mod_prelude::*, core, types, sys}; - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfSuperRes_BroxOpticalFlow = core::Ptr; - ptr_extern! { crate::superres::SuperRes_BroxOpticalFlow, cv_PtrLcv_superres_BroxOpticalFlowG_new_null_const, cv_PtrLcv_superres_BroxOpticalFlowG_delete, cv_PtrLcv_superres_BroxOpticalFlowG_getInnerPtr_const, cv_PtrLcv_superres_BroxOpticalFlowG_getInnerPtrMut } @@ -23765,9 +22262,6 @@ mod superres_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfSuperRes_DenseOpticalFlowExt = core::Ptr; - ptr_extern! { crate::superres::SuperRes_DenseOpticalFlowExt, cv_PtrLcv_superres_DenseOpticalFlowExtG_new_null_const, cv_PtrLcv_superres_DenseOpticalFlowExtG_delete, cv_PtrLcv_superres_DenseOpticalFlowExtG_getInnerPtr_const, cv_PtrLcv_superres_DenseOpticalFlowExtG_getInnerPtrMut } @@ -23803,9 +22297,6 @@ mod superres_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfSuperRes_DualTVL1OpticalFlow = core::Ptr; - ptr_extern! { crate::superres::SuperRes_DualTVL1OpticalFlow, cv_PtrLcv_superres_DualTVL1OpticalFlowG_new_null_const, cv_PtrLcv_superres_DualTVL1OpticalFlowG_delete, cv_PtrLcv_superres_DualTVL1OpticalFlowG_getInnerPtr_const, cv_PtrLcv_superres_DualTVL1OpticalFlowG_getInnerPtrMut } @@ -23851,9 +22342,6 @@ mod superres_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfSuperRes_FarnebackOpticalFlow = core::Ptr; - ptr_extern! { crate::superres::SuperRes_FarnebackOpticalFlow, cv_PtrLcv_superres_FarnebackOpticalFlowG_new_null_const, cv_PtrLcv_superres_FarnebackOpticalFlowG_delete, cv_PtrLcv_superres_FarnebackOpticalFlowG_getInnerPtr_const, cv_PtrLcv_superres_FarnebackOpticalFlowG_getInnerPtrMut } @@ -23899,9 +22387,6 @@ mod superres_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfSuperRes_FrameSource = core::Ptr; - ptr_extern! { crate::superres::SuperRes_FrameSource, cv_PtrLcv_superres_FrameSourceG_new_null_const, cv_PtrLcv_superres_FrameSourceG_delete, cv_PtrLcv_superres_FrameSourceG_getInnerPtr_const, cv_PtrLcv_superres_FrameSourceG_getInnerPtrMut } @@ -23927,9 +22412,6 @@ mod superres_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfSuperRes_PyrLKOpticalFlow = core::Ptr; - ptr_extern! { crate::superres::SuperRes_PyrLKOpticalFlow, cv_PtrLcv_superres_PyrLKOpticalFlowG_new_null_const, cv_PtrLcv_superres_PyrLKOpticalFlowG_delete, cv_PtrLcv_superres_PyrLKOpticalFlowG_getInnerPtr_const, cv_PtrLcv_superres_PyrLKOpticalFlowG_getInnerPtrMut } @@ -23975,9 +22457,6 @@ mod superres_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfSuperRes_SuperResolution = core::Ptr; - ptr_extern! { crate::superres::SuperRes_SuperResolution, cv_PtrLcv_superres_SuperResolutionG_new_null_const, cv_PtrLcv_superres_SuperResolutionG_delete, cv_PtrLcv_superres_SuperResolutionG_getInnerPtr_const, cv_PtrLcv_superres_SuperResolutionG_getInnerPtrMut } @@ -24024,16 +22503,11 @@ mod superres_types { } } -#[cfg(ocvrs_has_module_superres)] pub use superres_types::*; -#[cfg(ocvrs_has_module_surface_matching)] mod surface_matching_types { use crate::{mod_prelude::*, core, types, sys}; - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfPose3D = core::Ptr; - ptr_extern! { crate::surface_matching::Pose3D, cv_PtrLcv_ppf_match_3d_Pose3DG_new_null_const, cv_PtrLcv_ppf_match_3d_Pose3DG_delete, cv_PtrLcv_ppf_match_3d_Pose3DG_getInnerPtr_const, cv_PtrLcv_ppf_match_3d_Pose3DG_getInnerPtrMut } @@ -24068,9 +22542,6 @@ mod surface_matching_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfPoseCluster3D = core::Ptr; - ptr_extern! { crate::surface_matching::PoseCluster3D, cv_PtrLcv_ppf_match_3d_PoseCluster3DG_new_null_const, cv_PtrLcv_ppf_match_3d_PoseCluster3DG_delete, cv_PtrLcv_ppf_match_3d_PoseCluster3DG_getInnerPtr_const, cv_PtrLcv_ppf_match_3d_PoseCluster3DG_getInnerPtrMut } @@ -24100,9 +22571,6 @@ mod surface_matching_types { } } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfPose3DPtr = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfPose3DPtr(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfPose3DPtr(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -24122,16 +22590,11 @@ mod surface_matching_types { } -#[cfg(ocvrs_has_module_surface_matching)] pub use surface_matching_types::*; -#[cfg(ocvrs_has_module_text)] mod text_types { use crate::{mod_prelude::*, core, types, sys}; - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfBaseOCR = core::Ptr; - ptr_extern! { crate::text::BaseOCR, cv_PtrLcv_text_BaseOCRG_new_null_const, cv_PtrLcv_text_BaseOCRG_delete, cv_PtrLcv_text_BaseOCRG_getInnerPtr_const, cv_PtrLcv_text_BaseOCRG_getInnerPtrMut } @@ -24157,9 +22620,6 @@ mod text_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfERFilter = core::Ptr; - ptr_extern! { crate::text::ERFilter, cv_PtrLcv_text_ERFilterG_new_null_const, cv_PtrLcv_text_ERFilterG_delete, cv_PtrLcv_text_ERFilterG_getInnerPtr_const, cv_PtrLcv_text_ERFilterG_getInnerPtrMut } @@ -24195,9 +22655,6 @@ mod text_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfERFilter_Callback = core::Ptr; - ptr_extern! { crate::text::ERFilter_Callback, cv_PtrLcv_text_ERFilter_CallbackG_new_null_const, cv_PtrLcv_text_ERFilter_CallbackG_delete, cv_PtrLcv_text_ERFilter_CallbackG_getInnerPtr_const, cv_PtrLcv_text_ERFilter_CallbackG_getInnerPtrMut } @@ -24223,9 +22680,6 @@ mod text_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfOCRBeamSearchDecoder = core::Ptr; - ptr_extern! { crate::text::OCRBeamSearchDecoder, cv_PtrLcv_text_OCRBeamSearchDecoderG_new_null_const, cv_PtrLcv_text_OCRBeamSearchDecoderG_delete, cv_PtrLcv_text_OCRBeamSearchDecoderG_getInnerPtr_const, cv_PtrLcv_text_OCRBeamSearchDecoderG_getInnerPtrMut } @@ -24262,9 +22716,6 @@ mod text_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfOCRBeamSearchDecoder_ClassifierCallback = core::Ptr; - ptr_extern! { crate::text::OCRBeamSearchDecoder_ClassifierCallback, cv_PtrLcv_text_OCRBeamSearchDecoder_ClassifierCallbackG_new_null_const, cv_PtrLcv_text_OCRBeamSearchDecoder_ClassifierCallbackG_delete, cv_PtrLcv_text_OCRBeamSearchDecoder_ClassifierCallbackG_getInnerPtr_const, cv_PtrLcv_text_OCRBeamSearchDecoder_ClassifierCallbackG_getInnerPtrMut } @@ -24291,9 +22742,6 @@ mod text_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfOCRHMMDecoder = core::Ptr; - ptr_extern! { crate::text::OCRHMMDecoder, cv_PtrLcv_text_OCRHMMDecoderG_new_null_const, cv_PtrLcv_text_OCRHMMDecoderG_delete, cv_PtrLcv_text_OCRHMMDecoderG_getInnerPtr_const, cv_PtrLcv_text_OCRHMMDecoderG_getInnerPtrMut } @@ -24330,9 +22778,6 @@ mod text_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfOCRHMMDecoder_ClassifierCallback = core::Ptr; - ptr_extern! { crate::text::OCRHMMDecoder_ClassifierCallback, cv_PtrLcv_text_OCRHMMDecoder_ClassifierCallbackG_new_null_const, cv_PtrLcv_text_OCRHMMDecoder_ClassifierCallbackG_delete, cv_PtrLcv_text_OCRHMMDecoder_ClassifierCallbackG_getInnerPtr_const, cv_PtrLcv_text_OCRHMMDecoder_ClassifierCallbackG_getInnerPtrMut } @@ -24359,9 +22804,6 @@ mod text_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfOCRHolisticWordRecognizer = core::Ptr; - ptr_extern! { crate::text::OCRHolisticWordRecognizer, cv_PtrLcv_text_OCRHolisticWordRecognizerG_new_null_const, cv_PtrLcv_text_OCRHolisticWordRecognizerG_delete, cv_PtrLcv_text_OCRHolisticWordRecognizerG_getInnerPtr_const, cv_PtrLcv_text_OCRHolisticWordRecognizerG_getInnerPtrMut } @@ -24397,9 +22839,6 @@ mod text_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfOCRTesseract = core::Ptr; - ptr_extern! { crate::text::OCRTesseract, cv_PtrLcv_text_OCRTesseractG_new_null_const, cv_PtrLcv_text_OCRTesseractG_delete, cv_PtrLcv_text_OCRTesseractG_getInnerPtr_const, cv_PtrLcv_text_OCRTesseractG_getInnerPtrMut } @@ -24435,9 +22874,6 @@ mod text_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfTextDetector = core::Ptr; - ptr_extern! { crate::text::TextDetector, cv_PtrLcv_text_TextDetectorG_new_null_const, cv_PtrLcv_text_TextDetectorG_delete, cv_PtrLcv_text_TextDetectorG_getInnerPtr_const, cv_PtrLcv_text_TextDetectorG_getInnerPtrMut } @@ -24463,9 +22899,6 @@ mod text_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfTextDetectorCNN = core::Ptr; - ptr_extern! { crate::text::TextDetectorCNN, cv_PtrLcv_text_TextDetectorCNNG_new_null_const, cv_PtrLcv_text_TextDetectorCNNG_delete, cv_PtrLcv_text_TextDetectorCNNG_getInnerPtr_const, cv_PtrLcv_text_TextDetectorCNNG_getInnerPtrMut } @@ -24501,9 +22934,6 @@ mod text_types { } } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfERStat = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfERStat(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfERStat(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -24534,9 +22964,6 @@ mod text_types { } - #[deprecated = "Use the the non-alias form `core::Vector>` instead, removal in Nov 2024"] - pub type VectorOfVectorOfERStat = core::Vector>; - impl core::Vector> { pub fn as_raw_VectorOfVectorOfERStat(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfVectorOfERStat(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -24556,16 +22983,11 @@ mod text_types { } -#[cfg(ocvrs_has_module_text)] pub use text_types::*; -#[cfg(ocvrs_has_module_tracking)] mod tracking_types { use crate::{mod_prelude::*, core, types, sys}; - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfTrackerCSRT = core::Ptr; - ptr_extern! { crate::tracking::TrackerCSRT, cv_PtrLcv_tracking_TrackerCSRTG_new_null_const, cv_PtrLcv_tracking_TrackerCSRTG_delete, cv_PtrLcv_tracking_TrackerCSRTG_getInnerPtr_const, cv_PtrLcv_tracking_TrackerCSRTG_getInnerPtrMut } @@ -24601,9 +23023,6 @@ mod tracking_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfTrackerKCF = core::Ptr; - ptr_extern! { crate::tracking::TrackerKCF, cv_PtrLcv_tracking_TrackerKCFG_new_null_const, cv_PtrLcv_tracking_TrackerKCFG_delete, cv_PtrLcv_tracking_TrackerKCFG_getInnerPtr_const, cv_PtrLcv_tracking_TrackerKCFG_getInnerPtrMut } @@ -24640,16 +23059,11 @@ mod tracking_types { } } -#[cfg(ocvrs_has_module_tracking)] pub use tracking_types::*; -#[cfg(ocvrs_has_module_video)] mod video_types { use crate::{mod_prelude::*, core, types, sys}; - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfBackgroundSubtractor = core::Ptr; - ptr_extern! { crate::video::BackgroundSubtractor, cv_PtrLcv_BackgroundSubtractorG_new_null_const, cv_PtrLcv_BackgroundSubtractorG_delete, cv_PtrLcv_BackgroundSubtractorG_getInnerPtr_const, cv_PtrLcv_BackgroundSubtractorG_getInnerPtrMut } @@ -24685,9 +23099,6 @@ mod video_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfBackgroundSubtractorKNN = core::Ptr; - ptr_extern! { crate::video::BackgroundSubtractorKNN, cv_PtrLcv_BackgroundSubtractorKNNG_new_null_const, cv_PtrLcv_BackgroundSubtractorKNNG_delete, cv_PtrLcv_BackgroundSubtractorKNNG_getInnerPtr_const, cv_PtrLcv_BackgroundSubtractorKNNG_getInnerPtrMut } @@ -24733,9 +23144,6 @@ mod video_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfBackgroundSubtractorMOG2 = core::Ptr; - ptr_extern! { crate::video::BackgroundSubtractorMOG2, cv_PtrLcv_BackgroundSubtractorMOG2G_new_null_const, cv_PtrLcv_BackgroundSubtractorMOG2G_delete, cv_PtrLcv_BackgroundSubtractorMOG2G_getInnerPtr_const, cv_PtrLcv_BackgroundSubtractorMOG2G_getInnerPtrMut } @@ -24781,9 +23189,6 @@ mod video_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDISOpticalFlow = core::Ptr; - ptr_extern! { crate::video::DISOpticalFlow, cv_PtrLcv_DISOpticalFlowG_new_null_const, cv_PtrLcv_DISOpticalFlowG_delete, cv_PtrLcv_DISOpticalFlowG_getInnerPtr_const, cv_PtrLcv_DISOpticalFlowG_getInnerPtrMut } @@ -24829,9 +23234,6 @@ mod video_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDenseOpticalFlow = core::Ptr; - ptr_extern! { crate::video::DenseOpticalFlow, cv_PtrLcv_DenseOpticalFlowG_new_null_const, cv_PtrLcv_DenseOpticalFlowG_delete, cv_PtrLcv_DenseOpticalFlowG_getInnerPtr_const, cv_PtrLcv_DenseOpticalFlowG_getInnerPtrMut } @@ -24867,9 +23269,6 @@ mod video_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfFarnebackOpticalFlow = core::Ptr; - ptr_extern! { crate::video::FarnebackOpticalFlow, cv_PtrLcv_FarnebackOpticalFlowG_new_null_const, cv_PtrLcv_FarnebackOpticalFlowG_delete, cv_PtrLcv_FarnebackOpticalFlowG_getInnerPtr_const, cv_PtrLcv_FarnebackOpticalFlowG_getInnerPtrMut } @@ -24915,9 +23314,6 @@ mod video_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfSparseOpticalFlow = core::Ptr; - ptr_extern! { crate::video::SparseOpticalFlow, cv_PtrLcv_SparseOpticalFlowG_new_null_const, cv_PtrLcv_SparseOpticalFlowG_delete, cv_PtrLcv_SparseOpticalFlowG_getInnerPtr_const, cv_PtrLcv_SparseOpticalFlowG_getInnerPtrMut } @@ -24953,9 +23349,6 @@ mod video_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfSparsePyrLKOpticalFlow = core::Ptr; - ptr_extern! { crate::video::SparsePyrLKOpticalFlow, cv_PtrLcv_SparsePyrLKOpticalFlowG_new_null_const, cv_PtrLcv_SparsePyrLKOpticalFlowG_delete, cv_PtrLcv_SparsePyrLKOpticalFlowG_getInnerPtr_const, cv_PtrLcv_SparsePyrLKOpticalFlowG_getInnerPtrMut } @@ -25001,9 +23394,6 @@ mod video_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfTracker = core::Ptr; - ptr_extern! { crate::video::Tracker, cv_PtrLcv_TrackerG_new_null_const, cv_PtrLcv_TrackerG_delete, cv_PtrLcv_TrackerG_getInnerPtr_const, cv_PtrLcv_TrackerG_getInnerPtrMut } @@ -25029,9 +23419,6 @@ mod video_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfTrackerDaSiamRPN = core::Ptr; - ptr_extern! { crate::video::TrackerDaSiamRPN, cv_PtrLcv_TrackerDaSiamRPNG_new_null_const, cv_PtrLcv_TrackerDaSiamRPNG_delete, cv_PtrLcv_TrackerDaSiamRPNG_getInnerPtr_const, cv_PtrLcv_TrackerDaSiamRPNG_getInnerPtrMut } @@ -25067,9 +23454,6 @@ mod video_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfTrackerGOTURN = core::Ptr; - ptr_extern! { crate::video::TrackerGOTURN, cv_PtrLcv_TrackerGOTURNG_new_null_const, cv_PtrLcv_TrackerGOTURNG_delete, cv_PtrLcv_TrackerGOTURNG_getInnerPtr_const, cv_PtrLcv_TrackerGOTURNG_getInnerPtrMut } @@ -25105,9 +23489,6 @@ mod video_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfTrackerMIL = core::Ptr; - ptr_extern! { crate::video::TrackerMIL, cv_PtrLcv_TrackerMILG_new_null_const, cv_PtrLcv_TrackerMILG_delete, cv_PtrLcv_TrackerMILG_getInnerPtr_const, cv_PtrLcv_TrackerMILG_getInnerPtrMut } @@ -25143,9 +23524,6 @@ mod video_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfTrackerNano = core::Ptr; - ptr_extern! { crate::video::TrackerNano, cv_PtrLcv_TrackerNanoG_new_null_const, cv_PtrLcv_TrackerNanoG_delete, cv_PtrLcv_TrackerNanoG_getInnerPtr_const, cv_PtrLcv_TrackerNanoG_getInnerPtrMut } @@ -25181,9 +23559,6 @@ mod video_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfTrackerVit = core::Ptr; - ptr_extern! { crate::video::TrackerVit, cv_PtrLcv_TrackerVitG_new_null_const, cv_PtrLcv_TrackerVitG_delete, cv_PtrLcv_TrackerVitG_getInnerPtr_const, cv_PtrLcv_TrackerVitG_getInnerPtrMut } @@ -25219,9 +23594,6 @@ mod video_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfVariationalRefinement = core::Ptr; - ptr_extern! { crate::video::VariationalRefinement, cv_PtrLcv_VariationalRefinementG_new_null_const, cv_PtrLcv_VariationalRefinementG_delete, cv_PtrLcv_VariationalRefinementG_getInnerPtr_const, cv_PtrLcv_VariationalRefinementG_getInnerPtrMut } @@ -25268,16 +23640,11 @@ mod video_types { } } -#[cfg(ocvrs_has_module_video)] pub use video_types::*; -#[cfg(ocvrs_has_module_videoio)] mod videoio_types { use crate::{mod_prelude::*, core, types, sys}; - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfIStreamReader = core::Ptr; - ptr_extern! { crate::videoio::IStreamReader, cv_PtrLcv_IStreamReaderG_new_null_const, cv_PtrLcv_IStreamReaderG_delete, cv_PtrLcv_IStreamReaderG_getInnerPtr_const, cv_PtrLcv_IStreamReaderG_getInnerPtrMut } @@ -25303,9 +23670,6 @@ mod videoio_types { } } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfVideoCapture = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfVideoCapture(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfVideoCapture(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -25336,9 +23700,6 @@ mod videoio_types { } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfVideoCaptureAPIs = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfVideoCaptureAPIs(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfVideoCaptureAPIs(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -25361,16 +23722,11 @@ mod videoio_types { } -#[cfg(ocvrs_has_module_videoio)] pub use videoio_types::*; -#[cfg(ocvrs_has_module_videostab)] mod videostab_types { use crate::{mod_prelude::*, core, types, sys}; - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfColorAverageInpainter = core::Ptr; - ptr_extern! { crate::videostab::ColorAverageInpainter, cv_PtrLcv_videostab_ColorAverageInpainterG_new_null_const, cv_PtrLcv_videostab_ColorAverageInpainterG_delete, cv_PtrLcv_videostab_ColorAverageInpainterG_getInnerPtr_const, cv_PtrLcv_videostab_ColorAverageInpainterG_getInnerPtrMut } @@ -25407,9 +23763,6 @@ mod videostab_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfColorInpainter = core::Ptr; - ptr_extern! { crate::videostab::ColorInpainter, cv_PtrLcv_videostab_ColorInpainterG_new_null_const, cv_PtrLcv_videostab_ColorInpainterG_delete, cv_PtrLcv_videostab_ColorInpainterG_getInnerPtr_const, cv_PtrLcv_videostab_ColorInpainterG_getInnerPtrMut } @@ -25446,9 +23799,6 @@ mod videostab_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfConsistentMosaicInpainter = core::Ptr; - ptr_extern! { crate::videostab::ConsistentMosaicInpainter, cv_PtrLcv_videostab_ConsistentMosaicInpainterG_new_null_const, cv_PtrLcv_videostab_ConsistentMosaicInpainterG_delete, cv_PtrLcv_videostab_ConsistentMosaicInpainterG_getInnerPtr_const, cv_PtrLcv_videostab_ConsistentMosaicInpainterG_getInnerPtrMut } @@ -25485,9 +23835,6 @@ mod videostab_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDeblurerBase = core::Ptr; - ptr_extern! { crate::videostab::DeblurerBase, cv_PtrLcv_videostab_DeblurerBaseG_new_null_const, cv_PtrLcv_videostab_DeblurerBaseG_delete, cv_PtrLcv_videostab_DeblurerBaseG_getInnerPtr_const, cv_PtrLcv_videostab_DeblurerBaseG_getInnerPtrMut } @@ -25513,9 +23860,6 @@ mod videostab_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDensePyrLkOptFlowEstimatorGpu = core::Ptr; - ptr_extern! { crate::videostab::DensePyrLkOptFlowEstimatorGpu, cv_PtrLcv_videostab_DensePyrLkOptFlowEstimatorGpuG_new_null_const, cv_PtrLcv_videostab_DensePyrLkOptFlowEstimatorGpuG_delete, cv_PtrLcv_videostab_DensePyrLkOptFlowEstimatorGpuG_getInnerPtr_const, cv_PtrLcv_videostab_DensePyrLkOptFlowEstimatorGpuG_getInnerPtrMut } @@ -25562,9 +23906,6 @@ mod videostab_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfFromFileMotionReader = core::Ptr; - ptr_extern! { crate::videostab::FromFileMotionReader, cv_PtrLcv_videostab_FromFileMotionReaderG_new_null_const, cv_PtrLcv_videostab_FromFileMotionReaderG_delete, cv_PtrLcv_videostab_FromFileMotionReaderG_getInnerPtr_const, cv_PtrLcv_videostab_FromFileMotionReaderG_getInnerPtrMut } @@ -25601,9 +23942,6 @@ mod videostab_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfGaussianMotionFilter = core::Ptr; - ptr_extern! { crate::videostab::GaussianMotionFilter, cv_PtrLcv_videostab_GaussianMotionFilterG_new_null_const, cv_PtrLcv_videostab_GaussianMotionFilterG_delete, cv_PtrLcv_videostab_GaussianMotionFilterG_getInnerPtr_const, cv_PtrLcv_videostab_GaussianMotionFilterG_getInnerPtrMut } @@ -25650,9 +23988,6 @@ mod videostab_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfIDenseOptFlowEstimator = core::Ptr; - ptr_extern! { crate::videostab::IDenseOptFlowEstimator, cv_PtrLcv_videostab_IDenseOptFlowEstimatorG_new_null_const, cv_PtrLcv_videostab_IDenseOptFlowEstimatorG_delete, cv_PtrLcv_videostab_IDenseOptFlowEstimatorG_getInnerPtr_const, cv_PtrLcv_videostab_IDenseOptFlowEstimatorG_getInnerPtrMut } @@ -25678,9 +24013,6 @@ mod videostab_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfIFrameSource = core::Ptr; - ptr_extern! { crate::videostab::IFrameSource, cv_PtrLcv_videostab_IFrameSourceG_new_null_const, cv_PtrLcv_videostab_IFrameSourceG_delete, cv_PtrLcv_videostab_IFrameSourceG_getInnerPtr_const, cv_PtrLcv_videostab_IFrameSourceG_getInnerPtrMut } @@ -25706,9 +24038,6 @@ mod videostab_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfILog = core::Ptr; - ptr_extern! { crate::videostab::ILog, cv_PtrLcv_videostab_ILogG_new_null_const, cv_PtrLcv_videostab_ILogG_delete, cv_PtrLcv_videostab_ILogG_getInnerPtr_const, cv_PtrLcv_videostab_ILogG_getInnerPtrMut } @@ -25734,9 +24063,6 @@ mod videostab_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfIMotionStabilizer = core::Ptr; - ptr_extern! { crate::videostab::IMotionStabilizer, cv_PtrLcv_videostab_IMotionStabilizerG_new_null_const, cv_PtrLcv_videostab_IMotionStabilizerG_delete, cv_PtrLcv_videostab_IMotionStabilizerG_getInnerPtr_const, cv_PtrLcv_videostab_IMotionStabilizerG_getInnerPtrMut } @@ -25762,9 +24088,6 @@ mod videostab_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfIOutlierRejector = core::Ptr; - ptr_extern! { crate::videostab::IOutlierRejector, cv_PtrLcv_videostab_IOutlierRejectorG_new_null_const, cv_PtrLcv_videostab_IOutlierRejectorG_delete, cv_PtrLcv_videostab_IOutlierRejectorG_getInnerPtr_const, cv_PtrLcv_videostab_IOutlierRejectorG_getInnerPtrMut } @@ -25790,9 +24113,6 @@ mod videostab_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfISparseOptFlowEstimator = core::Ptr; - ptr_extern! { crate::videostab::ISparseOptFlowEstimator, cv_PtrLcv_videostab_ISparseOptFlowEstimatorG_new_null_const, cv_PtrLcv_videostab_ISparseOptFlowEstimatorG_delete, cv_PtrLcv_videostab_ISparseOptFlowEstimatorG_getInnerPtr_const, cv_PtrLcv_videostab_ISparseOptFlowEstimatorG_getInnerPtrMut } @@ -25818,9 +24138,6 @@ mod videostab_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfImageMotionEstimatorBase = core::Ptr; - ptr_extern! { crate::videostab::ImageMotionEstimatorBase, cv_PtrLcv_videostab_ImageMotionEstimatorBaseG_new_null_const, cv_PtrLcv_videostab_ImageMotionEstimatorBaseG_delete, cv_PtrLcv_videostab_ImageMotionEstimatorBaseG_getInnerPtr_const, cv_PtrLcv_videostab_ImageMotionEstimatorBaseG_getInnerPtrMut } @@ -25846,9 +24163,6 @@ mod videostab_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfInpainterBase = core::Ptr; - ptr_extern! { crate::videostab::InpainterBase, cv_PtrLcv_videostab_InpainterBaseG_new_null_const, cv_PtrLcv_videostab_InpainterBaseG_delete, cv_PtrLcv_videostab_InpainterBaseG_getInnerPtr_const, cv_PtrLcv_videostab_InpainterBaseG_getInnerPtrMut } @@ -25874,9 +24188,6 @@ mod videostab_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfInpaintingPipeline = core::Ptr; - ptr_extern! { crate::videostab::InpaintingPipeline, cv_PtrLcv_videostab_InpaintingPipelineG_new_null_const, cv_PtrLcv_videostab_InpaintingPipelineG_delete, cv_PtrLcv_videostab_InpaintingPipelineG_getInnerPtr_const, cv_PtrLcv_videostab_InpaintingPipelineG_getInnerPtrMut } @@ -25913,9 +24224,6 @@ mod videostab_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfKeypointBasedMotionEstimator = core::Ptr; - ptr_extern! { crate::videostab::KeypointBasedMotionEstimator, cv_PtrLcv_videostab_KeypointBasedMotionEstimatorG_new_null_const, cv_PtrLcv_videostab_KeypointBasedMotionEstimatorG_delete, cv_PtrLcv_videostab_KeypointBasedMotionEstimatorG_getInnerPtr_const, cv_PtrLcv_videostab_KeypointBasedMotionEstimatorG_getInnerPtrMut } @@ -25952,9 +24260,6 @@ mod videostab_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfKeypointBasedMotionEstimatorGpu = core::Ptr; - ptr_extern! { crate::videostab::KeypointBasedMotionEstimatorGpu, cv_PtrLcv_videostab_KeypointBasedMotionEstimatorGpuG_new_null_const, cv_PtrLcv_videostab_KeypointBasedMotionEstimatorGpuG_delete, cv_PtrLcv_videostab_KeypointBasedMotionEstimatorGpuG_getInnerPtr_const, cv_PtrLcv_videostab_KeypointBasedMotionEstimatorGpuG_getInnerPtrMut } @@ -25991,9 +24296,6 @@ mod videostab_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfLogToStdout = core::Ptr; - ptr_extern! { crate::videostab::LogToStdout, cv_PtrLcv_videostab_LogToStdoutG_new_null_const, cv_PtrLcv_videostab_LogToStdoutG_delete, cv_PtrLcv_videostab_LogToStdoutG_getInnerPtr_const, cv_PtrLcv_videostab_LogToStdoutG_getInnerPtrMut } @@ -26030,9 +24332,6 @@ mod videostab_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfLpMotionStabilizer = core::Ptr; - ptr_extern! { crate::videostab::LpMotionStabilizer, cv_PtrLcv_videostab_LpMotionStabilizerG_new_null_const, cv_PtrLcv_videostab_LpMotionStabilizerG_delete, cv_PtrLcv_videostab_LpMotionStabilizerG_getInnerPtr_const, cv_PtrLcv_videostab_LpMotionStabilizerG_getInnerPtrMut } @@ -26069,9 +24368,6 @@ mod videostab_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfMaskFrameSource = core::Ptr; - ptr_extern! { crate::videostab::MaskFrameSource, cv_PtrLcv_videostab_MaskFrameSourceG_new_null_const, cv_PtrLcv_videostab_MaskFrameSourceG_delete, cv_PtrLcv_videostab_MaskFrameSourceG_getInnerPtr_const, cv_PtrLcv_videostab_MaskFrameSourceG_getInnerPtrMut } @@ -26108,9 +24404,6 @@ mod videostab_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfMoreAccurateMotionWobbleSuppressor = core::Ptr; - ptr_extern! { crate::videostab::MoreAccurateMotionWobbleSuppressor, cv_PtrLcv_videostab_MoreAccurateMotionWobbleSuppressorG_new_null_const, cv_PtrLcv_videostab_MoreAccurateMotionWobbleSuppressorG_delete, cv_PtrLcv_videostab_MoreAccurateMotionWobbleSuppressorG_getInnerPtr_const, cv_PtrLcv_videostab_MoreAccurateMotionWobbleSuppressorG_getInnerPtrMut } @@ -26157,9 +24450,6 @@ mod videostab_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfMoreAccurateMotionWobbleSuppressorBase = core::Ptr; - ptr_extern! { crate::videostab::MoreAccurateMotionWobbleSuppressorBase, cv_PtrLcv_videostab_MoreAccurateMotionWobbleSuppressorBaseG_new_null_const, cv_PtrLcv_videostab_MoreAccurateMotionWobbleSuppressorBaseG_delete, cv_PtrLcv_videostab_MoreAccurateMotionWobbleSuppressorBaseG_getInnerPtr_const, cv_PtrLcv_videostab_MoreAccurateMotionWobbleSuppressorBaseG_getInnerPtrMut } @@ -26195,9 +24485,6 @@ mod videostab_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfMoreAccurateMotionWobbleSuppressorGpu = core::Ptr; - ptr_extern! { crate::videostab::MoreAccurateMotionWobbleSuppressorGpu, cv_PtrLcv_videostab_MoreAccurateMotionWobbleSuppressorGpuG_new_null_const, cv_PtrLcv_videostab_MoreAccurateMotionWobbleSuppressorGpuG_delete, cv_PtrLcv_videostab_MoreAccurateMotionWobbleSuppressorGpuG_getInnerPtr_const, cv_PtrLcv_videostab_MoreAccurateMotionWobbleSuppressorGpuG_getInnerPtrMut } @@ -26244,9 +24531,6 @@ mod videostab_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfMotionEstimatorBase = core::Ptr; - ptr_extern! { crate::videostab::MotionEstimatorBase, cv_PtrLcv_videostab_MotionEstimatorBaseG_new_null_const, cv_PtrLcv_videostab_MotionEstimatorBaseG_delete, cv_PtrLcv_videostab_MotionEstimatorBaseG_getInnerPtr_const, cv_PtrLcv_videostab_MotionEstimatorBaseG_getInnerPtrMut } @@ -26272,9 +24556,6 @@ mod videostab_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfMotionEstimatorL1 = core::Ptr; - ptr_extern! { crate::videostab::MotionEstimatorL1, cv_PtrLcv_videostab_MotionEstimatorL1G_new_null_const, cv_PtrLcv_videostab_MotionEstimatorL1G_delete, cv_PtrLcv_videostab_MotionEstimatorL1G_getInnerPtr_const, cv_PtrLcv_videostab_MotionEstimatorL1G_getInnerPtrMut } @@ -26311,9 +24592,6 @@ mod videostab_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfMotionEstimatorRansacL2 = core::Ptr; - ptr_extern! { crate::videostab::MotionEstimatorRansacL2, cv_PtrLcv_videostab_MotionEstimatorRansacL2G_new_null_const, cv_PtrLcv_videostab_MotionEstimatorRansacL2G_delete, cv_PtrLcv_videostab_MotionEstimatorRansacL2G_getInnerPtr_const, cv_PtrLcv_videostab_MotionEstimatorRansacL2G_getInnerPtrMut } @@ -26350,9 +24628,6 @@ mod videostab_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfMotionFilterBase = core::Ptr; - ptr_extern! { crate::videostab::MotionFilterBase, cv_PtrLcv_videostab_MotionFilterBaseG_new_null_const, cv_PtrLcv_videostab_MotionFilterBaseG_delete, cv_PtrLcv_videostab_MotionFilterBaseG_getInnerPtr_const, cv_PtrLcv_videostab_MotionFilterBaseG_getInnerPtrMut } @@ -26388,9 +24663,6 @@ mod videostab_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfMotionInpainter = core::Ptr; - ptr_extern! { crate::videostab::MotionInpainter, cv_PtrLcv_videostab_MotionInpainterG_new_null_const, cv_PtrLcv_videostab_MotionInpainterG_delete, cv_PtrLcv_videostab_MotionInpainterG_getInnerPtr_const, cv_PtrLcv_videostab_MotionInpainterG_getInnerPtrMut } @@ -26427,9 +24699,6 @@ mod videostab_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfMotionStabilizationPipeline = core::Ptr; - ptr_extern! { crate::videostab::MotionStabilizationPipeline, cv_PtrLcv_videostab_MotionStabilizationPipelineG_new_null_const, cv_PtrLcv_videostab_MotionStabilizationPipelineG_delete, cv_PtrLcv_videostab_MotionStabilizationPipelineG_getInnerPtr_const, cv_PtrLcv_videostab_MotionStabilizationPipelineG_getInnerPtrMut } @@ -26466,9 +24735,6 @@ mod videostab_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfNullDeblurer = core::Ptr; - ptr_extern! { crate::videostab::NullDeblurer, cv_PtrLcv_videostab_NullDeblurerG_new_null_const, cv_PtrLcv_videostab_NullDeblurerG_delete, cv_PtrLcv_videostab_NullDeblurerG_getInnerPtr_const, cv_PtrLcv_videostab_NullDeblurerG_getInnerPtrMut } @@ -26505,9 +24771,6 @@ mod videostab_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfNullFrameSource = core::Ptr; - ptr_extern! { crate::videostab::NullFrameSource, cv_PtrLcv_videostab_NullFrameSourceG_new_null_const, cv_PtrLcv_videostab_NullFrameSourceG_delete, cv_PtrLcv_videostab_NullFrameSourceG_getInnerPtr_const, cv_PtrLcv_videostab_NullFrameSourceG_getInnerPtrMut } @@ -26544,9 +24807,6 @@ mod videostab_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfNullInpainter = core::Ptr; - ptr_extern! { crate::videostab::NullInpainter, cv_PtrLcv_videostab_NullInpainterG_new_null_const, cv_PtrLcv_videostab_NullInpainterG_delete, cv_PtrLcv_videostab_NullInpainterG_getInnerPtr_const, cv_PtrLcv_videostab_NullInpainterG_getInnerPtrMut } @@ -26583,9 +24843,6 @@ mod videostab_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfNullLog = core::Ptr; - ptr_extern! { crate::videostab::NullLog, cv_PtrLcv_videostab_NullLogG_new_null_const, cv_PtrLcv_videostab_NullLogG_delete, cv_PtrLcv_videostab_NullLogG_getInnerPtr_const, cv_PtrLcv_videostab_NullLogG_getInnerPtrMut } @@ -26622,9 +24879,6 @@ mod videostab_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfNullOutlierRejector = core::Ptr; - ptr_extern! { crate::videostab::NullOutlierRejector, cv_PtrLcv_videostab_NullOutlierRejectorG_new_null_const, cv_PtrLcv_videostab_NullOutlierRejectorG_delete, cv_PtrLcv_videostab_NullOutlierRejectorG_getInnerPtr_const, cv_PtrLcv_videostab_NullOutlierRejectorG_getInnerPtrMut } @@ -26661,9 +24915,6 @@ mod videostab_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfNullWobbleSuppressor = core::Ptr; - ptr_extern! { crate::videostab::NullWobbleSuppressor, cv_PtrLcv_videostab_NullWobbleSuppressorG_new_null_const, cv_PtrLcv_videostab_NullWobbleSuppressorG_delete, cv_PtrLcv_videostab_NullWobbleSuppressorG_getInnerPtr_const, cv_PtrLcv_videostab_NullWobbleSuppressorG_getInnerPtrMut } @@ -26700,9 +24951,6 @@ mod videostab_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfOnePassStabilizer = core::Ptr; - ptr_extern! { crate::videostab::OnePassStabilizer, cv_PtrLcv_videostab_OnePassStabilizerG_new_null_const, cv_PtrLcv_videostab_OnePassStabilizerG_delete, cv_PtrLcv_videostab_OnePassStabilizerG_getInnerPtr_const, cv_PtrLcv_videostab_OnePassStabilizerG_getInnerPtrMut } @@ -26749,9 +24997,6 @@ mod videostab_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfPyrLkOptFlowEstimatorBase = core::Ptr; - ptr_extern! { crate::videostab::PyrLkOptFlowEstimatorBase, cv_PtrLcv_videostab_PyrLkOptFlowEstimatorBaseG_new_null_const, cv_PtrLcv_videostab_PyrLkOptFlowEstimatorBaseG_delete, cv_PtrLcv_videostab_PyrLkOptFlowEstimatorBaseG_getInnerPtr_const, cv_PtrLcv_videostab_PyrLkOptFlowEstimatorBaseG_getInnerPtrMut } @@ -26778,9 +25023,6 @@ mod videostab_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfSparsePyrLkOptFlowEstimator = core::Ptr; - ptr_extern! { crate::videostab::SparsePyrLkOptFlowEstimator, cv_PtrLcv_videostab_SparsePyrLkOptFlowEstimatorG_new_null_const, cv_PtrLcv_videostab_SparsePyrLkOptFlowEstimatorG_delete, cv_PtrLcv_videostab_SparsePyrLkOptFlowEstimatorG_getInnerPtr_const, cv_PtrLcv_videostab_SparsePyrLkOptFlowEstimatorG_getInnerPtrMut } @@ -26827,9 +25069,6 @@ mod videostab_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfSparsePyrLkOptFlowEstimatorGpu = core::Ptr; - ptr_extern! { crate::videostab::SparsePyrLkOptFlowEstimatorGpu, cv_PtrLcv_videostab_SparsePyrLkOptFlowEstimatorGpuG_new_null_const, cv_PtrLcv_videostab_SparsePyrLkOptFlowEstimatorGpuG_delete, cv_PtrLcv_videostab_SparsePyrLkOptFlowEstimatorGpuG_getInnerPtr_const, cv_PtrLcv_videostab_SparsePyrLkOptFlowEstimatorGpuG_getInnerPtrMut } @@ -26876,9 +25115,6 @@ mod videostab_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfStabilizerBase = core::Ptr; - ptr_extern! { crate::videostab::StabilizerBase, cv_PtrLcv_videostab_StabilizerBaseG_new_null_const, cv_PtrLcv_videostab_StabilizerBaseG_delete, cv_PtrLcv_videostab_StabilizerBaseG_getInnerPtr_const, cv_PtrLcv_videostab_StabilizerBaseG_getInnerPtrMut } @@ -26904,9 +25140,6 @@ mod videostab_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfToFileMotionWriter = core::Ptr; - ptr_extern! { crate::videostab::ToFileMotionWriter, cv_PtrLcv_videostab_ToFileMotionWriterG_new_null_const, cv_PtrLcv_videostab_ToFileMotionWriterG_delete, cv_PtrLcv_videostab_ToFileMotionWriterG_getInnerPtr_const, cv_PtrLcv_videostab_ToFileMotionWriterG_getInnerPtrMut } @@ -26943,9 +25176,6 @@ mod videostab_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfTranslationBasedLocalOutlierRejector = core::Ptr; - ptr_extern! { crate::videostab::TranslationBasedLocalOutlierRejector, cv_PtrLcv_videostab_TranslationBasedLocalOutlierRejectorG_new_null_const, cv_PtrLcv_videostab_TranslationBasedLocalOutlierRejectorG_delete, cv_PtrLcv_videostab_TranslationBasedLocalOutlierRejectorG_getInnerPtr_const, cv_PtrLcv_videostab_TranslationBasedLocalOutlierRejectorG_getInnerPtrMut } @@ -26982,9 +25212,6 @@ mod videostab_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfTwoPassStabilizer = core::Ptr; - ptr_extern! { crate::videostab::TwoPassStabilizer, cv_PtrLcv_videostab_TwoPassStabilizerG_new_null_const, cv_PtrLcv_videostab_TwoPassStabilizerG_delete, cv_PtrLcv_videostab_TwoPassStabilizerG_getInnerPtr_const, cv_PtrLcv_videostab_TwoPassStabilizerG_getInnerPtrMut } @@ -27031,9 +25258,6 @@ mod videostab_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfVideoFileSource = core::Ptr; - ptr_extern! { crate::videostab::VideoFileSource, cv_PtrLcv_videostab_VideoFileSourceG_new_null_const, cv_PtrLcv_videostab_VideoFileSourceG_delete, cv_PtrLcv_videostab_VideoFileSourceG_getInnerPtr_const, cv_PtrLcv_videostab_VideoFileSourceG_getInnerPtrMut } @@ -27070,9 +25294,6 @@ mod videostab_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfWeightingDeblurer = core::Ptr; - ptr_extern! { crate::videostab::WeightingDeblurer, cv_PtrLcv_videostab_WeightingDeblurerG_new_null_const, cv_PtrLcv_videostab_WeightingDeblurerG_delete, cv_PtrLcv_videostab_WeightingDeblurerG_getInnerPtr_const, cv_PtrLcv_videostab_WeightingDeblurerG_getInnerPtrMut } @@ -27109,9 +25330,6 @@ mod videostab_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfWobbleSuppressorBase = core::Ptr; - ptr_extern! { crate::videostab::WobbleSuppressorBase, cv_PtrLcv_videostab_WobbleSuppressorBaseG_new_null_const, cv_PtrLcv_videostab_WobbleSuppressorBaseG_delete, cv_PtrLcv_videostab_WobbleSuppressorBaseG_getInnerPtr_const, cv_PtrLcv_videostab_WobbleSuppressorBaseG_getInnerPtrMut } @@ -27138,16 +25356,11 @@ mod videostab_types { } } -#[cfg(ocvrs_has_module_videostab)] pub use videostab_types::*; -#[cfg(ocvrs_has_module_xfeatures2d)] mod xfeatures2d_types { use crate::{mod_prelude::*, core, types, sys}; - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfAffineFeature2D = core::Ptr; - ptr_extern! { crate::xfeatures2d::AffineFeature2D, cv_PtrLcv_xfeatures2d_AffineFeature2DG_new_null_const, cv_PtrLcv_xfeatures2d_AffineFeature2DG_delete, cv_PtrLcv_xfeatures2d_AffineFeature2DG_getInnerPtr_const, cv_PtrLcv_xfeatures2d_AffineFeature2DG_getInnerPtrMut } @@ -27193,9 +25406,6 @@ mod xfeatures2d_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfBEBLID = core::Ptr; - ptr_extern! { crate::xfeatures2d::BEBLID, cv_PtrLcv_xfeatures2d_BEBLIDG_new_null_const, cv_PtrLcv_xfeatures2d_BEBLIDG_delete, cv_PtrLcv_xfeatures2d_BEBLIDG_getInnerPtr_const, cv_PtrLcv_xfeatures2d_BEBLIDG_getInnerPtrMut } @@ -27241,9 +25451,6 @@ mod xfeatures2d_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfBoostDesc = core::Ptr; - ptr_extern! { crate::xfeatures2d::BoostDesc, cv_PtrLcv_xfeatures2d_BoostDescG_new_null_const, cv_PtrLcv_xfeatures2d_BoostDescG_delete, cv_PtrLcv_xfeatures2d_BoostDescG_getInnerPtr_const, cv_PtrLcv_xfeatures2d_BoostDescG_getInnerPtrMut } @@ -27289,9 +25496,6 @@ mod xfeatures2d_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfBriefDescriptorExtractor = core::Ptr; - ptr_extern! { crate::xfeatures2d::BriefDescriptorExtractor, cv_PtrLcv_xfeatures2d_BriefDescriptorExtractorG_new_null_const, cv_PtrLcv_xfeatures2d_BriefDescriptorExtractorG_delete, cv_PtrLcv_xfeatures2d_BriefDescriptorExtractorG_getInnerPtr_const, cv_PtrLcv_xfeatures2d_BriefDescriptorExtractorG_getInnerPtrMut } @@ -27337,9 +25541,6 @@ mod xfeatures2d_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDAISY = core::Ptr; - ptr_extern! { crate::xfeatures2d::DAISY, cv_PtrLcv_xfeatures2d_DAISYG_new_null_const, cv_PtrLcv_xfeatures2d_DAISYG_delete, cv_PtrLcv_xfeatures2d_DAISYG_getInnerPtr_const, cv_PtrLcv_xfeatures2d_DAISYG_getInnerPtrMut } @@ -27385,9 +25586,6 @@ mod xfeatures2d_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfFREAK = core::Ptr; - ptr_extern! { crate::xfeatures2d::FREAK, cv_PtrLcv_xfeatures2d_FREAKG_new_null_const, cv_PtrLcv_xfeatures2d_FREAKG_delete, cv_PtrLcv_xfeatures2d_FREAKG_getInnerPtr_const, cv_PtrLcv_xfeatures2d_FREAKG_getInnerPtrMut } @@ -27433,9 +25631,6 @@ mod xfeatures2d_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfHarrisLaplaceFeatureDetector = core::Ptr; - ptr_extern! { crate::xfeatures2d::HarrisLaplaceFeatureDetector, cv_PtrLcv_xfeatures2d_HarrisLaplaceFeatureDetectorG_new_null_const, cv_PtrLcv_xfeatures2d_HarrisLaplaceFeatureDetectorG_delete, cv_PtrLcv_xfeatures2d_HarrisLaplaceFeatureDetectorG_getInnerPtr_const, cv_PtrLcv_xfeatures2d_HarrisLaplaceFeatureDetectorG_getInnerPtrMut } @@ -27481,9 +25676,6 @@ mod xfeatures2d_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfLATCH = core::Ptr; - ptr_extern! { crate::xfeatures2d::LATCH, cv_PtrLcv_xfeatures2d_LATCHG_new_null_const, cv_PtrLcv_xfeatures2d_LATCHG_delete, cv_PtrLcv_xfeatures2d_LATCHG_getInnerPtr_const, cv_PtrLcv_xfeatures2d_LATCHG_getInnerPtrMut } @@ -27529,9 +25721,6 @@ mod xfeatures2d_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfLUCID = core::Ptr; - ptr_extern! { crate::xfeatures2d::LUCID, cv_PtrLcv_xfeatures2d_LUCIDG_new_null_const, cv_PtrLcv_xfeatures2d_LUCIDG_delete, cv_PtrLcv_xfeatures2d_LUCIDG_getInnerPtr_const, cv_PtrLcv_xfeatures2d_LUCIDG_getInnerPtrMut } @@ -27577,9 +25766,6 @@ mod xfeatures2d_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfMSDDetector = core::Ptr; - ptr_extern! { crate::xfeatures2d::MSDDetector, cv_PtrLcv_xfeatures2d_MSDDetectorG_new_null_const, cv_PtrLcv_xfeatures2d_MSDDetectorG_delete, cv_PtrLcv_xfeatures2d_MSDDetectorG_getInnerPtr_const, cv_PtrLcv_xfeatures2d_MSDDetectorG_getInnerPtrMut } @@ -27625,9 +25811,6 @@ mod xfeatures2d_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfPCTSignatures = core::Ptr; - ptr_extern! { crate::xfeatures2d::PCTSignatures, cv_PtrLcv_xfeatures2d_PCTSignaturesG_new_null_const, cv_PtrLcv_xfeatures2d_PCTSignaturesG_delete, cv_PtrLcv_xfeatures2d_PCTSignaturesG_getInnerPtr_const, cv_PtrLcv_xfeatures2d_PCTSignaturesG_getInnerPtrMut } @@ -27663,9 +25846,6 @@ mod xfeatures2d_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfPCTSignaturesSQFD = core::Ptr; - ptr_extern! { crate::xfeatures2d::PCTSignaturesSQFD, cv_PtrLcv_xfeatures2d_PCTSignaturesSQFDG_new_null_const, cv_PtrLcv_xfeatures2d_PCTSignaturesSQFDG_delete, cv_PtrLcv_xfeatures2d_PCTSignaturesSQFDG_getInnerPtr_const, cv_PtrLcv_xfeatures2d_PCTSignaturesSQFDG_getInnerPtrMut } @@ -27701,9 +25881,6 @@ mod xfeatures2d_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfSURF = core::Ptr; - ptr_extern! { crate::xfeatures2d::SURF, cv_PtrLcv_xfeatures2d_SURFG_new_null_const, cv_PtrLcv_xfeatures2d_SURFG_delete, cv_PtrLcv_xfeatures2d_SURFG_getInnerPtr_const, cv_PtrLcv_xfeatures2d_SURFG_getInnerPtrMut } @@ -27749,9 +25926,6 @@ mod xfeatures2d_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfSURF_CUDA = core::Ptr; - ptr_extern! { crate::xfeatures2d::SURF_CUDA, cv_PtrLcv_cuda_SURF_CUDAG_new_null_const, cv_PtrLcv_cuda_SURF_CUDAG_delete, cv_PtrLcv_cuda_SURF_CUDAG_getInnerPtr_const, cv_PtrLcv_cuda_SURF_CUDAG_getInnerPtrMut } @@ -27790,9 +25964,6 @@ mod xfeatures2d_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfStarDetector = core::Ptr; - ptr_extern! { crate::xfeatures2d::StarDetector, cv_PtrLcv_xfeatures2d_StarDetectorG_new_null_const, cv_PtrLcv_xfeatures2d_StarDetectorG_delete, cv_PtrLcv_xfeatures2d_StarDetectorG_getInnerPtr_const, cv_PtrLcv_xfeatures2d_StarDetectorG_getInnerPtrMut } @@ -27838,9 +26009,6 @@ mod xfeatures2d_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfTBMR = core::Ptr; - ptr_extern! { crate::xfeatures2d::TBMR, cv_PtrLcv_xfeatures2d_TBMRG_new_null_const, cv_PtrLcv_xfeatures2d_TBMRG_delete, cv_PtrLcv_xfeatures2d_TBMRG_getInnerPtr_const, cv_PtrLcv_xfeatures2d_TBMRG_getInnerPtrMut } @@ -27896,9 +26064,6 @@ mod xfeatures2d_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfTEBLID = core::Ptr; - ptr_extern! { crate::xfeatures2d::TEBLID, cv_PtrLcv_xfeatures2d_TEBLIDG_new_null_const, cv_PtrLcv_xfeatures2d_TEBLIDG_delete, cv_PtrLcv_xfeatures2d_TEBLIDG_getInnerPtr_const, cv_PtrLcv_xfeatures2d_TEBLIDG_getInnerPtrMut } @@ -27945,9 +26110,6 @@ mod xfeatures2d_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfVGG = core::Ptr; - ptr_extern! { crate::xfeatures2d::VGG, cv_PtrLcv_xfeatures2d_VGGG_new_null_const, cv_PtrLcv_xfeatures2d_VGGG_delete, cv_PtrLcv_xfeatures2d_VGGG_getInnerPtr_const, cv_PtrLcv_xfeatures2d_VGGG_getInnerPtrMut } @@ -27993,9 +26155,6 @@ mod xfeatures2d_types { } } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfElliptic_KeyPoint = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfElliptic_KeyPoint(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfElliptic_KeyPoint(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -28027,16 +26186,11 @@ mod xfeatures2d_types { } -#[cfg(ocvrs_has_module_xfeatures2d)] pub use xfeatures2d_types::*; -#[cfg(ocvrs_has_module_ximgproc)] mod ximgproc_types { use crate::{mod_prelude::*, core, types, sys}; - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfAdaptiveManifoldFilter = core::Ptr; - ptr_extern! { crate::ximgproc::AdaptiveManifoldFilter, cv_PtrLcv_ximgproc_AdaptiveManifoldFilterG_new_null_const, cv_PtrLcv_ximgproc_AdaptiveManifoldFilterG_delete, cv_PtrLcv_ximgproc_AdaptiveManifoldFilterG_getInnerPtr_const, cv_PtrLcv_ximgproc_AdaptiveManifoldFilterG_getInnerPtrMut } @@ -28072,9 +26226,6 @@ mod ximgproc_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfContourFitting = core::Ptr; - ptr_extern! { crate::ximgproc::ContourFitting, cv_PtrLcv_ximgproc_ContourFittingG_new_null_const, cv_PtrLcv_ximgproc_ContourFittingG_delete, cv_PtrLcv_ximgproc_ContourFittingG_getInnerPtr_const, cv_PtrLcv_ximgproc_ContourFittingG_getInnerPtrMut } @@ -28111,9 +26262,6 @@ mod ximgproc_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDTFilter = core::Ptr; - ptr_extern! { crate::ximgproc::DTFilter, cv_PtrLcv_ximgproc_DTFilterG_new_null_const, cv_PtrLcv_ximgproc_DTFilterG_delete, cv_PtrLcv_ximgproc_DTFilterG_getInnerPtr_const, cv_PtrLcv_ximgproc_DTFilterG_getInnerPtrMut } @@ -28149,9 +26297,6 @@ mod ximgproc_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDisparityFilter = core::Ptr; - ptr_extern! { crate::ximgproc::DisparityFilter, cv_PtrLcv_ximgproc_DisparityFilterG_new_null_const, cv_PtrLcv_ximgproc_DisparityFilterG_delete, cv_PtrLcv_ximgproc_DisparityFilterG_getInnerPtr_const, cv_PtrLcv_ximgproc_DisparityFilterG_getInnerPtrMut } @@ -28187,9 +26332,6 @@ mod ximgproc_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfDisparityWLSFilter = core::Ptr; - ptr_extern! { crate::ximgproc::DisparityWLSFilter, cv_PtrLcv_ximgproc_DisparityWLSFilterG_new_null_const, cv_PtrLcv_ximgproc_DisparityWLSFilterG_delete, cv_PtrLcv_ximgproc_DisparityWLSFilterG_getInnerPtr_const, cv_PtrLcv_ximgproc_DisparityWLSFilterG_getInnerPtrMut } @@ -28235,9 +26377,6 @@ mod ximgproc_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfEdgeAwareInterpolator = core::Ptr; - ptr_extern! { crate::ximgproc::EdgeAwareInterpolator, cv_PtrLcv_ximgproc_EdgeAwareInterpolatorG_new_null_const, cv_PtrLcv_ximgproc_EdgeAwareInterpolatorG_delete, cv_PtrLcv_ximgproc_EdgeAwareInterpolatorG_getInnerPtr_const, cv_PtrLcv_ximgproc_EdgeAwareInterpolatorG_getInnerPtrMut } @@ -28283,9 +26422,6 @@ mod ximgproc_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfEdgeBoxes = core::Ptr; - ptr_extern! { crate::ximgproc::EdgeBoxes, cv_PtrLcv_ximgproc_EdgeBoxesG_new_null_const, cv_PtrLcv_ximgproc_EdgeBoxesG_delete, cv_PtrLcv_ximgproc_EdgeBoxesG_getInnerPtr_const, cv_PtrLcv_ximgproc_EdgeBoxesG_getInnerPtrMut } @@ -28321,9 +26457,6 @@ mod ximgproc_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfEdgeDrawing = core::Ptr; - ptr_extern! { crate::ximgproc::EdgeDrawing, cv_PtrLcv_ximgproc_EdgeDrawingG_new_null_const, cv_PtrLcv_ximgproc_EdgeDrawingG_delete, cv_PtrLcv_ximgproc_EdgeDrawingG_getInnerPtr_const, cv_PtrLcv_ximgproc_EdgeDrawingG_getInnerPtrMut } @@ -28360,9 +26493,6 @@ mod ximgproc_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfFastBilateralSolverFilter = core::Ptr; - ptr_extern! { crate::ximgproc::FastBilateralSolverFilter, cv_PtrLcv_ximgproc_FastBilateralSolverFilterG_new_null_const, cv_PtrLcv_ximgproc_FastBilateralSolverFilterG_delete, cv_PtrLcv_ximgproc_FastBilateralSolverFilterG_getInnerPtr_const, cv_PtrLcv_ximgproc_FastBilateralSolverFilterG_getInnerPtrMut } @@ -28398,9 +26528,6 @@ mod ximgproc_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfFastGlobalSmootherFilter = core::Ptr; - ptr_extern! { crate::ximgproc::FastGlobalSmootherFilter, cv_PtrLcv_ximgproc_FastGlobalSmootherFilterG_new_null_const, cv_PtrLcv_ximgproc_FastGlobalSmootherFilterG_delete, cv_PtrLcv_ximgproc_FastGlobalSmootherFilterG_getInnerPtr_const, cv_PtrLcv_ximgproc_FastGlobalSmootherFilterG_getInnerPtrMut } @@ -28436,9 +26563,6 @@ mod ximgproc_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfFastLineDetector = core::Ptr; - ptr_extern! { crate::ximgproc::FastLineDetector, cv_PtrLcv_ximgproc_FastLineDetectorG_new_null_const, cv_PtrLcv_ximgproc_FastLineDetectorG_delete, cv_PtrLcv_ximgproc_FastLineDetectorG_getInnerPtr_const, cv_PtrLcv_ximgproc_FastLineDetectorG_getInnerPtrMut } @@ -28474,9 +26598,6 @@ mod ximgproc_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfGraphSegmentation = core::Ptr; - ptr_extern! { crate::ximgproc::GraphSegmentation, cv_PtrLcv_ximgproc_segmentation_GraphSegmentationG_new_null_const, cv_PtrLcv_ximgproc_segmentation_GraphSegmentationG_delete, cv_PtrLcv_ximgproc_segmentation_GraphSegmentationG_getInnerPtr_const, cv_PtrLcv_ximgproc_segmentation_GraphSegmentationG_getInnerPtrMut } @@ -28512,9 +26633,6 @@ mod ximgproc_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfGuidedFilter = core::Ptr; - ptr_extern! { crate::ximgproc::GuidedFilter, cv_PtrLcv_ximgproc_GuidedFilterG_new_null_const, cv_PtrLcv_ximgproc_GuidedFilterG_delete, cv_PtrLcv_ximgproc_GuidedFilterG_getInnerPtr_const, cv_PtrLcv_ximgproc_GuidedFilterG_getInnerPtrMut } @@ -28550,9 +26668,6 @@ mod ximgproc_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfRFFeatureGetter = core::Ptr; - ptr_extern! { crate::ximgproc::RFFeatureGetter, cv_PtrLcv_ximgproc_RFFeatureGetterG_new_null_const, cv_PtrLcv_ximgproc_RFFeatureGetterG_delete, cv_PtrLcv_ximgproc_RFFeatureGetterG_getInnerPtr_const, cv_PtrLcv_ximgproc_RFFeatureGetterG_getInnerPtrMut } @@ -28588,9 +26703,6 @@ mod ximgproc_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfRICInterpolator = core::Ptr; - ptr_extern! { crate::ximgproc::RICInterpolator, cv_PtrLcv_ximgproc_RICInterpolatorG_new_null_const, cv_PtrLcv_ximgproc_RICInterpolatorG_delete, cv_PtrLcv_ximgproc_RICInterpolatorG_getInnerPtr_const, cv_PtrLcv_ximgproc_RICInterpolatorG_getInnerPtrMut } @@ -28636,9 +26748,6 @@ mod ximgproc_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfRidgeDetectionFilter = core::Ptr; - ptr_extern! { crate::ximgproc::RidgeDetectionFilter, cv_PtrLcv_ximgproc_RidgeDetectionFilterG_new_null_const, cv_PtrLcv_ximgproc_RidgeDetectionFilterG_delete, cv_PtrLcv_ximgproc_RidgeDetectionFilterG_getInnerPtr_const, cv_PtrLcv_ximgproc_RidgeDetectionFilterG_getInnerPtrMut } @@ -28674,9 +26783,6 @@ mod ximgproc_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfScanSegment = core::Ptr; - ptr_extern! { crate::ximgproc::ScanSegment, cv_PtrLcv_ximgproc_ScanSegmentG_new_null_const, cv_PtrLcv_ximgproc_ScanSegmentG_delete, cv_PtrLcv_ximgproc_ScanSegmentG_getInnerPtr_const, cv_PtrLcv_ximgproc_ScanSegmentG_getInnerPtrMut } @@ -28712,9 +26818,6 @@ mod ximgproc_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfSelectiveSearchSegmentation = core::Ptr; - ptr_extern! { crate::ximgproc::SelectiveSearchSegmentation, cv_PtrLcv_ximgproc_segmentation_SelectiveSearchSegmentationG_new_null_const, cv_PtrLcv_ximgproc_segmentation_SelectiveSearchSegmentationG_delete, cv_PtrLcv_ximgproc_segmentation_SelectiveSearchSegmentationG_getInnerPtr_const, cv_PtrLcv_ximgproc_segmentation_SelectiveSearchSegmentationG_getInnerPtrMut } @@ -28750,9 +26853,6 @@ mod ximgproc_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfSelectiveSearchSegmentationStrategy = core::Ptr; - ptr_extern! { crate::ximgproc::SelectiveSearchSegmentationStrategy, cv_PtrLcv_ximgproc_segmentation_SelectiveSearchSegmentationStrategyG_new_null_const, cv_PtrLcv_ximgproc_segmentation_SelectiveSearchSegmentationStrategyG_delete, cv_PtrLcv_ximgproc_segmentation_SelectiveSearchSegmentationStrategyG_getInnerPtr_const, cv_PtrLcv_ximgproc_segmentation_SelectiveSearchSegmentationStrategyG_getInnerPtrMut } @@ -28788,9 +26888,6 @@ mod ximgproc_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfSelectiveSearchSegmentationStrategyColor = core::Ptr; - ptr_extern! { crate::ximgproc::SelectiveSearchSegmentationStrategyColor, cv_PtrLcv_ximgproc_segmentation_SelectiveSearchSegmentationStrategyColorG_new_null_const, cv_PtrLcv_ximgproc_segmentation_SelectiveSearchSegmentationStrategyColorG_delete, cv_PtrLcv_ximgproc_segmentation_SelectiveSearchSegmentationStrategyColorG_getInnerPtr_const, cv_PtrLcv_ximgproc_segmentation_SelectiveSearchSegmentationStrategyColorG_getInnerPtrMut } @@ -28836,9 +26933,6 @@ mod ximgproc_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfSelectiveSearchSegmentationStrategyFill = core::Ptr; - ptr_extern! { crate::ximgproc::SelectiveSearchSegmentationStrategyFill, cv_PtrLcv_ximgproc_segmentation_SelectiveSearchSegmentationStrategyFillG_new_null_const, cv_PtrLcv_ximgproc_segmentation_SelectiveSearchSegmentationStrategyFillG_delete, cv_PtrLcv_ximgproc_segmentation_SelectiveSearchSegmentationStrategyFillG_getInnerPtr_const, cv_PtrLcv_ximgproc_segmentation_SelectiveSearchSegmentationStrategyFillG_getInnerPtrMut } @@ -28884,9 +26978,6 @@ mod ximgproc_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfSelectiveSearchSegmentationStrategyMultiple = core::Ptr; - ptr_extern! { crate::ximgproc::SelectiveSearchSegmentationStrategyMultiple, cv_PtrLcv_ximgproc_segmentation_SelectiveSearchSegmentationStrategyMultipleG_new_null_const, cv_PtrLcv_ximgproc_segmentation_SelectiveSearchSegmentationStrategyMultipleG_delete, cv_PtrLcv_ximgproc_segmentation_SelectiveSearchSegmentationStrategyMultipleG_getInnerPtr_const, cv_PtrLcv_ximgproc_segmentation_SelectiveSearchSegmentationStrategyMultipleG_getInnerPtrMut } @@ -28932,9 +27023,6 @@ mod ximgproc_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfSelectiveSearchSegmentationStrategySize = core::Ptr; - ptr_extern! { crate::ximgproc::SelectiveSearchSegmentationStrategySize, cv_PtrLcv_ximgproc_segmentation_SelectiveSearchSegmentationStrategySizeG_new_null_const, cv_PtrLcv_ximgproc_segmentation_SelectiveSearchSegmentationStrategySizeG_delete, cv_PtrLcv_ximgproc_segmentation_SelectiveSearchSegmentationStrategySizeG_getInnerPtr_const, cv_PtrLcv_ximgproc_segmentation_SelectiveSearchSegmentationStrategySizeG_getInnerPtrMut } @@ -28980,9 +27068,6 @@ mod ximgproc_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfSelectiveSearchSegmentationStrategyTexture = core::Ptr; - ptr_extern! { crate::ximgproc::SelectiveSearchSegmentationStrategyTexture, cv_PtrLcv_ximgproc_segmentation_SelectiveSearchSegmentationStrategyTextureG_new_null_const, cv_PtrLcv_ximgproc_segmentation_SelectiveSearchSegmentationStrategyTextureG_delete, cv_PtrLcv_ximgproc_segmentation_SelectiveSearchSegmentationStrategyTextureG_getInnerPtr_const, cv_PtrLcv_ximgproc_segmentation_SelectiveSearchSegmentationStrategyTextureG_getInnerPtrMut } @@ -29028,9 +27113,6 @@ mod ximgproc_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfSparseMatchInterpolator = core::Ptr; - ptr_extern! { crate::ximgproc::SparseMatchInterpolator, cv_PtrLcv_ximgproc_SparseMatchInterpolatorG_new_null_const, cv_PtrLcv_ximgproc_SparseMatchInterpolatorG_delete, cv_PtrLcv_ximgproc_SparseMatchInterpolatorG_getInnerPtr_const, cv_PtrLcv_ximgproc_SparseMatchInterpolatorG_getInnerPtrMut } @@ -29066,9 +27148,6 @@ mod ximgproc_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfStructuredEdgeDetection = core::Ptr; - ptr_extern! { crate::ximgproc::StructuredEdgeDetection, cv_PtrLcv_ximgproc_StructuredEdgeDetectionG_new_null_const, cv_PtrLcv_ximgproc_StructuredEdgeDetectionG_delete, cv_PtrLcv_ximgproc_StructuredEdgeDetectionG_getInnerPtr_const, cv_PtrLcv_ximgproc_StructuredEdgeDetectionG_getInnerPtrMut } @@ -29104,9 +27183,6 @@ mod ximgproc_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfSuperpixelLSC = core::Ptr; - ptr_extern! { crate::ximgproc::SuperpixelLSC, cv_PtrLcv_ximgproc_SuperpixelLSCG_new_null_const, cv_PtrLcv_ximgproc_SuperpixelLSCG_delete, cv_PtrLcv_ximgproc_SuperpixelLSCG_getInnerPtr_const, cv_PtrLcv_ximgproc_SuperpixelLSCG_getInnerPtrMut } @@ -29142,9 +27218,6 @@ mod ximgproc_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfSuperpixelSEEDS = core::Ptr; - ptr_extern! { crate::ximgproc::SuperpixelSEEDS, cv_PtrLcv_ximgproc_SuperpixelSEEDSG_new_null_const, cv_PtrLcv_ximgproc_SuperpixelSEEDSG_delete, cv_PtrLcv_ximgproc_SuperpixelSEEDSG_getInnerPtr_const, cv_PtrLcv_ximgproc_SuperpixelSEEDSG_getInnerPtrMut } @@ -29180,9 +27253,6 @@ mod ximgproc_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfSuperpixelSLIC = core::Ptr; - ptr_extern! { crate::ximgproc::SuperpixelSLIC, cv_PtrLcv_ximgproc_SuperpixelSLICG_new_null_const, cv_PtrLcv_ximgproc_SuperpixelSLICG_delete, cv_PtrLcv_ximgproc_SuperpixelSLICG_getInnerPtr_const, cv_PtrLcv_ximgproc_SuperpixelSLICG_getInnerPtrMut } @@ -29218,9 +27288,6 @@ mod ximgproc_types { } } - #[deprecated = "Use the the non-alias form `core::Vector` instead, removal in Nov 2024"] - pub type VectorOfBox = core::Vector; - impl core::Vector { pub fn as_raw_VectorOfBox(&self) -> extern_send!(Self) { self.as_raw() } pub fn as_raw_mut_VectorOfBox(&mut self) -> extern_send!(mut Self) { self.as_raw_mut() } @@ -29243,16 +27310,11 @@ mod ximgproc_types { } -#[cfg(ocvrs_has_module_ximgproc)] pub use ximgproc_types::*; -#[cfg(ocvrs_has_module_xobjdetect)] mod xobjdetect_types { use crate::{mod_prelude::*, core, types, sys}; - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfWBDetector = core::Ptr; - ptr_extern! { crate::xobjdetect::WBDetector, cv_PtrLcv_xobjdetect_WBDetectorG_new_null_const, cv_PtrLcv_xobjdetect_WBDetectorG_delete, cv_PtrLcv_xobjdetect_WBDetectorG_getInnerPtr_const, cv_PtrLcv_xobjdetect_WBDetectorG_getInnerPtrMut } @@ -29279,16 +27341,11 @@ mod xobjdetect_types { } } -#[cfg(ocvrs_has_module_xobjdetect)] pub use xobjdetect_types::*; -#[cfg(ocvrs_has_module_xphoto)] mod xphoto_types { use crate::{mod_prelude::*, core, types, sys}; - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfGrayworldWB = core::Ptr; - ptr_extern! { crate::xphoto::GrayworldWB, cv_PtrLcv_xphoto_GrayworldWBG_new_null_const, cv_PtrLcv_xphoto_GrayworldWBG_delete, cv_PtrLcv_xphoto_GrayworldWBG_getInnerPtr_const, cv_PtrLcv_xphoto_GrayworldWBG_getInnerPtrMut } @@ -29334,9 +27391,6 @@ mod xphoto_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfLearningBasedWB = core::Ptr; - ptr_extern! { crate::xphoto::LearningBasedWB, cv_PtrLcv_xphoto_LearningBasedWBG_new_null_const, cv_PtrLcv_xphoto_LearningBasedWBG_delete, cv_PtrLcv_xphoto_LearningBasedWBG_getInnerPtr_const, cv_PtrLcv_xphoto_LearningBasedWBG_getInnerPtrMut } @@ -29382,9 +27436,6 @@ mod xphoto_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfSimpleWB = core::Ptr; - ptr_extern! { crate::xphoto::SimpleWB, cv_PtrLcv_xphoto_SimpleWBG_new_null_const, cv_PtrLcv_xphoto_SimpleWBG_delete, cv_PtrLcv_xphoto_SimpleWBG_getInnerPtr_const, cv_PtrLcv_xphoto_SimpleWBG_getInnerPtrMut } @@ -29430,9 +27481,6 @@ mod xphoto_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfTonemapDurand = core::Ptr; - ptr_extern! { crate::xphoto::TonemapDurand, cv_PtrLcv_xphoto_TonemapDurandG_new_null_const, cv_PtrLcv_xphoto_TonemapDurandG_delete, cv_PtrLcv_xphoto_TonemapDurandG_getInnerPtr_const, cv_PtrLcv_xphoto_TonemapDurandG_getInnerPtrMut } @@ -29478,9 +27526,6 @@ mod xphoto_types { } } - #[deprecated = "Use the the non-alias form `core::Ptr` instead, removal in Nov 2024"] - pub type PtrOfWhiteBalancer = core::Ptr; - ptr_extern! { crate::xphoto::WhiteBalancer, cv_PtrLcv_xphoto_WhiteBalancerG_new_null_const, cv_PtrLcv_xphoto_WhiteBalancerG_delete, cv_PtrLcv_xphoto_WhiteBalancerG_getInnerPtr_const, cv_PtrLcv_xphoto_WhiteBalancerG_getInnerPtrMut } @@ -29517,7 +27562,6 @@ mod xphoto_types { } } -#[cfg(ocvrs_has_module_xphoto)] pub use xphoto_types::*; pub use crate::manual::types::*; diff --git a/docs/viz.rs b/docs/viz.rs index f310601c..3d58bb62 100644 --- a/docs/viz.rs +++ b/docs/viz.rs @@ -2418,9 +2418,6 @@ pub mod viz { /// * callback: Keyboard callback (void (\*KeyboardCallbackFunction(const /// KeyboardEvent&, void\*)). /// * cookie: The optional parameter passed to the callback. - /// - /// ## C++ default parameters - /// * cookie: 0 #[inline] fn register_keyboard_callback(&mut self, callback: crate::viz::Viz3d_KeyboardCallback) -> Result<()> { callback_arg!(callback_trampoline(unnamed: *const c_void, unnamed_1: *mut c_void) -> () => unnamed_1 in callback(unnamed: *const c_void) -> ()); @@ -2437,9 +2434,6 @@ pub mod viz { /// ## Parameters /// * callback: Mouse callback (void (\*MouseCallback)(const MouseEvent&, void\*)). /// * cookie: The optional parameter passed to the callback. - /// - /// ## C++ default parameters - /// * cookie: 0 #[inline] fn register_mouse_callback(&mut self, callback: crate::viz::Viz3d_MouseCallback) -> Result<()> { callback_arg!(callback_trampoline(unnamed: *const c_void, unnamed_1: *mut c_void) -> () => unnamed_1 in callback(unnamed: *const c_void) -> ());