| Modifier and Type | Method and Description |
|---|---|
static Stream |
opencv_core.wrapStream(long cudaStreamMemoryAddress)
\brief Bindings overload to create a Stream object from the address stored in an existing CUDA Runtime API stream pointer (cudaStream_t).
|
| 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.absdiffWithScalar(GpuMat src1,
Scalar src2,
GpuMat dst,
Stream stream) |
static void |
opencv_cudaarithm.absdiffWithScalar(Mat src1,
Scalar src2,
Mat dst,
Stream stream)
\brief Computes per-element absolute difference of a matrix and scalar.
|
static void |
opencv_cudaarithm.absdiffWithScalar(UMat src1,
Scalar 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_cudaarithm.addWithScalar(GpuMat src1,
Scalar src2,
GpuMat dst,
GpuMat mask,
int dtype,
Stream stream) |
static void |
opencv_cudaarithm.addWithScalar(Mat src1,
Scalar src2,
Mat dst,
Mat mask,
int dtype,
Stream stream)
\brief Computes a matrix-scalar sum.
|
static void |
opencv_cudaarithm.addWithScalar(UMat src1,
Scalar src2,
UMat dst,
UMat mask,
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_with_scalar(GpuMat src1,
Scalar src2,
GpuMat dst,
GpuMat mask,
Stream stream) |
static void |
opencv_cudaarithm.bitwise_and_with_scalar(Mat src1,
Scalar src2,
Mat dst,
Mat mask,
Stream stream)
\brief Performs a per-element bitwise conjunction of a matrix and a scalar.
|
static void |
opencv_cudaarithm.bitwise_and_with_scalar(UMat src1,
Scalar src2,
UMat dst,
UMat mask,
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_with_scalar(GpuMat src1,
Scalar src2,
GpuMat dst,
GpuMat mask,
Stream stream) |
static void |
opencv_cudaarithm.bitwise_or_with_scalar(Mat src1,
Scalar src2,
Mat dst,
Mat mask,
Stream stream)
\brief Performs a per-element bitwise disjunction of a matrix and scalar.
|
static void |
opencv_cudaarithm.bitwise_or_with_scalar(UMat src1,
Scalar src2,
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_with_scalar(GpuMat src1,
Scalar src2,
GpuMat dst,
GpuMat mask,
Stream stream) |
static void |
opencv_cudaarithm.bitwise_xor_with_scalar(Mat src1,
Scalar src2,
Mat dst,
Mat mask,
Stream stream)
\brief Performs a per-element bitwise exclusive or operation of a matrix and a scalar.
|
static void |
opencv_cudaarithm.bitwise_xor_with_scalar(UMat src1,
Scalar 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 xy,
GpuMat magnitudeAngle,
boolean angleInDegrees,
Stream stream) |
static void |
opencv_cudaarithm.cartToPolar(GpuMat xy,
GpuMat magnitude,
GpuMat angle,
boolean angleInDegrees,
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 xy,
Mat magnitudeAngle,
boolean angleInDegrees,
Stream stream)
\brief Converts Cartesian coordinates into polar.
|
static void |
opencv_cudaarithm.cartToPolar(Mat xy,
Mat magnitude,
Mat angle,
boolean angleInDegrees,
Stream stream)
\brief Converts Cartesian coordinates into polar.
|
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 xy,
UMat magnitudeAngle,
boolean angleInDegrees,
Stream stream) |
static void |
opencv_cudaarithm.cartToPolar(UMat xy,
UMat magnitude,
UMat angle,
boolean angleInDegrees,
Stream stream) |
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.compareWithScalar(GpuMat src1,
Scalar src2,
GpuMat dst,
int cmpop,
Stream stream) |
static void |
opencv_cudaarithm.compareWithScalar(Mat src1,
Scalar src2,
Mat dst,
int cmpop,
Stream stream)
\brief Compares elements of a matrix and scalar.
|
static void |
opencv_cudaarithm.compareWithScalar(UMat src1,
Scalar 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 VideoWriter |
opencv_cudacodec.createVideoWriter(BytePointer fileName,
Size frameSize,
int codec,
double fps,
int colorFormat,
EncoderCallback encoderCallback,
Stream stream)
\brief Creates video writer.
|
static VideoWriter |
opencv_cudacodec.createVideoWriter(BytePointer fileName,
Size frameSize,
int codec,
double fps,
int colorFormat,
EncoderParams params,
EncoderCallback encoderCallback,
Stream stream)
\brief Creates video writer.
|
static VideoWriter |
opencv_cudacodec.createVideoWriter(String fileName,
Size frameSize,
int codec,
double fps,
int colorFormat,
EncoderCallback encoderCallback,
Stream stream) |
static VideoWriter |
opencv_cudacodec.createVideoWriter(String fileName,
Size frameSize,
int codec,
double fps,
int colorFormat,
EncoderParams params,
EncoderCallback encoderCallback,
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_cudaarithm.divideWithScalar(GpuMat src1,
Scalar src2,
GpuMat dst,
double scale,
int dtype,
Stream stream) |
static void |
opencv_cudaarithm.divideWithScalar(Mat src1,
Scalar src2,
Mat dst,
double scale,
int dtype,
Stream stream)
\brief Computes a matrix-scalar division.
|
static void |
opencv_cudaarithm.divideWithScalar(UMat src1,
Scalar 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.inRange(GpuMat src,
Scalar lowerb,
Scalar upperb,
GpuMat dst,
Stream stream) |
static void |
opencv_cudaarithm.inRange(Mat src,
Scalar lowerb,
Scalar upperb,
Mat dst,
Stream stream)
\brief Checks if array elements lie between two scalars.
|
static void |
opencv_cudaarithm.inRange(UMat src,
Scalar lowerb,
Scalar upperb,
UMat dst,
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_cudaarithm.maxWithScalar(GpuMat src1,
Scalar src2,
GpuMat dst,
Stream stream) |
static void |
opencv_cudaarithm.maxWithScalar(Mat src1,
Scalar src2,
Mat dst,
Stream stream)
\brief Computes the per-element maximum of a matrix and a scalar.
|
static void |
opencv_cudaarithm.maxWithScalar(UMat src1,
Scalar 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 src,
GpuMat dst,
GpuMat mask,
Stream stream) |
static void |
opencv_cudaarithm.meanStdDev(GpuMat mtx,
GpuMat dst,
Stream stream) |
static void |
opencv_cudaarithm.meanStdDev(Mat src,
Mat dst,
Mat mask,
Stream stream)
\brief Computes a mean value and a standard deviation of matrix elements.
|
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.meanStdDev(UMat src,
UMat dst,
UMat mask,
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.minWithScalar(GpuMat src1,
Scalar src2,
GpuMat dst,
Stream stream) |
static void |
opencv_cudaarithm.minWithScalar(Mat src1,
Scalar src2,
Mat dst,
Stream stream)
\brief Computes the per-element minimum or a matrix and a scalar.
|
static void |
opencv_cudaarithm.minWithScalar(UMat src1,
Scalar 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_cudaarithm.multiplyWithScalar(GpuMat src1,
Scalar src2,
GpuMat dst,
double scale,
int dtype,
Stream stream) |
static void |
opencv_cudaarithm.multiplyWithScalar(Mat src1,
Scalar src2,
Mat dst,
double scale,
int dtype,
Stream stream)
\brief Computes a matrix-scalar per-element product.
|
static void |
opencv_cudaarithm.multiplyWithScalar(UMat src1,
Scalar 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 xy,
GpuMat angle,
boolean angleInDegrees,
Stream stream) |
static void |
opencv_cudaarithm.phase(GpuMat x,
GpuMat y,
GpuMat angle,
boolean angleInDegrees,
Stream stream) |
static void |
opencv_cudaarithm.phase(Mat xy,
Mat angle,
boolean angleInDegrees,
Stream stream)
\brief Computes polar angles of complex matrix elements.
|
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 xy,
UMat angle,
boolean angleInDegrees,
Stream stream) |
static void |
opencv_cudaarithm.phase(UMat x,
UMat y,
UMat angle,
boolean angleInDegrees,
Stream stream) |
static void |
opencv_cudaarithm.polarToCart(GpuMat magnitudeAngle,
GpuMat xy,
boolean angleInDegrees,
Stream stream) |
static void |
opencv_cudaarithm.polarToCart(GpuMat magnitude,
GpuMat angle,
GpuMat xy,
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 magnitudeAngle,
Mat xy,
boolean angleInDegrees,
Stream stream)
\brief Converts polar coordinates into Cartesian.
|
static void |
opencv_cudaarithm.polarToCart(Mat magnitude,
Mat angle,
Mat xy,
boolean angleInDegrees,
Stream stream)
\brief Converts polar coordinates into Cartesian.
|
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 magnitudeAngle,
UMat xy,
boolean angleInDegrees,
Stream stream) |
static void |
opencv_cudaarithm.polarToCart(UMat magnitude,
UMat angle,
UMat xy,
boolean angleInDegrees,
Stream stream) |
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(GpuMat disp,
GpuMat xyzw,
Mat 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_cudaimgproc.spatialMoments(GpuMat src,
GpuMat moments,
boolean binaryImage,
int order,
int momentsType,
Stream stream) |
static void |
opencv_cudaimgproc.spatialMoments(Mat src,
Mat moments,
boolean binaryImage,
int order,
int momentsType,
Stream stream)
\brief Calculates all of the spatial moments up to the 3rd order of a rasterized shape.
|
static void |
opencv_cudaimgproc.spatialMoments(UMat src,
UMat moments,
boolean binaryImage,
int order,
int momentsType,
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_cudaarithm.subtractWithScalar(GpuMat src1,
Scalar src2,
GpuMat dst,
GpuMat mask,
int dtype,
Stream stream) |
static void |
opencv_cudaarithm.subtractWithScalar(Mat src1,
Scalar src2,
Mat dst,
Mat mask,
int dtype,
Stream stream)
\brief Computes matrix-scalar difference.
|
static void |
opencv_cudaarithm.subtractWithScalar(UMat src1,
Scalar 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
|
| Modifier and Type | Method and Description |
|---|---|
GpuMatND |
GpuMatND.clone(Stream stream)
\overload
This overload is non-blocking, so it may return even if the copy operation is not finished.
|
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 |
GpuMatND.download(GpuMat dst,
Stream stream) |
void |
GpuMat.download(GpuMat dst,
Stream stream) |
void |
GpuMatND.download(Mat dst,
Stream stream) |
void |
GpuMat.download(Mat dst,
Stream stream)
\brief Performs data download from GpuMat (Non-Blocking call)
|
void |
GpuMatND.download(UMat dst,
Stream stream) |
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 |
GpuMatND.upload(GpuMat src,
Stream stream) |
void |
GpuMat.upload(GpuMat arr,
Stream stream) |
void |
GpuMatND.upload(Mat src,
Stream stream) |
void |
GpuMat.upload(Mat arr,
Stream stream)
\brief Performs data upload to GpuMat (Non-Blocking call)
|
void |
GpuMatND.upload(UMat src,
Stream stream) |
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 |
BackgroundSubtractorMOG2.apply(GpuMat image,
GpuMat fgmask,
double learningRate,
Stream stream) |
void |
BackgroundSubtractorMOG.apply(GpuMat image,
GpuMat fgmask,
double learningRate,
Stream stream) |
void |
BackgroundSubtractorMOG2.apply(GpuMat image,
GpuMat knownForegroundMask,
GpuMat fgmask,
double learningRate,
Stream stream) |
void |
BackgroundSubtractorMOG.apply(GpuMat image,
GpuMat knownForegroundMask,
GpuMat fgmask,
double learningRate,
Stream stream) |
void |
BackgroundSubtractorMOG2.apply(Mat image,
Mat fgmask,
double learningRate,
Stream stream) |
void |
BackgroundSubtractorMOG.apply(Mat image,
Mat fgmask,
double learningRate,
Stream stream) |
void |
BackgroundSubtractorMOG2.apply(Mat image,
Mat knownForegroundMask,
Mat fgmask,
double learningRate,
Stream stream) |
void |
BackgroundSubtractorMOG.apply(Mat image,
Mat knownForegroundMask,
Mat fgmask,
double learningRate,
Stream stream) |
void |
BackgroundSubtractorMOG2.apply(UMat image,
UMat fgmask,
double learningRate,
Stream stream) |
void |
BackgroundSubtractorMOG.apply(UMat image,
UMat fgmask,
double learningRate,
Stream stream) |
void |
BackgroundSubtractorMOG2.apply(UMat image,
UMat knownForegroundMask,
UMat fgmask,
double learningRate,
Stream stream) |
void |
BackgroundSubtractorMOG.apply(UMat image,
UMat knownForegroundMask,
UMat fgmask,
double learningRate,
Stream stream) |
void |
BackgroundSubtractorMOG2.getBackgroundImage(GpuMat backgroundImage,
Stream stream) |
void |
BackgroundSubtractorMOG.getBackgroundImage(GpuMat backgroundImage,
Stream stream) |
void |
BackgroundSubtractorMOG2.getBackgroundImage(Mat backgroundImage,
Stream stream) |
void |
BackgroundSubtractorMOG.getBackgroundImage(Mat backgroundImage,
Stream stream) |
void |
BackgroundSubtractorMOG2.getBackgroundImage(UMat backgroundImage,
Stream stream) |
void |
BackgroundSubtractorMOG.getBackgroundImage(UMat backgroundImage,
Stream stream) |
| Modifier and Type | Method and Description |
|---|---|
boolean |
NVSurfaceToColorConverter.convert(GpuMat yuv,
GpuMat color,
int surfaceFormat,
int outputFormat,
int bitDepth,
boolean planar,
Stream stream) |
boolean |
NVSurfaceToColorConverter.convert(Mat yuv,
Mat color,
int surfaceFormat,
int outputFormat,
int bitDepth,
boolean planar,
Stream stream)
\brief Performs the conversion from the raw YUV Surface output from VideoReader to the requested color format.
|
boolean |
NVSurfaceToColorConverter.convert(UMat yuv,
UMat color,
int surfaceFormat,
int outputFormat,
int bitDepth,
boolean planar,
Stream stream) |
boolean |
VideoReader.grab(Stream stream)
\brief Grabs the next frame from the video source.
|
boolean |
VideoReader.nextFrame(GpuMat frame,
Stream stream)
\brief Grabs, decodes and returns the next video frame.
|
boolean |
VideoReader.nextFrameWithHist(GpuMat frame,
GpuMat histogram,
Stream stream)
\brief Grabs, decodes and returns the next video frame and frame luma histogram.
|
| 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 |
CornersDetector.detect(GpuMat image,
GpuMat corners,
GpuMat mask,
Stream stream) |
void |
CannyEdgeDetector.detect(GpuMat dx,
GpuMat dy,
GpuMat edges,
Stream stream) |
void |
HoughSegmentDetector.detect(GpuMat src,
GpuMat lines,
Stream stream) |
void |
HoughLinesDetector.detect(GpuMat src,
GpuMat lines,
Stream stream) |
void |
HoughCirclesDetector.detect(GpuMat src,
GpuMat circles,
Stream stream) |
void |
CannyEdgeDetector.detect(GpuMat image,
GpuMat edges,
Stream stream) |
void |
CornersDetector.detect(Mat image,
Mat corners,
Mat mask,
Stream stream)
\brief Determines strong corners on an image.
|
void |
CannyEdgeDetector.detect(Mat dx,
Mat dy,
Mat edges,
Stream stream)
\overload
|
void |
HoughSegmentDetector.detect(Mat src,
Mat lines,
Stream stream)
\brief Finds line segments in a binary image using the probabilistic Hough transform.
|
void |
HoughLinesDetector.detect(Mat src,
Mat lines,
Stream stream)
\brief Finds lines in a binary image using the classical Hough transform.
|
void |
HoughCirclesDetector.detect(Mat src,
Mat circles,
Stream stream)
\brief Finds circles in a grayscale image using the 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(UMat src,
UMat lines,
Stream stream) |
void |
HoughLinesDetector.detect(UMat src,
UMat lines,
Stream stream) |
void |
HoughCirclesDetector.detect(UMat src,
UMat circles,
Stream stream) |
void |
CannyEdgeDetector.detect(UMat image,
UMat edges,
Stream stream) |
void |
CornersDetector.detect(UMat image,
UMat corners,
UMat mask,
Stream stream) |
void |
CannyEdgeDetector.detect(UMat dx,
UMat dy,
UMat edges,
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) |
static NvidiaOpticalFlow_1_0 |
NvidiaOpticalFlow_1_0.create(Size imageSize,
int perfPreset,
boolean enableTemporalHints,
boolean enableExternalHints,
boolean enableCostBuffer,
int gpuId,
Stream inputStream,
Stream outputStream)
\brief Instantiate NVIDIA Optical Flow
|
static NvidiaOpticalFlow_2_0 |
NvidiaOpticalFlow_2_0.create(Size imageSize,
int perfPreset,
int outputGridSize,
int hintGridSize,
boolean enableTemporalHints,
boolean enableExternalHints,
boolean enableCostBuffer,
int gpuId,
Stream inputStream,
Stream outputStream)
\brief Instantiate NVIDIA Optical Flow
|
static NvidiaOpticalFlow_2_0 |
NvidiaOpticalFlow_2_0.create(Size imageSize,
RectVector roiData,
int perfPreset,
int outputGridSize,
int hintGridSize,
boolean enableTemporalHints,
boolean enableExternalHints,
boolean enableCostBuffer,
int gpuId,
Stream inputStream,
Stream outputStream)
\brief Instantiate NVIDIA Optical Flow with ROI Feature
|
| 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 |
StereoSGM.compute_with_stream(GpuMat left,
GpuMat right,
GpuMat disparity,
Stream stream) |
void |
StereoSGM.compute_with_stream(Mat left,
Mat right,
Mat disparity,
Stream stream)
\brief Computes disparity map with specified CUDA Stream
|
void |
StereoSGM.compute_with_stream(UMat left,
UMat right,
UMat disparity,
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 © 2026. All rights reserved.