Struct opencv::core::_OutputArray

pub struct _OutputArray { /* fields omitted */ }

This type is very similar to InputArray except that it is used for input/output and output function parameters.

Just like with InputArray, OpenCV users should not care about OutputArray, they just pass Mat, vector<T> etc. to the functions. The same limitation as for InputArray: Do not explicitly create OutputArray instances applies here too.

If you want to make your function polymorphic (i.e. accept different arrays as output parameters), it is also not very difficult. Take the sample above as the reference. Note that _OutputArray::create() needs to be called before _OutputArray::getMat(). This way you guarantee that the output array is properly allocated.

Optional output parameters. If you do not need certain output array to be computed and returned to you, pass cv::noArray(), just like you would in the case of optional input array. At the implementation level, use _OutputArray::needed() to check if certain output array needs to be computed or not.

There are several synonyms for OutputArray that are used to assist automatic Python/Java/... wrapper generators:

   typedef OutputArray OutputArrayOfArrays;
   typedef OutputArray InputOutputArray;
   typedef OutputArray InputOutputArrayOfArrays;

Implementations

impl _OutputArray

pub fn as_raw__OutputArray(&self) -> *const c_void

pub fn as_raw_mut__OutputArray(&mut self) -> *mut c_void

impl _OutputArray

pub fn default() -> Result<_OutputArray>

/////////////////////////////////////////////////////////////////////////////////////

pub fn new(_flags: i32, _obj: *mut c_void) -> Result<_OutputArray>

pub fn from_mat_mut(m: &mut Mat) -> Result<_OutputArray>

pub fn from_mat_vec_mut(vec: &mut Vector<Mat>) -> Result<_OutputArray>

pub fn from_gpumat_mut(d_mat: &mut GpuMat) -> Result<_OutputArray>

pub fn from_gpumat_vec_mut(d_mat: &mut Vector<GpuMat>) -> Result<_OutputArray>

pub fn new_1(buf: &mut Buffer) -> Result<_OutputArray>

pub fn from_hostmem_mut(cuda_mem: &mut HostMem) -> Result<_OutputArray>

pub fn from_umat_mut(m: &mut UMat) -> Result<_OutputArray>

pub fn from_umat_vec_mut(vec: &mut Vector<UMat>) -> Result<_OutputArray>

pub fn from_mat(m: &Mat) -> Result<_OutputArray>

pub fn from_mat_vec(vec: &Vector<Mat>) -> Result<_OutputArray>

pub fn from_gpumat(d_mat: &GpuMat) -> Result<_OutputArray>

pub fn new_2(buf: &Buffer) -> Result<_OutputArray>

pub fn from_hostmem(cuda_mem: &HostMem) -> Result<_OutputArray>

pub fn from_umat(m: &UMat) -> Result<_OutputArray>

pub fn from_umat_vec(vec: &Vector<UMat>) -> Result<_OutputArray>

Trait Implementations

impl Boxed for _OutputArray

pub unsafe fn from_raw(ptr: *mut c_void) -> Self

Wrap the specified raw pointer

pub fn into_raw(self) -> *mut c_void

Return an the underlying raw pointer while consuming this wrapper.

pub fn as_raw(&self) -> *const c_void

Return the underlying raw pointer.

pub fn as_raw_mut(&mut self) -> *mut c_void

Return the underlying mutable raw pointer

impl Drop for _OutputArray

pub fn drop(&mut self)

Executes the destructor for this type.

impl Send for _OutputArray

impl _InputArrayTrait for _OutputArray

pub fn as_raw__InputArray(&self) -> *const c_void

pub fn as_raw_mut__InputArray(&mut self) -> *mut c_void

pub fn get_mat(&self, idx: i32) -> Result<Mat>

C++ default parameters

pub fn get_mat_(&self, idx: i32) -> Result<Mat>

C++ default parameters

pub fn get_umat(&self, idx: i32) -> Result<UMat>

C++ default parameters

pub fn get_mat_vector(&self, mv: &mut Vector<Mat>) -> Result<()>

pub fn get_umat_vector(&self, umv: &mut Vector<UMat>) -> Result<()>

pub fn get_gpu_mat_vector(&self, gpumv: &mut Vector<GpuMat>) -> Result<()>

pub fn get_gpu_mat(&self) -> Result<GpuMat>

pub fn get_o_gl_buffer(&self) -> Result<Buffer>

pub fn get_flags(&self) -> Result<i32>

pub fn get_obj(&self) -> Result<*mut c_void>

pub fn get_sz(&self) -> Result<Size>

pub fn kind(&self) -> Result<_InputArray_KindFlag>

pub fn dims(&self, i: i32) -> Result<i32>

C++ default parameters

pub fn cols(&self, i: i32) -> Result<i32>

C++ default parameters

pub fn rows(&self, i: i32) -> Result<i32>

C++ default parameters

pub fn size(&self, i: i32) -> Result<Size>

C++ default parameters

pub fn sizend(&self, sz: &mut i32, i: i32) -> Result<i32>

C++ default parameters

pub fn same_size(&self, arr: &dyn ToInputArray) -> Result<bool>

pub fn total(&self, i: i32) -> Result<size_t>

C++ default parameters

pub fn typ(&self, i: i32) -> Result<i32>

C++ default parameters

pub fn depth(&self, i: i32) -> Result<i32>

C++ default parameters

pub fn channels(&self, i: i32) -> Result<i32>

C++ default parameters

pub fn is_continuous(&self, i: i32) -> Result<bool>

C++ default parameters

pub fn is_submatrix(&self, i: i32) -> Result<bool>

C++ default parameters

pub fn empty(&self) -> Result<bool>

pub fn copy_to(&self, arr: &mut dyn ToOutputArray) -> Result<()>

pub fn copy_to_masked(
    &self,
    arr: &mut dyn ToOutputArray,
    mask: &dyn ToInputArray
) -> Result<()>

pub fn offset(&self, i: i32) -> Result<size_t>

C++ default parameters

pub fn step(&self, i: i32) -> Result<size_t>

C++ default parameters

pub fn is_mat(&self) -> Result<bool>

pub fn is_umat(&self) -> Result<bool>

pub fn is_mat_vector(&self) -> Result<bool>

pub fn is_umat_vector(&self) -> Result<bool>

pub fn is_matx(&self) -> Result<bool>

pub fn is_vector(&self) -> Result<bool>

pub fn is_gpu_mat(&self) -> Result<bool>

pub fn is_gpu_mat_vector(&self) -> Result<bool>

impl _OutputArrayTrait for _OutputArray

pub fn as_raw__OutputArray(&self) -> *const c_void

pub fn as_raw_mut__OutputArray(&mut self) -> *mut c_void

pub fn fixed_size(&self) -> Result<bool>

pub fn fixed_type(&self) -> Result<bool>

pub fn needed(&self) -> Result<bool>

pub fn get_mat_ref(&self, i: i32) -> Result<Mat>

C++ default parameters

pub fn get_umat_ref(&self, i: i32) -> Result<UMat>

C++ default parameters

pub fn get_gpu_mat_ref(&self) -> Result<GpuMat>

pub fn get_gpu_mat_vec_ref(&self) -> Result<Vector<GpuMat>>

pub fn get_o_gl_buffer_ref(&self) -> Result<Buffer>

pub fn get_host_mem_ref(&self) -> Result<HostMem>

pub fn create_size(
    &self,
    sz: Size,
    typ: i32,
    i: i32,
    allow_transposed: bool,
    fixed_depth_mask: _OutputArray_DepthMask
) -> Result<()>

C++ default parameters

pub fn create(
    &self,
    rows: i32,
    cols: i32,
    typ: i32,
    i: i32,
    allow_transposed: bool,
    fixed_depth_mask: _OutputArray_DepthMask
) -> Result<()>

C++ default parameters

pub fn create_nd(
    &self,
    size: &[i32],
    typ: i32,
    i: i32,
    allow_transposed: bool,
    fixed_depth_mask: _OutputArray_DepthMask
) -> Result<()>

C++ default parameters

pub unsafe fn create_same_size(
    &self,
    arr: &dyn ToInputArray,
    mtype: i32
) -> Result<()>

pub fn release(&self) -> Result<()>

pub fn clear(&self) -> Result<()>

pub fn set_to(
    &self,
    value: &dyn ToInputArray,
    mask: &dyn ToInputArray
) -> Result<()>

C++ default parameters

pub fn assign(&self, u: &UMat) -> Result<()>

pub fn assign_1(&self, m: &Mat) -> Result<()>

pub fn assign_2(&self, v: &Vector<UMat>) -> Result<()>

pub fn assign_3(&self, v: &Vector<Mat>) -> Result<()>

pub fn move_(&self, u: &mut UMat) -> Result<()>

pub fn move__1(&self, m: &mut Mat) -> Result<()>