Modifier and Type | Method and Description |
---|---|
static void |
opencv_cudaarithm.abs(GpuMat src,
GpuMat dst,
Stream stream) |
static void |
opencv_cudaarithm.abs(Mat src,
Mat dst,
Stream stream)
\brief Computes an absolute value of each matrix element.
|
static void |
opencv_cudaarithm.abs(UMat src,
UMat dst,
Stream stream) |
static void |
opencv_cudaarithm.absdiff(GpuMat src1,
GpuMat src2,
GpuMat dst,
Stream stream) |
static void |
opencv_cudaarithm.absdiff(Mat src1,
Mat src2,
Mat dst,
Stream stream)
\brief Computes per-element absolute difference of two matrices (or of a matrix and scalar).
|
static void |
opencv_cudaarithm.absdiff(UMat src1,
UMat src2,
UMat dst,
Stream stream) |
static void |
opencv_cudaarithm.add(GpuMat src1,
GpuMat src2,
GpuMat dst,
GpuMat mask,
int dtype,
Stream stream) |
static void |
opencv_cudaarithm.add(Mat src1,
Mat src2,
Mat dst,
Mat mask,
int dtype,
Stream stream)
\addtogroup cudaarithm
\{
|
static void |
opencv_cudaarithm.add(UMat src1,
UMat src2,
UMat dst,
UMat mask,
int dtype,
Stream stream) |
static void |
opencv_cudaarithm.addWeighted(GpuMat src1,
double alpha,
GpuMat src2,
double beta,
double gamma,
GpuMat dst,
int dtype,
Stream stream) |
static void |
opencv_cudaarithm.addWeighted(Mat src1,
double alpha,
Mat src2,
double beta,
double gamma,
Mat dst,
int dtype,
Stream stream)
\brief Computes the weighted sum of two arrays.
|
static void |
opencv_cudaarithm.addWeighted(UMat src1,
double alpha,
UMat src2,
double beta,
double gamma,
UMat dst,
int dtype,
Stream stream) |
static void |
opencv_cudaimgproc.alphaComp(GpuMat img1,
GpuMat img2,
GpuMat dst,
int alpha_op,
Stream stream) |
static void |
opencv_cudaimgproc.alphaComp(Mat img1,
Mat img2,
Mat dst,
int alpha_op,
Stream stream)
\brief Composites two images using alpha opacity values contained in each image.
|
static void |
opencv_cudaimgproc.alphaComp(UMat img1,
UMat img2,
UMat dst,
int alpha_op,
Stream stream) |
static void |
opencv_cudaimgproc.bilateralFilter(GpuMat src,
GpuMat dst,
int kernel_size,
float sigma_color,
float sigma_spatial,
int borderMode,
Stream stream) |
static void |
opencv_cudaimgproc.bilateralFilter(Mat src,
Mat dst,
int kernel_size,
float sigma_color,
float sigma_spatial,
int borderMode,
Stream stream)
\brief Performs bilateral filtering of passed image
|
static void |
opencv_cudaimgproc.bilateralFilter(UMat src,
UMat dst,
int kernel_size,
float sigma_color,
float sigma_spatial,
int borderMode,
Stream stream) |
static void |
opencv_cudaarithm.bitwise_and(GpuMat src1,
GpuMat src2,
GpuMat dst,
GpuMat mask,
Stream stream) |
static void |
opencv_cudaarithm.bitwise_and(Mat src1,
Mat src2,
Mat dst,
Mat mask,
Stream stream)
\brief Performs a per-element bitwise conjunction of two matrices (or of matrix and scalar).
|
static void |
opencv_cudaarithm.bitwise_and(UMat src1,
UMat src2,
UMat dst,
UMat mask,
Stream stream) |
static void |
opencv_cudaarithm.bitwise_not(GpuMat src,
GpuMat dst,
GpuMat mask,
Stream stream) |
static void |
opencv_cudaarithm.bitwise_not(Mat src,
Mat dst,
Mat mask,
Stream stream)
\brief Performs a per-element bitwise inversion.
|
static void |
opencv_cudaarithm.bitwise_not(UMat src,
UMat dst,
UMat mask,
Stream stream) |
static void |
opencv_cudaarithm.bitwise_or(GpuMat src1,
GpuMat src2,
GpuMat dst,
GpuMat mask,
Stream stream) |
static void |
opencv_cudaarithm.bitwise_or(Mat src1,
Mat src2,
Mat dst,
Mat mask,
Stream stream)
\brief Performs a per-element bitwise disjunction of two matrices (or of matrix and scalar).
|
static void |
opencv_cudaarithm.bitwise_or(UMat src1,
UMat src2,
UMat dst,
UMat mask,
Stream stream) |
static void |
opencv_cudaarithm.bitwise_xor(GpuMat src1,
GpuMat src2,
GpuMat dst,
GpuMat mask,
Stream stream) |
static void |
opencv_cudaarithm.bitwise_xor(Mat src1,
Mat src2,
Mat dst,
Mat mask,
Stream stream)
\brief Performs a per-element bitwise exclusive or operation of two matrices (or of matrix and scalar).
|
static void |
opencv_cudaarithm.bitwise_xor(UMat src1,
UMat src2,
UMat dst,
UMat mask,
Stream stream) |
static void |
opencv_cudaimgproc.blendLinear(GpuMat img1,
GpuMat img2,
GpuMat weights1,
GpuMat weights2,
GpuMat result,
Stream stream) |
static void |
opencv_cudaimgproc.blendLinear(Mat img1,
Mat img2,
Mat weights1,
Mat weights2,
Mat result,
Stream stream)
\brief Performs linear blending of two images.
|
static void |
opencv_cudaimgproc.blendLinear(UMat img1,
UMat img2,
UMat weights1,
UMat weights2,
UMat result,
Stream stream) |
static void |
opencv_cudawarping.buildWarpAffineMaps(GpuMat M,
boolean inverse,
Size dsize,
GpuMat xmap,
GpuMat ymap,
Stream stream) |
static void |
opencv_cudawarping.buildWarpAffineMaps(Mat M,
boolean inverse,
Size dsize,
GpuMat xmap,
GpuMat ymap,
Stream stream) |
static void |
opencv_cudawarping.buildWarpAffineMaps(Mat M,
boolean inverse,
Size dsize,
Mat xmap,
Mat ymap,
Stream stream)
\brief Builds transformation maps for affine transformation.
|
static void |
opencv_cudawarping.buildWarpAffineMaps(UMat M,
boolean inverse,
Size dsize,
GpuMat xmap,
GpuMat ymap,
Stream stream) |
static void |
opencv_cudawarping.buildWarpAffineMaps(UMat M,
boolean inverse,
Size dsize,
UMat xmap,
UMat ymap,
Stream stream) |
static void |
opencv_cudawarping.buildWarpPerspectiveMaps(GpuMat M,
boolean inverse,
Size dsize,
GpuMat xmap,
GpuMat ymap,
Stream stream) |
static void |
opencv_cudawarping.buildWarpPerspectiveMaps(Mat M,
boolean inverse,
Size dsize,
GpuMat xmap,
GpuMat ymap,
Stream stream) |
static void |
opencv_cudawarping.buildWarpPerspectiveMaps(Mat M,
boolean inverse,
Size dsize,
Mat xmap,
Mat ymap,
Stream stream)
\brief Builds transformation maps for perspective transformation.
|
static void |
opencv_cudawarping.buildWarpPerspectiveMaps(UMat M,
boolean inverse,
Size dsize,
GpuMat xmap,
GpuMat ymap,
Stream stream) |
static void |
opencv_cudawarping.buildWarpPerspectiveMaps(UMat M,
boolean inverse,
Size dsize,
UMat xmap,
UMat ymap,
Stream stream) |
static void |
opencv_cudaarithm.calcAbsSum(GpuMat src,
GpuMat dst,
GpuMat mask,
Stream stream) |
static void |
opencv_cudaarithm.calcAbsSum(Mat src,
Mat dst,
Mat mask,
Stream stream)
\overload
|
static void |
opencv_cudaarithm.calcAbsSum(UMat src,
UMat dst,
UMat mask,
Stream stream) |
static void |
opencv_cudaimgproc.calcHist(GpuMat src,
GpuMat mask,
GpuMat hist,
Stream stream) |
static void |
opencv_cudaimgproc.calcHist(GpuMat src,
GpuMat hist,
Stream stream) |
static void |
opencv_cudaimgproc.calcHist(Mat src,
Mat mask,
Mat hist,
Stream stream)
\brief Calculates histogram for one channel 8-bit image confined in given mask.
|
static void |
opencv_cudaimgproc.calcHist(Mat src,
Mat hist,
Stream stream)
\} cudaimgproc_color
|
static void |
opencv_cudaimgproc.calcHist(UMat src,
UMat hist,
Stream stream) |
static void |
opencv_cudaimgproc.calcHist(UMat src,
UMat mask,
UMat hist,
Stream stream) |
static void |
opencv_cudaarithm.calcNorm(GpuMat src,
GpuMat dst,
int normType,
GpuMat mask,
Stream stream) |
static void |
opencv_cudaarithm.calcNorm(Mat src,
Mat dst,
int normType,
Mat mask,
Stream stream)
\overload
|
static void |
opencv_cudaarithm.calcNorm(UMat src,
UMat dst,
int normType,
UMat mask,
Stream stream) |
static void |
opencv_cudaarithm.calcNormDiff(GpuMat src1,
GpuMat src2,
GpuMat dst,
int normType,
Stream stream) |
static void |
opencv_cudaarithm.calcNormDiff(Mat src1,
Mat src2,
Mat dst,
int normType,
Stream stream)
\overload
|
static void |
opencv_cudaarithm.calcNormDiff(UMat src1,
UMat src2,
UMat dst,
int normType,
Stream stream) |
static void |
opencv_cudaarithm.calcSqrSum(GpuMat src,
GpuMat dst,
GpuMat mask,
Stream stream) |
static void |
opencv_cudaarithm.calcSqrSum(Mat src,
Mat dst,
Mat mask,
Stream stream)
\overload
|
static void |
opencv_cudaarithm.calcSqrSum(UMat src,
UMat dst,
UMat mask,
Stream stream) |
static void |
opencv_cudaarithm.calcSum(GpuMat src,
GpuMat dst,
GpuMat mask,
Stream stream) |
static void |
opencv_cudaarithm.calcSum(Mat src,
Mat dst,
Mat mask,
Stream stream)
\overload
|
static void |
opencv_cudaarithm.calcSum(UMat src,
UMat dst,
UMat mask,
Stream stream) |
static void |
opencv_cudaarithm.cartToPolar(GpuMat x,
GpuMat y,
GpuMat magnitude,
GpuMat angle,
boolean angleInDegrees,
Stream stream) |
static void |
opencv_cudaarithm.cartToPolar(Mat x,
Mat y,
Mat magnitude,
Mat angle,
boolean angleInDegrees,
Stream stream)
\brief Converts Cartesian coordinates into polar.
|
static void |
opencv_cudaarithm.cartToPolar(UMat x,
UMat y,
UMat magnitude,
UMat angle,
boolean angleInDegrees,
Stream stream) |
static void |
opencv_cudaarithm.compare(GpuMat src1,
GpuMat src2,
GpuMat dst,
int cmpop,
Stream stream) |
static void |
opencv_cudaarithm.compare(Mat src1,
Mat src2,
Mat dst,
int cmpop,
Stream stream)
\brief Compares elements of two matrices (or of a matrix and scalar).
|
static void |
opencv_cudaarithm.compare(UMat src1,
UMat src2,
UMat dst,
int cmpop,
Stream stream) |
static void |
opencv_cudaarithm.copyMakeBorder(GpuMat src,
GpuMat dst,
int top,
int bottom,
int left,
int right,
int borderType,
Scalar value,
Stream stream) |
static void |
opencv_cudaarithm.copyMakeBorder(Mat src,
Mat dst,
int top,
int bottom,
int left,
int right,
int borderType,
Scalar value,
Stream stream)
\brief Forms a border around an image.
|
static void |
opencv_cudaarithm.copyMakeBorder(UMat src,
UMat dst,
int top,
int bottom,
int left,
int right,
int borderType,
Scalar value,
Stream stream) |
static void |
opencv_cudaarithm.countNonZero(GpuMat src,
GpuMat dst,
Stream stream) |
static void |
opencv_cudaarithm.countNonZero(Mat src,
Mat dst,
Stream stream)
\overload
|
static void |
opencv_cudaarithm.countNonZero(UMat src,
UMat dst,
Stream stream) |
static void |
opencv_cudaimgproc.cvtColor(GpuMat src,
GpuMat dst,
int code,
int dcn,
Stream stream) |
static void |
opencv_cudaimgproc.cvtColor(Mat src,
Mat dst,
int code,
int dcn,
Stream stream)
\addtogroup cudaimgproc
\{
|
static void |
opencv_cudaimgproc.cvtColor(UMat src,
UMat dst,
int code,
int dcn,
Stream stream) |
static void |
opencv_cudaimgproc.demosaicing(GpuMat src,
GpuMat dst,
int code,
int dcn,
Stream stream) |
static void |
opencv_cudaimgproc.demosaicing(Mat src,
Mat dst,
int code,
int dcn,
Stream stream)
\brief Converts an image from Bayer pattern to RGB or grayscale.
|
static void |
opencv_cudaimgproc.demosaicing(UMat src,
UMat dst,
int code,
int dcn,
Stream stream) |
static void |
opencv_cudaarithm.dft(GpuMat src,
GpuMat dst,
Size dft_size,
int flags,
Stream stream) |
static void |
opencv_cudaarithm.dft(Mat src,
Mat dst,
Size dft_size,
int flags,
Stream stream)
\brief Performs a forward or inverse discrete Fourier transform (1D or 2D) of the floating point matrix.
|
static void |
opencv_cudaarithm.dft(UMat src,
UMat dst,
Size dft_size,
int flags,
Stream stream) |
static void |
opencv_cudaarithm.divide(GpuMat src1,
GpuMat src2,
GpuMat dst,
double scale,
int dtype,
Stream stream) |
static void |
opencv_cudaarithm.divide(Mat src1,
Mat src2,
Mat dst,
double scale,
int dtype,
Stream stream)
\brief Computes a matrix-matrix or matrix-scalar division.
|
static void |
opencv_cudaarithm.divide(UMat src1,
UMat src2,
UMat dst,
double scale,
int dtype,
Stream stream) |
static void |
opencv_cudastereo.drawColorDisp(GpuMat src_disp,
GpuMat dst_disp,
int ndisp,
Stream stream) |
static void |
opencv_cudastereo.drawColorDisp(Mat src_disp,
Mat dst_disp,
int ndisp,
Stream stream)
\brief Colors a disparity image.
|
static void |
opencv_cudastereo.drawColorDisp(UMat src_disp,
UMat dst_disp,
int ndisp,
Stream stream) |
static void |
opencv_cudaimgproc.equalizeHist(GpuMat src,
GpuMat dst,
Stream stream) |
static void |
opencv_cudaimgproc.equalizeHist(Mat src,
Mat dst,
Stream stream)
\brief Equalizes the histogram of a grayscale image.
|
static void |
opencv_cudaimgproc.equalizeHist(UMat src,
UMat dst,
Stream stream) |
static void |
opencv_cudaimgproc.evenLevels(GpuMat levels,
int nLevels,
int lowerLevel,
int upperLevel,
Stream stream) |
static void |
opencv_cudaimgproc.evenLevels(Mat levels,
int nLevels,
int lowerLevel,
int upperLevel,
Stream stream)
\brief Computes levels with even distribution.
|
static void |
opencv_cudaimgproc.evenLevels(UMat levels,
int nLevels,
int lowerLevel,
int upperLevel,
Stream stream) |
static void |
opencv_cudaarithm.exp(GpuMat src,
GpuMat dst,
Stream stream) |
static void |
opencv_cudaarithm.exp(Mat src,
Mat dst,
Stream stream)
\brief Computes an exponent of each matrix element.
|
static void |
opencv_cudaarithm.exp(UMat src,
UMat dst,
Stream stream) |
static void |
opencv_photo.fastNlMeansDenoising(GpuMat src,
GpuMat dst,
float h,
int search_window,
int block_size,
Stream stream) |
static void |
opencv_photo.fastNlMeansDenoising(Mat src,
Mat dst,
float h,
int search_window,
int block_size,
Stream stream)
\brief Perform image denoising using Non-local Means Denoising algorithm
|
static void |
opencv_photo.fastNlMeansDenoising(UMat src,
UMat dst,
float h,
int search_window,
int block_size,
Stream stream) |
static void |
opencv_photo.fastNlMeansDenoisingColored(GpuMat src,
GpuMat dst,
float h_luminance,
float photo_render,
int search_window,
int block_size,
Stream stream) |
static void |
opencv_photo.fastNlMeansDenoisingColored(Mat src,
Mat dst,
float h_luminance,
float photo_render,
int search_window,
int block_size,
Stream stream)
\brief Modification of fastNlMeansDenoising function for colored images
|
static void |
opencv_photo.fastNlMeansDenoisingColored(UMat src,
UMat dst,
float h_luminance,
float photo_render,
int search_window,
int block_size,
Stream stream) |
static void |
opencv_cudaarithm.findMinMax(GpuMat src,
GpuMat dst,
GpuMat mask,
Stream stream) |
static void |
opencv_cudaarithm.findMinMax(Mat src,
Mat dst,
Mat mask,
Stream stream)
\overload
|
static void |
opencv_cudaarithm.findMinMax(UMat src,
UMat dst,
UMat mask,
Stream stream) |
static void |
opencv_cudaarithm.findMinMaxLoc(GpuMat src,
GpuMat minMaxVals,
GpuMat loc,
GpuMat mask,
Stream stream) |
static void |
opencv_cudaarithm.findMinMaxLoc(Mat src,
Mat minMaxVals,
Mat loc,
Mat mask,
Stream stream)
\overload
|
static void |
opencv_cudaarithm.findMinMaxLoc(UMat src,
UMat minMaxVals,
UMat loc,
UMat mask,
Stream stream) |
static void |
opencv_cudaarithm.flip(GpuMat src,
GpuMat dst,
int flipCode,
Stream stream) |
static void |
opencv_cudaarithm.flip(Mat src,
Mat dst,
int flipCode,
Stream stream)
\brief Flips a 2D matrix around vertical, horizontal, or both axes.
|
static void |
opencv_cudaarithm.flip(UMat src,
UMat dst,
int flipCode,
Stream stream) |
static void |
opencv_cudaimgproc.gammaCorrection(GpuMat src,
GpuMat dst,
boolean forward,
Stream stream) |
static void |
opencv_cudaimgproc.gammaCorrection(Mat src,
Mat dst,
boolean forward,
Stream stream)
\brief Routines for correcting image color gamma.
|
static void |
opencv_cudaimgproc.gammaCorrection(UMat src,
UMat dst,
boolean forward,
Stream stream) |
static void |
opencv_cudaarithm.gemm(GpuMat src1,
GpuMat src2,
double alpha,
GpuMat src3,
double beta,
GpuMat dst,
int flags,
Stream stream) |
static void |
opencv_cudaarithm.gemm(Mat src1,
Mat src2,
double alpha,
Mat src3,
double beta,
Mat dst,
int flags,
Stream stream)
\} cudaarithm_reduce
|
static void |
opencv_cudaarithm.gemm(UMat src1,
UMat src2,
double alpha,
UMat src3,
double beta,
UMat dst,
int flags,
Stream stream) |
static void |
opencv_cudaimgproc.histEven(GpuMat src,
GpuMat hist,
int[] histSize,
int[] lowerLevel,
int[] upperLevel,
Stream stream) |
static void |
opencv_cudaimgproc.histEven(GpuMat src,
GpuMat hist,
IntBuffer histSize,
IntBuffer lowerLevel,
IntBuffer upperLevel,
Stream stream) |
static void |
opencv_cudaimgproc.histEven(GpuMat src,
GpuMat hist,
int histSize,
int lowerLevel,
int upperLevel,
Stream stream) |
static void |
opencv_cudaimgproc.histEven(GpuMat src,
GpuMat hist,
IntPointer histSize,
IntPointer lowerLevel,
IntPointer upperLevel,
Stream stream) |
static void |
opencv_cudaimgproc.histEven(Mat src,
GpuMat hist,
int[] histSize,
int[] lowerLevel,
int[] upperLevel,
Stream stream) |
static void |
opencv_cudaimgproc.histEven(Mat src,
GpuMat hist,
IntBuffer histSize,
IntBuffer lowerLevel,
IntBuffer upperLevel,
Stream stream) |
static void |
opencv_cudaimgproc.histEven(Mat src,
GpuMat hist,
IntPointer histSize,
IntPointer lowerLevel,
IntPointer upperLevel,
Stream stream)
\overload
|
static void |
opencv_cudaimgproc.histEven(Mat src,
Mat hist,
int histSize,
int lowerLevel,
int upperLevel,
Stream stream)
\brief Calculates a histogram with evenly distributed bins.
|
static void |
opencv_cudaimgproc.histEven(UMat src,
GpuMat hist,
int[] histSize,
int[] lowerLevel,
int[] upperLevel,
Stream stream) |
static void |
opencv_cudaimgproc.histEven(UMat src,
GpuMat hist,
IntBuffer histSize,
IntBuffer lowerLevel,
IntBuffer upperLevel,
Stream stream) |
static void |
opencv_cudaimgproc.histEven(UMat src,
GpuMat hist,
IntPointer histSize,
IntPointer lowerLevel,
IntPointer upperLevel,
Stream stream) |
static void |
opencv_cudaimgproc.histEven(UMat src,
UMat hist,
int histSize,
int lowerLevel,
int upperLevel,
Stream stream) |
static void |
opencv_cudaimgproc.histRange(GpuMat src,
GpuMat hist,
GpuMat levels,
Stream stream) |
static void |
opencv_cudaimgproc.histRange(Mat src,
GpuMat hist,
GpuMat levels,
Stream stream)
\overload
|
static void |
opencv_cudaimgproc.histRange(Mat src,
Mat hist,
Mat levels,
Stream stream)
\brief Calculates a histogram with bins determined by the levels array.
|
static void |
opencv_cudaimgproc.histRange(UMat src,
GpuMat hist,
GpuMat levels,
Stream stream) |
static void |
opencv_cudaimgproc.histRange(UMat src,
UMat hist,
UMat levels,
Stream stream) |
static void |
opencv_cudaarithm.integral(GpuMat src,
GpuMat sum,
Stream stream) |
static void |
opencv_cudaarithm.integral(Mat src,
Mat sum,
Stream stream)
\brief Computes an integral image.
|
static void |
opencv_cudaarithm.integral(UMat src,
UMat sum,
Stream stream) |
static void |
opencv_cudaarithm.log(GpuMat src,
GpuMat dst,
Stream stream) |
static void |
opencv_cudaarithm.log(Mat src,
Mat dst,
Stream stream)
\brief Computes a natural logarithm of absolute value of each matrix element.
|
static void |
opencv_cudaarithm.log(UMat src,
UMat dst,
Stream stream) |
static void |
opencv_cudaarithm.lshift(GpuMat src,
Scalar4i val,
GpuMat dst,
Stream stream) |
static void |
opencv_cudaarithm.lshift(GpuMat src,
Scalar val,
GpuMat dst,
Stream stream) |
static void |
opencv_cudaarithm.lshift(Mat src,
Scalar4i val,
Mat dst,
Stream stream)
\brief Performs pixel by pixel right left of an image by a constant value.
|
static void |
opencv_cudaarithm.lshift(Mat src,
Scalar val,
Mat dst,
Stream stream) |
static void |
opencv_cudaarithm.lshift(UMat src,
Scalar4i val,
UMat dst,
Stream stream) |
static void |
opencv_cudaarithm.lshift(UMat src,
Scalar val,
UMat dst,
Stream stream) |
static void |
opencv_cudaarithm.magnitude(GpuMat x,
GpuMat y,
GpuMat magnitude,
Stream stream) |
static void |
opencv_cudaarithm.magnitude(GpuMat xy,
GpuMat magnitude,
Stream stream) |
static void |
opencv_cudaarithm.magnitude(Mat x,
Mat y,
Mat magnitude,
Stream stream)
\overload
computes magnitude of each (x(i), y(i)) vector
supports only floating-point source
|
static void |
opencv_cudaarithm.magnitude(Mat xy,
Mat magnitude,
Stream stream)
\brief Computes magnitudes of complex matrix elements.
|
static void |
opencv_cudaarithm.magnitude(UMat xy,
UMat magnitude,
Stream stream) |
static void |
opencv_cudaarithm.magnitude(UMat x,
UMat y,
UMat magnitude,
Stream stream) |
static void |
opencv_cudaarithm.magnitudeSqr(GpuMat x,
GpuMat y,
GpuMat magnitude,
Stream stream) |
static void |
opencv_cudaarithm.magnitudeSqr(GpuMat xy,
GpuMat magnitude,
Stream stream) |
static void |
opencv_cudaarithm.magnitudeSqr(Mat x,
Mat y,
Mat magnitude,
Stream stream)
\overload
computes squared magnitude of each (x(i), y(i)) vector
supports only floating-point source
|
static void |
opencv_cudaarithm.magnitudeSqr(Mat xy,
Mat magnitude,
Stream stream)
\brief Computes squared magnitudes of complex matrix elements.
|
static void |
opencv_cudaarithm.magnitudeSqr(UMat xy,
UMat magnitude,
Stream stream) |
static void |
opencv_cudaarithm.magnitudeSqr(UMat x,
UMat y,
UMat magnitude,
Stream stream) |
static void |
opencv_cudaarithm.max(GpuMat src1,
GpuMat src2,
GpuMat dst,
Stream stream) |
static void |
opencv_cudaarithm.max(Mat src1,
Mat src2,
Mat dst,
Stream stream)
\brief Computes the per-element maximum of two matrices (or a matrix and a scalar).
|
static void |
opencv_cudaarithm.max(UMat src1,
UMat src2,
UMat dst,
Stream stream) |
static void |
opencv_cudaimgproc.meanShiftFiltering(GpuMat src,
GpuMat dst,
int sp,
int sr,
TermCriteria criteria,
Stream stream) |
static void |
opencv_cudaimgproc.meanShiftFiltering(Mat src,
Mat dst,
int sp,
int sr,
TermCriteria criteria,
Stream stream)
\} cudaimgproc_feature
|
static void |
opencv_cudaimgproc.meanShiftFiltering(UMat src,
UMat dst,
int sp,
int sr,
TermCriteria criteria,
Stream stream) |
static void |
opencv_cudaimgproc.meanShiftProc(GpuMat src,
GpuMat dstr,
GpuMat dstsp,
int sp,
int sr,
TermCriteria criteria,
Stream stream) |
static void |
opencv_cudaimgproc.meanShiftProc(Mat src,
Mat dstr,
Mat dstsp,
int sp,
int sr,
TermCriteria criteria,
Stream stream)
\brief Performs a mean-shift procedure and stores information about processed points (their colors and
positions) in two images.
|
static void |
opencv_cudaimgproc.meanShiftProc(UMat src,
UMat dstr,
UMat dstsp,
int sp,
int sr,
TermCriteria criteria,
Stream stream) |
static void |
opencv_cudaimgproc.meanShiftSegmentation(GpuMat src,
GpuMat dst,
int sp,
int sr,
int minsize,
TermCriteria criteria,
Stream stream) |
static void |
opencv_cudaimgproc.meanShiftSegmentation(Mat src,
Mat dst,
int sp,
int sr,
int minsize,
TermCriteria criteria,
Stream stream)
\brief Performs a mean-shift segmentation of the source image and eliminates small segments.
|
static void |
opencv_cudaimgproc.meanShiftSegmentation(UMat src,
UMat dst,
int sp,
int sr,
int minsize,
TermCriteria criteria,
Stream stream) |
static void |
opencv_cudaarithm.meanStdDev(GpuMat mtx,
GpuMat dst,
Stream stream) |
static void |
opencv_cudaarithm.meanStdDev(Mat mtx,
Mat dst,
Stream stream)
\overload
|
static void |
opencv_cudaarithm.meanStdDev(UMat mtx,
UMat dst,
Stream stream) |
static void |
opencv_cudaarithm.merge(GpuMat src,
long n,
GpuMat dst,
Stream stream) |
static void |
opencv_cudaarithm.merge(GpuMat src,
long n,
Mat dst,
Stream stream)
\} cudaarithm_elem
|
static void |
opencv_cudaarithm.merge(GpuMat src,
long n,
UMat dst,
Stream stream) |
static void |
opencv_cudaarithm.merge(GpuMatVector src,
GpuMat dst,
Stream stream) |
static void |
opencv_cudaarithm.merge(GpuMatVector src,
Mat dst,
Stream stream)
\overload
|
static void |
opencv_cudaarithm.merge(GpuMatVector src,
UMat dst,
Stream stream) |
static void |
opencv_cudaarithm.min(GpuMat src1,
GpuMat src2,
GpuMat dst,
Stream stream) |
static void |
opencv_cudaarithm.min(Mat src1,
Mat src2,
Mat dst,
Stream stream)
\brief Computes the per-element minimum of two matrices (or a matrix and a scalar).
|
static void |
opencv_cudaarithm.min(UMat src1,
UMat src2,
UMat dst,
Stream stream) |
static void |
opencv_cudaarithm.mulAndScaleSpectrums(GpuMat src1,
GpuMat src2,
GpuMat dst,
int flags,
float scale,
boolean conjB,
Stream stream) |
static void |
opencv_cudaarithm.mulAndScaleSpectrums(Mat src1,
Mat src2,
Mat dst,
int flags,
float scale,
boolean conjB,
Stream stream)
\brief Performs a per-element multiplication of two Fourier spectrums and scales the result.
|
static void |
opencv_cudaarithm.mulAndScaleSpectrums(UMat src1,
UMat src2,
UMat dst,
int flags,
float scale,
boolean conjB,
Stream stream) |
static void |
opencv_cudaarithm.mulSpectrums(GpuMat src1,
GpuMat src2,
GpuMat dst,
int flags,
boolean conjB,
Stream stream) |
static void |
opencv_cudaarithm.mulSpectrums(Mat src1,
Mat src2,
Mat dst,
int flags,
boolean conjB,
Stream stream)
\brief Performs a per-element multiplication of two Fourier spectrums.
|
static void |
opencv_cudaarithm.mulSpectrums(UMat src1,
UMat src2,
UMat dst,
int flags,
boolean conjB,
Stream stream) |
static void |
opencv_cudaarithm.multiply(GpuMat src1,
GpuMat src2,
GpuMat dst,
double scale,
int dtype,
Stream stream) |
static void |
opencv_cudaarithm.multiply(Mat src1,
Mat src2,
Mat dst,
double scale,
int dtype,
Stream stream)
\brief Computes a matrix-matrix or matrix-scalar per-element product.
|
static void |
opencv_cudaarithm.multiply(UMat src1,
UMat src2,
UMat dst,
double scale,
int dtype,
Stream stream) |
static void |
opencv_photo.nonLocalMeans(GpuMat src,
GpuMat dst,
float h,
int search_window,
int block_size,
int borderMode,
Stream stream) |
static void |
opencv_photo.nonLocalMeans(Mat src,
Mat dst,
float h,
int search_window,
int block_size,
int borderMode,
Stream stream)
\addtogroup photo_denoise
\{
|
static void |
opencv_photo.nonLocalMeans(UMat src,
UMat dst,
float h,
int search_window,
int block_size,
int borderMode,
Stream stream) |
static void |
opencv_cudaarithm.normalize(GpuMat src,
GpuMat dst,
double alpha,
double beta,
int norm_type,
int dtype,
GpuMat mask,
Stream stream) |
static void |
opencv_cudaarithm.normalize(Mat src,
Mat dst,
double alpha,
double beta,
int norm_type,
int dtype,
Mat mask,
Stream stream)
\brief Normalizes the norm or value range of an array.
|
static void |
opencv_cudaarithm.normalize(UMat src,
UMat dst,
double alpha,
double beta,
int norm_type,
int dtype,
UMat mask,
Stream stream) |
static void |
opencv_cudaarithm.phase(GpuMat x,
GpuMat y,
GpuMat angle,
boolean angleInDegrees,
Stream stream) |
static void |
opencv_cudaarithm.phase(Mat x,
Mat y,
Mat angle,
boolean angleInDegrees,
Stream stream)
\brief Computes polar angles of complex matrix elements.
|
static void |
opencv_cudaarithm.phase(UMat x,
UMat y,
UMat angle,
boolean angleInDegrees,
Stream stream) |
static void |
opencv_cudaarithm.polarToCart(GpuMat magnitude,
GpuMat angle,
GpuMat x,
GpuMat y,
boolean angleInDegrees,
Stream stream) |
static void |
opencv_cudaarithm.polarToCart(Mat magnitude,
Mat angle,
Mat x,
Mat y,
boolean angleInDegrees,
Stream stream)
\brief Converts polar coordinates into Cartesian.
|
static void |
opencv_cudaarithm.polarToCart(UMat magnitude,
UMat angle,
UMat x,
UMat y,
boolean angleInDegrees,
Stream stream) |
static void |
opencv_cudaarithm.pow(GpuMat src,
double power,
GpuMat dst,
Stream stream) |
static void |
opencv_cudaarithm.pow(Mat src,
double power,
Mat dst,
Stream stream)
\brief Raises every matrix element to a power.
|
static void |
opencv_cudaarithm.pow(UMat src,
double power,
UMat dst,
Stream stream) |
static void |
opencv_cudawarping.pyrDown(GpuMat src,
GpuMat dst,
Stream stream) |
static void |
opencv_cudawarping.pyrDown(Mat src,
Mat dst,
Stream stream)
\brief Smoothes an image and downsamples it.
|
static void |
opencv_cudawarping.pyrDown(UMat src,
UMat dst,
Stream stream) |
static void |
opencv_cudawarping.pyrUp(GpuMat src,
GpuMat dst,
Stream stream) |
static void |
opencv_cudawarping.pyrUp(Mat src,
Mat dst,
Stream stream)
\brief Upsamples an image and then smoothes it.
|
static void |
opencv_cudawarping.pyrUp(UMat src,
UMat dst,
Stream stream) |
static void |
opencv_cudaarithm.rectStdDev(GpuMat src,
GpuMat sqr,
GpuMat dst,
Rect rect,
Stream stream) |
static void |
opencv_cudaarithm.rectStdDev(Mat src,
Mat sqr,
Mat dst,
Rect rect,
Stream stream)
\brief Computes a standard deviation of integral images.
|
static void |
opencv_cudaarithm.rectStdDev(UMat src,
UMat sqr,
UMat dst,
Rect rect,
Stream stream) |
static void |
opencv_cudaarithm.reduce(GpuMat mtx,
GpuMat vec,
int dim,
int reduceOp,
int dtype,
Stream stream) |
static void |
opencv_cudaarithm.reduce(Mat mtx,
Mat vec,
int dim,
int reduceOp,
int dtype,
Stream stream)
\brief Reduces a matrix to a vector.
|
static void |
opencv_cudaarithm.reduce(UMat mtx,
UMat vec,
int dim,
int reduceOp,
int dtype,
Stream stream) |
static void |
opencv_cudawarping.remap(GpuMat src,
GpuMat dst,
GpuMat xmap,
GpuMat ymap,
int interpolation,
int borderMode,
Scalar borderValue,
Stream stream) |
static void |
opencv_cudawarping.remap(Mat src,
Mat dst,
Mat xmap,
Mat ymap,
int interpolation,
int borderMode,
Scalar borderValue,
Stream stream)
\addtogroup cudawarping
\{
|
static void |
opencv_cudawarping.remap(UMat src,
UMat dst,
UMat xmap,
UMat ymap,
int interpolation,
int borderMode,
Scalar borderValue,
Stream stream) |
static void |
opencv_cudastereo.reprojectImageTo3D(GpuMat disp,
GpuMat xyzw,
GpuMat Q,
int dst_cn,
Stream stream) |
static void |
opencv_cudastereo.reprojectImageTo3D(Mat disp,
Mat xyzw,
Mat Q,
int dst_cn,
Stream stream)
\brief Reprojects a disparity image to 3D space.
|
static void |
opencv_cudastereo.reprojectImageTo3D(UMat disp,
UMat xyzw,
UMat Q,
int dst_cn,
Stream stream) |
static void |
opencv_cudawarping.resize(GpuMat src,
GpuMat dst,
Size dsize,
double fx,
double fy,
int interpolation,
Stream stream) |
static void |
opencv_cudawarping.resize(Mat src,
Mat dst,
Size dsize,
double fx,
double fy,
int interpolation,
Stream stream)
\brief Resizes an image.
|
static void |
opencv_cudawarping.resize(UMat src,
UMat dst,
Size dsize,
double fx,
double fy,
int interpolation,
Stream stream) |
static void |
opencv_cudawarping.rotate(GpuMat src,
GpuMat dst,
Size dsize,
double angle,
double xShift,
double yShift,
int interpolation,
Stream stream) |
static void |
opencv_cudawarping.rotate(Mat src,
Mat dst,
Size dsize,
double angle,
double xShift,
double yShift,
int interpolation,
Stream stream)
\brief Rotates an image around the origin (0,0) and then shifts it.
|
static void |
opencv_cudawarping.rotate(UMat src,
UMat dst,
Size dsize,
double angle,
double xShift,
double yShift,
int interpolation,
Stream stream) |
static void |
opencv_cudaarithm.rshift(GpuMat src,
Scalar4i val,
GpuMat dst,
Stream stream) |
static void |
opencv_cudaarithm.rshift(GpuMat src,
Scalar val,
GpuMat dst,
Stream stream) |
static void |
opencv_cudaarithm.rshift(Mat src,
Scalar4i val,
Mat dst,
Stream stream)
\brief Performs pixel by pixel right shift of an image by a constant value.
|
static void |
opencv_cudaarithm.rshift(Mat src,
Scalar val,
Mat dst,
Stream stream) |
static void |
opencv_cudaarithm.rshift(UMat src,
Scalar4i val,
UMat dst,
Stream stream) |
static void |
opencv_cudaarithm.rshift(UMat src,
Scalar val,
UMat dst,
Stream stream) |
static void |
opencv_cudaarithm.scaleAdd(GpuMat src1,
double alpha,
GpuMat src2,
GpuMat dst,
Stream stream) |
static void |
opencv_cudaarithm.scaleAdd(Mat src1,
double alpha,
Mat src2,
Mat dst,
Stream stream)
adds scaled array to another one (dst = alpha*src1 + src2)
|
static void |
opencv_cudaarithm.scaleAdd(UMat src1,
double alpha,
UMat src2,
UMat dst,
Stream stream) |
static void |
opencv_cudaarithm.split(GpuMat src,
GpuMat dst,
Stream stream) |
static void |
opencv_cudaarithm.split(GpuMat src,
GpuMatVector dst,
Stream stream) |
static void |
opencv_cudaarithm.split(Mat src,
GpuMat dst,
Stream stream)
\brief Copies each plane of a multi-channel matrix into an array.
|
static void |
opencv_cudaarithm.split(Mat src,
GpuMatVector dst,
Stream stream)
\overload
|
static void |
opencv_cudaarithm.split(UMat src,
GpuMat dst,
Stream stream) |
static void |
opencv_cudaarithm.split(UMat src,
GpuMatVector dst,
Stream stream) |
static void |
opencv_cudaarithm.sqr(GpuMat src,
GpuMat dst,
Stream stream) |
static void |
opencv_cudaarithm.sqr(Mat src,
Mat dst,
Stream stream)
\brief Computes a square value of each matrix element.
|
static void |
opencv_cudaarithm.sqr(UMat src,
UMat dst,
Stream stream) |
static void |
opencv_cudaarithm.sqrIntegral(GpuMat src,
GpuMat sqsum,
Stream stream) |
static void |
opencv_cudaarithm.sqrIntegral(Mat src,
Mat sqsum,
Stream stream)
\brief Computes a squared integral image.
|
static void |
opencv_cudaarithm.sqrIntegral(UMat src,
UMat sqsum,
Stream stream) |
static void |
opencv_cudaarithm.sqrt(GpuMat src,
GpuMat dst,
Stream stream) |
static void |
opencv_cudaarithm.sqrt(Mat src,
Mat dst,
Stream stream)
\brief Computes a square root of each matrix element.
|
static void |
opencv_cudaarithm.sqrt(UMat src,
UMat dst,
Stream stream) |
static void |
opencv_cudaarithm.subtract(GpuMat src1,
GpuMat src2,
GpuMat dst,
GpuMat mask,
int dtype,
Stream stream) |
static void |
opencv_cudaarithm.subtract(Mat src1,
Mat src2,
Mat dst,
Mat mask,
int dtype,
Stream stream)
\brief Computes a matrix-matrix or matrix-scalar difference.
|
static void |
opencv_cudaarithm.subtract(UMat src1,
UMat src2,
UMat dst,
UMat mask,
int dtype,
Stream stream) |
static void |
opencv_cudaimgproc.swapChannels(GpuMat image,
int[] dstOrder,
Stream stream) |
static void |
opencv_cudaimgproc.swapChannels(GpuMat image,
IntBuffer dstOrder,
Stream stream) |
static void |
opencv_cudaimgproc.swapChannels(GpuMat image,
IntPointer dstOrder,
Stream stream) |
static void |
opencv_cudaimgproc.swapChannels(Mat image,
int[] dstOrder,
Stream stream) |
static void |
opencv_cudaimgproc.swapChannels(Mat image,
IntBuffer dstOrder,
Stream stream) |
static void |
opencv_cudaimgproc.swapChannels(Mat image,
IntPointer dstOrder,
Stream stream)
\brief Exchanges the color channels of an image in-place.
|
static void |
opencv_cudaimgproc.swapChannels(UMat image,
int[] dstOrder,
Stream stream) |
static void |
opencv_cudaimgproc.swapChannels(UMat image,
IntBuffer dstOrder,
Stream stream) |
static void |
opencv_cudaimgproc.swapChannels(UMat image,
IntPointer dstOrder,
Stream stream) |
static double |
opencv_cudaarithm.threshold(GpuMat src,
GpuMat dst,
double thresh,
double maxval,
int type,
Stream stream) |
static double |
opencv_cudaarithm.threshold(Mat src,
Mat dst,
double thresh,
double maxval,
int type,
Stream stream)
\brief Applies a fixed-level threshold to each array element.
|
static double |
opencv_cudaarithm.threshold(UMat src,
UMat dst,
double thresh,
double maxval,
int type,
Stream stream) |
static void |
opencv_cudaarithm.transpose(GpuMat src1,
GpuMat dst,
Stream stream) |
static void |
opencv_cudaarithm.transpose(Mat src1,
Mat dst,
Stream stream)
\brief Transposes a matrix.
|
static void |
opencv_cudaarithm.transpose(UMat src1,
UMat dst,
Stream stream) |
static void |
opencv_cudawarping.warpAffine(GpuMat src,
GpuMat dst,
Mat M,
Size dsize,
int flags,
int borderMode,
Scalar borderValue,
Stream stream)
\brief Applies an affine transformation to an image.
|
static void |
opencv_cudawarping.warpPerspective(GpuMat src,
GpuMat dst,
Mat M,
Size dsize,
int flags,
int borderMode,
Scalar borderValue,
Stream stream)
\brief Applies a perspective transformation to an image.
|
Modifier and Type | Method and Description |
---|---|
static Stream |
Stream.Null()
return Stream object for default CUDA stream
|
Stream |
Stream.position(long position) |
Modifier and Type | Method and Description |
---|---|
void |
GpuMat.convertTo(GpuMat dst,
int rtype,
double alpha,
double beta,
Stream stream) |
void |
GpuMat.convertTo(GpuMat dst,
int rtype,
double alpha,
Stream stream) |
void |
GpuMat.convertTo(GpuMat dst,
int rtype,
Stream stream) |
void |
GpuMat.convertTo(Mat dst,
int rtype,
double alpha,
double beta,
Stream stream)
converts GpuMat to another datatype with scaling (Non-Blocking call)
|
void |
GpuMat.convertTo(Mat dst,
int rtype,
double alpha,
Stream stream)
converts GpuMat to another datatype with scaling (Non-Blocking call)
|
void |
GpuMat.convertTo(Mat dst,
int rtype,
Stream stream)
converts GpuMat to another datatype (Non-Blocking call)
|
void |
GpuMat.convertTo(UMat dst,
int rtype,
double alpha,
double beta,
Stream stream) |
void |
GpuMat.convertTo(UMat dst,
int rtype,
double alpha,
Stream stream) |
void |
GpuMat.convertTo(UMat dst,
int rtype,
Stream stream) |
void |
GpuMat.copyTo(GpuMat dst,
GpuMat mask,
Stream stream) |
void |
GpuMat.copyTo(GpuMat dst,
Stream stream) |
void |
GpuMat.copyTo(Mat dst,
Mat mask,
Stream stream)
copies those GpuMat elements to "m" that are marked with non-zero mask elements (Non-Blocking call)
|
void |
GpuMat.copyTo(Mat dst,
Stream stream)
copies the GpuMat content to device memory (Non-Blocking call)
|
void |
GpuMat.copyTo(UMat dst,
Stream stream) |
void |
GpuMat.copyTo(UMat dst,
UMat mask,
Stream stream) |
void |
GpuMat.download(GpuMat dst,
Stream stream) |
void |
GpuMat.download(Mat dst,
Stream stream)
\brief Performs data download from GpuMat (Non-Blocking call)
|
void |
GpuMat.download(UMat dst,
Stream stream) |
void |
Event.record(Stream stream)
records an event
|
GpuMat |
GpuMat.setTo(Scalar s,
GpuMat mask,
Stream stream) |
GpuMat |
GpuMat.setTo(Scalar s,
Mat mask,
Stream stream)
sets some of the GpuMat elements to s, according to the mask (Non-Blocking call)
|
GpuMat |
GpuMat.setTo(Scalar s,
Stream stream)
sets some of the GpuMat elements to s (Non-Blocking call)
|
GpuMat |
GpuMat.setTo(Scalar s,
UMat mask,
Stream stream) |
void |
GpuMat.upload(GpuMat arr,
Stream stream) |
void |
GpuMat.upload(Mat arr,
Stream stream)
\brief Performs data upload to GpuMat (Non-Blocking call)
|
void |
GpuMat.upload(UMat arr,
Stream stream) |
Constructor and Description |
---|
BufferPool(Stream stream)
Gets the BufferPool for the given stream.
|
Modifier and Type | Method and Description |
---|---|
void |
DFT.compute(GpuMat image,
GpuMat result,
Stream stream) |
void |
DFT.compute(Mat image,
Mat result,
Stream stream)
\brief Computes an FFT of a given image.
|
void |
DFT.compute(UMat image,
UMat result,
Stream stream) |
void |
Convolution.convolve(GpuMat image,
GpuMat templ,
GpuMat result,
boolean ccorr,
Stream stream) |
void |
Convolution.convolve(Mat image,
Mat templ,
Mat result,
boolean ccorr,
Stream stream)
\brief Computes a convolution (or cross-correlation) of two images.
|
void |
Convolution.convolve(UMat image,
UMat templ,
UMat result,
boolean ccorr,
Stream stream) |
void |
LookUpTable.transform(GpuMat src,
GpuMat dst,
Stream stream) |
void |
LookUpTable.transform(Mat src,
Mat dst,
Stream stream)
\brief Transforms the source matrix into the destination matrix using the given look-up table:
dst(I) = lut(src(I)) .
|
void |
LookUpTable.transform(UMat src,
UMat dst,
Stream stream) |
Modifier and Type | Method and Description |
---|---|
void |
BackgroundSubtractorMOG.apply(GpuMat image,
GpuMat fgmask,
double learningRate,
Stream stream) |
void |
BackgroundSubtractorMOG2.apply(GpuMat image,
GpuMat fgmask,
double learningRate,
Stream stream) |
void |
BackgroundSubtractorMOG.apply(Mat image,
Mat fgmask,
double learningRate,
Stream stream) |
void |
BackgroundSubtractorMOG2.apply(Mat image,
Mat fgmask,
double learningRate,
Stream stream) |
void |
BackgroundSubtractorMOG.apply(UMat image,
UMat fgmask,
double learningRate,
Stream stream) |
void |
BackgroundSubtractorMOG2.apply(UMat image,
UMat fgmask,
double learningRate,
Stream stream) |
void |
BackgroundSubtractorMOG.getBackgroundImage(GpuMat backgroundImage,
Stream stream) |
void |
BackgroundSubtractorMOG2.getBackgroundImage(GpuMat backgroundImage,
Stream stream) |
void |
BackgroundSubtractorMOG.getBackgroundImage(Mat backgroundImage,
Stream stream) |
void |
BackgroundSubtractorMOG2.getBackgroundImage(Mat backgroundImage,
Stream stream) |
void |
BackgroundSubtractorMOG.getBackgroundImage(UMat backgroundImage,
Stream stream) |
void |
BackgroundSubtractorMOG2.getBackgroundImage(UMat backgroundImage,
Stream stream) |
Modifier and Type | Method and Description |
---|---|
boolean |
VideoReader.nextFrame(GpuMat frame,
Stream stream)
\brief Grabs, decodes and returns the next video frame.
|
Modifier and Type | Method and Description |
---|---|
void |
Feature2DAsync.computeAsync(GpuMat image,
GpuMat keypoints,
GpuMat descriptors,
Stream stream) |
void |
Feature2DAsync.computeAsync(Mat image,
Mat keypoints,
Mat descriptors,
Stream stream)
\brief Computes the descriptors for a set of keypoints detected in an image.
|
void |
Feature2DAsync.computeAsync(UMat image,
UMat keypoints,
UMat descriptors,
Stream stream) |
void |
Feature2DAsync.detectAndComputeAsync(GpuMat image,
GpuMat mask,
GpuMat keypoints,
GpuMat descriptors,
boolean useProvidedKeypoints,
Stream stream) |
void |
Feature2DAsync.detectAndComputeAsync(Mat image,
Mat mask,
Mat keypoints,
Mat descriptors,
boolean useProvidedKeypoints,
Stream stream)
Detects keypoints and computes the descriptors.
|
void |
Feature2DAsync.detectAndComputeAsync(UMat image,
UMat mask,
UMat keypoints,
UMat descriptors,
boolean useProvidedKeypoints,
Stream stream) |
void |
Feature2DAsync.detectAsync(GpuMat image,
GpuMat keypoints,
GpuMat mask,
Stream stream) |
void |
Feature2DAsync.detectAsync(Mat image,
Mat keypoints,
Mat mask,
Stream stream)
\brief Detects keypoints in an image.
|
void |
Feature2DAsync.detectAsync(UMat image,
UMat keypoints,
UMat mask,
Stream stream) |
void |
DescriptorMatcher.knnMatchAsync(GpuMat queryDescriptors,
GpuMat trainDescriptors,
GpuMat matches,
int k,
GpuMat mask,
Stream stream) |
void |
DescriptorMatcher.knnMatchAsync(GpuMat queryDescriptors,
GpuMat matches,
int k,
GpuMatVector masks,
Stream stream) |
void |
DescriptorMatcher.knnMatchAsync(Mat queryDescriptors,
Mat matches,
int k,
GpuMatVector masks,
Stream stream)
\overload
|
void |
DescriptorMatcher.knnMatchAsync(Mat queryDescriptors,
Mat trainDescriptors,
Mat matches,
int k,
Mat mask,
Stream stream)
\brief Finds the k best matches for each descriptor from a query set (asynchronous version).
|
void |
DescriptorMatcher.knnMatchAsync(UMat queryDescriptors,
UMat matches,
int k,
GpuMatVector masks,
Stream stream) |
void |
DescriptorMatcher.knnMatchAsync(UMat queryDescriptors,
UMat trainDescriptors,
UMat matches,
int k,
UMat mask,
Stream stream) |
void |
DescriptorMatcher.matchAsync(GpuMat queryDescriptors,
GpuMat trainDescriptors,
GpuMat matches,
GpuMat mask,
Stream stream) |
void |
DescriptorMatcher.matchAsync(GpuMat queryDescriptors,
GpuMat matches,
GpuMatVector masks,
Stream stream) |
void |
DescriptorMatcher.matchAsync(Mat queryDescriptors,
Mat matches,
GpuMatVector masks,
Stream stream)
\overload
|
void |
DescriptorMatcher.matchAsync(Mat queryDescriptors,
Mat trainDescriptors,
Mat matches,
Mat mask,
Stream stream)
\brief Finds the best match for each descriptor from a query set (asynchronous version).
|
void |
DescriptorMatcher.matchAsync(UMat queryDescriptors,
UMat matches,
GpuMatVector masks,
Stream stream) |
void |
DescriptorMatcher.matchAsync(UMat queryDescriptors,
UMat trainDescriptors,
UMat matches,
UMat mask,
Stream stream) |
void |
DescriptorMatcher.radiusMatchAsync(GpuMat queryDescriptors,
GpuMat matches,
float maxDistance,
GpuMatVector masks,
Stream stream) |
void |
DescriptorMatcher.radiusMatchAsync(GpuMat queryDescriptors,
GpuMat trainDescriptors,
GpuMat matches,
float maxDistance,
GpuMat mask,
Stream stream) |
void |
DescriptorMatcher.radiusMatchAsync(Mat queryDescriptors,
Mat matches,
float maxDistance,
GpuMatVector masks,
Stream stream)
\overload
|
void |
DescriptorMatcher.radiusMatchAsync(Mat queryDescriptors,
Mat trainDescriptors,
Mat matches,
float maxDistance,
Mat mask,
Stream stream)
\brief For each query descriptor, finds the training descriptors not farther than the specified distance (asynchronous version).
|
void |
DescriptorMatcher.radiusMatchAsync(UMat queryDescriptors,
UMat matches,
float maxDistance,
GpuMatVector masks,
Stream stream) |
void |
DescriptorMatcher.radiusMatchAsync(UMat queryDescriptors,
UMat trainDescriptors,
UMat matches,
float maxDistance,
UMat mask,
Stream stream) |
Modifier and Type | Method and Description |
---|---|
void |
Filter.apply(GpuMat src,
GpuMat dst,
Stream stream) |
void |
Filter.apply(Mat src,
Mat dst,
Stream stream)
\brief Applies the specified filter to the image.
|
void |
Filter.apply(UMat src,
UMat dst,
Stream stream) |
Modifier and Type | Method and Description |
---|---|
void |
CudaCLAHE.apply(GpuMat src,
GpuMat dst,
Stream stream) |
void |
CudaCLAHE.apply(Mat src,
Mat dst,
Stream stream)
\brief Equalizes the histogram of a grayscale image using Contrast Limited Adaptive Histogram Equalization.
|
void |
CudaCLAHE.apply(UMat src,
UMat dst,
Stream stream) |
void |
CornernessCriteria.compute(GpuMat src,
GpuMat dst,
Stream stream) |
void |
CornernessCriteria.compute(Mat src,
Mat dst,
Stream stream)
\brief Computes the cornerness criteria at each image pixel.
|
void |
CornernessCriteria.compute(UMat src,
UMat dst,
Stream stream) |
void |
CannyEdgeDetector.detect(GpuMat dx,
GpuMat dy,
GpuMat edges,
Stream stream) |
void |
CornersDetector.detect(GpuMat image,
GpuMat corners,
GpuMat mask,
Stream stream) |
void |
HoughLinesDetector.detect(GpuMat src,
GpuMat lines,
Stream stream) |
void |
CannyEdgeDetector.detect(GpuMat image,
GpuMat edges,
Stream stream) |
void |
HoughSegmentDetector.detect(GpuMat src,
GpuMat lines,
Stream stream) |
void |
HoughCirclesDetector.detect(GpuMat src,
GpuMat circles,
Stream stream) |
void |
CannyEdgeDetector.detect(Mat dx,
Mat dy,
Mat edges,
Stream stream)
\overload
|
void |
CornersDetector.detect(Mat image,
Mat corners,
Mat mask,
Stream stream)
\brief Determines strong corners on an image.
|
void |
HoughLinesDetector.detect(Mat src,
Mat lines,
Stream stream)
\brief Finds lines in a binary image using the classical Hough transform.
|
void |
CannyEdgeDetector.detect(Mat image,
Mat edges,
Stream stream)
\brief Finds edges in an image using the \cite Canny86 algorithm.
|
void |
HoughSegmentDetector.detect(Mat src,
Mat lines,
Stream stream)
\brief Finds line segments in a binary image using the probabilistic Hough transform.
|
void |
HoughCirclesDetector.detect(Mat src,
Mat circles,
Stream stream)
\brief Finds circles in a grayscale image using the Hough transform.
|
void |
HoughLinesDetector.detect(UMat src,
UMat lines,
Stream stream) |
void |
CannyEdgeDetector.detect(UMat image,
UMat edges,
Stream stream) |
void |
HoughSegmentDetector.detect(UMat src,
UMat lines,
Stream stream) |
void |
HoughCirclesDetector.detect(UMat src,
UMat circles,
Stream stream) |
void |
CannyEdgeDetector.detect(UMat dx,
UMat dy,
UMat edges,
Stream stream) |
void |
CornersDetector.detect(UMat image,
UMat corners,
UMat mask,
Stream stream) |
void |
HoughLinesDetector.downloadResults(GpuMat d_lines,
GpuMat h_lines,
GpuMat h_votes,
Stream stream) |
void |
HoughLinesDetector.downloadResults(Mat d_lines,
Mat h_lines,
Mat h_votes,
Stream stream)
\brief Downloads results from cuda::HoughLinesDetector::detect to host memory.
|
void |
HoughLinesDetector.downloadResults(UMat d_lines,
UMat h_lines,
UMat h_votes,
Stream stream) |
void |
TemplateMatching.match(GpuMat image,
GpuMat templ,
GpuMat result,
Stream stream) |
void |
TemplateMatching.match(Mat image,
Mat templ,
Mat result,
Stream stream)
\brief Computes a proximity map for a raster template and an image where the template is searched for.
|
void |
TemplateMatching.match(UMat image,
UMat templ,
UMat result,
Stream stream) |
Modifier and Type | Method and Description |
---|---|
void |
HOG.compute(GpuMat img,
GpuMat descriptors,
Stream stream) |
void |
HOG.compute(Mat img,
Mat descriptors,
Stream stream)
\brief Returns block descriptors computed for the whole image.
|
void |
HOG.compute(UMat img,
UMat descriptors,
Stream stream) |
void |
CudaCascadeClassifier.detectMultiScale(GpuMat image,
GpuMat objects,
Stream stream) |
void |
CudaCascadeClassifier.detectMultiScale(Mat image,
Mat objects,
Stream stream)
\brief Detects objects of different sizes in the input image.
|
void |
CudaCascadeClassifier.detectMultiScale(UMat image,
UMat objects,
Stream stream) |
Modifier and Type | Method and Description |
---|---|
void |
SparseOpticalFlow.calc(GpuMat prevImg,
GpuMat nextImg,
GpuMat prevPts,
GpuMat nextPts,
GpuMat status,
GpuMat err,
Stream stream) |
void |
DenseOpticalFlow.calc(GpuMat I0,
GpuMat I1,
GpuMat flow,
Stream stream) |
void |
NvidiaHWOpticalFlow.calc(GpuMat inputImage,
GpuMat referenceImage,
GpuMat flow,
Stream stream,
GpuMat hint,
GpuMat cost) |
void |
SparseOpticalFlow.calc(Mat prevImg,
Mat nextImg,
Mat prevPts,
Mat nextPts,
Mat status,
Mat err,
Stream stream)
\brief Calculates a sparse optical flow.
|
void |
DenseOpticalFlow.calc(Mat I0,
Mat I1,
Mat flow,
Stream stream)
\brief Calculates a dense optical flow.
|
void |
NvidiaHWOpticalFlow.calc(Mat inputImage,
Mat referenceImage,
Mat flow,
Stream stream,
Mat hint,
Mat cost)
\brief Calculates Optical Flow using NVIDIA Optical Flow SDK.
|
void |
DenseOpticalFlow.calc(UMat I0,
UMat I1,
UMat flow,
Stream stream) |
void |
NvidiaHWOpticalFlow.calc(UMat inputImage,
UMat referenceImage,
UMat flow,
Stream stream,
UMat hint,
UMat cost) |
void |
SparseOpticalFlow.calc(UMat prevImg,
UMat nextImg,
UMat prevPts,
UMat nextPts,
UMat status,
UMat err,
Stream stream) |
Modifier and Type | Method and Description |
---|---|
void |
DisparityBilateralFilter.apply(GpuMat disparity,
GpuMat image,
GpuMat dst,
Stream stream) |
void |
DisparityBilateralFilter.apply(Mat disparity,
Mat image,
Mat dst,
Stream stream)
\brief Refines a disparity map using joint bilateral filtering.
|
void |
DisparityBilateralFilter.apply(UMat disparity,
UMat image,
UMat dst,
Stream stream) |
void |
StereoBM.compute(GpuMat left,
GpuMat right,
GpuMat disparity,
Stream stream) |
void |
StereoBeliefPropagation.compute(GpuMat left,
GpuMat right,
GpuMat disparity,
Stream stream) |
void |
StereoBeliefPropagation.compute(GpuMat data,
GpuMat disparity,
Stream stream) |
void |
StereoBM.compute(Mat left,
Mat right,
Mat disparity,
Stream stream) |
void |
StereoBeliefPropagation.compute(Mat left,
Mat right,
Mat disparity,
Stream stream)
\overload
|
void |
StereoBeliefPropagation.compute(Mat data,
Mat disparity,
Stream stream)
\brief Enables the stereo correspondence operator that finds the disparity for the specified data cost.
|
void |
StereoBeliefPropagation.compute(UMat data,
UMat disparity,
Stream stream) |
void |
StereoBM.compute(UMat left,
UMat right,
UMat disparity,
Stream stream) |
void |
StereoBeliefPropagation.compute(UMat left,
UMat right,
UMat disparity,
Stream stream) |
Copyright © 2020. All rights reserved.