CudaInvoke Class 
Namespace: Emgu.CV.Cuda
The CudaInvoke type exposes the following members.
Name  Description  

Abs 
Computes absolute value of each pixel in an image
 
Absdiff 
Computes elementwise absolute difference of two GpuMats (c = abs(a  b)).
 
AbsSum 
Returns the sum of absolute values for matrix elements.
 
Add 
Adds one matrix to another (c = a + b).
 
AddWeighted 
Computes the weighted sum of two arrays (dst = alpha*src1 + beta*src2 + gamma)
 
AlphaComp 
Composites two images using alpha opacity values contained in each image.
 
BilateralFilter 
Applies bilateral filter to the image.
 
BitwiseAnd 
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 
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 
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
 
BlendLinear 
Performs linear blending of two images.
 
Calc(ICudaDenseOpticalFlow, IInputArray, IInputArray, IInputOutputArray, Stream) 
Calculates a dense optical flow.
 
Calc(ICudaSparseOpticalFlow, IInputArray, IInputArray, IInputArray, IInputOutputArray, IOutputArray, IOutputArray, Stream) 
Calculates a sparse optical flow.
 
CalcAbsSum 
Returns the sum of absolute values for matrix elements.
 
CalcHist 
Calculates histogram for one channel 8bit image.
 
CalcNorm 
Returns the norm of a matrix.
 
CalcNormDiff 
Returns the difference of two matrices.
 
CalcSqrSum 
Returns the squared sum of matrix elements.
 
CartToPolar 
Converts Cartesian coordinates to polar
 
Compare 
Compares elements of two GpuMats (c = a <cmpop> b).
Supports CV_8UC4, CV_32FC1 types
 
CopyMakeBorder 
Copies a 2D array to a larger destination array and pads borders with the given constant.
 
CountNonZero(IInputArray) 
Counts nonzero array elements
 
CountNonZero(IInputArray, IOutputArray, Stream) 
Counts nonzero array elements
 
CvtColor 
Converts image from one color space to another
 
Demosaicing 
Converts an image from Bayer pattern to RGB or grayscale.
 
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.
 
Divide 
Computes elementwise quotient of the two GpuMat (c = scale * a / b).
 
EqualizeHist 
Equalizes the histogram of a grayscale image.
 
Exp 
Computes exponent of each matrix element (b = exp(a))
 
FindMinMaxLoc 
Finds global minimum and maximum matrix elements and returns their values with locations.
 
Flip 
Flips the GpuMat<Byte> in one of different 3 ways (row and column indices are 0based).
 
GammaCorrection 
Routines for correcting image color gamma
 
Gemm 
Performs generalized matrix multiplication:
dst = alpha*op(src1)*op(src2) + beta*op(src3), where op(X) is X or XT
 
GetCudaDevicesSummary 
Get the opencl platform summary as a string
 
GetCudaEnabledDeviceCount 
Get the number of Cuda enabled devices
 
GetDevice 
Get the current Cuda device id
 
GetRegion 
Create a GpuMat from the specific region of gpuMat. The data is shared between the two GpuMat.
 
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.
 
GpuMatReshape 
gpuMatReshape the src GpuMat
 
GpuMatResize 
Resize the GpuMat
 
HistEven 
Calculates histogram with evenly distributed bins for single channel source.
 
HistRange 
Calculates a histogram with bins determined by the levels array
 
Integral 
Computes the integral image and integral for the squared image
 
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)
 
Magnitude 
Computes magnitude of each (x(i), y(i)) vector
 
MagnitudeSqr 
Computes squared magnitude of each (x(i), y(i)) vector
 
Max 
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 
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.
 
MulAndScaleSpectrums 
Performs a perelement multiplication of two Fourier spectrums and scales the result.
 
MulSpectrums 
Performs a perelement multiplication of two Fourier spectrums.
 
Multiply 
Computes elementwise product of the two GpuMat: c = scale * a * b.
 
Norm(IInputArray, NormType, IInputArray) 
Returns the norm of a matrix.
 
Norm(IInputArray, IInputArray, NormType) 
Computes norm of the difference between two GpuMats
 
Normalize 
Normalizes the norm or value range of an array.
 
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.
 
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
 
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
 
SqrSum 
Returns the squared sum of matrix elements.
 
Sqrt 
Computes square root of each pixel in an image
 
Subtract 
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
 
Transpose 
Transposes a matrix.
 
WarpAffine 
Warps the image using affine transformation
 
WarpPerspective 
Warps the image using perspective transformation
