﻿GpuInvoke Members
http://www.emgu.com

The GpuInvoke type exposes the following members.

# Methods

NameDescription
Abs
Computes absolute value of each pixel in an image
Absdiff(IntPtr, MCvScalar, IntPtr, IntPtr)
Computes element-wise absolute difference of GpuMat and scalar (c = abs(a - s)).
Absdiff(IntPtr, IntPtr, IntPtr, IntPtr)
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)
BitwiseAnd(IntPtr, MCvScalar, IntPtr, IntPtr)
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.
BitwiseAnd(IntPtr, IntPtr, IntPtr, IntPtr, IntPtr)
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
BitwiseNot
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
BitwiseOr(IntPtr, MCvScalar, IntPtr, IntPtr)
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.
BitwiseOr(IntPtr, IntPtr, IntPtr, IntPtr, IntPtr)
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
BitwiseXor(IntPtr, MCvScalar, IntPtr, IntPtr)
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.
BitwiseXor(IntPtr, IntPtr, IntPtr, IntPtr, IntPtr)
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
Canny
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.
CartToPolar
Converts Cartesian coordinates to polar
Compare
Compares elements of two GpuMats (c = a <cmpop> b). Supports CV_8UC4, CV_32FC1 types
ConvertTo
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
Copy the source GpuMat to destination GpuMat, using an optional mask.
CopyMakeBorder
Copies a 2D array to a larger destination array and pads borders with the given constant.
CornerHarris
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.
CountNonZero
Counts non-zero array elements
CreateOpticalFlowNeedleMap
Draw the optical flow needle map
CvtColor
Converts image from one color space to another
Dft
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
Dilate the image (applies the local maximum operator). Supports CV_8UC1, CV_8UC4 type.
Divide(Double, IntPtr, IntPtr, IntPtr)
Computes element-wise weighted reciprocal of an array (c = scale/ b).
Divide(IntPtr, MCvScalar, IntPtr, IntPtr)
Computes element-wise quotient of a GpuMat and scalar (c = a / scalar).
Divide(IntPtr, IntPtr, IntPtr, Double, IntPtr)
Computes element-wise quotient of the two GpuMat (c = scale * a / b).
Erode
Erodes the image (applies the local minimum operator). Supports CV_8UC1, CV_8UC4 type.
Exp
Computes exponent of each matrix element (b = exp(a))
Filter2D
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
Flip
Flips the GpuMat<Byte> in one of different 3 ways (row and column indices are 0-based).
GaussianBlur
Smooths the GpuMat using Gaussian filter.
Gemm
Performs generalized matrix multiplication: dst = alpha*op(src1)*op(src2) + beta*op(src3), where op(X) is X or XT
GetCudaEnabledDeviceCount
Get the number of Cuda enabled devices
GetDevice
Get the current Cuda device id
GetSubRect
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.
GpuMatCreate
Create a GpuMat of the specified size
GpuMatCreateFromArr
Convert a CvArr to a GpuMat
GpuMatGetChannels
Get the number of channels in the GpuMat
GpuMatGetRegion
Create a GpuMat from the specific region of gpuMat. The data is shared between the two GpuMat.
GpuMatGetSize
Get the GpuMat size: width == number of columns, height == number of rows
GpuMatGetType
Get the GpuMat type
GpuMatIsContinuous
Returns true iff the GpuMatrix data is continuous (i.e. when there are no gaps between successive rows).
GpuMatIsEmpty
Check if the GpuMat is empty
GpuMatRelease
Release the GpuMat
GpuMatReshape
Reshape the src GpuMat
GpuMatResize
Resize the GpuMat
GpuMatSetTo
Copies scalar value to every selected element of the destination GpuMat: arr(I)=value if mask(I)!=0
Pefroms blocking upload data to GpuMat.
HistEven(IntPtr, IntPtr, Int32, Int32, Int32, IntPtr)
Calculates histogram with evenly distributed bins for signle channel source.
HistEven(IntPtr, IntPtr, IntPtr, Int32, Int32, Int32, IntPtr)
Calculates histogram with evenly distributed bins for signle channel source.
Integral
Computes the integral image
IntegralBuffered
Computes the integral image and integral for the squared image
Laplacian
Applies Laplacian operator to the GpuMat
Log
Computes natural logarithm of absolute value of each matrix element: b = log(abs(a))
LShift
Shifts a matrix to the left (c = a << scalar)
LUT
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.
Magnitude
Computes magnitude of each (x(i), y(i)) vector
MagnitudeSqr
Computes squared magnitude of each (x(i), y(i)) vector
Max(IntPtr, Double, IntPtr, IntPtr)
Computes per-element maximum of GpuMat and scalar (dst = max(src1, src2))
Max(IntPtr, IntPtr, IntPtr, IntPtr)
Computes per-element maximum of two GpuMats (dst = max(src1, src2))
MeanShiftFiltering
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.
MeanShiftProc
Performs mean-shift procedure and stores information about processed points (i.e. their colors and positions) into two images.
MeanShiftSegmentation
Performs mean-shift segmentation of the source image and eleminates small segments.
MeanStdDev
Computes mean value and standard deviation
Merge
Makes multi-channel GpuMat out of several single-channel GpuMats
Min(IntPtr, Double, IntPtr, IntPtr)
Computes per-element minimum of GpuMat and scalar (dst = min(src1, src2))
Min(IntPtr, IntPtr, IntPtr, IntPtr)
Computes per-element minimum of two GpuMats (dst = min(src1, src2))
MinMaxLoc
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.
MorphologyEx
Applies an advanced morphological operation to the image Supports CV_8UC1, CV_8UC4 type.
Multiply(IntPtr, MCvScalar, IntPtr, IntPtr)
Multiplies GpuMat to a scalar (c = a * scalar).
Multiply(IntPtr, IntPtr, IntPtr, Double, IntPtr)
Computes element-wise product of the two GpuMat: c = scale * a * b.
Norm
Computes norm of the difference between two GpuMats
Phase
Computes angle (angle(i)) of each (x(i), y(i)) vector
PolarToCart
Converts polar coordinates to Cartesian
Pow
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
PyrDown
Performs downsampling step of Gaussian pyramid decomposition.
PyrUp
Performs up-sampling step of Gaussian pyramid decomposition.
Reduce
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.
Remap
DST[x,y] = SRC[xmap[x,y],ymap[x,y]] with bilinear interpolation.
Reshape
Changes shape of GpuMat without copying data.
Resize
Resizes the image.
Rotate
Rotates an image around the origin (0,0) and then shifts it.
RShift
Shifts a matrix to the right (c = a >> scalar)
SetDevice
Set the current Gpu Device
Sobel
Applies generalized Sobel operator to the image
Split
Copies each plane of a multi-channel GpuMat to a dedicated GpuMat
Sqr
Computes square of each pixel in an image
SqrIntegral
Computes squared integral image
Sqrt
Computes square root of each pixel in an image
Subtract(IntPtr, MCvScalar, IntPtr, IntPtr, IntPtr)
Computes element-wise weighted product of the two arrays (c = scale * a * b) Supports CV_32FC1 and CV_32FC2 type.
Subtract(IntPtr, IntPtr, IntPtr, IntPtr, IntPtr)
Subtracts one matrix from another (c = a - b).
SwapChannels
Swap channels.
Threshold
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
WarpAffine
Warps the image using affine transformation
WarpPerspective
Warps the image using perspective transformation

# Properties

NameDescription
HasCuda
Return true if Cuda is found on the system