Computes absolute value of each pixel in an image

Computes element-wise absolute difference of GpuMat and scalar (c = abs(a - s)).

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

Adds scalar to a matrix (c = a + scalar)

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

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

Calculates per-element bit-wise logical and of a GpuMat and a scalar: dst(I)=src1(I) & scalar In the case of a floating-point GpuMat its bit representation is used for the operation.

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 a GpuMat and a scalar: dst(I)=src1(I) | scalar In the case of a floating-point GpuMat its bit representation is used for the operation.

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 a GpuMat and a scalar: dst(I)=src1(I)^scalar In the case of a floating-point GpuMat its bit representation is used for the operation.

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

Finds the edges on the input image and marks them in the output image edges using the Canny algorithm. The smallest of threshold1 and threshold2 is used for edge linking, the largest - to find initial segments of strong edges.

Converts Cartesian coordinates to polar

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

This function has several different purposes and thus has several synonyms. It copies one GpuMat to another with optional scaling, which is performed first, and/or optional type conversion, performed after: dst(I)=src(I)*scale + (shift,shift,...) All the channels of multi-channel GpuMats are processed independently. The type conversion is done with rounding and saturation, that is if a result of scaling + conversion can not be represented exactly by a value of destination GpuMat element type, it is set to the nearest representable value on the real axis. In case of scale=1, shift=0 no prescaling is done. This is a specially optimized case and it has the appropriate convertTo synonym.

Copy the source GpuMat to destination GpuMat, using an optional mask.

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

Runs the Harris edge detector on image. Similarly to cvCornerMinEigenVal and cvCornerEigenValsAndVecs, for each pixel it calculates 2x2 gradient covariation matrix M over block_size x block_size neighborhood. Then, it stores det(M) - k*trace(M)^2 to the destination image. Corners in the image can be found as local maxima of the destination image.

Counts non-zero array elements

Converts image from one color space to another

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.

Dilate the image (applies the local maximum operator). Supports CV_8UC1, CV_8UC4 type.

Computes element-wise weighted reciprocal of an array (c = scale/ b).

Computes element-wise quotient of a GpuMat and scalar (c = a / scalar).

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

Erodes the image (applies the local minimum operator). Supports CV_8UC1, CV_8UC4 type.

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

Applies arbitrary linear filter to the image. In-place operation is supported. When the aperture is partially outside the image, the function interpolates outlier pixel values from the nearest pixels that is inside the image

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

Smooths the GpuMat using Gaussian filter.

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

Get the number of Cuda enabled devices

Get the current Cuda device id

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.

Create a GpuMat of the specified size

Convert a CvArr to a GpuMat

Downloads data from device to host memory. Blocking calls.

Get the number of channels in the GpuMat

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

Get the GpuMat size: width == number of columns, height == number of rows

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

Check if the GpuMat is empty

Release the GpuMat

Reshape the src GpuMat

Resize the GpuMat

Copies scalar value to every selected element of the destination GpuMat: arr(I)=value if mask(I)!=0

Pefroms blocking upload data to GpuMat.

Calculates histogram with evenly distributed bins for signle channel source.

Calculates histogram with evenly distributed bins for signle channel source.

Computes the integral image

Computes the integral image and integral for the squared image

Applies Laplacian operator to the GpuMat

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

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

Transforms 8-bit unsigned integers using lookup table: dst(i)=lut(src(i)). Destination GpuMat will have the depth type as lut and the same channels number as source. Supports CV_8UC1, CV_8UC3 types.

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

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

This function is similiar to cvCalcBackProjectPatch. It slids through image, compares overlapped patches of size wxh with templ using the specified method and stores the comparison results to result

Computes per-element maximum of GpuMat and scalar (dst = max(src1, src2))

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 GpuMat and scalar (dst = min(src1, src2))

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.

Applies an advanced morphological operation to the image Supports CV_8UC1, CV_8UC4 type.

Multiplies GpuMat to a scalar (c = a * scalar).

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

Computes norm of the difference between two GpuMats

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.

Changes shape of GpuMat without copying data.

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

Applies generalized Sobel operator to the image

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

Computes square of each pixel in an image

Computes squared integral image

Computes square root of each pixel in an image

Computes element-wise weighted product of the two arrays (c = scale * a * b) Supports CV_32FC1 and CV_32FC2 type.

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

Warps the image using affine transformation

Warps the image using perspective transformation

Return true if Cuda is found on the system