http://www.emgu.com
The GpuInvoke type exposes the following members.
Methods
Name  Description  

Abs 
Computes absolute value of each pixel in an image
 
Absdiff(IntPtr, MCvScalar, IntPtr, IntPtr) 
Computes elementwise absolute difference of GpuMat and scalar (c = abs(a  s)).
 
Absdiff(IntPtr, IntPtr, IntPtr, IntPtr) 
Computes elementwise absolute difference of two GpuMats (c = abs(a  b)).
 
Add(IntPtr, MCvScalar, IntPtr, IntPtr, IntPtr) 
Adds scalar to a matrix (c = a + scalar)
 
Add(IntPtr, IntPtr, IntPtr, IntPtr, IntPtr) 
Adds one matrix to another (c = a + b).
 
AddWeighted 
Computes the weighted sum of two arrays (dst = alpha*src1 + beta*src2 + gamma)
 
BitwiseAnd(IntPtr, MCvScalar, IntPtr, IntPtr) 
Calculates perelement bitwise logical and of a GpuMat and a scalar:
dst(I)=src1(I) & scalar
In the case of a floatingpoint GpuMat its bit representation is used for the operation.
 
BitwiseAnd(IntPtr, IntPtr, IntPtr, IntPtr, IntPtr) 
Calculates perelement bitwise logical and of two GpuMats:
dst(I)=src1(I) & src2(I) if mask(I)!=0
In the case of floatingpoint 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 perelement bitwise logical not
dst(I)=~src(I) if mask(I)!=0
In the case of floatingpoint 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 perelement bitwise logical or a GpuMat and a scalar:
dst(I)=src1(I)  scalar
In the case of a floatingpoint GpuMat its bit representation is used for the operation.
 
BitwiseOr(IntPtr, IntPtr, IntPtr, IntPtr, IntPtr) 
Calculates perelement bitwise logical or of two GpuMats:
dst(I)=src1(I)  src2(I) if mask(I)!=0
In the case of floatingpoint 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 perelement bitwise logical conjunction of a GpuMat and a scalar:
dst(I)=src1(I)^scalar
In the case of a floatingpoint GpuMat its bit representation is used for the operation.
 
BitwiseXor(IntPtr, IntPtr, IntPtr, IntPtr, IntPtr) 
Calculates perelement bitwise logical conjunction of two GpuMats:
dst(I)=src1(I)^src2(I) if mask(I)!=0
In the case of floatingpoint 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 multichannel 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 nonzero array elements
 
CreateOpticalFlowNeedleMap  
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 realtocomplex transform result contains only nonredundant values
in CUFFT's format. Result as full complex matrix for such kind of transform cannot be retrieved.
For complextoreal 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 elementwise weighted reciprocal of an array (c = scale/ b).
 
Divide(IntPtr, MCvScalar, IntPtr, IntPtr) 
Computes elementwise quotient of a GpuMat and scalar (c = a / scalar).
 
Divide(IntPtr, IntPtr, IntPtr, Double, IntPtr) 
Computes elementwise 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. Inplace 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 0based).
 
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 standalone array.
 
GpuMatCreate 
Create a GpuMat of the specified size
 
GpuMatCreateFromArr 
Convert a CvArr to a GpuMat
 
GpuMatDownload 
Downloads data from device to host memory. Blocking calls.
 
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
 
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
 
GpuMatUpload 
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 8bit 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
 
MatchTemplate 
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
 
Max(IntPtr, Double, IntPtr, IntPtr) 
Computes perelement maximum of GpuMat and scalar (dst = max(src1, src2))
 
Max(IntPtr, IntPtr, IntPtr, IntPtr) 
Computes perelement maximum of two GpuMats (dst = max(src1, src2))
 
MeanShiftFiltering 
Performs meanshift 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 meanshift procedure and stores information about processed points (i.e. their colors
and positions) into two images.
 
MeanShiftSegmentation 
Performs meanshift segmentation of the source image and eleminates small segments.
 
MeanStdDev 
Computes mean value and standard deviation
 
Merge 
Makes multichannel GpuMat out of several singlechannel GpuMats
 
Min(IntPtr, Double, IntPtr, IntPtr) 
Computes perelement minimum of GpuMat and scalar (dst = min(src1, src2))
 
Min(IntPtr, IntPtr, IntPtr, IntPtr) 
Computes perelement 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 elementwise 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 upsampling 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 multichannel 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 elementwise 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 fixedlevel thresholding to singlechannel array. The function is typically used to get bilevel (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
Name  Description  

HasCuda 
Return true if Cuda is found on the system
