CudaInvoke Class

Return true if Cuda is found on the system

Computes absolute value of each pixel in an image

Computes element-wise absolute difference of two GpuMats (c = abs(a - b)).

Returns the sum of absolute values for matrix elements.

Adds one matrix to another (c = a + b).

Computes the weighted sum of two arrays (dst = alpha*src1 + beta*src2 + gamma)

Composites two images using alpha opacity values contained in each image.

Applies bilateral filter to the image.

Calculates per-element bit-wise logical and of two GpuMats: dst(I)=src1(I) & src2(I) if mask(I)!=0 In the case of floating-point GpuMats their bit representations are used for the operation. All the GpuMats must have the same type, except the mask, and the same size

Calculates per-element bit-wise logical not dst(I)=~src(I) if mask(I)!=0 In the case of floating-point GpuMats their bit representations are used for the operation. All the GpuMats must have the same type, except the mask, and the same size

Calculates per-element bit-wise logical or of two GpuMats: dst(I)=src1(I) | src2(I) if mask(I)!=0 In the case of floating-point GpuMats their bit representations are used for the operation. All the GpuMats must have the same type, except the mask, and the same size

Calculates per-element bit-wise logical conjunction of two GpuMats: dst(I)=src1(I)^src2(I) if mask(I)!=0 In the case of floating-point GpuMats their bit representations are used for the operation. All the GpuMats must have the same type, except the mask, and the same size

Performs linear blending of two images.

Calculates a dense optical flow.

Calculates a sparse optical flow.

Returns the sum of absolute values for matrix elements.

Calculates histogram for one channel 8-bit image.

Returns the norm of a matrix.

Returns the difference of two matrices.

Returns the squared sum of matrix elements.

Converts Cartesian coordinates to polar

Compares elements of two GpuMats (c = a <cmpop> b). Supports CV_8UC4, CV_32FC1 types

Copies a 2D array to a larger destination array and pads borders with the given constant.

Counts non-zero array elements

Counts non-zero array elements

Converts image from one color space to another

Converts an image from Bayer pattern to RGB or grayscale.

Performs a forward or inverse discrete Fourier transform (1D or 2D) of floating point matrix. Param dft_size is the size of DFT transform. If the source matrix is not continous, then additional copy will be done, so to avoid copying ensure the source matrix is continous one. If you want to use preallocated output ensure it is continuous too, otherwise it will be reallocated. Being implemented via CUFFT real-to-complex transform result contains only non-redundant values in CUFFT's format. Result as full complex matrix for such kind of transform cannot be retrieved. For complex-to-real transform it is assumed that the source matrix is packed in CUFFT's format.

Computes element-wise quotient of the two GpuMat (c = scale * a / b).

Colors a disparity image.

Equalizes the histogram of a grayscale image.

Computes exponent of each matrix element (b = exp(a))

Finds global minimum and maximum matrix elements and returns their values with locations.

Flips the GpuMat<Byte> in one of different 3 ways (row and column indices are 0-based).

Routines for correcting image color gamma

Performs generalized matrix multiplication: dst = alpha*op(src1)*op(src2) + beta*op(src3), where op(X) is X or XT

Get the opencl platform summary as a string

Get the number of Cuda enabled devices

Get the current Cuda device id

Create a GpuMat from the specific region of gpuMat. The data is shared between the two GpuMat.

Returns header, corresponding to a specified rectangle of the input GpuMat. In other words, it allows the user to treat a rectangular part of input array as a stand-alone array.

gpuMatReshape the src GpuMat

Resize the GpuMat

Calculates histogram with evenly distributed bins for single channel source.

Calculates a histogram with bins determined by the levels array

Computes the integral image and integral for the squared image

Computes natural logarithm of absolute value of each matrix element: b = log(abs(a))

Shifts a matrix to the left (c = a << scalar)

Computes magnitude of each (x(i), y(i)) vector

Computes squared magnitude of each (x(i), y(i)) vector

Computes per-element maximum of two GpuMats (dst = max(src1, src2))

Performs mean-shift filtering for each point of the source image. It maps each point of the source image into another point, and as the result we have new color and new position of each point.

Performs mean-shift procedure and stores information about processed points (i.e. their colors and positions) into two images.

Performs mean-shift segmentation of the source image and eleminates small segments.

Computes mean value and standard deviation

Makes multi-channel GpuMat out of several single-channel GpuMats

Computes per-element minimum of two GpuMats (dst = min(src1, src2))

Finds minimum and maximum element values and their positions. The extremums are searched over the whole GpuMat or, if mask is not IntPtr.Zero, in the specified GpuMat region.

Performs a per-element multiplication of two Fourier spectrums and scales the result.

Performs a per-element multiplication of two Fourier spectrums.

Computes element-wise product of the two GpuMat: c = scale * a * b.

Returns the norm of a matrix.

Computes norm of the difference between two GpuMats

Normalizes the norm or value range of an array.

Computes angle (angle(i)) of each (x(i), y(i)) vector

Converts polar coordinates to Cartesian

Computes power of each matrix element: (dst(i,j) = pow( src(i,j) , power), if src.type() is integer; (dst(i,j) = pow(fabs(src(i,j)), power), otherwise. supports all, except depth == CV_64F

Performs downsampling step of Gaussian pyramid decomposition.

Performs up-sampling step of Gaussian pyramid decomposition.

Reduces GpuMat to a vector by treating the GpuMat rows/columns as a set of 1D vectors and performing the specified operation on the vectors until a single row/column is obtained.

DST[x,y] = SRC[xmap[x,y],ymap[x,y]] with bilinear interpolation.

Resizes the image.

Rotates an image around the origin (0,0) and then shifts it.

Shifts a matrix to the right (c = a >> scalar)

Set the current Gpu Device

Sets a CUDA device and initializes it for the current thread with OpenGL interoperability. This function should be explicitly called after OpenGL context creation and before any CUDA calls.

Copies each plane of a multi-channel GpuMat to a dedicated GpuMat

Computes square of each pixel in an image

Computes squared integral image

Returns the squared sum of matrix elements.

Computes square root of each pixel in an image

Subtracts one matrix from another (c = a - b).

Swap channels.

Applies fixed-level thresholding to single-channel array. The function is typically used to get bi-level (binary) image out of grayscale image or for removing a noise, i.e. filtering out pixels with too small or too large values. There are several types of thresholding the function supports that are determined by thresholdType

Transposes a matrix.

Warps the image using affine transformation

Warps the image using perspective transformation