Struct opencv::core::GpuMat

pub struct GpuMat { /* fields omitted */ }

Base storage class for GPU memory with reference counting.

Its interface matches the Mat interface with the following limitations:

• no arbitrary dimensions support (only 2D)
• no functions that return references to their data (because references on GPU are not valid for CPU)
• no expression templates technique support

Beware that the latter limitation may lead to overloaded matrix operators that cause memory allocations. The GpuMat class is convertible to cuda::PtrStepSz and cuda::PtrStep so it can be passed directly to the kernel.

Note: In contrast with Mat, in most cases GpuMat::isContinuous() == false . This means that rows are aligned to a size depending on the hardware. Single-row GpuMat is always a continuous matrix.

Note: You are not recommended to leave static or global GpuMat variables allocated, that is, to rely on its destructor. The destruction order of such variables and CUDA context is undefined. GPU memory release function returns error if the CUDA context has been destroyed before.

Some member functions are described as a "Blocking Call" while some are described as a "Non-Blocking Call". Blocking functions are synchronous to host. It is guaranteed that the GPU operation is finished when the function returns. However, non-blocking functions are asynchronous to host. Those functions may return even if the GPU operation is not finished.

Compared to their blocking counterpart, non-blocking functions accept Stream as an additional argument. If a non-default stream is passed, the GPU operation may overlap with operations in other streams.

See also

Mat

Implementations

impl GpuMat

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

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

impl GpuMat

pub fn default_allocator(
) -> Result<AbstractRefMut<'static, dyn GpuMat_Allocator>>

default allocator

pub unsafe fn set_default_allocator(
    allocator: &mut dyn GpuMat_Allocator
) -> Result<()>

pub unsafe fn new(allocator: &mut dyn GpuMat_Allocator) -> Result<GpuMat>

default constructor

C++ default parameters

• allocator: GpuMat::defaultAllocator()

pub unsafe fn new_rows_cols(
    rows: i32,
    cols: i32,
    typ: i32,
    allocator: &mut dyn GpuMat_Allocator
) -> Result<GpuMat>

constructs GpuMat of the specified size and type

C++ default parameters

• allocator: GpuMat::defaultAllocator()

pub unsafe fn new_size(
    size: Size,
    typ: i32,
    allocator: &mut dyn GpuMat_Allocator
) -> Result<GpuMat>

C++ default parameters

• allocator: GpuMat::defaultAllocator()

pub unsafe fn new_rows_cols_with_default(
    rows: i32,
    cols: i32,
    typ: i32,
    s: Scalar,
    allocator: &mut dyn GpuMat_Allocator
) -> Result<GpuMat>

constructs GpuMat and fills it with the specified value _s

C++ default parameters

• allocator: GpuMat::defaultAllocator()

pub unsafe fn new_size_with_default(
    size: Size,
    typ: i32,
    s: Scalar,
    allocator: &mut dyn GpuMat_Allocator
) -> Result<GpuMat>

C++ default parameters

• allocator: GpuMat::defaultAllocator()

pub fn copy(m: &GpuMat) -> Result<GpuMat>

copy constructor

pub unsafe fn new_rows_cols_with_data(
    rows: i32,
    cols: i32,
    typ: i32,
    data: *mut c_void,
    step: size_t
) -> Result<GpuMat>

constructor for GpuMat headers pointing to user-allocated data

C++ default parameters

• step: Mat::AUTO_STEP

pub unsafe fn new_size_with_data(
    size: Size,
    typ: i32,
    data: *mut c_void,
    step: size_t
) -> Result<GpuMat>

C++ default parameters

• step: Mat::AUTO_STEP

pub fn rowscols(
    m: &GpuMat,
    row_range: Range,
    col_range: Range
) -> Result<GpuMat>

creates a GpuMat header for a part of the bigger matrix

pub fn roi(m: &GpuMat, roi: Rect) -> Result<GpuMat>

pub unsafe fn from_hostmem(
    arr: &dyn ToInputArray,
    allocator: &mut dyn GpuMat_Allocator
) -> Result<GpuMat>

builds GpuMat from host memory (Blocking call)

C++ default parameters

• allocator: GpuMat::defaultAllocator()

impl GpuMat

pub fn default() -> Result<Self>

Trait Implementations

impl Boxed for GpuMat

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 Clone for GpuMat

pub fn clone(&self) -> Self

Calls try_clone() and panics if that fails

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Drop for GpuMat

pub fn drop(&mut self)

Executes the destructor for this type.

impl GpuMatTrait for GpuMat

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

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

pub fn flags(&self) -> i32

! includes several bit-fields:

pub fn set_flags(&mut self, val: i32)

! includes several bit-fields:

pub fn rows(&self) -> i32

the number of rows and columns

pub fn set_rows(&mut self, val: i32)

the number of rows and columns

pub fn cols(&self) -> i32

the number of rows and columns

pub fn set_cols(&mut self, val: i32)

the number of rows and columns

pub fn step(&self) -> size_t

a distance between successive rows in bytes; includes the gap if any

pub fn set_step(&mut self, val: size_t)

a distance between successive rows in bytes; includes the gap if any

pub fn data(&mut self) -> &mut u8

pointer to the data

pub fn set_data(&mut self, val: &mut u8)

pointer to the data

pub fn refcount(&mut self) -> &mut i32

pointer to the reference counter; when GpuMat points to user-allocated data, the pointer is NULL

pub fn set_refcount(&mut self, val: &mut i32)

pointer to the reference counter; when GpuMat points to user-allocated data, the pointer is NULL

pub fn datastart(&mut self) -> &mut u8

helper fields used in locateROI and adjustROI

pub fn set_datastart(&mut self, val: &mut u8)

helper fields used in locateROI and adjustROI

pub fn dataend(&self) -> &u8

pub fn allocator(&mut self) -> AbstractRefMut<'_, dyn GpuMat_Allocator>

allocator

pub unsafe fn set_allocator(&mut self, val: &mut dyn GpuMat_Allocator)

allocator

pub fn create(&mut self, rows: i32, cols: i32, typ: i32) -> Result<()>

allocates new GpuMat data unless the GpuMat already has specified size and type

pub fn create_1(&mut self, size: Size, typ: i32) -> Result<()>

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

decreases reference counter, deallocate the data when reference counter reaches 0

pub fn swap(&mut self, mat: &mut GpuMat) -> Result<()>

swaps with other smart pointer

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

Performs data upload to GpuMat (Blocking call)

pub fn upload_async(
    &mut self,
    arr: &dyn ToInputArray,
    stream: &mut Stream
) -> Result<()>

Performs data upload to GpuMat (Non-Blocking call)

pub fn download(&self, dst: &mut dyn ToOutputArray) -> Result<()>

Performs data download from GpuMat (Blocking call)

pub fn download_async(
    &self,
    dst: &mut dyn ToOutputArray,
    stream: &mut Stream
) -> Result<()>

Performs data download from GpuMat (Non-Blocking call)

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

returns deep copy of the GpuMat, i.e. the data is copied

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

copies the GpuMat content to device memory (Blocking call)

pub fn copy_to_1(
    &self,
    dst: &mut dyn ToOutputArray,
    stream: &mut Stream
) -> Result<()>

copies the GpuMat content to device memory (Non-Blocking call)

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

copies those GpuMat elements to "m" that are marked with non-zero mask elements (Blocking call)

pub fn copy_to_3(
    &self,
    dst: &mut dyn ToOutputArray,
    mask: &dyn ToInputArray,
    stream: &mut Stream
) -> Result<()>

copies those GpuMat elements to "m" that are marked with non-zero mask elements (Non-Blocking call)

pub fn set_to(&mut self, s: Scalar) -> Result<GpuMat>

sets some of the GpuMat elements to s (Blocking call)

pub fn set_to_1(&mut self, s: Scalar, stream: &mut Stream) -> Result<GpuMat>

sets some of the GpuMat elements to s (Non-Blocking call)

pub fn set_to_2(&mut self, s: Scalar, mask: &dyn ToInputArray) -> Result<GpuMat>

sets some of the GpuMat elements to s, according to the mask (Blocking call)

pub fn set_to_3(
    &mut self,
    s: Scalar,
    mask: &dyn ToInputArray,
    stream: &mut Stream
) -> Result<GpuMat>

sets some of the GpuMat elements to s, according to the mask (Non-Blocking call)

pub fn convert_to(&self, dst: &mut dyn ToOutputArray, rtype: i32) -> Result<()>

converts GpuMat to another datatype (Blocking call)

pub fn convert_to_1(
    &self,
    dst: &mut dyn ToOutputArray,
    rtype: i32,
    stream: &mut Stream
) -> Result<()>

converts GpuMat to another datatype (Non-Blocking call)

pub fn convert_to_2(
    &self,
    dst: &mut dyn ToOutputArray,
    rtype: i32,
    alpha: f64,
    beta: f64
) -> Result<()>

converts GpuMat to another datatype with scaling (Blocking call)

pub fn convert_to_3(
    &self,
    dst: &mut dyn ToOutputArray,
    rtype: i32,
    alpha: f64,
    stream: &mut Stream
) -> Result<()>

converts GpuMat to another datatype with scaling (Non-Blocking call)

pub fn convert_to_4(
    &self,
    dst: &mut dyn ToOutputArray,
    rtype: i32,
    alpha: f64,
    beta: f64,
    stream: &mut Stream
) -> Result<()>

converts GpuMat to another datatype with scaling (Non-Blocking call)

pub fn assign_to(&self, m: &mut GpuMat, typ: i32) -> Result<()>

C++ default parameters

pub fn ptr(&mut self, y: i32) -> Result<&mut u8>

returns pointer to y-th row

pub fn ptr_1(&self, y: i32) -> Result<&u8>

C++ default parameters

pub fn row(&self, y: i32) -> Result<GpuMat>

returns a new GpuMat header for the specified row

pub fn col(&self, x: i32) -> Result<GpuMat>

returns a new GpuMat header for the specified column

pub fn row_range(&self, startrow: i32, endrow: i32) -> Result<GpuMat>

... for the specified row span

pub fn row_range_1(&self, r: Range) -> Result<GpuMat>

pub fn col_range(&self, startcol: i32, endcol: i32) -> Result<GpuMat>

... for the specified column span

pub fn col_range_1(&self, r: Range) -> Result<GpuMat>

pub fn reshape(&self, cn: i32, rows: i32) -> Result<GpuMat>

creates alternative GpuMat header for the same data, with different number of channels and/or different number of rows

pub fn locate_roi(&self, whole_size: &mut Size, ofs: &mut Point) -> Result<()>

locates GpuMat header within a parent GpuMat

pub fn adjust_roi(
    &mut self,
    dtop: i32,
    dbottom: i32,
    dleft: i32,
    dright: i32
) -> Result<GpuMat>

moves/resizes the current GpuMat ROI inside the parent GpuMat

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

returns true iff the GpuMat data is continuous (i.e. when there are no gaps between successive rows)

pub fn elem_size(&self) -> Result<size_t>

returns element size in bytes

pub fn elem_size1(&self) -> Result<size_t>

returns the size of element channel in bytes

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

returns element type

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

returns element type

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

returns number of channels

pub fn step1(&self) -> Result<size_t>

returns step/elemSize1()

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

returns GpuMat size : width == number of columns, height == number of rows

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

returns true if GpuMat data is NULL

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

pub fn update_continuity_flag(&mut self) -> Result<()>

internal use method: updates the continuity flag

impl Send for GpuMat

impl ToInputArray for GpuMat

pub fn input_array(&self) -> Result<_InputArray>

impl<'_> ToInputArray for &'_ GpuMat

pub fn input_array(&self) -> Result<_InputArray>

impl ToInputOutputArray for GpuMat

pub fn input_output_array(&mut self) -> Result<_InputOutputArray>

impl<'_> ToInputOutputArray for &'_ mut GpuMat

pub fn input_output_array(&mut self) -> Result<_InputOutputArray>

impl ToOutputArray for GpuMat

pub fn output_array(&mut self) -> Result<_OutputArray>

impl<'_> ToOutputArray for &'_ mut GpuMat

pub fn output_array(&mut self) -> Result<_OutputArray>

impl VectorElement for GpuMat where
    Vector<GpuMat>: VectorExtern<GpuMat>, 

pub fn opencv_vector_to_vec(v: &Vector<GpuMat>) -> Vec<GpuMat>