Modifier and Type | Method and Description |
---|---|
static void |
opencv_cudaarithm.abs(UMat src,
UMat dst) |
static void |
opencv_cudaarithm.abs(UMat src,
UMat dst,
Stream stream) |
static void |
opencv_cudaarithm.absdiff(UMat src1,
UMat src2,
UMat dst) |
static void |
opencv_core.absdiff(UMat src1,
UMat src2,
UMat dst) |
static void |
opencv_cudaarithm.absdiff(UMat src1,
UMat src2,
UMat dst,
Stream stream) |
static Scalar |
opencv_cudaarithm.absSum(UMat src) |
static Scalar |
opencv_cudaarithm.absSum(UMat src,
UMat mask) |
static void |
opencv_imgproc.accumulate(UMat src,
UMat dst) |
static void |
opencv_imgproc.accumulate(UMat src,
UMat dst,
UMat mask) |
static void |
opencv_imgproc.accumulateProduct(UMat src1,
UMat src2,
UMat dst) |
static void |
opencv_imgproc.accumulateProduct(UMat src1,
UMat src2,
UMat dst,
UMat mask) |
static void |
opencv_imgproc.accumulateSquare(UMat src,
UMat dst) |
static void |
opencv_imgproc.accumulateSquare(UMat src,
UMat dst,
UMat mask) |
static void |
opencv_imgproc.accumulateWeighted(UMat src,
UMat dst,
double alpha) |
static void |
opencv_imgproc.accumulateWeighted(UMat src,
UMat dst,
double alpha,
UMat mask) |
static void |
opencv_imgproc.adaptiveThreshold(UMat src,
UMat dst,
double maxValue,
int adaptiveMethod,
int thresholdType,
int blockSize,
double C) |
static void |
opencv_cudaarithm.add(UMat src1,
UMat src2,
UMat dst) |
static void |
opencv_core.add(UMat src1,
UMat src2,
UMat dst) |
static void |
opencv_core.add(UMat src1,
UMat src2,
UMat dst,
UMat mask,
int dtype) |
static void |
opencv_cudaarithm.add(UMat src1,
UMat src2,
UMat dst,
UMat mask,
int dtype,
Stream stream) |
static void |
opencv_cudaarithm.addWeighted(UMat src1,
double alpha,
UMat src2,
double beta,
double gamma,
UMat dst) |
static void |
opencv_core.addWeighted(UMat src1,
double alpha,
UMat src2,
double beta,
double gamma,
UMat dst) |
static void |
opencv_core.addWeighted(UMat src1,
double alpha,
UMat src2,
double beta,
double gamma,
UMat dst,
int dtype) |
static void |
opencv_cudaarithm.addWeighted(UMat src1,
double alpha,
UMat src2,
double beta,
double gamma,
UMat dst,
int dtype,
Stream stream) |
static void |
opencv_features2d.AGAST(UMat image,
KeyPointVector keypoints,
int threshold) |
static void |
opencv_features2d.AGAST(UMat image,
KeyPointVector keypoints,
int threshold,
boolean nonmaxSuppression) |
static void |
opencv_features2d.AGAST(UMat image,
KeyPointVector keypoints,
int threshold,
boolean nonmaxSuppression,
int type) |
static void |
opencv_cudaimgproc.alphaComp(UMat img1,
UMat img2,
UMat dst,
int alpha_op) |
static void |
opencv_cudaimgproc.alphaComp(UMat img1,
UMat img2,
UMat dst,
int alpha_op,
Stream stream) |
static void |
opencv_ximgproc.amFilter(UMat joint,
UMat src,
UMat dst,
double sigma_s,
double sigma_r) |
static void |
opencv_ximgproc.amFilter(UMat joint,
UMat src,
UMat dst,
double sigma_s,
double sigma_r,
boolean adjust_outliers) |
static void |
opencv_ximgproc.anisotropicDiffusion(UMat src,
UMat dst,
float alpha,
float K,
int niters) |
static void |
opencv_xphoto.applyChannelGains(UMat src,
UMat dst,
float gainB,
float gainG,
float gainR) |
static void |
opencv_imgproc.applyColorMap(UMat src,
UMat dst,
int colormap) |
static void |
opencv_imgproc.applyColorMap(UMat src,
UMat dst,
UMat userColor) |
static void |
opencv_imgproc.approxPolyDP(UMat curve,
UMat approxCurve,
double epsilon,
boolean closed) |
static double |
opencv_imgproc.arcLength(UMat curve,
boolean closed) |
static void |
opencv_imgproc.arrowedLine(UMat img,
Point pt1,
Point pt2,
Scalar color) |
static void |
opencv_imgproc.arrowedLine(UMat img,
Point pt1,
Point pt2,
Scalar color,
int thickness,
int line_type,
int shift,
double tipLength) |
static void |
opencv_img_hash.averageHash(UMat inputArr,
UMat outputArr) |
static void |
opencv_core.batchDistance(UMat src1,
UMat src2,
UMat dist,
int dtype,
UMat nidx) |
static void |
opencv_core.batchDistance(UMat src1,
UMat src2,
UMat dist,
int dtype,
UMat nidx,
int normType,
int K,
UMat mask,
int update,
boolean crosscheck) |
static void |
opencv_imgproc.bilateralFilter(UMat src,
UMat dst,
int d,
double sigmaColor,
double sigmaSpace) |
static void |
opencv_imgproc.bilateralFilter(UMat src,
UMat dst,
int d,
double sigmaColor,
double sigmaSpace,
int borderType) |
static void |
opencv_cudaimgproc.bilateralFilter(UMat src,
UMat dst,
int kernel_size,
float sigma_color,
float sigma_spatial) |
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_ximgproc.bilateralTextureFilter(UMat src,
UMat dst) |
static void |
opencv_ximgproc.bilateralTextureFilter(UMat src,
UMat dst,
int fr,
int numIter,
double sigmaAlpha,
double sigmaAvg) |
static void |
opencv_cudaarithm.bitwise_and(UMat src1,
UMat src2,
UMat dst) |
static void |
opencv_core.bitwise_and(UMat src1,
UMat src2,
UMat dst) |
static void |
opencv_core.bitwise_and(UMat src1,
UMat src2,
UMat dst,
UMat mask) |
static void |
opencv_cudaarithm.bitwise_and(UMat src1,
UMat src2,
UMat dst,
UMat mask,
Stream stream) |
static void |
opencv_cudaarithm.bitwise_not(UMat src,
UMat dst) |
static void |
opencv_core.bitwise_not(UMat src,
UMat dst) |
static void |
opencv_core.bitwise_not(UMat src,
UMat dst,
UMat mask) |
static void |
opencv_cudaarithm.bitwise_not(UMat src,
UMat dst,
UMat mask,
Stream stream) |
static void |
opencv_cudaarithm.bitwise_or(UMat src1,
UMat src2,
UMat dst) |
static void |
opencv_core.bitwise_or(UMat src1,
UMat src2,
UMat dst) |
static void |
opencv_core.bitwise_or(UMat src1,
UMat src2,
UMat dst,
UMat mask) |
static void |
opencv_cudaarithm.bitwise_or(UMat src1,
UMat src2,
UMat dst,
UMat mask,
Stream stream) |
static void |
opencv_cudaarithm.bitwise_xor(UMat src1,
UMat src2,
UMat dst) |
static void |
opencv_core.bitwise_xor(UMat src1,
UMat src2,
UMat dst) |
static void |
opencv_core.bitwise_xor(UMat src1,
UMat src2,
UMat dst,
UMat mask) |
static void |
opencv_cudaarithm.bitwise_xor(UMat src1,
UMat src2,
UMat dst,
UMat mask,
Stream stream) |
static void |
opencv_imgproc.blendLinear(UMat src1,
UMat src2,
UMat weights1,
UMat weights2,
UMat dst) |
static void |
opencv_cudaimgproc.blendLinear(UMat img1,
UMat img2,
UMat weights1,
UMat weights2,
UMat result) |
static void |
opencv_cudaimgproc.blendLinear(UMat img1,
UMat img2,
UMat weights1,
UMat weights2,
UMat result,
Stream stream) |
static Mat |
opencv_dnn.blobFromImage(UMat image) |
static Mat |
opencv_dnn.blobFromImage(UMat image,
double scalefactor,
Size size,
Scalar mean,
boolean swapRB,
boolean crop,
int ddepth) |
static void |
opencv_dnn.blobFromImage(UMat image,
UMat blob) |
static void |
opencv_dnn.blobFromImage(UMat image,
UMat blob,
double scalefactor,
Size size,
Scalar mean,
boolean swapRB,
boolean crop,
int ddepth) |
static void |
opencv_dnn.blobFromImages(GpuMatVector images,
UMat blob) |
static void |
opencv_dnn.blobFromImages(GpuMatVector images,
UMat blob,
double scalefactor,
Size size,
Scalar mean,
boolean swapRB,
boolean crop,
int ddepth) |
static void |
opencv_dnn.blobFromImages(MatVector images,
UMat blob) |
static void |
opencv_dnn.blobFromImages(MatVector images,
UMat blob,
double scalefactor,
Size size,
Scalar mean,
boolean swapRB,
boolean crop,
int ddepth) |
static void |
opencv_dnn.blobFromImages(UMatVector images,
UMat blob) |
static void |
opencv_dnn.blobFromImages(UMatVector images,
UMat blob,
double scalefactor,
Size size,
Scalar mean,
boolean swapRB,
boolean crop,
int ddepth) |
static void |
opencv_img_hash.blockMeanHash(UMat inputArr,
UMat outputArr) |
static void |
opencv_img_hash.blockMeanHash(UMat inputArr,
UMat outputArr,
int mode) |
static void |
opencv_imgproc.blur(UMat src,
UMat dst,
Size ksize) |
static void |
opencv_imgproc.blur(UMat src,
UMat dst,
Size ksize,
Point anchor,
int borderType) |
static void |
opencv_xphoto.bm3dDenoising(UMat src,
UMat dst) |
static void |
opencv_xphoto.bm3dDenoising(UMat src,
UMat dst,
float h,
int templateWindowSize,
int searchWindowSize,
int blockMatchingStep1,
int blockMatchingStep2,
int groupSize,
int slidingStep,
float beta,
int normType,
int step,
int transformType) |
static void |
opencv_xphoto.bm3dDenoising(UMat src,
UMat dstStep1,
UMat dstStep2) |
static void |
opencv_xphoto.bm3dDenoising(UMat src,
UMat dstStep1,
UMat dstStep2,
float h,
int templateWindowSize,
int searchWindowSize,
int blockMatchingStep1,
int blockMatchingStep2,
int groupSize,
int slidingStep,
float beta,
int normType,
int step,
int transformType) |
static Rect |
opencv_imgproc.boundingRect(UMat array) |
static void |
opencv_imgproc.boxFilter(UMat src,
UMat dst,
int ddepth,
Size ksize) |
static void |
opencv_imgproc.boxFilter(UMat src,
UMat dst,
int ddepth,
Size ksize,
Point anchor,
boolean normalize,
int borderType) |
static void |
opencv_imgproc.boxPoints(RotatedRect box,
UMat points) |
static int |
opencv_video.buildOpticalFlowPyramid(UMat img,
GpuMatVector pyramid,
Size winSize,
int maxLevel) |
static int |
opencv_video.buildOpticalFlowPyramid(UMat img,
GpuMatVector pyramid,
Size winSize,
int maxLevel,
boolean withDerivatives,
int pyrBorder,
int derivBorder,
boolean tryReuseInputImage) |
static int |
opencv_video.buildOpticalFlowPyramid(UMat img,
MatVector pyramid,
Size winSize,
int maxLevel) |
static int |
opencv_video.buildOpticalFlowPyramid(UMat img,
MatVector pyramid,
Size winSize,
int maxLevel,
boolean withDerivatives,
int pyrBorder,
int derivBorder,
boolean tryReuseInputImage) |
static int |
opencv_video.buildOpticalFlowPyramid(UMat img,
UMatVector pyramid,
Size winSize,
int maxLevel) |
static int |
opencv_video.buildOpticalFlowPyramid(UMat img,
UMatVector pyramid,
Size winSize,
int maxLevel,
boolean withDerivatives,
int pyrBorder,
int derivBorder,
boolean tryReuseInputImage) |
static void |
opencv_core.buildOptionsAddMatrixDescription(BytePointer buildOptions,
BytePointer name,
UMat _m) |
static void |
opencv_core.buildOptionsAddMatrixDescription(String buildOptions,
String name,
UMat _m) |
static void |
opencv_imgproc.buildPyramid(UMat src,
GpuMatVector dst,
int maxlevel) |
static void |
opencv_imgproc.buildPyramid(UMat src,
GpuMatVector dst,
int maxlevel,
int borderType) |
static void |
opencv_imgproc.buildPyramid(UMat src,
MatVector dst,
int maxlevel) |
static void |
opencv_imgproc.buildPyramid(UMat src,
MatVector dst,
int maxlevel,
int borderType) |
static void |
opencv_imgproc.buildPyramid(UMat src,
UMatVector dst,
int maxlevel) |
static void |
opencv_imgproc.buildPyramid(UMat src,
UMatVector dst,
int maxlevel,
int borderType) |
static void |
opencv_cudawarping.buildWarpAffineMaps(UMat M,
boolean inverse,
Size dsize,
GpuMat xmap,
GpuMat ymap) |
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) |
static void |
opencv_cudawarping.buildWarpAffineMaps(UMat M,
boolean inverse,
Size dsize,
UMat xmap,
UMat ymap,
Stream stream) |
static void |
opencv_cudawarping.buildWarpPerspectiveMaps(UMat M,
boolean inverse,
Size dsize,
GpuMat xmap,
GpuMat ymap) |
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) |
static void |
opencv_cudawarping.buildWarpPerspectiveMaps(UMat M,
boolean inverse,
Size dsize,
UMat xmap,
UMat ymap,
Stream stream) |
static void |
opencv_cudaarithm.calcAbsSum(UMat src,
UMat dst) |
static void |
opencv_cudaarithm.calcAbsSum(UMat src,
UMat dst,
UMat mask,
Stream stream) |
static void |
opencv_imgproc.calcBackProject(GpuMatVector images,
int[] channels,
UMat hist,
UMat dst,
float[] ranges,
double scale) |
static void |
opencv_imgproc.calcBackProject(Mat images,
int nimages,
int[] channels,
SparseMat hist,
UMat backProject,
float[] ranges) |
static void |
opencv_imgproc.calcBackProject(Mat images,
int nimages,
int[] channels,
SparseMat hist,
UMat backProject,
float[] ranges,
double scale,
boolean uniform) |
static void |
opencv_imgproc.calcBackProject(Mat images,
int nimages,
int[] channels,
UMat hist,
UMat backProject,
float[] ranges) |
static void |
opencv_imgproc.calcBackProject(Mat images,
int nimages,
int[] channels,
UMat hist,
UMat backProject,
float[] ranges,
double scale,
boolean uniform) |
static void |
opencv_imgproc.calcBackProject(Mat images,
int nimages,
IntBuffer channels,
SparseMat hist,
UMat backProject,
FloatBuffer ranges) |
static void |
opencv_imgproc.calcBackProject(Mat images,
int nimages,
IntBuffer channels,
SparseMat hist,
UMat backProject,
FloatBuffer ranges,
double scale,
boolean uniform) |
static void |
opencv_imgproc.calcBackProject(Mat images,
int nimages,
IntBuffer channels,
UMat hist,
UMat backProject,
FloatBuffer ranges) |
static void |
opencv_imgproc.calcBackProject(Mat images,
int nimages,
IntBuffer channels,
UMat hist,
UMat backProject,
FloatBuffer ranges,
double scale,
boolean uniform) |
static void |
opencv_imgproc.calcBackProject(Mat images,
int nimages,
IntPointer channels,
SparseMat hist,
UMat backProject,
FloatPointer ranges) |
static void |
opencv_imgproc.calcBackProject(Mat images,
int nimages,
IntPointer channels,
SparseMat hist,
UMat backProject,
FloatPointer ranges,
double scale,
boolean uniform) |
static void |
opencv_imgproc.calcBackProject(Mat images,
int nimages,
IntPointer channels,
UMat hist,
UMat backProject,
FloatPointer ranges) |
static void |
opencv_imgproc.calcBackProject(Mat images,
int nimages,
IntPointer channels,
UMat hist,
UMat backProject,
FloatPointer ranges,
double scale,
boolean uniform) |
static void |
opencv_imgproc.calcBackProject(MatVector images,
IntPointer channels,
UMat hist,
UMat dst,
FloatPointer ranges,
double scale) |
static void |
opencv_imgproc.calcBackProject(UMatVector images,
IntBuffer channels,
UMat hist,
UMat dst,
FloatBuffer ranges,
double scale) |
static void |
opencv_core.calcCovarMatrix(UMat samples,
UMat covar,
UMat mean,
int flags) |
static void |
opencv_core.calcCovarMatrix(UMat samples,
UMat covar,
UMat mean,
int flags,
int ctype) |
static double |
opencv_optflow.calcGlobalOrientation(UMat orientation,
UMat mask,
UMat mhi,
double timestamp,
double duration) |
static void |
opencv_imgproc.calcHist(GpuMatVector images,
int[] channels,
UMat mask,
UMat hist,
int[] histSize,
float[] ranges) |
static void |
opencv_imgproc.calcHist(GpuMatVector images,
int[] channels,
UMat mask,
UMat hist,
int[] histSize,
float[] ranges,
boolean accumulate) |
static void |
opencv_imgproc.calcHist(Mat images,
int nimages,
int[] channels,
UMat mask,
SparseMat hist,
int dims,
int[] histSize,
float[] ranges) |
static void |
opencv_imgproc.calcHist(Mat images,
int nimages,
int[] channels,
UMat mask,
SparseMat hist,
int dims,
int[] histSize,
float[] ranges,
boolean uniform,
boolean accumulate) |
static void |
opencv_imgproc.calcHist(Mat images,
int nimages,
int[] channels,
UMat mask,
UMat hist,
int dims,
int[] histSize,
float[] ranges) |
static void |
opencv_imgproc.calcHist(Mat images,
int nimages,
int[] channels,
UMat mask,
UMat hist,
int dims,
int[] histSize,
float[] ranges,
boolean uniform,
boolean accumulate) |
static void |
opencv_imgproc.calcHist(Mat images,
int nimages,
IntBuffer channels,
UMat mask,
SparseMat hist,
int dims,
IntBuffer histSize,
FloatBuffer ranges) |
static void |
opencv_imgproc.calcHist(Mat images,
int nimages,
IntBuffer channels,
UMat mask,
SparseMat hist,
int dims,
IntBuffer histSize,
FloatBuffer ranges,
boolean uniform,
boolean accumulate) |
static void |
opencv_imgproc.calcHist(Mat images,
int nimages,
IntBuffer channels,
UMat mask,
UMat hist,
int dims,
IntBuffer histSize,
FloatBuffer ranges) |
static void |
opencv_imgproc.calcHist(Mat images,
int nimages,
IntBuffer channels,
UMat mask,
UMat hist,
int dims,
IntBuffer histSize,
FloatBuffer ranges,
boolean uniform,
boolean accumulate) |
static void |
opencv_imgproc.calcHist(Mat images,
int nimages,
IntPointer channels,
UMat mask,
SparseMat hist,
int dims,
IntPointer histSize,
FloatPointer ranges) |
static void |
opencv_imgproc.calcHist(Mat images,
int nimages,
IntPointer channels,
UMat mask,
SparseMat hist,
int dims,
IntPointer histSize,
FloatPointer ranges,
boolean uniform,
boolean accumulate) |
static void |
opencv_imgproc.calcHist(Mat images,
int nimages,
IntPointer channels,
UMat mask,
UMat hist,
int dims,
IntPointer histSize,
FloatPointer ranges) |
static void |
opencv_imgproc.calcHist(Mat images,
int nimages,
IntPointer channels,
UMat mask,
UMat hist,
int dims,
IntPointer histSize,
FloatPointer ranges,
boolean uniform,
boolean accumulate) |
static void |
opencv_imgproc.calcHist(MatVector images,
IntPointer channels,
UMat mask,
UMat hist,
IntPointer histSize,
FloatPointer ranges) |
static void |
opencv_imgproc.calcHist(MatVector images,
IntPointer channels,
UMat mask,
UMat hist,
IntPointer histSize,
FloatPointer ranges,
boolean accumulate) |
static void |
opencv_cudaimgproc.calcHist(UMat src,
UMat hist) |
static void |
opencv_cudaimgproc.calcHist(UMat src,
UMat hist,
Stream stream) |
static void |
opencv_cudaimgproc.calcHist(UMat src,
UMat mask,
UMat hist) |
static void |
opencv_cudaimgproc.calcHist(UMat src,
UMat mask,
UMat hist,
Stream stream) |
static void |
opencv_imgproc.calcHist(UMatVector images,
IntBuffer channels,
UMat mask,
UMat hist,
IntBuffer histSize,
FloatBuffer ranges) |
static void |
opencv_imgproc.calcHist(UMatVector images,
IntBuffer channels,
UMat mask,
UMat hist,
IntBuffer histSize,
FloatBuffer ranges,
boolean accumulate) |
static void |
opencv_optflow.calcMotionGradient(UMat mhi,
UMat mask,
UMat orientation,
double delta1,
double delta2) |
static void |
opencv_optflow.calcMotionGradient(UMat mhi,
UMat mask,
UMat orientation,
double delta1,
double delta2,
int apertureSize) |
static void |
opencv_cudaarithm.calcNorm(UMat src,
UMat dst,
int normType) |
static void |
opencv_cudaarithm.calcNorm(UMat src,
UMat dst,
int normType,
UMat mask,
Stream stream) |
static void |
opencv_cudaarithm.calcNormDiff(UMat src1,
UMat src2,
UMat dst) |
static void |
opencv_cudaarithm.calcNormDiff(UMat src1,
UMat src2,
UMat dst,
int normType,
Stream stream) |
static void |
opencv_video.calcOpticalFlowFarneback(UMat prev,
UMat next,
UMat flow,
double pyr_scale,
int levels,
int winsize,
int iterations,
int poly_n,
double poly_sigma,
int flags) |
static void |
opencv_video.calcOpticalFlowPyrLK(UMat prevImg,
UMat nextImg,
UMat prevPts,
UMat nextPts,
UMat status,
UMat err) |
static void |
opencv_video.calcOpticalFlowPyrLK(UMat prevImg,
UMat nextImg,
UMat prevPts,
UMat nextPts,
UMat status,
UMat err,
Size winSize,
int maxLevel,
TermCriteria criteria,
int flags,
double minEigThreshold) |
static void |
opencv_optflow.calcOpticalFlowSF(UMat from,
UMat to,
UMat flow,
int layers,
int averaging_block_size,
int max_flow) |
static void |
opencv_optflow.calcOpticalFlowSF(UMat from,
UMat to,
UMat flow,
int layers,
int averaging_block_size,
int max_flow,
double sigma_dist,
double sigma_color,
int postprocess_window,
double sigma_dist_fix,
double sigma_color_fix,
double occ_thr,
int upscale_averaging_radius,
double upscale_sigma_dist,
double upscale_sigma_color,
double speed_up_thr) |
static void |
opencv_optflow.calcOpticalFlowSparseToDense(UMat from,
UMat to,
UMat flow) |
static void |
opencv_optflow.calcOpticalFlowSparseToDense(UMat from,
UMat to,
UMat flow,
int grid_step,
int k,
float sigma,
boolean use_post_proc,
float fgs_lambda,
float fgs_sigma) |
static void |
opencv_cudaarithm.calcSqrSum(UMat src,
UMat dst) |
static void |
opencv_cudaarithm.calcSqrSum(UMat src,
UMat dst,
UMat mask,
Stream stream) |
static void |
opencv_cudaarithm.calcSum(UMat src,
UMat dst) |
static void |
opencv_cudaarithm.calcSum(UMat src,
UMat dst,
UMat mask,
Stream stream) |
static double |
opencv_calib3d.calibrate(GpuMatVector objectPoints,
GpuMatVector imagePoints,
Size image_size,
UMat K,
UMat D,
GpuMatVector rvecs,
GpuMatVector tvecs) |
static double |
opencv_calib3d.calibrate(GpuMatVector objectPoints,
GpuMatVector imagePoints,
Size image_size,
UMat K,
UMat D,
GpuMatVector rvecs,
GpuMatVector tvecs,
int flags,
TermCriteria criteria) |
static double |
opencv_calib3d.calibrate(MatVector objectPoints,
MatVector imagePoints,
Size image_size,
UMat K,
UMat D,
MatVector rvecs,
MatVector tvecs) |
static double |
opencv_calib3d.calibrate(MatVector objectPoints,
MatVector imagePoints,
Size image_size,
UMat K,
UMat D,
MatVector rvecs,
MatVector tvecs,
int flags,
TermCriteria criteria) |
static double |
opencv_calib3d.calibrate(UMatVector objectPoints,
UMatVector imagePoints,
Size image_size,
UMat K,
UMat D,
UMatVector rvecs,
UMatVector tvecs) |
static double |
opencv_calib3d.calibrate(UMatVector objectPoints,
UMatVector imagePoints,
Size image_size,
UMat K,
UMat D,
UMatVector rvecs,
UMatVector tvecs,
int flags,
TermCriteria criteria) |
static double |
opencv_aruco.calibrateCameraAruco(GpuMatVector corners,
UMat ids,
UMat counter,
Board board,
Size imageSize,
UMat cameraMatrix,
UMat distCoeffs) |
static double |
opencv_aruco.calibrateCameraAruco(GpuMatVector corners,
UMat ids,
UMat counter,
Board board,
Size imageSize,
UMat cameraMatrix,
UMat distCoeffs,
GpuMatVector rvecs,
GpuMatVector tvecs,
int flags,
TermCriteria criteria) |
static double |
opencv_aruco.calibrateCameraAruco(MatVector corners,
UMat ids,
UMat counter,
Board board,
Size imageSize,
UMat cameraMatrix,
UMat distCoeffs) |
static double |
opencv_aruco.calibrateCameraAruco(MatVector corners,
UMat ids,
UMat counter,
Board board,
Size imageSize,
UMat cameraMatrix,
UMat distCoeffs,
MatVector rvecs,
MatVector tvecs,
int flags,
TermCriteria criteria) |
static double |
opencv_aruco.calibrateCameraAruco(UMatVector corners,
UMat ids,
UMat counter,
Board board,
Size imageSize,
UMat cameraMatrix,
UMat distCoeffs) |
static double |
opencv_aruco.calibrateCameraAruco(UMatVector corners,
UMat ids,
UMat counter,
Board board,
Size imageSize,
UMat cameraMatrix,
UMat distCoeffs,
UMatVector rvecs,
UMatVector tvecs,
int flags,
TermCriteria criteria) |
static double |
opencv_aruco.calibrateCameraArucoExtended(GpuMatVector corners,
UMat ids,
UMat counter,
Board board,
Size imageSize,
UMat cameraMatrix,
UMat distCoeffs,
GpuMatVector rvecs,
GpuMatVector tvecs,
UMat stdDeviationsIntrinsics,
UMat stdDeviationsExtrinsics,
UMat perViewErrors) |
static double |
opencv_aruco.calibrateCameraArucoExtended(GpuMatVector corners,
UMat ids,
UMat counter,
Board board,
Size imageSize,
UMat cameraMatrix,
UMat distCoeffs,
GpuMatVector rvecs,
GpuMatVector tvecs,
UMat stdDeviationsIntrinsics,
UMat stdDeviationsExtrinsics,
UMat perViewErrors,
int flags,
TermCriteria criteria) |
static double |
opencv_aruco.calibrateCameraArucoExtended(MatVector corners,
UMat ids,
UMat counter,
Board board,
Size imageSize,
UMat cameraMatrix,
UMat distCoeffs,
MatVector rvecs,
MatVector tvecs,
UMat stdDeviationsIntrinsics,
UMat stdDeviationsExtrinsics,
UMat perViewErrors) |
static double |
opencv_aruco.calibrateCameraArucoExtended(MatVector corners,
UMat ids,
UMat counter,
Board board,
Size imageSize,
UMat cameraMatrix,
UMat distCoeffs,
MatVector rvecs,
MatVector tvecs,
UMat stdDeviationsIntrinsics,
UMat stdDeviationsExtrinsics,
UMat perViewErrors,
int flags,
TermCriteria criteria) |
static double |
opencv_aruco.calibrateCameraArucoExtended(UMatVector corners,
UMat ids,
UMat counter,
Board board,
Size imageSize,
UMat cameraMatrix,
UMat distCoeffs,
UMatVector rvecs,
UMatVector tvecs,
UMat stdDeviationsIntrinsics,
UMat stdDeviationsExtrinsics,
UMat perViewErrors) |
static double |
opencv_aruco.calibrateCameraArucoExtended(UMatVector corners,
UMat ids,
UMat counter,
Board board,
Size imageSize,
UMat cameraMatrix,
UMat distCoeffs,
UMatVector rvecs,
UMatVector tvecs,
UMat stdDeviationsIntrinsics,
UMat stdDeviationsExtrinsics,
UMat perViewErrors,
int flags,
TermCriteria criteria) |
static double |
opencv_aruco.calibrateCameraCharuco(GpuMatVector charucoCorners,
GpuMatVector charucoIds,
CharucoBoard board,
Size imageSize,
UMat cameraMatrix,
UMat distCoeffs) |
static double |
opencv_aruco.calibrateCameraCharuco(GpuMatVector charucoCorners,
GpuMatVector charucoIds,
CharucoBoard board,
Size imageSize,
UMat cameraMatrix,
UMat distCoeffs,
GpuMatVector rvecs,
GpuMatVector tvecs,
int flags,
TermCriteria criteria) |
static double |
opencv_aruco.calibrateCameraCharuco(MatVector charucoCorners,
MatVector charucoIds,
CharucoBoard board,
Size imageSize,
UMat cameraMatrix,
UMat distCoeffs) |
static double |
opencv_aruco.calibrateCameraCharuco(MatVector charucoCorners,
MatVector charucoIds,
CharucoBoard board,
Size imageSize,
UMat cameraMatrix,
UMat distCoeffs,
MatVector rvecs,
MatVector tvecs,
int flags,
TermCriteria criteria) |
static double |
opencv_aruco.calibrateCameraCharuco(UMatVector charucoCorners,
UMatVector charucoIds,
CharucoBoard board,
Size imageSize,
UMat cameraMatrix,
UMat distCoeffs) |
static double |
opencv_aruco.calibrateCameraCharuco(UMatVector charucoCorners,
UMatVector charucoIds,
CharucoBoard board,
Size imageSize,
UMat cameraMatrix,
UMat distCoeffs,
UMatVector rvecs,
UMatVector tvecs,
int flags,
TermCriteria criteria) |
static double |
opencv_aruco.calibrateCameraCharucoExtended(GpuMatVector charucoCorners,
GpuMatVector charucoIds,
CharucoBoard board,
Size imageSize,
UMat cameraMatrix,
UMat distCoeffs,
GpuMatVector rvecs,
GpuMatVector tvecs,
UMat stdDeviationsIntrinsics,
UMat stdDeviationsExtrinsics,
UMat perViewErrors) |
static double |
opencv_aruco.calibrateCameraCharucoExtended(GpuMatVector charucoCorners,
GpuMatVector charucoIds,
CharucoBoard board,
Size imageSize,
UMat cameraMatrix,
UMat distCoeffs,
GpuMatVector rvecs,
GpuMatVector tvecs,
UMat stdDeviationsIntrinsics,
UMat stdDeviationsExtrinsics,
UMat perViewErrors,
int flags,
TermCriteria criteria) |
static double |
opencv_aruco.calibrateCameraCharucoExtended(MatVector charucoCorners,
MatVector charucoIds,
CharucoBoard board,
Size imageSize,
UMat cameraMatrix,
UMat distCoeffs,
MatVector rvecs,
MatVector tvecs,
UMat stdDeviationsIntrinsics,
UMat stdDeviationsExtrinsics,
UMat perViewErrors) |
static double |
opencv_aruco.calibrateCameraCharucoExtended(MatVector charucoCorners,
MatVector charucoIds,
CharucoBoard board,
Size imageSize,
UMat cameraMatrix,
UMat distCoeffs,
MatVector rvecs,
MatVector tvecs,
UMat stdDeviationsIntrinsics,
UMat stdDeviationsExtrinsics,
UMat perViewErrors,
int flags,
TermCriteria criteria) |
static double |
opencv_aruco.calibrateCameraCharucoExtended(UMatVector charucoCorners,
UMatVector charucoIds,
CharucoBoard board,
Size imageSize,
UMat cameraMatrix,
UMat distCoeffs,
UMatVector rvecs,
UMatVector tvecs,
UMat stdDeviationsIntrinsics,
UMat stdDeviationsExtrinsics,
UMat perViewErrors) |
static double |
opencv_aruco.calibrateCameraCharucoExtended(UMatVector charucoCorners,
UMatVector charucoIds,
CharucoBoard board,
Size imageSize,
UMat cameraMatrix,
UMat distCoeffs,
UMatVector rvecs,
UMatVector tvecs,
UMat stdDeviationsIntrinsics,
UMat stdDeviationsExtrinsics,
UMat perViewErrors,
int flags,
TermCriteria criteria) |
static void |
opencv_calib3d.calibrateHandEye(GpuMatVector R_gripper2base,
GpuMatVector t_gripper2base,
GpuMatVector R_target2cam,
GpuMatVector t_target2cam,
UMat R_cam2gripper,
UMat t_cam2gripper) |
static void |
opencv_calib3d.calibrateHandEye(GpuMatVector R_gripper2base,
GpuMatVector t_gripper2base,
GpuMatVector R_target2cam,
GpuMatVector t_target2cam,
UMat R_cam2gripper,
UMat t_cam2gripper,
int method) |
static void |
opencv_calib3d.calibrateHandEye(MatVector R_gripper2base,
MatVector t_gripper2base,
MatVector R_target2cam,
MatVector t_target2cam,
UMat R_cam2gripper,
UMat t_cam2gripper) |
static void |
opencv_calib3d.calibrateHandEye(MatVector R_gripper2base,
MatVector t_gripper2base,
MatVector R_target2cam,
MatVector t_target2cam,
UMat R_cam2gripper,
UMat t_cam2gripper,
int method) |
static void |
opencv_calib3d.calibrateHandEye(UMatVector R_gripper2base,
UMatVector t_gripper2base,
UMatVector R_target2cam,
UMatVector t_target2cam,
UMat R_cam2gripper,
UMat t_cam2gripper) |
static void |
opencv_calib3d.calibrateHandEye(UMatVector R_gripper2base,
UMatVector t_gripper2base,
UMatVector R_target2cam,
UMatVector t_target2cam,
UMat R_cam2gripper,
UMat t_cam2gripper,
int method) |
static void |
opencv_calib3d.calibrationMatrixValues(UMat cameraMatrix,
Size imageSize,
double apertureWidth,
double apertureHeight,
double[] fovx,
double[] fovy,
double[] focalLength,
Point2d principalPoint,
double[] aspectRatio) |
static void |
opencv_calib3d.calibrationMatrixValues(UMat cameraMatrix,
Size imageSize,
double apertureWidth,
double apertureHeight,
DoubleBuffer fovx,
DoubleBuffer fovy,
DoubleBuffer focalLength,
Point2d principalPoint,
DoubleBuffer aspectRatio) |
static void |
opencv_calib3d.calibrationMatrixValues(UMat cameraMatrix,
Size imageSize,
double apertureWidth,
double apertureHeight,
DoublePointer fovx,
DoublePointer fovy,
DoublePointer focalLength,
Point2d principalPoint,
DoublePointer aspectRatio) |
static RotatedRect |
opencv_video.CamShift(UMat probImage,
Rect window,
TermCriteria criteria) |
static void |
opencv_imgproc.Canny(UMat image,
UMat edges,
double threshold1,
double threshold2) |
static void |
opencv_imgproc.Canny(UMat image,
UMat edges,
double threshold1,
double threshold2,
int apertureSize,
boolean L2gradient) |
static void |
opencv_imgproc.Canny(UMat dx,
UMat dy,
UMat edges,
double threshold1,
double threshold2) |
static void |
opencv_imgproc.Canny(UMat dx,
UMat dy,
UMat edges,
double threshold1,
double threshold2,
boolean L2gradient) |
static void |
opencv_cudaarithm.cartToPolar(UMat x,
UMat y,
UMat magnitude,
UMat angle) |
static void |
opencv_core.cartToPolar(UMat x,
UMat y,
UMat magnitude,
UMat angle) |
static void |
opencv_core.cartToPolar(UMat x,
UMat y,
UMat magnitude,
UMat angle,
boolean angleInDegrees) |
static void |
opencv_cudaarithm.cartToPolar(UMat x,
UMat y,
UMat magnitude,
UMat angle,
boolean angleInDegrees,
Stream stream) |
static boolean |
opencv_calib3d.checkChessboard(UMat img,
Size size) |
static int |
opencv_core.checkOptimalVectorWidth(int[] vectorWidths,
UMat src1) |
static int |
opencv_core.checkOptimalVectorWidth(int[] vectorWidths,
UMat src1,
UMat src2,
UMat src3,
UMat src4,
UMat src5,
UMat src6,
UMat src7,
UMat src8,
UMat src9,
int strat) |
static int |
opencv_core.checkOptimalVectorWidth(IntBuffer vectorWidths,
UMat src1) |
static int |
opencv_core.checkOptimalVectorWidth(IntBuffer vectorWidths,
UMat src1,
UMat src2,
UMat src3,
UMat src4,
UMat src5,
UMat src6,
UMat src7,
UMat src8,
UMat src9,
int strat) |
static int |
opencv_core.checkOptimalVectorWidth(IntPointer vectorWidths,
UMat src1) |
static int |
opencv_core.checkOptimalVectorWidth(IntPointer vectorWidths,
UMat src1,
UMat src2,
UMat src3,
UMat src4,
UMat src5,
UMat src6,
UMat src7,
UMat src8,
UMat src9,
int strat) |
static boolean |
opencv_core.checkRange(UMat a) |
static boolean |
opencv_core.checkRange(UMat a,
boolean quiet,
Point pos,
double minVal,
double maxVal) |
static void |
opencv_imgproc.circle(UMat img,
Point center,
int radius,
Scalar color) |
static void |
opencv_imgproc.circle(UMat img,
Point center,
int radius,
Scalar color,
int thickness,
int lineType,
int shift) |
static void |
opencv_photo.colorChange(UMat src,
UMat mask,
UMat dst) |
static void |
opencv_photo.colorChange(UMat src,
UMat mask,
UMat dst,
float red_mul,
float green_mul,
float blue_mul) |
static void |
opencv_img_hash.colorMomentHash(UMat inputArr,
UMat outputArr) |
static void |
opencv_cudaarithm.compare(UMat src1,
UMat src2,
UMat dst,
int cmpop) |
static void |
opencv_core.compare(UMat src1,
UMat src2,
UMat dst,
int cmpop) |
static void |
opencv_cudaarithm.compare(UMat src1,
UMat src2,
UMat dst,
int cmpop,
Stream stream) |
static double |
opencv_imgproc.compareHist(UMat H1,
UMat H2,
int method) |
static void |
opencv_core.completeSymm(UMat m) |
static void |
opencv_core.completeSymm(UMat m,
boolean lowerToUpper) |
static void |
opencv_calib3d.composeRT(UMat rvec1,
UMat tvec1,
UMat rvec2,
UMat tvec2,
UMat rvec3,
UMat tvec3) |
static void |
opencv_calib3d.composeRT(UMat rvec1,
UMat tvec1,
UMat rvec2,
UMat tvec2,
UMat rvec3,
UMat tvec3,
UMat dr3dr1,
UMat dr3dt1,
UMat dr3dr2,
UMat dr3dt2,
UMat dt3dr1,
UMat dt3dt1,
UMat dt3dr2,
UMat dt3dt2) |
static double |
opencv_ximgproc.computeBadPixelPercent(UMat GT,
UMat src,
Rect ROI) |
static double |
opencv_ximgproc.computeBadPixelPercent(UMat GT,
UMat src,
Rect ROI,
int thresh) |
static void |
opencv_calib3d.computeCorrespondEpilines(UMat points,
int whichImage,
UMat F,
UMat lines) |
static double |
opencv_video.computeECC(UMat templateImage,
UMat inputImage) |
static double |
opencv_video.computeECC(UMat templateImage,
UMat inputImage,
UMat inputMask) |
static void |
opencv_stitching.computeImageFeatures2(Feature2D featuresFinder,
UMat image,
ImageFeatures features) |
static void |
opencv_stitching.computeImageFeatures2(Feature2D featuresFinder,
UMat image,
ImageFeatures features,
UMat mask) |
static double |
opencv_ximgproc.computeMSE(UMat GT,
UMat src,
Rect ROI) |
static void |
opencv_text.computeNMChannels(UMat _src,
GpuMatVector _channels) |
static void |
opencv_text.computeNMChannels(UMat _src,
GpuMatVector _channels,
int _mode) |
static void |
opencv_text.computeNMChannels(UMat _src,
MatVector _channels) |
static void |
opencv_text.computeNMChannels(UMat _src,
MatVector _channels,
int _mode) |
static void |
opencv_text.computeNMChannels(UMat _src,
UMatVector _channels) |
static void |
opencv_text.computeNMChannels(UMat _src,
UMatVector _channels,
int _mode) |
static int |
opencv_imgproc.connectedComponents(UMat image,
UMat labels) |
static int |
opencv_imgproc.connectedComponents(UMat image,
UMat labels,
int connectivity,
int ltype) |
static int |
opencv_imgproc.connectedComponentsWithAlgorithm(UMat image,
UMat labels,
int connectivity,
int ltype,
int ccltype) |
static int |
opencv_imgproc.connectedComponentsWithStats(UMat image,
UMat labels,
UMat stats,
UMat centroids) |
static int |
opencv_imgproc.connectedComponentsWithStats(UMat image,
UMat labels,
UMat stats,
UMat centroids,
int connectivity,
int ltype) |
static int |
opencv_imgproc.connectedComponentsWithStatsWithAlgorithm(UMat image,
UMat labels,
UMat stats,
UMat centroids,
int connectivity,
int ltype,
int ccltype) |
static double |
opencv_imgproc.contourArea(UMat contour) |
static double |
opencv_imgproc.contourArea(UMat contour,
boolean oriented) |
static void |
opencv_core.convertFp16(UMat src,
UMat dst) |
static void |
opencv_core.convertFromBuffer(Pointer cl_mem_buffer,
long step,
int rows,
int cols,
int type,
UMat dst)
\brief Convert OpenCL buffer to UMat
\note
OpenCL buffer (cl_mem_buffer) should contain 2D image data, compatible with OpenCV.
|
static void |
opencv_core.convertFromImage(Pointer cl_mem_image,
UMat dst)
\brief Convert OpenCL image2d_t to UMat
\note
OpenCL
image2d_t (cl_mem_image), should be compatible with OpenCV UMat formats. |
static void |
opencv_imgproc.convertMaps(UMat map1,
UMat map2,
UMat dstmap1,
UMat dstmap2,
int dstmap1type) |
static void |
opencv_imgproc.convertMaps(UMat map1,
UMat map2,
UMat dstmap1,
UMat dstmap2,
int dstmap1type,
boolean nninterpolation) |
static void |
opencv_calib3d.convertPointsFromHomogeneous(UMat src,
UMat dst) |
static void |
opencv_calib3d.convertPointsHomogeneous(UMat src,
UMat dst) |
static void |
opencv_calib3d.convertPointsToHomogeneous(UMat src,
UMat dst) |
static void |
opencv_core.convertScaleAbs(UMat src,
UMat dst) |
static void |
opencv_core.convertScaleAbs(UMat src,
UMat dst,
double alpha,
double beta) |
static void |
opencv_imgproc.convexHull(UMat points,
UMat hull) |
static void |
opencv_imgproc.convexHull(UMat points,
UMat hull,
boolean clockwise,
boolean returnPoints) |
static void |
opencv_imgproc.convexityDefects(UMat contour,
UMat convexhull,
UMat convexityDefects) |
static void |
opencv_cudaarithm.copyMakeBorder(UMat src,
UMat dst,
int top,
int bottom,
int left,
int right,
int borderType) |
static void |
opencv_core.copyMakeBorder(UMat src,
UMat dst,
int top,
int bottom,
int left,
int right,
int borderType) |
static void |
opencv_core.copyMakeBorder(UMat src,
UMat dst,
int top,
int bottom,
int left,
int right,
int borderType,
Scalar value) |
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_core.copyTo(UMat src,
UMat dst,
UMat mask) |
static void |
opencv_imgproc.cornerEigenValsAndVecs(UMat src,
UMat dst,
int blockSize,
int ksize) |
static void |
opencv_imgproc.cornerEigenValsAndVecs(UMat src,
UMat dst,
int blockSize,
int ksize,
int borderType) |
static void |
opencv_imgproc.cornerHarris(UMat src,
UMat dst,
int blockSize,
int ksize,
double k) |
static void |
opencv_imgproc.cornerHarris(UMat src,
UMat dst,
int blockSize,
int ksize,
double k,
int borderType) |
static void |
opencv_imgproc.cornerMinEigenVal(UMat src,
UMat dst,
int blockSize) |
static void |
opencv_imgproc.cornerMinEigenVal(UMat src,
UMat dst,
int blockSize,
int ksize,
int borderType) |
static void |
opencv_imgproc.cornerSubPix(UMat image,
UMat corners,
Size winSize,
Size zeroZone,
TermCriteria criteria) |
static void |
opencv_calib3d.correctMatches(UMat F,
UMat points1,
UMat points2,
UMat newPoints1,
UMat newPoints2) |
static int |
opencv_cudaarithm.countNonZero(UMat src) |
static int |
opencv_core.countNonZero(UMat src) |
static void |
opencv_cudaarithm.countNonZero(UMat src,
UMat dst) |
static void |
opencv_cudaarithm.countNonZero(UMat src,
UMat dst,
Stream stream) |
static void |
opencv_ximgproc.covarianceEstimation(UMat src,
UMat dst,
int windowRows,
int windowCols) |
static void |
opencv_ml.createConcentricSpheresTestSet(int nsamples,
int nfeatures,
int nclasses,
UMat samples,
UMat responses) |
static void |
opencv_core.createContinuous(int rows,
int cols,
int type,
UMat arr) |
static DTFilter |
opencv_ximgproc.createDTFilter(UMat guide,
double sigmaSpatial,
double sigmaColor) |
static DTFilter |
opencv_ximgproc.createDTFilter(UMat guide,
double sigmaSpatial,
double sigmaColor,
int mode,
int numIters) |
static FastBilateralSolverFilter |
opencv_ximgproc.createFastBilateralSolverFilter(UMat guide,
double sigma_spatial,
double sigma_luma,
double sigma_chroma) |
static FastBilateralSolverFilter |
opencv_ximgproc.createFastBilateralSolverFilter(UMat guide,
double sigma_spatial,
double sigma_luma,
double sigma_chroma,
double lambda,
int num_iter,
double max_tol) |
static FastGlobalSmootherFilter |
opencv_ximgproc.createFastGlobalSmootherFilter(UMat guide,
double lambda,
double sigma_color) |
static FastGlobalSmootherFilter |
opencv_ximgproc.createFastGlobalSmootherFilter(UMat guide,
double lambda,
double sigma_color,
double lambda_attenuation,
int num_iter) |
static GuidedFilter |
opencv_ximgproc.createGuidedFilter(UMat guide,
int radius,
double eps) |
static void |
opencv_imgproc.createHanningWindow(UMat dst,
Size winSize,
int type) |
static void |
opencv_stitching.createLaplacePyr(UMat img,
int num_levels,
UMatVector pyr) |
static void |
opencv_stitching.createLaplacePyrGpu(UMat img,
int num_levels,
UMatVector pyr) |
static Filter |
opencv_cudafilters.createLinearFilter(int srcType,
int dstType,
UMat kernel) |
static Filter |
opencv_cudafilters.createLinearFilter(int srcType,
int dstType,
UMat kernel,
Point anchor,
int borderMode,
Scalar borderVal) |
static LookUpTable |
opencv_cudaarithm.createLookUpTable(UMat lut) |
static Filter |
opencv_cudafilters.createMorphologyFilter(int op,
int srcType,
UMat kernel) |
static Filter |
opencv_cudafilters.createMorphologyFilter(int op,
int srcType,
UMat kernel,
Point anchor,
int iterations) |
static void |
opencv_text.createOCRHMMTransitionsTable(BytePointer vocabulary,
StringVector lexicon,
UMat transition_probabilities_table) |
static Filter |
opencv_cudafilters.createSeparableLinearFilter(int srcType,
int dstType,
UMat rowKernel,
UMat columnKernel) |
static Filter |
opencv_cudafilters.createSeparableLinearFilter(int srcType,
int dstType,
UMat rowKernel,
UMat columnKernel,
Point anchor,
int rowBorderMode,
int columnBorderMode) |
static SuperpixelLSC |
opencv_ximgproc.createSuperpixelLSC(UMat image) |
static SuperpixelLSC |
opencv_ximgproc.createSuperpixelLSC(UMat image,
int region_size,
float ratio) |
static SuperpixelSLIC |
opencv_ximgproc.createSuperpixelSLIC(UMat image) |
static SuperpixelSLIC |
opencv_ximgproc.createSuperpixelSLIC(UMat image,
int algorithm,
int region_size,
float ruler) |
static SyntheticSequenceGenerator |
opencv_bgsegm.createSyntheticSequenceGenerator(UMat background,
UMat object) |
static SyntheticSequenceGenerator |
opencv_bgsegm.createSyntheticSequenceGenerator(UMat background,
UMat object,
double amplitude,
double wavelength,
double wavespeed,
double objspeed) |
static void |
opencv_stitching.createWeightMap(UMat mask,
float sharpness,
UMat weight) |
static void |
opencv_imgproc.cvtColor(UMat src,
UMat dst,
int code) |
static void |
opencv_cudaimgproc.cvtColor(UMat src,
UMat dst,
int code) |
static void |
opencv_imgproc.cvtColor(UMat src,
UMat dst,
int code,
int dstCn) |
static void |
opencv_cudaimgproc.cvtColor(UMat src,
UMat dst,
int code,
int dcn,
Stream stream) |
static void |
opencv_imgproc.cvtColorTwoPlane(UMat src1,
UMat src2,
UMat dst,
int code) |
static void |
opencv_core.dct(UMat src,
UMat dst) |
static void |
opencv_core.dct(UMat src,
UMat dst,
int flags) |
static void |
opencv_photo.decolor(UMat src,
UMat grayscale,
UMat color_boost) |
static void |
opencv_calib3d.decomposeEssentialMat(UMat E,
UMat R1,
UMat R2,
UMat t) |
static int |
opencv_calib3d.decomposeHomographyMat(UMat H,
UMat K,
GpuMatVector rotations,
GpuMatVector translations,
GpuMatVector normals) |
static int |
opencv_calib3d.decomposeHomographyMat(UMat H,
UMat K,
MatVector rotations,
MatVector translations,
MatVector normals) |
static int |
opencv_calib3d.decomposeHomographyMat(UMat H,
UMat K,
UMatVector rotations,
UMatVector translations,
UMatVector normals) |
static void |
opencv_calib3d.decomposeProjectionMatrix(UMat projMatrix,
UMat cameraMatrix,
UMat rotMatrix,
UMat transVect) |
static void |
opencv_calib3d.decomposeProjectionMatrix(UMat projMatrix,
UMat cameraMatrix,
UMat rotMatrix,
UMat transVect,
UMat rotMatrixX,
UMat rotMatrixY,
UMat rotMatrixZ,
UMat eulerAngles) |
static void |
opencv_imgproc.demosaicing(UMat src,
UMat dst,
int code) |
static void |
opencv_cudaimgproc.demosaicing(UMat src,
UMat dst,
int code) |
static void |
opencv_imgproc.demosaicing(UMat src,
UMat dst,
int code,
int dstCn) |
static void |
opencv_cudaimgproc.demosaicing(UMat src,
UMat dst,
int code,
int dcn,
Stream stream) |
static void |
opencv_photo.detailEnhance(UMat src,
UMat dst) |
static void |
opencv_photo.detailEnhance(UMat src,
UMat dst,
float sigma_s,
float sigma_r) |
static void |
opencv_aruco.detectCharucoDiamond(UMat image,
GpuMatVector markerCorners,
UMat markerIds,
float squareMarkerLengthRate,
GpuMatVector diamondCorners,
UMat diamondIds) |
static void |
opencv_aruco.detectCharucoDiamond(UMat image,
GpuMatVector markerCorners,
UMat markerIds,
float squareMarkerLengthRate,
GpuMatVector diamondCorners,
UMat diamondIds,
UMat cameraMatrix,
UMat distCoeffs) |
static void |
opencv_aruco.detectCharucoDiamond(UMat image,
MatVector markerCorners,
UMat markerIds,
float squareMarkerLengthRate,
MatVector diamondCorners,
UMat diamondIds) |
static void |
opencv_aruco.detectCharucoDiamond(UMat image,
MatVector markerCorners,
UMat markerIds,
float squareMarkerLengthRate,
MatVector diamondCorners,
UMat diamondIds,
UMat cameraMatrix,
UMat distCoeffs) |
static void |
opencv_aruco.detectCharucoDiamond(UMat image,
UMatVector markerCorners,
UMat markerIds,
float squareMarkerLengthRate,
UMatVector diamondCorners,
UMat diamondIds) |
static void |
opencv_aruco.detectCharucoDiamond(UMat image,
UMatVector markerCorners,
UMat markerIds,
float squareMarkerLengthRate,
UMatVector diamondCorners,
UMat diamondIds,
UMat cameraMatrix,
UMat distCoeffs) |
static void |
opencv_aruco.detectMarkers(UMat image,
Dictionary dictionary,
GpuMatVector corners,
UMat ids) |
static void |
opencv_aruco.detectMarkers(UMat image,
Dictionary dictionary,
GpuMatVector corners,
UMat ids,
DetectorParameters parameters,
GpuMatVector rejectedImgPoints,
UMat cameraMatrix,
UMat distCoeff) |
static void |
opencv_aruco.detectMarkers(UMat image,
Dictionary dictionary,
MatVector corners,
UMat ids) |
static void |
opencv_aruco.detectMarkers(UMat image,
Dictionary dictionary,
MatVector corners,
UMat ids,
DetectorParameters parameters,
MatVector rejectedImgPoints,
UMat cameraMatrix,
UMat distCoeff) |
static void |
opencv_aruco.detectMarkers(UMat image,
Dictionary dictionary,
UMatVector corners,
UMat ids) |
static void |
opencv_aruco.detectMarkers(UMat image,
Dictionary dictionary,
UMatVector corners,
UMat ids,
DetectorParameters parameters,
UMatVector rejectedImgPoints,
UMat cameraMatrix,
UMat distCoeff) |
static void |
opencv_text.detectRegions(UMat image,
ERFilter er_filter1,
ERFilter er_filter2,
PointVectorVector regions) |
static void |
opencv_text.detectRegions(UMat image,
ERFilter er_filter1,
ERFilter er_filter2,
RectVector groups_rects) |
static void |
opencv_text.detectRegions(UMat image,
ERFilter er_filter1,
ERFilter er_filter2,
RectVector groups_rects,
int method,
BytePointer filename,
float minProbability) |
static void |
opencv_text.detectRegions(UMat image,
ERFilter er_filter1,
ERFilter er_filter2,
RectVector groups_rects,
int method,
String filename,
float minProbability) |
static double |
opencv_core.determinant(UMat mtx) |
static void |
opencv_core.dft(UMat src,
UMat dst) |
static void |
opencv_core.dft(UMat src,
UMat dst,
int flags,
int nonzeroRows) |
static void |
opencv_cudaarithm.dft(UMat src,
UMat dst,
Size dft_size) |
static void |
opencv_cudaarithm.dft(UMat src,
UMat dst,
Size dft_size,
int flags,
Stream stream) |
static void |
opencv_imgproc.dilate(UMat src,
UMat dst,
UMat kernel) |
static void |
opencv_imgproc.dilate(UMat src,
UMat dst,
UMat kernel,
Point anchor,
int iterations,
int borderType,
Scalar borderValue) |
static void |
opencv_imgproc.distanceTransform(UMat src,
UMat dst,
int distanceType,
int maskSize) |
static void |
opencv_imgproc.distanceTransform(UMat src,
UMat dst,
int distanceType,
int maskSize,
int dstType) |
static void |
opencv_imgproc.distanceTransformWithLabels(UMat src,
UMat dst,
UMat labels,
int distanceType,
int maskSize) |
static void |
opencv_imgproc.distanceTransformWithLabels(UMat src,
UMat dst,
UMat labels,
int distanceType,
int maskSize,
int labelType) |
static void |
opencv_calib3d.distortPoints(UMat undistorted,
UMat distorted,
UMat K,
UMat D) |
static void |
opencv_calib3d.distortPoints(UMat undistorted,
UMat distorted,
UMat K,
UMat D,
double alpha) |
static void |
opencv_core.divide(double scale,
UMat src2,
UMat dst) |
static void |
opencv_core.divide(double scale,
UMat src2,
UMat dst,
int dtype) |
static void |
opencv_cudaarithm.divide(UMat src1,
UMat src2,
UMat dst) |
static void |
opencv_core.divide(UMat src1,
UMat src2,
UMat dst) |
static void |
opencv_core.divide(UMat src1,
UMat src2,
UMat dst,
double scale,
int dtype) |
static void |
opencv_cudaarithm.divide(UMat src1,
UMat src2,
UMat dst,
double scale,
int dtype,
Stream stream) |
static void |
opencv_aruco.drawAxis(UMat image,
UMat cameraMatrix,
UMat distCoeffs,
UMat rvec,
UMat tvec,
float length) |
static void |
opencv_aruco.drawCharucoDiamond(Dictionary dictionary,
Scalar4i ids,
int squareLength,
int markerLength,
UMat img) |
static void |
opencv_aruco.drawCharucoDiamond(Dictionary dictionary,
Scalar4i ids,
int squareLength,
int markerLength,
UMat img,
int marginSize,
int borderBits) |
static void |
opencv_calib3d.drawChessboardCorners(UMat image,
Size patternSize,
UMat corners,
boolean patternWasFound) |
static void |
opencv_cudastereo.drawColorDisp(UMat src_disp,
UMat dst_disp,
int ndisp) |
static void |
opencv_cudastereo.drawColorDisp(UMat src_disp,
UMat dst_disp,
int ndisp,
Stream stream) |
static void |
opencv_imgproc.drawContours(UMat image,
GpuMatVector contours,
int contourIdx,
Scalar color) |
static void |
opencv_imgproc.drawContours(UMat image,
GpuMatVector contours,
int contourIdx,
Scalar color,
int thickness,
int lineType,
UMat hierarchy,
int maxLevel,
Point offset) |
static void |
opencv_imgproc.drawContours(UMat image,
MatVector contours,
int contourIdx,
Scalar color) |
static void |
opencv_imgproc.drawContours(UMat image,
MatVector contours,
int contourIdx,
Scalar color,
int thickness,
int lineType,
UMat hierarchy,
int maxLevel,
Point offset) |
static void |
opencv_imgproc.drawContours(UMat image,
UMatVector contours,
int contourIdx,
Scalar color) |
static void |
opencv_imgproc.drawContours(UMat image,
UMatVector contours,
int contourIdx,
Scalar color,
int thickness,
int lineType,
UMat hierarchy,
int maxLevel,
Point offset) |
static void |
opencv_rapid.drawCorrespondencies(UMat bundle,
UMat srcLocations,
UMat newLocations) |
static void |
opencv_rapid.drawCorrespondencies(UMat bundle,
UMat srcLocations,
UMat newLocations,
UMat colors) |
static void |
opencv_aruco.drawDetectedCornersCharuco(UMat image,
UMat charucoCorners) |
static void |
opencv_aruco.drawDetectedCornersCharuco(UMat image,
UMat charucoCorners,
UMat charucoIds,
Scalar cornerColor) |
static void |
opencv_aruco.drawDetectedDiamonds(UMat image,
GpuMatVector diamondCorners) |
static void |
opencv_aruco.drawDetectedDiamonds(UMat image,
GpuMatVector diamondCorners,
UMat diamondIds,
Scalar borderColor) |
static void |
opencv_aruco.drawDetectedDiamonds(UMat image,
MatVector diamondCorners) |
static void |
opencv_aruco.drawDetectedDiamonds(UMat image,
MatVector diamondCorners,
UMat diamondIds,
Scalar borderColor) |
static void |
opencv_aruco.drawDetectedDiamonds(UMat image,
UMatVector diamondCorners) |
static void |
opencv_aruco.drawDetectedDiamonds(UMat image,
UMatVector diamondCorners,
UMat diamondIds,
Scalar borderColor) |
static void |
opencv_aruco.drawDetectedMarkers(UMat image,
GpuMatVector corners) |
static void |
opencv_aruco.drawDetectedMarkers(UMat image,
GpuMatVector corners,
UMat ids,
Scalar borderColor) |
static void |
opencv_aruco.drawDetectedMarkers(UMat image,
MatVector corners) |
static void |
opencv_aruco.drawDetectedMarkers(UMat image,
MatVector corners,
UMat ids,
Scalar borderColor) |
static void |
opencv_aruco.drawDetectedMarkers(UMat image,
UMatVector corners) |
static void |
opencv_aruco.drawDetectedMarkers(UMat image,
UMatVector corners,
UMat ids,
Scalar borderColor) |
static void |
opencv_calib3d.drawFrameAxes(UMat image,
UMat cameraMatrix,
UMat distCoeffs,
UMat rvec,
UMat tvec,
float length) |
static void |
opencv_calib3d.drawFrameAxes(UMat image,
UMat cameraMatrix,
UMat distCoeffs,
UMat rvec,
UMat tvec,
float length,
int thickness) |
static void |
opencv_features2d.drawKeypoints(UMat image,
KeyPointVector keypoints,
UMat outImage) |
static void |
opencv_features2d.drawKeypoints(UMat image,
KeyPointVector keypoints,
UMat outImage,
Scalar color,
int flags) |
static void |
opencv_aruco.drawMarker(Dictionary dictionary,
int id,
int sidePixels,
UMat img) |
static void |
opencv_aruco.drawMarker(Dictionary dictionary,
int id,
int sidePixels,
UMat img,
int borderBits) |
static void |
opencv_imgproc.drawMarker(UMat img,
Point _position,
Scalar color) |
static void |
opencv_imgproc.drawMarker(UMat img,
Point _position,
Scalar color,
int markerType,
int markerSize,
int thickness,
int line_type) |
static void |
opencv_features2d.drawMatches(UMat img1,
KeyPointVector keypoints1,
UMat img2,
KeyPointVector keypoints2,
DMatchVector matches1to2,
UMat outImg) |
static void |
opencv_features2d.drawMatches(UMat img1,
KeyPointVector keypoints1,
UMat img2,
KeyPointVector keypoints2,
DMatchVector matches1to2,
UMat outImg,
Scalar matchColor,
Scalar singlePointColor,
byte[] matchesMask,
int flags) |
static void |
opencv_features2d.drawMatches(UMat img1,
KeyPointVector keypoints1,
UMat img2,
KeyPointVector keypoints2,
DMatchVector matches1to2,
UMat outImg,
Scalar matchColor,
Scalar singlePointColor,
ByteBuffer matchesMask,
int flags) |
static void |
opencv_features2d.drawMatches(UMat img1,
KeyPointVector keypoints1,
UMat img2,
KeyPointVector keypoints2,
DMatchVector matches1to2,
UMat outImg,
Scalar matchColor,
Scalar singlePointColor,
BytePointer matchesMask,
int flags) |
static void |
opencv_features2d.drawMatchesKnn(UMat img1,
KeyPointVector keypoints1,
UMat img2,
KeyPointVector keypoints2,
DMatchVectorVector matches1to2,
UMat outImg) |
static void |
opencv_features2d.drawMatchesKnn(UMat img1,
KeyPointVector keypoints1,
UMat img2,
KeyPointVector keypoints2,
DMatchVectorVector matches1to2,
UMat outImg,
Scalar matchColor,
Scalar singlePointColor,
ByteVectorVector matchesMask,
int flags) |
static void |
opencv_aruco.drawPlanarBoard(Board board,
Size outSize,
UMat img) |
static void |
opencv_aruco.drawPlanarBoard(Board board,
Size outSize,
UMat img,
int marginSize,
int borderBits) |
static void |
opencv_rapid.drawSearchLines(UMat img,
UMat locations,
Scalar color) |
static void |
opencv_rapid.drawWireframe(UMat img,
UMat pts2d,
UMat tris,
Scalar color) |
static void |
opencv_rapid.drawWireframe(UMat img,
UMat pts2d,
UMat tris,
Scalar color,
int type,
boolean cullBackface) |
static void |
opencv_ximgproc.dtFilter(UMat guide,
UMat src,
UMat dst,
double sigmaSpatial,
double sigmaColor) |
static void |
opencv_ximgproc.dtFilter(UMat guide,
UMat src,
UMat dst,
double sigmaSpatial,
double sigmaColor,
int mode,
int numIters) |
static void |
opencv_photo.edgePreservingFilter(UMat src,
UMat dst) |
static void |
opencv_photo.edgePreservingFilter(UMat src,
UMat dst,
int flags,
float sigma_s,
float sigma_r) |
static boolean |
opencv_core.eigen(UMat src,
UMat eigenvalues) |
static boolean |
opencv_core.eigen(UMat src,
UMat eigenvalues,
UMat eigenvectors) |
static void |
opencv_core.eigenNonSymmetric(UMat src,
UMat eigenvalues,
UMat eigenvectors) |
static void |
opencv_imgproc.ellipse(UMat img,
Point center,
Size axes,
double angle,
double startAngle,
double endAngle,
Scalar color) |
static void |
opencv_imgproc.ellipse(UMat img,
Point center,
Size axes,
double angle,
double startAngle,
double endAngle,
Scalar color,
int thickness,
int lineType,
int shift) |
static void |
opencv_imgproc.ellipse(UMat img,
RotatedRect box,
Scalar color) |
static void |
opencv_imgproc.ellipse(UMat img,
RotatedRect box,
Scalar color,
int thickness,
int lineType) |
static float |
opencv_imgproc.EMD(UMat signature1,
UMat signature2,
int distType) |
static float |
opencv_imgproc.EMD(UMat signature1,
UMat signature2,
int distType,
UMat cost,
float[] lowerBound,
UMat flow) |
static float |
opencv_imgproc.EMD(UMat signature1,
UMat signature2,
int distType,
UMat cost,
FloatBuffer lowerBound,
UMat flow) |
static float |
opencv_imgproc.EMD(UMat signature1,
UMat signature2,
int distType,
UMat cost,
FloatPointer lowerBound,
UMat flow) |
static float |
opencv_shape.EMDL1(UMat signature1,
UMat signature2) |
static void |
opencv_core.ensureSizeIsEnough(int rows,
int cols,
int type,
UMat arr) |
static void |
opencv_imgproc.equalizeHist(UMat src,
UMat dst) |
static void |
opencv_cudaimgproc.equalizeHist(UMat src,
UMat dst) |
static void |
opencv_cudaimgproc.equalizeHist(UMat src,
UMat dst,
Stream stream) |
static void |
opencv_text.erGrouping(UMat img,
GpuMatVector channels,
ERStatVectorVector regions,
PointVectorVector groups,
RectVector groups_rects) |
static void |
opencv_text.erGrouping(UMat img,
GpuMatVector channels,
ERStatVectorVector regions,
PointVectorVector groups,
RectVector groups_rects,
int method,
BytePointer filename,
float minProbablity) |
static void |
opencv_text.erGrouping(UMat img,
GpuMatVector channels,
ERStatVectorVector regions,
PointVectorVector groups,
RectVector groups_rects,
int method,
String filename,
float minProbablity) |
static void |
opencv_text.erGrouping(UMat img,
MatVector channels,
ERStatVectorVector regions,
PointVectorVector groups,
RectVector groups_rects) |
static void |
opencv_text.erGrouping(UMat img,
MatVector channels,
ERStatVectorVector regions,
PointVectorVector groups,
RectVector groups_rects,
int method,
BytePointer filename,
float minProbablity) |
static void |
opencv_text.erGrouping(UMat img,
MatVector channels,
ERStatVectorVector regions,
PointVectorVector groups,
RectVector groups_rects,
int method,
String filename,
float minProbablity) |
static void |
opencv_text.erGrouping(UMat image,
UMat channel,
PointVectorVector regions,
RectVector groups_rects) |
static void |
opencv_text.erGrouping(UMat image,
UMat channel,
PointVectorVector regions,
RectVector groups_rects,
int method,
BytePointer filename,
float minProbablity) |
static void |
opencv_text.erGrouping(UMat image,
UMat channel,
PointVectorVector regions,
RectVector groups_rects,
int method,
String filename,
float minProbablity) |
static void |
opencv_text.erGrouping(UMat img,
UMatVector channels,
ERStatVectorVector regions,
PointVectorVector groups,
RectVector groups_rects) |
static void |
opencv_text.erGrouping(UMat img,
UMatVector channels,
ERStatVectorVector regions,
PointVectorVector groups,
RectVector groups_rects,
int method,
BytePointer filename,
float minProbablity) |
static void |
opencv_text.erGrouping(UMat img,
UMatVector channels,
ERStatVectorVector regions,
PointVectorVector groups,
RectVector groups_rects,
int method,
String filename,
float minProbablity) |
static void |
opencv_imgproc.erode(UMat src,
UMat dst,
UMat kernel) |
static void |
opencv_imgproc.erode(UMat src,
UMat dst,
UMat kernel,
Point anchor,
int iterations,
int borderType,
Scalar borderValue) |
static Mat |
opencv_calib3d.estimateAffine2D(UMat from,
UMat to) |
static Mat |
opencv_calib3d.estimateAffine2D(UMat from,
UMat to,
UMat inliers,
int method,
double ransacReprojThreshold,
long maxIters,
double confidence,
long refineIters) |
static int |
opencv_calib3d.estimateAffine3D(UMat src,
UMat dst,
UMat out,
UMat inliers) |
static int |
opencv_calib3d.estimateAffine3D(UMat src,
UMat dst,
UMat out,
UMat inliers,
double ransacThreshold,
double confidence) |
static Mat |
opencv_calib3d.estimateAffinePartial2D(UMat from,
UMat to) |
static Mat |
opencv_calib3d.estimateAffinePartial2D(UMat from,
UMat to,
UMat inliers,
int method,
double ransacReprojThreshold,
long maxIters,
double confidence,
long refineIters) |
static Scalar |
opencv_calib3d.estimateChessboardSharpness(UMat image,
Size patternSize,
UMat corners) |
static Scalar |
opencv_calib3d.estimateChessboardSharpness(UMat image,
Size patternSize,
UMat corners,
float rise_distance,
boolean vertical,
UMat sharpness) |
static Mat |
opencv_videostab.estimateGlobalMotionLeastSquares(UMat points0,
UMat points1) |
static Mat |
opencv_videostab.estimateGlobalMotionLeastSquares(UMat points0,
UMat points1,
int model,
float[] rmse) |
static Mat |
opencv_videostab.estimateGlobalMotionLeastSquares(UMat points0,
UMat points1,
int model,
FloatBuffer rmse) |
static Mat |
opencv_videostab.estimateGlobalMotionLeastSquares(UMat points0,
UMat points1,
int model,
FloatPointer rmse) |
static Mat |
opencv_videostab.estimateGlobalMotionRansac(UMat points0,
UMat points1) |
static Mat |
opencv_videostab.estimateGlobalMotionRansac(UMat points0,
UMat points1,
int model,
RansacParams params,
float[] rmse,
int[] ninliers) |
static Mat |
opencv_videostab.estimateGlobalMotionRansac(UMat points0,
UMat points1,
int model,
RansacParams params,
FloatBuffer rmse,
IntBuffer ninliers) |
static Mat |
opencv_videostab.estimateGlobalMotionRansac(UMat points0,
UMat points1,
int model,
RansacParams params,
FloatPointer rmse,
IntPointer ninliers) |
static void |
opencv_calib3d.estimateNewCameraMatrixForUndistortRectify(UMat K,
UMat D,
Size image_size,
UMat R,
UMat P) |
static void |
opencv_calib3d.estimateNewCameraMatrixForUndistortRectify(UMat K,
UMat D,
Size image_size,
UMat R,
UMat P,
double balance,
Size new_size,
double fov_scale) |
static int |
opencv_aruco.estimatePoseBoard(GpuMatVector corners,
UMat ids,
Board board,
UMat cameraMatrix,
UMat distCoeffs,
UMat rvec,
UMat tvec) |
static int |
opencv_aruco.estimatePoseBoard(GpuMatVector corners,
UMat ids,
Board board,
UMat cameraMatrix,
UMat distCoeffs,
UMat rvec,
UMat tvec,
boolean useExtrinsicGuess) |
static int |
opencv_aruco.estimatePoseBoard(MatVector corners,
UMat ids,
Board board,
UMat cameraMatrix,
UMat distCoeffs,
UMat rvec,
UMat tvec) |
static int |
opencv_aruco.estimatePoseBoard(MatVector corners,
UMat ids,
Board board,
UMat cameraMatrix,
UMat distCoeffs,
UMat rvec,
UMat tvec,
boolean useExtrinsicGuess) |
static int |
opencv_aruco.estimatePoseBoard(UMatVector corners,
UMat ids,
Board board,
UMat cameraMatrix,
UMat distCoeffs,
UMat rvec,
UMat tvec) |
static int |
opencv_aruco.estimatePoseBoard(UMatVector corners,
UMat ids,
Board board,
UMat cameraMatrix,
UMat distCoeffs,
UMat rvec,
UMat tvec,
boolean useExtrinsicGuess) |
static boolean |
opencv_aruco.estimatePoseCharucoBoard(UMat charucoCorners,
UMat charucoIds,
CharucoBoard board,
UMat cameraMatrix,
UMat distCoeffs,
UMat rvec,
UMat tvec) |
static boolean |
opencv_aruco.estimatePoseCharucoBoard(UMat charucoCorners,
UMat charucoIds,
CharucoBoard board,
UMat cameraMatrix,
UMat distCoeffs,
UMat rvec,
UMat tvec,
boolean useExtrinsicGuess) |
static void |
opencv_aruco.estimatePoseSingleMarkers(GpuMatVector corners,
float markerLength,
UMat cameraMatrix,
UMat distCoeffs,
UMat rvecs,
UMat tvecs) |
static void |
opencv_aruco.estimatePoseSingleMarkers(GpuMatVector corners,
float markerLength,
UMat cameraMatrix,
UMat distCoeffs,
UMat rvecs,
UMat tvecs,
UMat _objPoints) |
static void |
opencv_aruco.estimatePoseSingleMarkers(MatVector corners,
float markerLength,
UMat cameraMatrix,
UMat distCoeffs,
UMat rvecs,
UMat tvecs) |
static void |
opencv_aruco.estimatePoseSingleMarkers(MatVector corners,
float markerLength,
UMat cameraMatrix,
UMat distCoeffs,
UMat rvecs,
UMat tvecs,
UMat _objPoints) |
static void |
opencv_aruco.estimatePoseSingleMarkers(UMatVector corners,
float markerLength,
UMat cameraMatrix,
UMat distCoeffs,
UMat rvecs,
UMat tvecs) |
static void |
opencv_aruco.estimatePoseSingleMarkers(UMatVector corners,
float markerLength,
UMat cameraMatrix,
UMat distCoeffs,
UMat rvecs,
UMat tvecs,
UMat _objPoints) |
static Mat |
opencv_video.estimateRigidTransform(UMat src,
UMat dst,
boolean fullAffine)
Deprecated.
|
static void |
opencv_cudaimgproc.evenLevels(UMat levels,
int nLevels,
int lowerLevel,
int upperLevel) |
static void |
opencv_cudaimgproc.evenLevels(UMat levels,
int nLevels,
int lowerLevel,
int upperLevel,
Stream stream) |
static void |
opencv_cudaarithm.exp(UMat src,
UMat dst) |
static void |
opencv_core.exp(UMat src,
UMat dst) |
static void |
opencv_cudaarithm.exp(UMat src,
UMat dst,
Stream stream) |
static void |
opencv_core.extractChannel(UMat src,
UMat dst,
int coi) |
static void |
opencv_rapid.extractControlPoints(int num,
int len,
UMat pts3d,
UMat rvec,
UMat tvec,
UMat K,
Size imsize,
UMat tris,
UMat ctl2d,
UMat ctl3d) |
static void |
opencv_core.extractImageCOI(CvArr arr,
UMat coiimg) |
static void |
opencv_core.extractImageCOI(CvArr arr,
UMat coiimg,
int coi) |
static void |
opencv_rapid.extractLineBundle(int len,
UMat ctl2d,
UMat img,
UMat bundle,
UMat srcLocations) |
static void |
opencv_features2d.FAST(UMat image,
KeyPointVector keypoints,
int threshold) |
static void |
opencv_features2d.FAST(UMat image,
KeyPointVector keypoints,
int threshold,
boolean nonmaxSuppression) |
static void |
opencv_features2d.FAST(UMat image,
KeyPointVector keypoints,
int threshold,
boolean nonmaxSuppression,
int type) |
static void |
opencv_ximgproc.fastBilateralSolverFilter(UMat guide,
UMat src,
UMat confidence,
UMat dst) |
static void |
opencv_ximgproc.fastBilateralSolverFilter(UMat guide,
UMat src,
UMat confidence,
UMat dst,
double sigma_spatial,
double sigma_luma,
double sigma_chroma,
double lambda,
int num_iter,
double max_tol) |
static void |
opencv_xfeatures2d.FASTForPointSet(UMat image,
KeyPointVector keypoints,
int threshold) |
static void |
opencv_xfeatures2d.FASTForPointSet(UMat image,
KeyPointVector keypoints,
int threshold,
boolean nonmaxSuppression,
int type) |
static void |
opencv_ximgproc.fastGlobalSmootherFilter(UMat guide,
UMat src,
UMat dst,
double lambda,
double sigma_color) |
static void |
opencv_ximgproc.fastGlobalSmootherFilter(UMat guide,
UMat src,
UMat dst,
double lambda,
double sigma_color,
double lambda_attenuation,
int num_iter) |
static void |
opencv_ximgproc.FastHoughTransform(UMat src,
UMat dst,
int dstMatDepth) |
static void |
opencv_ximgproc.FastHoughTransform(UMat src,
UMat dst,
int dstMatDepth,
int angleRange,
int op,
int makeSkew) |
static void |
opencv_photo.fastNlMeansDenoising(UMat src,
UMat dst) |
static void |
opencv_photo.fastNlMeansDenoising(UMat src,
UMat dst,
float h) |
static void |
opencv_photo.fastNlMeansDenoising(UMat src,
UMat dst,
float[] h) |
static void |
opencv_photo.fastNlMeansDenoising(UMat src,
UMat dst,
float[] h,
int templateWindowSize,
int searchWindowSize,
int normType) |
static void |
opencv_photo.fastNlMeansDenoising(UMat src,
UMat dst,
FloatBuffer h) |
static void |
opencv_photo.fastNlMeansDenoising(UMat src,
UMat dst,
FloatBuffer h,
int templateWindowSize,
int searchWindowSize,
int normType) |
static void |
opencv_photo.fastNlMeansDenoising(UMat src,
UMat dst,
float h,
int templateWindowSize,
int searchWindowSize) |
static void |
opencv_photo.fastNlMeansDenoising(UMat src,
UMat dst,
float h,
int search_window,
int block_size,
Stream stream) |
static void |
opencv_photo.fastNlMeansDenoising(UMat src,
UMat dst,
FloatPointer h) |
static void |
opencv_photo.fastNlMeansDenoising(UMat src,
UMat dst,
FloatPointer h,
int templateWindowSize,
int searchWindowSize,
int normType) |
static void |
opencv_photo.fastNlMeansDenoisingColored(UMat src,
UMat dst) |
static void |
opencv_photo.fastNlMeansDenoisingColored(UMat src,
UMat dst,
float h_luminance,
float photo_render) |
static void |
opencv_photo.fastNlMeansDenoisingColored(UMat src,
UMat dst,
float h,
float hColor,
int templateWindowSize,
int searchWindowSize) |
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_photo.fastNlMeansDenoisingColoredMulti(GpuMatVector srcImgs,
UMat dst,
int imgToDenoiseIndex,
int temporalWindowSize) |
static void |
opencv_photo.fastNlMeansDenoisingColoredMulti(GpuMatVector srcImgs,
UMat dst,
int imgToDenoiseIndex,
int temporalWindowSize,
float h,
float hColor,
int templateWindowSize,
int searchWindowSize) |
static void |
opencv_photo.fastNlMeansDenoisingColoredMulti(MatVector srcImgs,
UMat dst,
int imgToDenoiseIndex,
int temporalWindowSize) |
static void |
opencv_photo.fastNlMeansDenoisingColoredMulti(MatVector srcImgs,
UMat dst,
int imgToDenoiseIndex,
int temporalWindowSize,
float h,
float hColor,
int templateWindowSize,
int searchWindowSize) |
static void |
opencv_photo.fastNlMeansDenoisingColoredMulti(UMatVector srcImgs,
UMat dst,
int imgToDenoiseIndex,
int temporalWindowSize) |
static void |
opencv_photo.fastNlMeansDenoisingColoredMulti(UMatVector srcImgs,
UMat dst,
int imgToDenoiseIndex,
int temporalWindowSize,
float h,
float hColor,
int templateWindowSize,
int searchWindowSize) |
static void |
opencv_photo.fastNlMeansDenoisingMulti(GpuMatVector srcImgs,
UMat dst,
int imgToDenoiseIndex,
int temporalWindowSize) |
static void |
opencv_photo.fastNlMeansDenoisingMulti(GpuMatVector srcImgs,
UMat dst,
int imgToDenoiseIndex,
int temporalWindowSize,
float[] h) |
static void |
opencv_photo.fastNlMeansDenoisingMulti(GpuMatVector srcImgs,
UMat dst,
int imgToDenoiseIndex,
int temporalWindowSize,
float[] h,
int templateWindowSize,
int searchWindowSize,
int normType) |
static void |
opencv_photo.fastNlMeansDenoisingMulti(GpuMatVector srcImgs,
UMat dst,
int imgToDenoiseIndex,
int temporalWindowSize,
float h,
int templateWindowSize,
int searchWindowSize) |
static void |
opencv_photo.fastNlMeansDenoisingMulti(MatVector srcImgs,
UMat dst,
int imgToDenoiseIndex,
int temporalWindowSize) |
static void |
opencv_photo.fastNlMeansDenoisingMulti(MatVector srcImgs,
UMat dst,
int imgToDenoiseIndex,
int temporalWindowSize,
float h,
int templateWindowSize,
int searchWindowSize) |
static void |
opencv_photo.fastNlMeansDenoisingMulti(MatVector srcImgs,
UMat dst,
int imgToDenoiseIndex,
int temporalWindowSize,
FloatPointer h) |
static void |
opencv_photo.fastNlMeansDenoisingMulti(MatVector srcImgs,
UMat dst,
int imgToDenoiseIndex,
int temporalWindowSize,
FloatPointer h,
int templateWindowSize,
int searchWindowSize,
int normType) |
static void |
opencv_photo.fastNlMeansDenoisingMulti(UMatVector srcImgs,
UMat dst,
int imgToDenoiseIndex,
int temporalWindowSize) |
static void |
opencv_photo.fastNlMeansDenoisingMulti(UMatVector srcImgs,
UMat dst,
int imgToDenoiseIndex,
int temporalWindowSize,
FloatBuffer h) |
static void |
opencv_photo.fastNlMeansDenoisingMulti(UMatVector srcImgs,
UMat dst,
int imgToDenoiseIndex,
int temporalWindowSize,
FloatBuffer h,
int templateWindowSize,
int searchWindowSize,
int normType) |
static void |
opencv_photo.fastNlMeansDenoisingMulti(UMatVector srcImgs,
UMat dst,
int imgToDenoiseIndex,
int temporalWindowSize,
float h,
int templateWindowSize,
int searchWindowSize) |
static void |
opencv_imgproc.fillConvexPoly(UMat img,
Point pts,
int npts,
Scalar color) |
static void |
opencv_imgproc.fillConvexPoly(UMat img,
Point pts,
int npts,
Scalar color,
int lineType,
int shift) |
static void |
opencv_imgproc.fillConvexPoly(UMat img,
UMat points,
Scalar color) |
static void |
opencv_imgproc.fillConvexPoly(UMat img,
UMat points,
Scalar color,
int lineType,
int shift) |
static void |
opencv_imgproc.fillPoly(UMat img,
GpuMatVector pts,
Scalar color) |
static void |
opencv_imgproc.fillPoly(UMat img,
GpuMatVector pts,
Scalar color,
int lineType,
int shift,
Point offset) |
static void |
opencv_imgproc.fillPoly(UMat img,
MatVector pts,
Scalar color) |
static void |
opencv_imgproc.fillPoly(UMat img,
MatVector pts,
Scalar color,
int lineType,
int shift,
Point offset) |
static void |
opencv_imgproc.fillPoly(UMat img,
Point pts,
int[] npts,
int ncontours,
Scalar color) |
static void |
opencv_imgproc.fillPoly(UMat img,
Point pts,
int[] npts,
int ncontours,
Scalar color,
int lineType,
int shift,
Point offset) |
static void |
opencv_imgproc.fillPoly(UMat img,
Point pts,
IntBuffer npts,
int ncontours,
Scalar color) |
static void |
opencv_imgproc.fillPoly(UMat img,
Point pts,
IntBuffer npts,
int ncontours,
Scalar color,
int lineType,
int shift,
Point offset) |
static void |
opencv_imgproc.fillPoly(UMat img,
Point pts,
IntPointer npts,
int ncontours,
Scalar color) |
static void |
opencv_imgproc.fillPoly(UMat img,
Point pts,
IntPointer npts,
int ncontours,
Scalar color,
int lineType,
int shift,
Point offset) |
static void |
opencv_imgproc.fillPoly(UMat img,
UMatVector pts,
Scalar color) |
static void |
opencv_imgproc.fillPoly(UMat img,
UMatVector pts,
Scalar color,
int lineType,
int shift,
Point offset) |
static void |
opencv_imgproc.filter2D(UMat src,
UMat dst,
int ddepth,
UMat kernel) |
static void |
opencv_imgproc.filter2D(UMat src,
UMat dst,
int ddepth,
UMat kernel,
Point anchor,
double delta,
int borderType) |
static void |
opencv_rapid.filterCorrespondencies(UMat pts2d,
UMat pts3d,
UMat mask) |
static void |
opencv_calib3d.filterHomographyDecompByVisibleRefpoints(GpuMatVector rotations,
GpuMatVector normals,
UMat beforePoints,
UMat afterPoints,
UMat possibleSolutions) |
static void |
opencv_calib3d.filterHomographyDecompByVisibleRefpoints(GpuMatVector rotations,
GpuMatVector normals,
UMat beforePoints,
UMat afterPoints,
UMat possibleSolutions,
UMat pointsMask) |
static void |
opencv_calib3d.filterHomographyDecompByVisibleRefpoints(MatVector rotations,
MatVector normals,
UMat beforePoints,
UMat afterPoints,
UMat possibleSolutions) |
static void |
opencv_calib3d.filterHomographyDecompByVisibleRefpoints(MatVector rotations,
MatVector normals,
UMat beforePoints,
UMat afterPoints,
UMat possibleSolutions,
UMat pointsMask) |
static void |
opencv_calib3d.filterHomographyDecompByVisibleRefpoints(UMatVector rotations,
UMatVector normals,
UMat beforePoints,
UMat afterPoints,
UMat possibleSolutions) |
static void |
opencv_calib3d.filterHomographyDecompByVisibleRefpoints(UMatVector rotations,
UMatVector normals,
UMat beforePoints,
UMat afterPoints,
UMat possibleSolutions,
UMat pointsMask) |
static void |
opencv_calib3d.filterSpeckles(UMat img,
double newVal,
int maxSpeckleSize,
double maxDiff) |
static void |
opencv_calib3d.filterSpeckles(UMat img,
double newVal,
int maxSpeckleSize,
double maxDiff,
UMat buf) |
static boolean |
opencv_calib3d.find4QuadCornerSubpix(UMat img,
UMat corners,
Size region_size) |
static boolean |
opencv_calib3d.findChessboardCorners(UMat image,
Size patternSize,
UMat corners) |
static boolean |
opencv_calib3d.findChessboardCorners(UMat image,
Size patternSize,
UMat corners,
int flags) |
static boolean |
opencv_calib3d.findChessboardCornersSB(UMat image,
Size patternSize,
UMat corners) |
static boolean |
opencv_calib3d.findChessboardCornersSB(UMat image,
Size patternSize,
UMat corners,
int flags) |
static boolean |
opencv_calib3d.findChessboardCornersSBWithMeta(UMat image,
Size patternSize,
UMat corners,
int flags,
UMat meta) |
static boolean |
opencv_calib3d.findCirclesGrid(UMat image,
Size patternSize,
UMat centers) |
static boolean |
opencv_calib3d.findCirclesGrid(UMat image,
Size patternSize,
UMat centers,
int flags,
Feature2D blobDetector) |
static boolean |
opencv_calib3d.findCirclesGrid(UMat image,
Size patternSize,
UMat centers,
int flags,
Feature2D blobDetector,
CirclesGridFinderParameters parameters) |
static void |
opencv_imgproc.findContours(UMat image,
GpuMatVector contours,
int mode,
int method) |
static void |
opencv_imgproc.findContours(UMat image,
GpuMatVector contours,
int mode,
int method,
Point offset) |
static void |
opencv_imgproc.findContours(UMat image,
GpuMatVector contours,
UMat hierarchy,
int mode,
int method) |
static void |
opencv_imgproc.findContours(UMat image,
GpuMatVector contours,
UMat hierarchy,
int mode,
int method,
Point offset) |
static void |
opencv_imgproc.findContours(UMat image,
MatVector contours,
int mode,
int method) |
static void |
opencv_imgproc.findContours(UMat image,
MatVector contours,
int mode,
int method,
Point offset) |
static void |
opencv_imgproc.findContours(UMat image,
MatVector contours,
UMat hierarchy,
int mode,
int method) |
static void |
opencv_imgproc.findContours(UMat image,
MatVector contours,
UMat hierarchy,
int mode,
int method,
Point offset) |
static void |
opencv_imgproc.findContours(UMat image,
UMatVector contours,
int mode,
int method) |
static void |
opencv_imgproc.findContours(UMat image,
UMatVector contours,
int mode,
int method,
Point offset) |
static void |
opencv_imgproc.findContours(UMat image,
UMatVector contours,
UMat hierarchy,
int mode,
int method) |
static void |
opencv_imgproc.findContours(UMat image,
UMatVector contours,
UMat hierarchy,
int mode,
int method,
Point offset) |
static void |
opencv_rapid.findCorrespondencies(UMat bundle,
UMat srcLocations,
UMat newLocations) |
static void |
opencv_rapid.findCorrespondencies(UMat bundle,
UMat srcLocations,
UMat newLocations,
UMat response) |
static Mat |
opencv_calib3d.findEssentialMat(UMat points1,
UMat points2) |
static Mat |
opencv_calib3d.findEssentialMat(UMat points1,
UMat points2,
double focal,
Point2d pp,
int method,
double prob,
double threshold,
UMat mask) |
static Mat |
opencv_calib3d.findEssentialMat(UMat points1,
UMat points2,
UMat cameraMatrix) |
static Mat |
opencv_calib3d.findEssentialMat(UMat points1,
UMat points2,
UMat cameraMatrix,
int method,
double prob,
double threshold,
UMat mask) |
static Mat |
opencv_calib3d.findFundamentalMat(UMat points1,
UMat points2) |
static Mat |
opencv_calib3d.findFundamentalMat(UMat points1,
UMat points2,
int method,
double ransacReprojThreshold,
double confidence,
int maxIters) |
static Mat |
opencv_calib3d.findFundamentalMat(UMat points1,
UMat points2,
int method,
double ransacReprojThreshold,
double confidence,
int maxIters,
UMat mask) |
static Mat |
opencv_calib3d.findFundamentalMat(UMat points1,
UMat points2,
int method,
double ransacReprojThreshold,
double confidence,
UMat mask) |
static Mat |
opencv_calib3d.findFundamentalMat(UMat points1,
UMat points2,
UMat mask) |
static Mat |
opencv_calib3d.findFundamentalMat(UMat points1,
UMat points2,
UMat mask,
int method,
double ransacReprojThreshold,
double confidence) |
static Mat |
opencv_calib3d.findHomography(UMat srcPoints,
UMat dstPoints) |
static Mat |
opencv_calib3d.findHomography(UMat srcPoints,
UMat dstPoints,
int method,
double ransacReprojThreshold,
UMat mask,
int maxIters,
double confidence) |
static Mat |
opencv_calib3d.findHomography(UMat srcPoints,
UMat dstPoints,
UMat mask) |
static Mat |
opencv_calib3d.findHomography(UMat srcPoints,
UMat dstPoints,
UMat mask,
int method,
double ransacReprojThreshold) |
static void |
opencv_cudaarithm.findMinMax(UMat src,
UMat dst) |
static void |
opencv_cudaarithm.findMinMax(UMat src,
UMat dst,
UMat mask,
Stream stream) |
static void |
opencv_cudaarithm.findMinMaxLoc(UMat src,
UMat minMaxVals,
UMat loc) |
static void |
opencv_cudaarithm.findMinMaxLoc(UMat src,
UMat minMaxVals,
UMat loc,
UMat mask,
Stream stream) |
static void |
opencv_core.findNonZero(UMat src,
UMat idx) |
static double |
opencv_video.findTransformECC(UMat templateImage,
UMat inputImage,
UMat warpMatrix) |
static double |
opencv_video.findTransformECC(UMat templateImage,
UMat inputImage,
UMat warpMatrix,
int motionType,
TermCriteria criteria,
UMat inputMask) |
static double |
opencv_video.findTransformECC(UMat templateImage,
UMat inputImage,
UMat warpMatrix,
int motionType,
TermCriteria criteria,
UMat inputMask,
int gaussFiltSize) |
static RotatedRect |
opencv_imgproc.fitEllipse(UMat points) |
static RotatedRect |
opencv_imgproc.fitEllipseAMS(UMat points) |
static RotatedRect |
opencv_imgproc.fitEllipseDirect(UMat points) |
static void |
opencv_imgproc.fitLine(UMat points,
UMat line,
int distType,
double param,
double reps,
double aeps) |
static void |
opencv_cudaarithm.flip(UMat src,
UMat dst,
int flipCode) |
static void |
opencv_core.flip(UMat src,
UMat dst,
int flipCode) |
static void |
opencv_cudaarithm.flip(UMat src,
UMat dst,
int flipCode,
Stream stream) |
static int |
opencv_imgproc.floodFill(UMat image,
Point seedPoint,
Scalar newVal) |
static int |
opencv_imgproc.floodFill(UMat image,
Point seedPoint,
Scalar newVal,
Rect rect,
Scalar loDiff,
Scalar upDiff,
int flags) |
static int |
opencv_imgproc.floodFill(UMat image,
UMat mask,
Point seedPoint,
Scalar newVal) |
static int |
opencv_imgproc.floodFill(UMat image,
UMat mask,
Point seedPoint,
Scalar newVal,
Rect rect,
Scalar loDiff,
Scalar upDiff,
int flags) |
static Formatted |
opencv_core.format(UMat mtx,
int fmt) |
static void |
opencv_cudaimgproc.gammaCorrection(UMat src,
UMat dst) |
static void |
opencv_cudaimgproc.gammaCorrection(UMat src,
UMat dst,
boolean forward,
Stream stream) |
static void |
opencv_imgproc.GaussianBlur(UMat src,
UMat dst,
Size ksize,
double sigmaX) |
static void |
opencv_imgproc.GaussianBlur(UMat src,
UMat dst,
Size ksize,
double sigmaX,
double sigmaY,
int borderType) |
static void |
opencv_cudaarithm.gemm(UMat src1,
UMat src2,
double alpha,
UMat src3,
double beta,
UMat dst) |
static void |
opencv_core.gemm(UMat src1,
UMat src2,
double alpha,
UMat src3,
double beta,
UMat dst) |
static void |
opencv_core.gemm(UMat src1,
UMat src2,
double alpha,
UMat src3,
double beta,
UMat dst,
int flags) |
static void |
opencv_cudaarithm.gemm(UMat src1,
UMat src2,
double alpha,
UMat src3,
double beta,
UMat dst,
int flags,
Stream stream) |
static Mat |
opencv_imgproc.getAffineTransform(UMat src,
UMat dst) |
static void |
opencv_aruco.getBoardObjectAndImagePoints(Board board,
GpuMatVector detectedCorners,
UMat detectedIds,
UMat objPoints,
UMat imgPoints) |
static void |
opencv_aruco.getBoardObjectAndImagePoints(Board board,
MatVector detectedCorners,
UMat detectedIds,
UMat objPoints,
UMat imgPoints) |
static void |
opencv_aruco.getBoardObjectAndImagePoints(Board board,
UMatVector detectedCorners,
UMat detectedIds,
UMat objPoints,
UMat imgPoints) |
static Mat |
opencv_calib3d.getDefaultNewCameraMatrix(UMat cameraMatrix) |
static Mat |
opencv_calib3d.getDefaultNewCameraMatrix(UMat cameraMatrix,
Size imgsize,
boolean centerPrincipalPoint) |
static void |
opencv_imgproc.getDerivKernels(UMat kx,
UMat ky,
int dx,
int dy,
int ksize) |
static void |
opencv_imgproc.getDerivKernels(UMat kx,
UMat ky,
int dx,
int dy,
int ksize,
boolean normalize,
int ktype) |
static void |
opencv_ximgproc.getDisparityVis(UMat src,
UMat dst) |
static void |
opencv_ximgproc.getDisparityVis(UMat src,
UMat dst,
double scale) |
static Mat |
opencv_calib3d.getOptimalNewCameraMatrix(UMat cameraMatrix,
UMat distCoeffs,
Size imageSize,
double alpha) |
static Mat |
opencv_calib3d.getOptimalNewCameraMatrix(UMat cameraMatrix,
UMat distCoeffs,
Size imageSize,
double alpha,
Size newImgSize,
Rect validPixROI,
boolean centerPrincipalPoint) |
static Mat |
opencv_imgproc.getPerspectiveTransform(UMat src,
UMat dst) |
static Mat |
opencv_imgproc.getPerspectiveTransform(UMat src,
UMat dst,
int solveMethod) |
static void |
opencv_imgproc.getRectSubPix(UMat image,
Size patchSize,
Point2f center,
UMat patch) |
static void |
opencv_imgproc.getRectSubPix(UMat image,
Size patchSize,
Point2f center,
UMat patch,
int patchType) |
static void |
opencv_imgproc.goodFeaturesToTrack(UMat image,
UMat corners,
int maxCorners,
double qualityLevel,
double minDistance) |
static void |
opencv_imgproc.goodFeaturesToTrack(UMat image,
UMat corners,
int maxCorners,
double qualityLevel,
double minDistance,
UMat mask,
int blockSize,
boolean useHarrisDetector,
double k) |
static void |
opencv_imgproc.goodFeaturesToTrack(UMat image,
UMat corners,
int maxCorners,
double qualityLevel,
double minDistance,
UMat mask,
int blockSize,
int gradientSize) |
static void |
opencv_imgproc.goodFeaturesToTrack(UMat image,
UMat corners,
int maxCorners,
double qualityLevel,
double minDistance,
UMat mask,
int blockSize,
int gradientSize,
boolean useHarrisDetector,
double k) |
static void |
opencv_imgproc.grabCut(UMat img,
UMat mask,
Rect rect,
UMat bgdModel,
UMat fgdModel,
int iterCount) |
static void |
opencv_imgproc.grabCut(UMat img,
UMat mask,
Rect rect,
UMat bgdModel,
UMat fgdModel,
int iterCount,
int mode) |
static void |
opencv_ximgproc.guidedFilter(UMat guide,
UMat src,
UMat dst,
int radius,
double eps) |
static void |
opencv_ximgproc.guidedFilter(UMat guide,
UMat src,
UMat dst,
int radius,
double eps,
int dDepth) |
static void |
opencv_core.hconcat(GpuMatVector src,
UMat dst) |
static void |
opencv_core.hconcat(Mat src,
long nsrc,
UMat dst) |
static void |
opencv_core.hconcat(MatVector src,
UMat dst) |
static void |
opencv_core.hconcat(UMat src1,
UMat src2,
UMat dst) |
static void |
opencv_core.hconcat(UMatVector src,
UMat dst) |
static void |
opencv_cudaimgproc.histEven(UMat src,
GpuMat hist,
int[] histSize,
int[] lowerLevel,
int[] upperLevel) |
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) |
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) |
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) |
static void |
opencv_cudaimgproc.histEven(UMat src,
UMat hist,
int histSize,
int lowerLevel,
int upperLevel,
Stream stream) |
static void |
opencv_cudaimgproc.histRange(UMat src,
GpuMat hist,
GpuMat levels) |
static void |
opencv_cudaimgproc.histRange(UMat src,
GpuMat hist,
GpuMat levels,
Stream stream) |
static void |
opencv_cudaimgproc.histRange(UMat src,
UMat hist,
UMat levels) |
static void |
opencv_cudaimgproc.histRange(UMat src,
UMat hist,
UMat levels,
Stream stream) |
static void |
opencv_imgproc.HoughLinesPointSet(UMat _point,
UMat _lines,
int lines_max,
int threshold,
double min_rho,
double max_rho,
double rho_step,
double min_theta,
double max_theta,
double theta_step) |
static Scalar4i |
opencv_ximgproc.HoughPoint2Line(Point houghPoint,
UMat srcImgInfo) |
static Scalar4i |
opencv_ximgproc.HoughPoint2Line(Point houghPoint,
UMat srcImgInfo,
int angleRange,
int makeSkew,
int rules) |
static void |
opencv_imgproc.HuMoments(Moments m,
UMat hu) |
static void |
opencv_core.idct(UMat src,
UMat dst) |
static void |
opencv_core.idct(UMat src,
UMat dst,
int flags) |
static void |
opencv_core.idft(UMat src,
UMat dst) |
static void |
opencv_core.idft(UMat src,
UMat dst,
int flags,
int nonzeroRows) |
static void |
opencv_photo.illuminationChange(UMat src,
UMat mask,
UMat dst) |
static void |
opencv_photo.illuminationChange(UMat src,
UMat mask,
UMat dst,
float alpha,
float beta) |
static Mat |
opencv_imgcodecs.imdecode(UMat buf,
int flags) |
static Mat |
opencv_imgcodecs.imdecode(UMat buf,
int flags,
Mat dst) |
static boolean |
opencv_imgcodecs.imencode(BytePointer ext,
UMat img,
byte[] buf) |
static boolean |
opencv_imgcodecs.imencode(BytePointer ext,
UMat img,
byte[] buf,
int[] params) |
static boolean |
opencv_imgcodecs.imencode(BytePointer ext,
UMat img,
ByteBuffer buf) |
static boolean |
opencv_imgcodecs.imencode(BytePointer ext,
UMat img,
ByteBuffer buf,
IntBuffer params) |
static boolean |
opencv_imgcodecs.imencode(BytePointer ext,
UMat img,
BytePointer buf) |
static boolean |
opencv_imgcodecs.imencode(BytePointer ext,
UMat img,
BytePointer buf,
IntPointer params) |
static boolean |
opencv_imgcodecs.imencode(String ext,
UMat img,
byte[] buf) |
static boolean |
opencv_imgcodecs.imencode(String ext,
UMat img,
byte[] buf,
int[] params) |
static boolean |
opencv_imgcodecs.imencode(String ext,
UMat img,
ByteBuffer buf) |
static boolean |
opencv_imgcodecs.imencode(String ext,
UMat img,
ByteBuffer buf,
IntBuffer params) |
static boolean |
opencv_imgcodecs.imencode(String ext,
UMat img,
BytePointer buf) |
static boolean |
opencv_imgcodecs.imencode(String ext,
UMat img,
BytePointer buf,
IntPointer params) |
static void |
opencv_highgui.imshow(BytePointer winname,
UMat mat) |
static void |
opencv_highgui.imshow(String winname,
UMat mat) |
static boolean |
opencv_imgcodecs.imwrite(BytePointer filename,
UMat img) |
static boolean |
opencv_imgcodecs.imwrite(BytePointer filename,
UMat img,
int[] params) |
static boolean |
opencv_imgcodecs.imwrite(BytePointer filename,
UMat img,
IntBuffer params) |
static boolean |
opencv_imgcodecs.imwrite(BytePointer filename,
UMat img,
IntPointer params) |
static boolean |
opencv_imgcodecs.imwrite(String filename,
UMat img) |
static boolean |
opencv_imgcodecs.imwrite(String filename,
UMat img,
int[] params) |
static boolean |
opencv_imgcodecs.imwrite(String filename,
UMat img,
IntBuffer params) |
static boolean |
opencv_imgcodecs.imwrite(String filename,
UMat img,
IntPointer params) |
static void |
opencv_calib3d.initUndistortRectifyMap(UMat cameraMatrix,
UMat distCoeffs,
UMat R,
UMat newCameraMatrix,
Size size,
int m1type,
UMat map1,
UMat map2) |
static float |
opencv_calib3d.initWideAngleProjMap(UMat cameraMatrix,
UMat distCoeffs,
Size imageSize,
int destImageWidth,
int m1type,
UMat map1,
UMat map2) |
static float |
opencv_calib3d.initWideAngleProjMap(UMat cameraMatrix,
UMat distCoeffs,
Size imageSize,
int destImageWidth,
int m1type,
UMat map1,
UMat map2,
int projType) |
static float |
opencv_calib3d.initWideAngleProjMap(UMat cameraMatrix,
UMat distCoeffs,
Size imageSize,
int destImageWidth,
int m1type,
UMat map1,
UMat map2,
int projType,
double alpha) |
static void |
opencv_photo.inpaint(UMat src,
UMat inpaintMask,
UMat dst,
double inpaintRadius,
int flags) |
static void |
opencv_core.inRange(UMat src,
UMat lowerb,
UMat upperb,
UMat dst) |
static void |
opencv_core.insertChannel(UMat src,
UMat dst,
int coi) |
static void |
opencv_core.insertImageCOI(UMat coiimg,
CvArr arr) |
static void |
opencv_core.insertImageCOI(UMat coiimg,
CvArr arr,
int coi) |
static void |
opencv_cudaarithm.integral(UMat src,
UMat sum) |
static void |
opencv_imgproc.integral(UMat src,
UMat sum) |
static void |
opencv_imgproc.integral(UMat src,
UMat sum,
int sdepth) |
static void |
opencv_cudaarithm.integral(UMat src,
UMat sum,
Stream stream) |
static void |
opencv_imgproc.integral2(UMat src,
UMat sum,
UMat sqsum) |
static void |
opencv_imgproc.integral2(UMat src,
UMat sum,
UMat sqsum,
int sdepth,
int sqdepth) |
static void |
opencv_imgproc.integral3(UMat src,
UMat sum,
UMat sqsum,
UMat tilted) |
static void |
opencv_imgproc.integral3(UMat src,
UMat sum,
UMat sqsum,
UMat tilted,
int sdepth,
int sqdepth) |
static int |
opencv_aruco.interpolateCornersCharuco(GpuMatVector markerCorners,
UMat markerIds,
UMat image,
CharucoBoard board,
UMat charucoCorners,
UMat charucoIds) |
static int |
opencv_aruco.interpolateCornersCharuco(GpuMatVector markerCorners,
UMat markerIds,
UMat image,
CharucoBoard board,
UMat charucoCorners,
UMat charucoIds,
UMat cameraMatrix,
UMat distCoeffs,
int minMarkers) |
static int |
opencv_aruco.interpolateCornersCharuco(MatVector markerCorners,
UMat markerIds,
UMat image,
CharucoBoard board,
UMat charucoCorners,
UMat charucoIds) |
static int |
opencv_aruco.interpolateCornersCharuco(MatVector markerCorners,
UMat markerIds,
UMat image,
CharucoBoard board,
UMat charucoCorners,
UMat charucoIds,
UMat cameraMatrix,
UMat distCoeffs,
int minMarkers) |
static int |
opencv_aruco.interpolateCornersCharuco(UMatVector markerCorners,
UMat markerIds,
UMat image,
CharucoBoard board,
UMat charucoCorners,
UMat charucoIds) |
static int |
opencv_aruco.interpolateCornersCharuco(UMatVector markerCorners,
UMat markerIds,
UMat image,
CharucoBoard board,
UMat charucoCorners,
UMat charucoIds,
UMat cameraMatrix,
UMat distCoeffs,
int minMarkers) |
static float |
opencv_imgproc.intersectConvexConvex(UMat _p1,
UMat _p2,
UMat _p12) |
static float |
opencv_imgproc.intersectConvexConvex(UMat _p1,
UMat _p2,
UMat _p12,
boolean handleNested) |
static double |
opencv_core.invert(UMat src,
UMat dst) |
static double |
opencv_core.invert(UMat src,
UMat dst,
int flags) |
static void |
opencv_imgproc.invertAffineTransform(UMat M,
UMat iM) |
static boolean |
opencv_imgproc.isContourConvex(UMat contour) |
static void |
opencv_ximgproc.jointBilateralFilter(UMat joint,
UMat src,
UMat dst,
int d,
double sigmaColor,
double sigmaSpace) |
static void |
opencv_ximgproc.jointBilateralFilter(UMat joint,
UMat src,
UMat dst,
int d,
double sigmaColor,
double sigmaSpace,
int borderType) |
static String |
opencv_core.kernelToStr(UMat _kernel) |
static BytePointer |
opencv_core.kernelToStr(UMat _kernel,
int ddepth,
BytePointer name) |
static String |
opencv_core.kernelToStr(UMat _kernel,
int ddepth,
String name) |
static double |
opencv_core.kmeans(UMat data,
int K,
UMat bestLabels,
TermCriteria criteria,
int attempts,
int flags) |
static double |
opencv_core.kmeans(UMat data,
int K,
UMat bestLabels,
TermCriteria criteria,
int attempts,
int flags,
UMat centers) |
static void |
opencv_ximgproc.l0Smooth(UMat src,
UMat dst) |
static void |
opencv_ximgproc.l0Smooth(UMat src,
UMat dst,
double lambda,
double kappa) |
static void |
opencv_imgproc.Laplacian(UMat src,
UMat dst,
int ddepth) |
static void |
opencv_imgproc.Laplacian(UMat src,
UMat dst,
int ddepth,
int ksize,
double scale,
double delta,
int borderType) |
static void |
opencv_imgproc.line(UMat img,
Point pt1,
Point pt2,
Scalar color) |
static void |
opencv_imgproc.line(UMat img,
Point pt1,
Point pt2,
Scalar color,
int thickness,
int lineType,
int shift) |
static void |
opencv_imgproc.linearPolar(UMat src,
UMat dst,
Point2f center,
double maxRadius,
int flags) |
static void |
opencv_cudaarithm.log(UMat src,
UMat dst) |
static void |
opencv_core.log(UMat src,
UMat dst) |
static void |
opencv_cudaarithm.log(UMat src,
UMat dst,
Stream stream) |
static void |
opencv_imgproc.logPolar(UMat src,
UMat dst,
Point2f center,
double M,
int flags) |
static void |
opencv_cudaarithm.lshift(UMat src,
Scalar4i val,
UMat dst) |
static void |
opencv_cudaarithm.lshift(UMat src,
Scalar4i val,
UMat dst,
Stream stream) |
static void |
opencv_cudaarithm.lshift(UMat src,
Scalar val,
UMat dst) |
static void |
opencv_cudaarithm.lshift(UMat src,
Scalar val,
UMat dst,
Stream stream) |
static void |
opencv_core.LUT(UMat src,
UMat lut,
UMat dst) |
static void |
opencv_cudaarithm.magnitude(UMat xy,
UMat magnitude) |
static void |
opencv_cudaarithm.magnitude(UMat xy,
UMat magnitude,
Stream stream) |
static void |
opencv_cudaarithm.magnitude(UMat x,
UMat y,
UMat magnitude) |
static void |
opencv_core.magnitude(UMat x,
UMat y,
UMat magnitude) |
static void |
opencv_cudaarithm.magnitude(UMat x,
UMat y,
UMat magnitude,
Stream stream) |
static void |
opencv_cudaarithm.magnitudeSqr(UMat xy,
UMat magnitude) |
static void |
opencv_cudaarithm.magnitudeSqr(UMat xy,
UMat magnitude,
Stream stream) |
static void |
opencv_cudaarithm.magnitudeSqr(UMat x,
UMat y,
UMat magnitude) |
static void |
opencv_cudaarithm.magnitudeSqr(UMat x,
UMat y,
UMat magnitude,
Stream stream) |
static double |
opencv_core.Mahalanobis(UMat v1,
UMat v2,
UMat icovar) |
static void |
opencv_img_hash.marrHildrethHash(UMat inputArr,
UMat outputArr) |
static void |
opencv_img_hash.marrHildrethHash(UMat inputArr,
UMat outputArr,
float alpha,
float scale) |
static double |
opencv_imgproc.matchShapes(UMat contour1,
UMat contour2,
int method,
double parameter) |
static void |
opencv_imgproc.matchTemplate(UMat image,
UMat templ,
UMat result,
int method) |
static void |
opencv_imgproc.matchTemplate(UMat image,
UMat templ,
UMat result,
int method,
UMat mask) |
static void |
opencv_calib3d.matMulDeriv(UMat A,
UMat B,
UMat dABdA,
UMat dABdB) |
static void |
opencv_cudaarithm.max(UMat src1,
UMat src2,
UMat dst) |
static void |
opencv_core.max(UMat src1,
UMat src2,
UMat dst)
\overload
needed to avoid conflicts with const _Tp& std::min(const _Tp&, const _Tp&, _Compare)
|
static void |
opencv_cudaarithm.max(UMat src1,
UMat src2,
UMat dst,
Stream stream) |
static Scalar |
opencv_core.mean(UMat src) |
static Scalar |
opencv_core.mean(UMat src,
UMat mask) |
static int |
opencv_video.meanShift(UMat probImage,
Rect window,
TermCriteria criteria) |
static void |
opencv_cudaimgproc.meanShiftFiltering(UMat src,
UMat dst,
int sp,
int sr) |
static void |
opencv_cudaimgproc.meanShiftFiltering(UMat src,
UMat dst,
int sp,
int sr,
TermCriteria criteria,
Stream stream) |
static void |
opencv_cudaimgproc.meanShiftProc(UMat src,
UMat dstr,
UMat dstsp,
int sp,
int sr) |
static void |
opencv_cudaimgproc.meanShiftProc(UMat src,
UMat dstr,
UMat dstsp,
int sp,
int sr,
TermCriteria criteria,
Stream stream) |
static void |
opencv_cudaimgproc.meanShiftSegmentation(UMat src,
UMat dst,
int sp,
int sr,
int minsize) |
static void |
opencv_cudaimgproc.meanShiftSegmentation(UMat src,
UMat dst,
int sp,
int sr,
int minsize,
TermCriteria criteria,
Stream stream) |
static void |
opencv_cudaarithm.meanStdDev(UMat mtx,
Scalar mean,
Scalar stddev) |
static void |
opencv_cudaarithm.meanStdDev(UMat mtx,
UMat dst) |
static void |
opencv_cudaarithm.meanStdDev(UMat mtx,
UMat dst,
Stream stream) |
static void |
opencv_core.meanStdDev(UMat src,
UMat mean,
UMat stddev) |
static void |
opencv_core.meanStdDev(UMat src,
UMat mean,
UMat stddev,
UMat mask) |
static void |
opencv_imgproc.medianBlur(UMat src,
UMat dst,
int ksize) |
static void |
opencv_cudaarithm.merge(GpuMat src,
long n,
UMat dst) |
static void |
opencv_cudaarithm.merge(GpuMat src,
long n,
UMat dst,
Stream stream) |
static void |
opencv_cudaarithm.merge(GpuMatVector src,
UMat dst) |
static void |
opencv_core.merge(GpuMatVector mv,
UMat dst) |
static void |
opencv_cudaarithm.merge(GpuMatVector src,
UMat dst,
Stream stream) |
static void |
opencv_core.merge(Mat mv,
long count,
UMat dst) |
static void |
opencv_core.merge(MatVector mv,
UMat dst) |
static void |
opencv_core.merge(UMatVector mv,
UMat dst) |
static void |
opencv_cudaarithm.min(UMat src1,
UMat src2,
UMat dst) |
static void |
opencv_core.min(UMat src1,
UMat src2,
UMat dst)
\overload
needed to avoid conflicts with const _Tp& std::min(const _Tp&, const _Tp&, _Compare)
|
static void |
opencv_cudaarithm.min(UMat src1,
UMat src2,
UMat dst,
Stream stream) |
static RotatedRect |
opencv_imgproc.minAreaRect(UMat points) |
static void |
opencv_imgproc.minEnclosingCircle(UMat points,
Point2f center,
float[] radius) |
static void |
opencv_imgproc.minEnclosingCircle(UMat points,
Point2f center,
FloatBuffer radius) |
static void |
opencv_imgproc.minEnclosingCircle(UMat points,
Point2f center,
FloatPointer radius) |
static double |
opencv_imgproc.minEnclosingTriangle(UMat points,
UMat triangle) |
static void |
opencv_cudaarithm.minMax(UMat src,
double[] minVal,
double[] maxVal) |
static void |
opencv_cudaarithm.minMax(UMat src,
double[] minVal,
double[] maxVal,
UMat mask) |
static void |
opencv_cudaarithm.minMax(UMat src,
DoubleBuffer minVal,
DoubleBuffer maxVal) |
static void |
opencv_cudaarithm.minMax(UMat src,
DoubleBuffer minVal,
DoubleBuffer maxVal,
UMat mask) |
static void |
opencv_cudaarithm.minMax(UMat src,
DoublePointer minVal,
DoublePointer maxVal) |
static void |
opencv_cudaarithm.minMax(UMat src,
DoublePointer minVal,
DoublePointer maxVal,
UMat mask) |
static void |
opencv_core.minMaxIdx(UMat src,
double[] minVal) |
static void |
opencv_core.minMaxIdx(UMat src,
double[] minVal,
double[] maxVal,
int[] minIdx,
int[] maxIdx,
UMat mask) |
static void |
opencv_core.minMaxIdx(UMat src,
DoubleBuffer minVal) |
static void |
opencv_core.minMaxIdx(UMat src,
DoubleBuffer minVal,
DoubleBuffer maxVal,
IntBuffer minIdx,
IntBuffer maxIdx,
UMat mask) |
static void |
opencv_core.minMaxIdx(UMat src,
DoublePointer minVal) |
static void |
opencv_core.minMaxIdx(UMat src,
DoublePointer minVal,
DoublePointer maxVal,
IntPointer minIdx,
IntPointer maxIdx,
UMat mask) |
static void |
opencv_core.minMaxLoc(UMat src,
double[] minVal) |
static void |
opencv_cudaarithm.minMaxLoc(UMat src,
double[] minVal,
double[] maxVal,
Point minLoc,
Point maxLoc) |
static void |
opencv_cudaarithm.minMaxLoc(UMat src,
double[] minVal,
double[] maxVal,
Point minLoc,
Point maxLoc,
UMat mask) |
static void |
opencv_core.minMaxLoc(UMat src,
double[] minVal,
double[] maxVal,
Point minLoc,
Point maxLoc,
UMat mask) |
static void |
opencv_core.minMaxLoc(UMat src,
DoubleBuffer minVal) |
static void |
opencv_cudaarithm.minMaxLoc(UMat src,
DoubleBuffer minVal,
DoubleBuffer maxVal,
Point minLoc,
Point maxLoc) |
static void |
opencv_cudaarithm.minMaxLoc(UMat src,
DoubleBuffer minVal,
DoubleBuffer maxVal,
Point minLoc,
Point maxLoc,
UMat mask) |
static void |
opencv_core.minMaxLoc(UMat src,
DoubleBuffer minVal,
DoubleBuffer maxVal,
Point minLoc,
Point maxLoc,
UMat mask) |
static void |
opencv_core.minMaxLoc(UMat src,
DoublePointer minVal) |
static void |
opencv_cudaarithm.minMaxLoc(UMat src,
DoublePointer minVal,
DoublePointer maxVal,
Point minLoc,
Point maxLoc) |
static void |
opencv_cudaarithm.minMaxLoc(UMat src,
DoublePointer minVal,
DoublePointer maxVal,
Point minLoc,
Point maxLoc,
UMat mask) |
static void |
opencv_core.minMaxLoc(UMat src,
DoublePointer minVal,
DoublePointer maxVal,
Point minLoc,
Point maxLoc,
UMat mask) |
static Moments |
opencv_imgproc.moments(UMat array) |
static Moments |
opencv_imgproc.moments(UMat array,
boolean binaryImage) |
static void |
opencv_imgproc.morphologyEx(UMat src,
UMat dst,
int op,
UMat kernel) |
static void |
opencv_imgproc.morphologyEx(UMat src,
UMat dst,
int op,
UMat kernel,
Point anchor,
int iterations,
int borderType,
Scalar borderValue) |
static void |
opencv_text.MSERsToERStats(UMat image,
PointVectorVector contours,
ERStatVectorVector regions) |
static void |
opencv_cudaarithm.mulAndScaleSpectrums(UMat src1,
UMat src2,
UMat dst,
int flags,
float scale) |
static void |
opencv_cudaarithm.mulAndScaleSpectrums(UMat src1,
UMat src2,
UMat dst,
int flags,
float scale,
boolean conjB,
Stream stream) |
static void |
opencv_cudaarithm.mulSpectrums(UMat src1,
UMat src2,
UMat dst,
int flags) |
static void |
opencv_core.mulSpectrums(UMat a,
UMat b,
UMat c,
int flags) |
static void |
opencv_core.mulSpectrums(UMat a,
UMat b,
UMat c,
int flags,
boolean conjB) |
static void |
opencv_cudaarithm.mulSpectrums(UMat src1,
UMat src2,
UMat dst,
int flags,
boolean conjB,
Stream stream) |
static void |
opencv_cudaarithm.multiply(UMat src1,
UMat src2,
UMat dst) |
static void |
opencv_core.multiply(UMat src1,
UMat src2,
UMat dst) |
static void |
opencv_core.multiply(UMat src1,
UMat src2,
UMat dst,
double scale,
int dtype) |
static void |
opencv_cudaarithm.multiply(UMat src1,
UMat src2,
UMat dst,
double scale,
int dtype,
Stream stream) |
static void |
opencv_core.mulTransposed(UMat src,
UMat dst,
boolean aTa) |
static void |
opencv_core.mulTransposed(UMat src,
UMat dst,
boolean aTa,
UMat delta,
double scale,
int dtype) |
static void |
opencv_ximgproc.niBlackThreshold(UMat _src,
UMat _dst,
double maxValue,
int type,
int blockSize,
double k) |
static void |
opencv_ximgproc.niBlackThreshold(UMat _src,
UMat _dst,
double maxValue,
int type,
int blockSize,
double k,
int binarizationMethod) |
static void |
opencv_photo.nonLocalMeans(UMat src,
UMat dst,
float h) |
static void |
opencv_photo.nonLocalMeans(UMat src,
UMat dst,
float h,
int search_window,
int block_size,
int borderMode,
Stream stream) |
static double |
opencv_core.norm(UMat src1) |
static double |
opencv_cudaarithm.norm(UMat src1,
int normType) |
static double |
opencv_cudaarithm.norm(UMat src1,
int normType,
UMat mask) |
static double |
opencv_core.norm(UMat src1,
int normType,
UMat mask) |
static double |
opencv_cudaarithm.norm(UMat src1,
UMat src2) |
static double |
opencv_core.norm(UMat src1,
UMat src2) |
static double |
opencv_cudaarithm.norm(UMat src1,
UMat src2,
int normType) |
static double |
opencv_core.norm(UMat src1,
UMat src2,
int normType,
UMat mask) |
static void |
opencv_core.normalize(UMat src,
UMat dst) |
static void |
opencv_cudaarithm.normalize(UMat src,
UMat dst,
double alpha,
double beta,
int norm_type,
int dtype) |
static void |
opencv_core.normalize(UMat src,
UMat dst,
double alpha,
double beta,
int norm_type,
int dtype,
UMat mask) |
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_stitching.normalizeUsingWeightMap(UMat weight,
UMat src) |
static void |
opencv_xphoto.oilPainting(UMat src,
UMat dst,
int size,
int dynRatio) |
static void |
opencv_xphoto.oilPainting(UMat src,
UMat dst,
int size,
int dynRatio,
int code) |
static void |
opencv_core.patchNaNs(UMat a) |
static void |
opencv_core.patchNaNs(UMat a,
double val) |
static void |
opencv_core.PCABackProject(UMat data,
UMat mean,
UMat eigenvectors,
UMat result) |
static void |
opencv_core.PCACompute(UMat data,
UMat mean,
UMat eigenvectors) |
static void |
opencv_core.PCACompute(UMat data,
UMat mean,
UMat eigenvectors,
double retainedVariance) |
static void |
opencv_core.PCACompute(UMat data,
UMat mean,
UMat eigenvectors,
int maxComponents) |
static void |
opencv_core.PCACompute2(UMat data,
UMat mean,
UMat eigenvectors,
UMat eigenvalues) |
static void |
opencv_core.PCACompute2(UMat data,
UMat mean,
UMat eigenvectors,
UMat eigenvalues,
double retainedVariance) |
static void |
opencv_core.PCACompute2(UMat data,
UMat mean,
UMat eigenvectors,
UMat eigenvalues,
int maxComponents) |
static void |
opencv_core.PCAProject(UMat data,
UMat mean,
UMat eigenvectors,
UMat result) |
static void |
opencv_photo.pencilSketch(UMat src,
UMat dst1,
UMat dst2) |
static void |
opencv_photo.pencilSketch(UMat src,
UMat dst1,
UMat dst2,
float sigma_s,
float sigma_r,
float shade_factor) |
static void |
opencv_core.perspectiveTransform(UMat src,
UMat dst,
UMat m) |
static void |
opencv_cudaarithm.phase(UMat x,
UMat y,
UMat angle) |
static void |
opencv_core.phase(UMat x,
UMat y,
UMat angle) |
static void |
opencv_core.phase(UMat x,
UMat y,
UMat angle,
boolean angleInDegrees) |
static void |
opencv_cudaarithm.phase(UMat x,
UMat y,
UMat angle,
boolean angleInDegrees,
Stream stream) |
static Point2d |
opencv_imgproc.phaseCorrelate(UMat src1,
UMat src2) |
static Point2d |
opencv_imgproc.phaseCorrelate(UMat src1,
UMat src2,
UMat window,
double[] response) |
static Point2d |
opencv_imgproc.phaseCorrelate(UMat src1,
UMat src2,
UMat window,
DoubleBuffer response) |
static Point2d |
opencv_imgproc.phaseCorrelate(UMat src1,
UMat src2,
UMat window,
DoublePointer response) |
static void |
opencv_img_hash.pHash(UMat inputArr,
UMat outputArr) |
static double |
opencv_imgproc.pointPolygonTest(UMat contour,
Point2f pt,
boolean measureDist) |
static void |
opencv_cudaarithm.polarToCart(UMat magnitude,
UMat angle,
UMat x,
UMat y) |
static void |
opencv_core.polarToCart(UMat magnitude,
UMat angle,
UMat x,
UMat y) |
static void |
opencv_core.polarToCart(UMat magnitude,
UMat angle,
UMat x,
UMat y,
boolean angleInDegrees) |
static void |
opencv_cudaarithm.polarToCart(UMat magnitude,
UMat angle,
UMat x,
UMat y,
boolean angleInDegrees,
Stream stream) |
static void |
opencv_imgproc.polylines(UMat img,
GpuMatVector pts,
boolean isClosed,
Scalar color) |
static void |
opencv_imgproc.polylines(UMat img,
GpuMatVector pts,
boolean isClosed,
Scalar color,
int thickness,
int lineType,
int shift) |
static void |
opencv_imgproc.polylines(UMat img,
MatVector pts,
boolean isClosed,
Scalar color) |
static void |
opencv_imgproc.polylines(UMat img,
MatVector pts,
boolean isClosed,
Scalar color,
int thickness,
int lineType,
int shift) |
static void |
opencv_imgproc.polylines(UMat img,
Point pts,
int[] npts,
int ncontours,
boolean isClosed,
Scalar color) |
static void |
opencv_imgproc.polylines(UMat img,
Point pts,
int[] npts,
int ncontours,
boolean isClosed,
Scalar color,
int thickness,
int lineType,
int shift) |
static void |
opencv_imgproc.polylines(UMat img,
Point pts,
IntBuffer npts,
int ncontours,
boolean isClosed,
Scalar color) |
static void |
opencv_imgproc.polylines(UMat img,
Point pts,
IntBuffer npts,
int ncontours,
boolean isClosed,
Scalar color,
int thickness,
int lineType,
int shift) |
static void |
opencv_imgproc.polylines(UMat img,
Point pts,
IntPointer npts,
int ncontours,
boolean isClosed,
Scalar color) |
static void |
opencv_imgproc.polylines(UMat img,
Point pts,
IntPointer npts,
int ncontours,
boolean isClosed,
Scalar color,
int thickness,
int lineType,
int shift) |
static void |
opencv_imgproc.polylines(UMat img,
UMatVector pts,
boolean isClosed,
Scalar color) |
static void |
opencv_imgproc.polylines(UMat img,
UMatVector pts,
boolean isClosed,
Scalar color,
int thickness,
int lineType,
int shift) |
static void |
opencv_cudaarithm.pow(UMat src,
double power,
UMat dst) |
static void |
opencv_core.pow(UMat src,
double power,
UMat dst) |
static void |
opencv_cudaarithm.pow(UMat src,
double power,
UMat dst,
Stream stream) |
static void |
opencv_imgproc.preCornerDetect(UMat src,
UMat dst,
int ksize) |
static void |
opencv_imgproc.preCornerDetect(UMat src,
UMat dst,
int ksize,
int borderType) |
static int |
opencv_core.predictOptimalVectorWidth(UMat src1) |
static int |
opencv_core.predictOptimalVectorWidth(UMat src1,
UMat src2,
UMat src3,
UMat src4,
UMat src5,
UMat src6,
UMat src7,
UMat src8,
UMat src9,
int strat) |
static int |
opencv_core.predictOptimalVectorWidthMax(UMat src1) |
static int |
opencv_core.predictOptimalVectorWidthMax(UMat src1,
UMat src2,
UMat src3,
UMat src4,
UMat src5,
UMat src6,
UMat src7,
UMat src8,
UMat src9) |
static int |
opencv_core.print(UMat mtx) |
static int |
opencv_core.print(UMat mtx,
Pointer stream) |
static void |
opencv_calib3d.projectPoints(UMat objectPoints,
UMat imagePoints,
Mat affine,
UMat K,
UMat D) |
static void |
opencv_calib3d.projectPoints(UMat objectPoints,
UMat imagePoints,
Mat affine,
UMat K,
UMat D,
double alpha,
UMat jacobian) |
static void |
opencv_calib3d.projectPoints(UMat objectPoints,
UMat rvec,
UMat tvec,
UMat cameraMatrix,
UMat distCoeffs,
UMat imagePoints) |
static void |
opencv_calib3d.projectPoints(UMat objectPoints,
UMat imagePoints,
UMat rvec,
UMat tvec,
UMat K,
UMat D,
double alpha,
UMat jacobian) |
static void |
opencv_calib3d.projectPoints(UMat objectPoints,
UMat rvec,
UMat tvec,
UMat cameraMatrix,
UMat distCoeffs,
UMat imagePoints,
UMat jacobian,
double aspectRatio) |
static double |
opencv_core.PSNR(UMat src1,
UMat src2) |
static double |
opencv_core.PSNR(UMat src1,
UMat src2,
double R) |
static void |
opencv_imgproc.putText(UMat img,
BytePointer text,
Point org,
int fontFace,
double fontScale,
Scalar color) |
static void |
opencv_imgproc.putText(UMat img,
BytePointer text,
Point org,
int fontFace,
double fontScale,
Scalar color,
int thickness,
int lineType,
boolean bottomLeftOrigin) |
static void |
opencv_imgproc.putText(UMat img,
String text,
Point org,
int fontFace,
double fontScale,
Scalar color) |
static void |
opencv_imgproc.putText(UMat img,
String text,
Point org,
int fontFace,
double fontScale,
Scalar color,
int thickness,
int lineType,
boolean bottomLeftOrigin) |
static void |
opencv_imgproc.pyrDown(UMat src,
UMat dst) |
static void |
opencv_cudawarping.pyrDown(UMat src,
UMat dst) |
static void |
opencv_imgproc.pyrDown(UMat src,
UMat dst,
Size dstsize,
int borderType) |
static void |
opencv_cudawarping.pyrDown(UMat src,
UMat dst,
Stream stream) |
static void |
opencv_imgproc.pyrMeanShiftFiltering(UMat src,
UMat dst,
double sp,
double sr) |
static void |
opencv_imgproc.pyrMeanShiftFiltering(UMat src,
UMat dst,
double sp,
double sr,
int maxLevel,
TermCriteria termcrit) |
static void |
opencv_imgproc.pyrUp(UMat src,
UMat dst) |
static void |
opencv_cudawarping.pyrUp(UMat src,
UMat dst) |
static void |
opencv_imgproc.pyrUp(UMat src,
UMat dst,
Size dstsize,
int borderType) |
static void |
opencv_cudawarping.pyrUp(UMat src,
UMat dst,
Stream stream) |
static void |
opencv_img_hash.radialVarianceHash(UMat inputArr,
UMat outputArr) |
static void |
opencv_img_hash.radialVarianceHash(UMat inputArr,
UMat outputArr,
double sigma,
int numOfAngleLine) |
static void |
opencv_ml.randMVNormal(UMat mean,
UMat cov,
int nsamples,
UMat samples) |
static void |
opencv_core.randn(UMat dst,
UMat mean,
UMat stddev) |
static void |
opencv_core.randShuffle(UMat dst) |
static void |
opencv_core.randShuffle(UMat dst,
double iterFactor,
RNG rng) |
static void |
opencv_core.randu(UMat dst,
UMat low,
UMat high) |
static float |
opencv_rapid.rapid(UMat img,
int num,
int len,
UMat pts3d,
UMat tris,
UMat K,
UMat rvec,
UMat tvec) |
static int |
opencv_ximgproc.readGT(BytePointer src_path,
UMat dst) |
static int |
opencv_ximgproc.readGT(String src_path,
UMat dst) |
static int |
opencv_calib3d.recoverPose(UMat E,
UMat points1,
UMat points2,
UMat R,
UMat t) |
static int |
opencv_calib3d.recoverPose(UMat E,
UMat points1,
UMat points2,
UMat R,
UMat t,
double focal,
Point2d pp,
UMat mask) |
static int |
opencv_calib3d.recoverPose(UMat E,
UMat points1,
UMat points2,
UMat cameraMatrix,
UMat R,
UMat t) |
static int |
opencv_calib3d.recoverPose(UMat E,
UMat points1,
UMat points2,
UMat cameraMatrix,
UMat R,
UMat t,
double distanceThresh) |
static int |
opencv_calib3d.recoverPose(UMat E,
UMat points1,
UMat points2,
UMat cameraMatrix,
UMat R,
UMat t,
double distanceThresh,
UMat mask,
UMat triangulatedPoints) |
static int |
opencv_calib3d.recoverPose(UMat E,
UMat points1,
UMat points2,
UMat cameraMatrix,
UMat R,
UMat t,
UMat mask) |
static void |
opencv_imgproc.rectangle(UMat img,
Point pt1,
Point pt2,
Scalar color) |
static void |
opencv_imgproc.rectangle(UMat img,
Point pt1,
Point pt2,
Scalar color,
int thickness,
int lineType,
int shift) |
static void |
opencv_imgproc.rectangle(UMat img,
Rect rec,
Scalar color) |
static void |
opencv_imgproc.rectangle(UMat img,
Rect rec,
Scalar color,
int thickness,
int lineType,
int shift) |
static float |
opencv_calib3d.rectify3Collinear(UMat cameraMatrix1,
UMat distCoeffs1,
UMat cameraMatrix2,
UMat distCoeffs2,
UMat cameraMatrix3,
UMat distCoeffs3,
GpuMatVector imgpt1,
GpuMatVector imgpt3,
Size imageSize,
UMat R12,
UMat T12,
UMat R13,
UMat T13,
UMat R1,
UMat R2,
UMat R3,
UMat P1,
UMat P2,
UMat P3,
UMat Q,
double alpha,
Size newImgSize,
Rect roi1,
Rect roi2,
int flags) |
static float |
opencv_calib3d.rectify3Collinear(UMat cameraMatrix1,
UMat distCoeffs1,
UMat cameraMatrix2,
UMat distCoeffs2,
UMat cameraMatrix3,
UMat distCoeffs3,
MatVector imgpt1,
MatVector imgpt3,
Size imageSize,
UMat R12,
UMat T12,
UMat R13,
UMat T13,
UMat R1,
UMat R2,
UMat R3,
UMat P1,
UMat P2,
UMat P3,
UMat Q,
double alpha,
Size newImgSize,
Rect roi1,
Rect roi2,
int flags) |
static float |
opencv_calib3d.rectify3Collinear(UMat cameraMatrix1,
UMat distCoeffs1,
UMat cameraMatrix2,
UMat distCoeffs2,
UMat cameraMatrix3,
UMat distCoeffs3,
UMatVector imgpt1,
UMatVector imgpt3,
Size imageSize,
UMat R12,
UMat T12,
UMat R13,
UMat T13,
UMat R1,
UMat R2,
UMat R3,
UMat P1,
UMat P2,
UMat P3,
UMat Q,
double alpha,
Size newImgSize,
Rect roi1,
Rect roi2,
int flags) |
static void |
opencv_cudaarithm.rectStdDev(UMat src,
UMat sqr,
UMat dst,
Rect rect) |
static void |
opencv_cudaarithm.rectStdDev(UMat src,
UMat sqr,
UMat dst,
Rect rect,
Stream stream) |
static void |
opencv_cudaarithm.reduce(UMat mtx,
UMat vec,
int dim,
int reduceOp) |
static void |
opencv_core.reduce(UMat src,
UMat dst,
int dim,
int rtype) |
static void |
opencv_core.reduce(UMat src,
UMat dst,
int dim,
int rtype,
int dtype) |
static void |
opencv_cudaarithm.reduce(UMat mtx,
UMat vec,
int dim,
int reduceOp,
int dtype,
Stream stream) |
static void |
opencv_aruco.refineDetectedMarkers(UMat image,
Board board,
GpuMatVector detectedCorners,
UMat detectedIds,
GpuMatVector rejectedCorners) |
static void |
opencv_aruco.refineDetectedMarkers(UMat image,
Board board,
GpuMatVector detectedCorners,
UMat detectedIds,
GpuMatVector rejectedCorners,
UMat cameraMatrix,
UMat distCoeffs,
float minRepDistance,
float errorCorrectionRate,
boolean checkAllOrders,
UMat recoveredIdxs,
DetectorParameters parameters) |
static void |
opencv_aruco.refineDetectedMarkers(UMat image,
Board board,
MatVector detectedCorners,
UMat detectedIds,
MatVector rejectedCorners) |
static void |
opencv_aruco.refineDetectedMarkers(UMat image,
Board board,
MatVector detectedCorners,
UMat detectedIds,
MatVector rejectedCorners,
UMat cameraMatrix,
UMat distCoeffs,
float minRepDistance,
float errorCorrectionRate,
boolean checkAllOrders,
UMat recoveredIdxs,
DetectorParameters parameters) |
static void |
opencv_aruco.refineDetectedMarkers(UMat image,
Board board,
UMatVector detectedCorners,
UMat detectedIds,
UMatVector rejectedCorners) |
static void |
opencv_aruco.refineDetectedMarkers(UMat image,
Board board,
UMatVector detectedCorners,
UMat detectedIds,
UMatVector rejectedCorners,
UMat cameraMatrix,
UMat distCoeffs,
float minRepDistance,
float errorCorrectionRate,
boolean checkAllOrders,
UMat recoveredIdxs,
DetectorParameters parameters) |
static void |
opencv_imgproc.remap(UMat src,
UMat dst,
UMat map1,
UMat map2,
int interpolation) |
static void |
opencv_cudawarping.remap(UMat src,
UMat dst,
UMat xmap,
UMat ymap,
int interpolation) |
static void |
opencv_imgproc.remap(UMat src,
UMat dst,
UMat map1,
UMat map2,
int interpolation,
int borderMode,
Scalar borderValue) |
static void |
opencv_cudawarping.remap(UMat src,
UMat dst,
UMat xmap,
UMat ymap,
int interpolation,
int borderMode,
Scalar borderValue,
Stream stream) |
static void |
opencv_core.repeat(UMat src,
int ny,
int nx,
UMat dst) |
static void |
opencv_cudastereo.reprojectImageTo3D(UMat disp,
UMat xyzw,
UMat Q) |
static void |
opencv_calib3d.reprojectImageTo3D(UMat disparity,
UMat _3dImage,
UMat Q) |
static void |
opencv_calib3d.reprojectImageTo3D(UMat disparity,
UMat _3dImage,
UMat Q,
boolean handleMissingValues,
int ddepth) |
static void |
opencv_cudastereo.reprojectImageTo3D(UMat disp,
UMat xyzw,
UMat Q,
int dst_cn,
Stream stream) |
static void |
opencv_imgproc.resize(UMat src,
UMat dst,
Size dsize) |
static void |
opencv_cudawarping.resize(UMat src,
UMat dst,
Size dsize) |
static void |
opencv_imgproc.resize(UMat src,
UMat dst,
Size dsize,
double fx,
double fy,
int interpolation) |
static void |
opencv_cudawarping.resize(UMat src,
UMat dst,
Size dsize,
double fx,
double fy,
int interpolation,
Stream stream) |
static void |
opencv_calib3d.Rodrigues(UMat src,
UMat dst) |
static void |
opencv_calib3d.Rodrigues(UMat src,
UMat dst,
UMat jacobian) |
static void |
opencv_ximgproc.rollingGuidanceFilter(UMat src,
UMat dst) |
static void |
opencv_ximgproc.rollingGuidanceFilter(UMat src,
UMat dst,
int d,
double sigmaColor,
double sigmaSpace,
int numOfIter,
int borderType) |
static void |
opencv_core.rotate(UMat src,
UMat dst,
int rotateCode) |
static void |
opencv_cudawarping.rotate(UMat src,
UMat dst,
Size dsize,
double angle) |
static void |
opencv_cudawarping.rotate(UMat src,
UMat dst,
Size dsize,
double angle,
double xShift,
double yShift,
int interpolation,
Stream stream) |
static int |
opencv_imgproc.rotatedRectangleIntersection(RotatedRect rect1,
RotatedRect rect2,
UMat intersectingRegion) |
static Point3d |
opencv_calib3d.RQDecomp3x3(UMat src,
UMat mtxR,
UMat mtxQ) |
static Point3d |
opencv_calib3d.RQDecomp3x3(UMat src,
UMat mtxR,
UMat mtxQ,
UMat Qx,
UMat Qy,
UMat Qz) |
static void |
opencv_cudaarithm.rshift(UMat src,
Scalar4i val,
UMat dst) |
static void |
opencv_cudaarithm.rshift(UMat src,
Scalar4i val,
UMat dst,
Stream stream) |
static void |
opencv_cudaarithm.rshift(UMat src,
Scalar val,
UMat dst) |
static void |
opencv_cudaarithm.rshift(UMat src,
Scalar val,
UMat dst,
Stream stream) |
static double |
opencv_calib3d.sampsonDistance(UMat pt1,
UMat pt2,
UMat F) |
static void |
opencv_cudaarithm.scaleAdd(UMat src1,
double alpha,
UMat src2,
UMat dst) |
static void |
opencv_core.scaleAdd(UMat src1,
double alpha,
UMat src2,
UMat dst) |
static void |
opencv_cudaarithm.scaleAdd(UMat src1,
double alpha,
UMat src2,
UMat dst,
Stream stream) |
static void |
opencv_imgproc.Scharr(UMat src,
UMat dst,
int ddepth,
int dx,
int dy) |
static void |
opencv_imgproc.Scharr(UMat src,
UMat dst,
int ddepth,
int dx,
int dy,
double scale,
double delta,
int borderType) |
static void |
opencv_photo.seamlessClone(UMat src,
UMat dst,
UMat mask,
Point p,
UMat blend,
int flags) |
static void |
opencv_optflow.segmentMotion(UMat mhi,
UMat segmask,
RectVector boundingRects,
double timestamp,
double segThresh) |
static Rect |
opencv_highgui.selectROI(BytePointer windowName,
UMat img) |
static Rect |
opencv_highgui.selectROI(BytePointer windowName,
UMat img,
boolean showCrosshair,
boolean fromCenter) |
static Rect |
opencv_highgui.selectROI(String windowName,
UMat img) |
static Rect |
opencv_highgui.selectROI(String windowName,
UMat img,
boolean showCrosshair,
boolean fromCenter) |
static Rect |
opencv_highgui.selectROI(UMat img) |
static Rect |
opencv_highgui.selectROI(UMat img,
boolean showCrosshair,
boolean fromCenter) |
static void |
opencv_highgui.selectROIs(BytePointer windowName,
UMat img,
RectVector boundingBoxes) |
static void |
opencv_highgui.selectROIs(BytePointer windowName,
UMat img,
RectVector boundingBoxes,
boolean showCrosshair,
boolean fromCenter) |
static void |
opencv_highgui.selectROIs(String windowName,
UMat img,
RectVector boundingBoxes) |
static void |
opencv_highgui.selectROIs(String windowName,
UMat img,
RectVector boundingBoxes,
boolean showCrosshair,
boolean fromCenter) |
static void |
opencv_imgproc.sepFilter2D(UMat src,
UMat dst,
int ddepth,
UMat kernelX,
UMat kernelY) |
static void |
opencv_imgproc.sepFilter2D(UMat src,
UMat dst,
int ddepth,
UMat kernelX,
UMat kernelY,
Point anchor,
double delta,
int borderType) |
static void |
opencv_core.setIdentity(UMat mtx) |
static void |
opencv_core.setIdentity(UMat mtx,
Scalar s) |
static IntPointer |
opencv_dnn.shape(UMat mat) |
static void |
opencv_imgproc.Sobel(UMat src,
UMat dst,
int ddepth,
int dx,
int dy) |
static void |
opencv_imgproc.Sobel(UMat src,
UMat dst,
int ddepth,
int dx,
int dy,
int ksize,
double scale,
double delta,
int borderType) |
static boolean |
opencv_core.solve(UMat src1,
UMat src2,
UMat dst) |
static boolean |
opencv_core.solve(UMat src1,
UMat src2,
UMat dst,
int flags) |
static int |
opencv_core.solveCubic(UMat coeffs,
UMat roots) |
static int |
opencv_core.solveLP(UMat Func,
UMat Constr,
UMat z) |
static int |
opencv_calib3d.solveP3P(UMat objectPoints,
UMat imagePoints,
UMat cameraMatrix,
UMat distCoeffs,
GpuMatVector rvecs,
GpuMatVector tvecs,
int flags) |
static int |
opencv_calib3d.solveP3P(UMat objectPoints,
UMat imagePoints,
UMat cameraMatrix,
UMat distCoeffs,
MatVector rvecs,
MatVector tvecs,
int flags) |
static int |
opencv_calib3d.solveP3P(UMat objectPoints,
UMat imagePoints,
UMat cameraMatrix,
UMat distCoeffs,
UMatVector rvecs,
UMatVector tvecs,
int flags) |
static boolean |
opencv_calib3d.solvePnP(UMat objectPoints,
UMat imagePoints,
UMat cameraMatrix,
UMat distCoeffs,
UMat rvec,
UMat tvec) |
static boolean |
opencv_calib3d.solvePnP(UMat objectPoints,
UMat imagePoints,
UMat cameraMatrix,
UMat distCoeffs,
UMat rvec,
UMat tvec,
boolean useExtrinsicGuess,
int flags) |
static int |
opencv_calib3d.solvePnPGeneric(UMat objectPoints,
UMat imagePoints,
UMat cameraMatrix,
UMat distCoeffs,
GpuMatVector rvecs,
GpuMatVector tvecs) |
static int |
opencv_calib3d.solvePnPGeneric(UMat objectPoints,
UMat imagePoints,
UMat cameraMatrix,
UMat distCoeffs,
GpuMatVector rvecs,
GpuMatVector tvecs,
boolean useExtrinsicGuess,
int flags,
UMat rvec,
UMat tvec,
UMat reprojectionError) |
static int |
opencv_calib3d.solvePnPGeneric(UMat objectPoints,
UMat imagePoints,
UMat cameraMatrix,
UMat distCoeffs,
MatVector rvecs,
MatVector tvecs) |
static int |
opencv_calib3d.solvePnPGeneric(UMat objectPoints,
UMat imagePoints,
UMat cameraMatrix,
UMat distCoeffs,
MatVector rvecs,
MatVector tvecs,
boolean useExtrinsicGuess,
int flags,
UMat rvec,
UMat tvec,
UMat reprojectionError) |
static int |
opencv_calib3d.solvePnPGeneric(UMat objectPoints,
UMat imagePoints,
UMat cameraMatrix,
UMat distCoeffs,
UMatVector rvecs,
UMatVector tvecs) |
static int |
opencv_calib3d.solvePnPGeneric(UMat objectPoints,
UMat imagePoints,
UMat cameraMatrix,
UMat distCoeffs,
UMatVector rvecs,
UMatVector tvecs,
boolean useExtrinsicGuess,
int flags,
UMat rvec,
UMat tvec,
UMat reprojectionError) |
static boolean |
opencv_calib3d.solvePnPRansac(UMat objectPoints,
UMat imagePoints,
UMat cameraMatrix,
UMat distCoeffs,
UMat rvec,
UMat tvec) |
static boolean |
opencv_calib3d.solvePnPRansac(UMat objectPoints,
UMat imagePoints,
UMat cameraMatrix,
UMat distCoeffs,
UMat rvec,
UMat tvec,
boolean useExtrinsicGuess,
int iterationsCount,
float reprojectionError,
double confidence,
UMat inliers,
int flags) |
static void |
opencv_calib3d.solvePnPRefineLM(UMat objectPoints,
UMat imagePoints,
UMat cameraMatrix,
UMat distCoeffs,
UMat rvec,
UMat tvec) |
static void |
opencv_calib3d.solvePnPRefineLM(UMat objectPoints,
UMat imagePoints,
UMat cameraMatrix,
UMat distCoeffs,
UMat rvec,
UMat tvec,
TermCriteria criteria) |
static void |
opencv_calib3d.solvePnPRefineVVS(UMat objectPoints,
UMat imagePoints,
UMat cameraMatrix,
UMat distCoeffs,
UMat rvec,
UMat tvec) |
static void |
opencv_calib3d.solvePnPRefineVVS(UMat objectPoints,
UMat imagePoints,
UMat cameraMatrix,
UMat distCoeffs,
UMat rvec,
UMat tvec,
TermCriteria criteria,
double VVSlambda) |
static double |
opencv_core.solvePoly(UMat coeffs,
UMat roots) |
static double |
opencv_core.solvePoly(UMat coeffs,
UMat roots,
int maxIters) |
static void |
opencv_core.sort(UMat src,
UMat dst,
int flags) |
static void |
opencv_core.sortIdx(UMat src,
UMat dst,
int flags) |
static void |
opencv_imgproc.spatialGradient(UMat src,
UMat dx,
UMat dy) |
static void |
opencv_imgproc.spatialGradient(UMat src,
UMat dx,
UMat dy,
int ksize,
int borderType) |
static void |
opencv_cudaarithm.split(UMat src,
GpuMat dst) |
static void |
opencv_cudaarithm.split(UMat src,
GpuMat dst,
Stream stream) |
static void |
opencv_cudaarithm.split(UMat src,
GpuMatVector dst) |
static void |
opencv_core.split(UMat m,
GpuMatVector mv) |
static void |
opencv_cudaarithm.split(UMat src,
GpuMatVector dst,
Stream stream) |
static void |
opencv_core.split(UMat m,
MatVector mv) |
static void |
opencv_core.split(UMat m,
UMatVector mv) |
static void |
opencv_cudaarithm.sqr(UMat src,
UMat dst) |
static void |
opencv_cudaarithm.sqr(UMat src,
UMat dst,
Stream stream) |
static void |
opencv_imgproc.sqrBoxFilter(UMat src,
UMat dst,
int ddepth,
Size ksize) |
static void |
opencv_imgproc.sqrBoxFilter(UMat src,
UMat dst,
int ddepth,
Size ksize,
Point anchor,
boolean normalize,
int borderType) |
static void |
opencv_cudaarithm.sqrIntegral(UMat src,
UMat sqsum) |
static void |
opencv_cudaarithm.sqrIntegral(UMat src,
UMat sqsum,
Stream stream) |
static Scalar |
opencv_cudaarithm.sqrSum(UMat src) |
static Scalar |
opencv_cudaarithm.sqrSum(UMat src,
UMat mask) |
static void |
opencv_cudaarithm.sqrt(UMat src,
UMat dst) |
static void |
opencv_core.sqrt(UMat src,
UMat dst) |
static void |
opencv_cudaarithm.sqrt(UMat src,
UMat dst,
Stream stream) |
static void |
opencv_calib3d.stereoRectify(UMat cameraMatrix1,
UMat distCoeffs1,
UMat cameraMatrix2,
UMat distCoeffs2,
Size imageSize,
UMat R,
UMat T,
UMat R1,
UMat R2,
UMat P1,
UMat P2,
UMat Q) |
static void |
opencv_calib3d.stereoRectify(UMat K1,
UMat D1,
UMat K2,
UMat D2,
Size imageSize,
UMat R,
UMat tvec,
UMat R1,
UMat R2,
UMat P1,
UMat P2,
UMat Q,
int flags) |
static void |
opencv_calib3d.stereoRectify(UMat cameraMatrix1,
UMat distCoeffs1,
UMat cameraMatrix2,
UMat distCoeffs2,
Size imageSize,
UMat R,
UMat T,
UMat R1,
UMat R2,
UMat P1,
UMat P2,
UMat Q,
int flags,
double alpha,
Size newImageSize,
Rect validPixROI1,
Rect validPixROI2) |
static void |
opencv_calib3d.stereoRectify(UMat K1,
UMat D1,
UMat K2,
UMat D2,
Size imageSize,
UMat R,
UMat tvec,
UMat R1,
UMat R2,
UMat P1,
UMat P2,
UMat Q,
int flags,
Size newImageSize,
double balance,
double fov_scale) |
static boolean |
opencv_calib3d.stereoRectifyUncalibrated(UMat points1,
UMat points2,
UMat F,
Size imgSize,
UMat H1,
UMat H2) |
static boolean |
opencv_calib3d.stereoRectifyUncalibrated(UMat points1,
UMat points2,
UMat F,
Size imgSize,
UMat H1,
UMat H2,
double threshold) |
static void |
opencv_photo.stylization(UMat src,
UMat dst) |
static void |
opencv_photo.stylization(UMat src,
UMat dst,
float sigma_s,
float sigma_r) |
static void |
opencv_cudaarithm.subtract(UMat src1,
UMat src2,
UMat dst) |
static void |
opencv_core.subtract(UMat src1,
UMat src2,
UMat dst) |
static void |
opencv_core.subtract(UMat src1,
UMat src2,
UMat dst,
UMat mask,
int dtype) |
static void |
opencv_cudaarithm.subtract(UMat src1,
UMat src2,
UMat dst,
UMat mask,
int dtype,
Stream stream) |
static Scalar |
opencv_cudaarithm.sum(UMat src) |
static Scalar |
opencv_cudaarithm.sum(UMat src,
UMat mask) |
static Scalar |
opencv_core.sumElems(UMat src) |
static void |
opencv_core.SVBackSubst(UMat w,
UMat u,
UMat vt,
UMat rhs,
UMat dst) |
static void |
opencv_core.SVDecomp(UMat src,
UMat w,
UMat u,
UMat vt) |
static void |
opencv_core.SVDecomp(UMat src,
UMat w,
UMat u,
UMat vt,
int flags) |
static void |
opencv_core.swap(UMat a,
UMat b)
\overload
|
static void |
opencv_cudaimgproc.swapChannels(UMat image,
int[] dstOrder) |
static void |
opencv_cudaimgproc.swapChannels(UMat image,
int[] dstOrder,
Stream stream) |
static void |
opencv_cudaimgproc.swapChannels(UMat image,
IntBuffer dstOrder) |
static void |
opencv_cudaimgproc.swapChannels(UMat image,
IntBuffer dstOrder,
Stream stream) |
static void |
opencv_cudaimgproc.swapChannels(UMat image,
IntPointer dstOrder) |
static void |
opencv_cudaimgproc.swapChannels(UMat image,
IntPointer dstOrder,
Stream stream) |
static void |
opencv_photo.textureFlattening(UMat src,
UMat mask,
UMat dst) |
static void |
opencv_photo.textureFlattening(UMat src,
UMat mask,
UMat dst,
float low_threshold,
float high_threshold,
int kernel_size) |
static void |
opencv_ximgproc.thinning(UMat src,
UMat dst) |
static void |
opencv_ximgproc.thinning(UMat src,
UMat dst,
int thinningType) |
static double |
opencv_cudaarithm.threshold(UMat src,
UMat dst,
double thresh,
double maxval,
int type) |
static double |
opencv_imgproc.threshold(UMat src,
UMat dst,
double thresh,
double maxval,
int type) |
static double |
opencv_cudaarithm.threshold(UMat src,
UMat dst,
double thresh,
double maxval,
int type,
Stream stream) |
static Scalar |
opencv_core.trace(UMat mtx) |
static void |
opencv_core.transform(UMat src,
UMat dst,
UMat m) |
static void |
opencv_cudaarithm.transpose(UMat src1,
UMat dst) |
static void |
opencv_core.transpose(UMat src,
UMat dst) |
static void |
opencv_cudaarithm.transpose(UMat src1,
UMat dst,
Stream stream) |
static void |
opencv_calib3d.triangulatePoints(UMat projMatr1,
UMat projMatr2,
UMat projPoints1,
UMat projPoints2,
UMat points4D) |
static void |
opencv_calib3d.undistort(UMat src,
UMat dst,
UMat cameraMatrix,
UMat distCoeffs) |
static void |
opencv_calib3d.undistort(UMat src,
UMat dst,
UMat cameraMatrix,
UMat distCoeffs,
UMat newCameraMatrix) |
static void |
opencv_calib3d.undistortImage(UMat distorted,
UMat undistorted,
UMat K,
UMat D) |
static void |
opencv_calib3d.undistortImage(UMat distorted,
UMat undistorted,
UMat K,
UMat D,
UMat Knew,
Size new_size) |
static void |
opencv_calib3d.undistortPoints(UMat src,
UMat dst,
UMat cameraMatrix,
UMat distCoeffs) |
static void |
opencv_calib3d.undistortPoints(UMat src,
UMat dst,
UMat cameraMatrix,
UMat distCoeffs,
UMat R,
UMat P) |
static void |
opencv_calib3d.undistortPointsIter(UMat src,
UMat dst,
UMat cameraMatrix,
UMat distCoeffs,
UMat R,
UMat P,
TermCriteria criteria) |
static void |
opencv_optflow.updateMotionHistory(UMat silhouette,
UMat mhi,
double timestamp,
double duration) |
static void |
opencv_calib3d.validateDisparity(UMat disparity,
UMat cost,
int minDisparity,
int numberOfDisparities) |
static void |
opencv_calib3d.validateDisparity(UMat disparity,
UMat cost,
int minDisparity,
int numberOfDisparities,
int disp12MaxDisp) |
static void |
opencv_core.vconcat(GpuMatVector src,
UMat dst) |
static void |
opencv_core.vconcat(Mat src,
long nsrc,
UMat dst) |
static void |
opencv_core.vconcat(MatVector src,
UMat dst) |
static void |
opencv_core.vconcat(UMat src1,
UMat src2,
UMat dst) |
static void |
opencv_core.vconcat(UMatVector src,
UMat dst) |
static void |
opencv_imgproc.warpAffine(UMat src,
UMat dst,
UMat M,
Size dsize) |
static void |
opencv_imgproc.warpAffine(UMat src,
UMat dst,
UMat M,
Size dsize,
int flags,
int borderMode,
Scalar borderValue) |
static void |
opencv_imgproc.warpPerspective(UMat src,
UMat dst,
UMat M,
Size dsize) |
static void |
opencv_imgproc.warpPerspective(UMat src,
UMat dst,
UMat M,
Size dsize,
int flags,
int borderMode,
Scalar borderValue) |
static void |
opencv_imgproc.warpPolar(UMat src,
UMat dst,
Size dsize,
Point2f center,
double maxRadius,
int flags) |
static void |
opencv_imgproc.watershed(UMat image,
UMat markers) |
static boolean |
opencv_video.writeOpticalFlow(BytePointer path,
UMat flow) |
static boolean |
opencv_video.writeOpticalFlow(String path,
UMat flow) |
Modifier and Type | Method and Description |
---|---|
static Board |
Board.create(GpuMatVector objPoints,
Dictionary dictionary,
UMat ids) |
static Board |
Board.create(MatVector objPoints,
Dictionary dictionary,
UMat ids) |
static Board |
Board.create(UMatVector objPoints,
Dictionary dictionary,
UMat ids) |
void |
GridBoard.draw(Size outSize,
UMat img) |
void |
CharucoBoard.draw(Size outSize,
UMat img) |
void |
GridBoard.draw(Size outSize,
UMat img,
int marginSize,
int borderBits) |
void |
CharucoBoard.draw(Size outSize,
UMat img,
int marginSize,
int borderBits) |
void |
Dictionary.drawMarker(int id,
int sidePixels,
UMat _img) |
void |
Dictionary.drawMarker(int id,
int sidePixels,
UMat _img,
int borderBits) |
int |
Dictionary.getDistanceToId(UMat bits,
int id) |
int |
Dictionary.getDistanceToId(UMat bits,
int id,
boolean allRotations) |
Modifier and Type | Method and Description |
---|---|
void |
BackgroundSubtractorCNT.apply(UMat image,
UMat fgmask) |
void |
BackgroundSubtractorLSBP.apply(UMat image,
UMat fgmask) |
void |
BackgroundSubtractorGSOC.apply(UMat image,
UMat fgmask) |
void |
BackgroundSubtractorCNT.apply(UMat image,
UMat fgmask,
double learningRate) |
void |
BackgroundSubtractorLSBP.apply(UMat image,
UMat fgmask,
double learningRate) |
void |
BackgroundSubtractorGSOC.apply(UMat image,
UMat fgmask,
double learningRate) |
static void |
BackgroundSubtractorLSBPDesc.calcLocalSVDValues(UMat localSVDValues,
Mat frame) |
static void |
BackgroundSubtractorLSBPDesc.compute(UMat desc,
Mat frame,
Point LSBPSamplePoints) |
static void |
BackgroundSubtractorLSBPDesc.computeFromLocalSVDValues(UMat desc,
Mat localSVDValues,
Point LSBPSamplePoints) |
void |
BackgroundSubtractorCNT.getBackgroundImage(UMat backgroundImage) |
void |
BackgroundSubtractorLSBP.getBackgroundImage(UMat backgroundImage) |
void |
BackgroundSubtractorGSOC.getBackgroundImage(UMat backgroundImage) |
void |
SyntheticSequenceGenerator.getNextFrame(UMat frame,
UMat gtMask) |
Constructor and Description |
---|
SyntheticSequenceGenerator(UMat background,
UMat object,
double amplitude,
double wavelength,
double wavespeed,
double objspeed) |
Modifier and Type | Method and Description |
---|---|
void |
RetinaFastToneMapping.applyFastToneMapping(UMat inputImage,
UMat outputToneMappedImage) |
void |
Retina.applyFastToneMapping(UMat inputImage,
UMat outputToneMappedImage) |
void |
Retina.getMagno(UMat retinaOutput_magno) |
void |
Retina.getMagnoRAW(UMat retinaOutput_magno) |
void |
Retina.getParvo(UMat retinaOutput_parvo) |
void |
Retina.getParvoRAW(UMat retinaOutput_parvo) |
void |
TransientAreasSegmentationModule.getSegmentationPicture(UMat transientAreas) |
void |
Retina.run(UMat inputImage) |
void |
TransientAreasSegmentationModule.run(UMat inputToSegment) |
void |
TransientAreasSegmentationModule.run(UMat inputToSegment,
int channelIndex) |
Modifier and Type | Method and Description |
---|---|
boolean |
LMSolver.Callback.compute(UMat param,
UMat err,
UMat J) |
void |
StereoMatcher.compute(UMat left,
UMat right,
UMat disparity) |
int |
LMSolver.run(UMat param) |
Modifier and Type | Method and Description |
---|---|
UMat |
UMat.adjustROI(int dtop,
int dbottom,
int dleft,
int dright)
moves/resizes the current matrix ROI inside the parent matrix.
|
UMat |
UMat.allocator(MatAllocator setter) |
UMat |
UMat.apply(Range ranges) |
UMat |
UMat.apply(Range rowRange,
Range colRange)
extracts a rectangular sub-matrix
|
UMat |
UMat.apply(Rect roi) |
UMat |
UMat.clone()
returns deep copy of the matrix, i.e.
|
UMat |
UMat.col(int x)
returns a new matrix header for the specified column
|
UMat |
UMat.colRange(int startcol,
int endcol)
...
|
UMat |
UMat.colRange(Range r) |
UMat |
UMat.cols(int setter) |
UMat |
UMat.diag() |
UMat |
UMat.diag(int d)
...
|
static UMat |
UMat.diag(UMat d)
constructs a square diagonal matrix which main diagonal is vector "d"
|
UMat |
UMat.dims(int setter) |
static UMat |
UMat.eye(int rows,
int cols,
int type) |
static UMat |
UMat.eye(Size size,
int type) |
UMat |
UMatBytePairVector.first(long i) |
UMat |
UMat.flags(int setter) |
UMat[] |
UMatVector.get() |
UMat |
UMatVector.Iterator.get() |
UMat |
UMatVector.get(long i) |
UMat |
Mat.getUMat(int accessFlags) |
UMat |
Mat.getUMat(int accessFlags,
int usageFlags)
retrieve UMat from Mat
|
UMat |
UMat.inv() |
UMat |
UMat.inv(int method)
matrix inversion by means of matrix expressions
|
UMat |
KernelArg.m() |
UMat |
UMat.mul(GpuMat m) |
UMat |
UMat.mul(GpuMat m,
double scale) |
UMat |
UMat.mul(Mat m) |
UMat |
UMat.mul(Mat m,
double scale)
per-element matrix multiplication by means of matrix expressions
|
UMat |
UMat.mul(UMat m) |
UMat |
UMat.mul(UMat m,
double scale) |
UMat |
UMat.offset(long setter) |
static UMat |
UMat.ones(int rows,
int cols,
int type) |
static UMat |
UMat.ones(Size size,
int type) |
UMat |
UMatVector.pop_back() |
UMat |
UMat.put(Scalar s)
sets every matrix element to s
|
UMat |
UMat.put(UMat m)
assignment operators
|
UMat |
UMat.reshape(int cn) |
UMat |
UMat.reshape(int cn,
int rows)
creates alternative matrix header for the same data, with different
|
UMat |
UMat.reshape(int cn,
int newndims,
int[] newsz) |
UMat |
UMat.reshape(int cn,
int newndims,
IntBuffer newsz) |
UMat |
UMat.reshape(int cn,
int newndims,
IntPointer newsz) |
UMat |
UMat.row(int y)
returns a new matrix header for the specified row
|
UMat |
UMat.rowRange(int startrow,
int endrow)
...
|
UMat |
UMat.rowRange(Range r) |
UMat |
UMat.rows(int setter) |
UMat |
UMat.setTo(GpuMat value) |
UMat |
UMat.setTo(GpuMat value,
GpuMat mask) |
UMat |
UMat.setTo(Mat value) |
UMat |
UMat.setTo(Mat value,
Mat mask)
sets some of the matrix elements to s, according to the mask
|
UMat |
UMat.setTo(UMat value) |
UMat |
UMat.setTo(UMat value,
UMat mask) |
UMat |
UMat.t()
matrix transposition by means of matrix expressions
|
UMat |
UMat.u(UMatData setter) |
UMat |
UMat.usageFlags(int setter) |
static UMat |
UMat.zeros(int rows,
int cols,
int type)
Matlab-style matrix initialization
|
static UMat |
UMat.zeros(Size size,
int type) |
Modifier and Type | Method and Description |
---|---|
void |
RNG._fill(UMat mat,
int distType,
UMat a,
UMat b) |
void |
RNG._fill(UMat mat,
int distType,
UMat a,
UMat b,
boolean saturateRange) |
SVD |
SVD.apply(UMat src) |
SVD |
SVD.apply(UMat src,
int flags) |
PCA |
PCA.apply(UMat data,
UMat mean,
int flags) |
PCA |
PCA.apply(UMat data,
UMat mean,
int flags,
double retainedVariance) |
PCA |
PCA.apply(UMat data,
UMat mean,
int flags,
int maxComponents) |
void |
UMat.assignTo(UMat m) |
void |
UMat.assignTo(UMat m,
int type) |
Mat |
PCA.backProject(UMat vec) |
void |
PCA.backProject(UMat vec,
UMat result) |
void |
SVD.backSubst(UMat rhs,
UMat dst) |
static void |
SVD.backSubst(UMat w,
UMat u,
UMat vt,
UMat rhs,
UMat dst) |
static boolean |
Image2D.canCreateAlias(UMat u)
Indicates if creating an aliased image should succeed.
|
void |
LDA.compute(GpuMatVector src,
UMat labels) |
void |
LDA.compute(MatVector src,
UMat labels) |
static void |
SVD.compute(UMat src,
UMat w) |
static void |
SVD.compute(UMat src,
UMat w,
int flags) |
static void |
SVD.compute(UMat src,
UMat w,
UMat u,
UMat vt) |
static void |
SVD.compute(UMat src,
UMat w,
UMat u,
UMat vt,
int flags) |
void |
LDA.compute(UMatVector src,
UMat labels) |
void |
Mat.convertTo(UMat m,
int rtype) |
void |
UMat.convertTo(UMat m,
int rtype) |
void |
GpuMat.convertTo(UMat dst,
int rtype) |
void |
GpuMat.convertTo(UMat dst,
int rtype,
double alpha) |
void |
Mat.convertTo(UMat m,
int rtype,
double alpha,
double beta) |
void |
UMat.convertTo(UMat m,
int rtype,
double alpha,
double beta) |
void |
GpuMat.convertTo(UMat dst,
int rtype,
double alpha,
double beta) |
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 |
UMat.copySize(UMat m)
internal use function; properly re-allocates _size, _step arrays
|
void |
Mat.copyTo(UMat m) |
void |
UMat.copyTo(UMat m) |
void |
GpuMat.copyTo(UMat dst) |
void |
GpuMat.copyTo(UMat dst,
Stream stream) |
void |
Mat.copyTo(UMat m,
UMat mask) |
void |
UMat.copyTo(UMat m,
UMat mask) |
void |
GpuMat.copyTo(UMat dst,
UMat mask) |
void |
GpuMat.copyTo(UMat dst,
UMat mask,
Stream stream) |
static DownhillSolver |
DownhillSolver.create(MinProblemSolver.Function f,
UMat initStep,
TermCriteria termcrit) |
Mat |
Mat.cross(UMat m) |
static UMat |
UMat.diag(UMat d)
constructs a square diagonal matrix which main diagonal is vector "d"
|
double |
Mat.dot(UMat m) |
double |
UMat.dot(UMat m) |
void |
GpuMat.download(UMat dst) |
void |
GpuMat.download(UMat dst,
Stream stream) |
UMatBytePairVector |
UMatBytePairVector.first(long i,
UMat first) |
void |
AsyncArray.get(UMat dst) |
boolean |
AsyncArray.get(UMat dst,
double timeoutNs) |
boolean |
AsyncArray.get(UMat dst,
long timeoutNs) |
void |
DownhillSolver.getInitStep(UMat step) |
UMatVector.Iterator |
UMatVector.insert(UMatVector.Iterator pos,
UMat value) |
KernelArg |
KernelArg.m(UMat setter) |
double |
MinProblemSolver.minimize(UMat x) |
MatExpr |
Mat.mul(UMat m) |
UMat |
UMat.mul(UMat m) |
MatExpr |
Mat.mul(UMat m,
double scale) |
UMat |
UMat.mul(UMat m,
double scale) |
Mat |
LDA.project(UMat src) |
Mat |
PCA.project(UMat vec) |
void |
PCA.project(UMat vec,
UMat result) |
static KernelArg |
KernelArg.PtrReadOnly(UMat m) |
static KernelArg |
KernelArg.PtrReadWrite(UMat m) |
static KernelArg |
KernelArg.PtrWriteOnly(UMat m) |
UMatVector |
UMatVector.push_back(UMat value) |
UMatVector |
UMatVector.put(long i,
UMat value) |
UMatVector |
UMatVector.put(UMat... array) |
UMatVector |
UMatVector.put(UMat value) |
UMat |
UMat.put(UMat m)
assignment operators
|
UMatBytePairVector |
UMatBytePairVector.put(UMat[] firstValue,
byte[] secondValue) |
static KernelArg |
KernelArg.ReadOnly(UMat m) |
static KernelArg |
KernelArg.ReadOnly(UMat m,
int wscale,
int iwscale) |
static KernelArg |
KernelArg.ReadOnlyNoSize(UMat m) |
static KernelArg |
KernelArg.ReadOnlyNoSize(UMat m,
int wscale,
int iwscale) |
static KernelArg |
KernelArg.ReadWrite(UMat m) |
static KernelArg |
KernelArg.ReadWrite(UMat m,
int wscale,
int iwscale) |
static KernelArg |
KernelArg.ReadWriteNoSize(UMat m) |
static KernelArg |
KernelArg.ReadWriteNoSize(UMat m,
int wscale,
int iwscale) |
Mat |
LDA.reconstruct(UMat src) |
int |
Kernel.set(int i,
UMat m) |
void |
DownhillSolver.setInitStep(UMat step) |
GpuMat |
GpuMat.setTo(Scalar s,
UMat mask) |
GpuMat |
GpuMat.setTo(Scalar s,
UMat mask,
Stream stream) |
Mat |
Mat.setTo(UMat value) |
UMat |
UMat.setTo(UMat value) |
Mat |
Mat.setTo(UMat value,
UMat mask) |
UMat |
UMat.setTo(UMat value,
UMat mask) |
static void |
SVD.solveZ(UMat src,
UMat dst) |
static Mat |
LDA.subspaceProject(UMat W,
UMat mean,
UMat src) |
static Mat |
LDA.subspaceReconstruct(UMat W,
UMat mean,
UMat src) |
void |
GpuMat.upload(UMat arr) |
void |
GpuMat.upload(UMat arr,
Stream stream) |
static KernelArg |
KernelArg.WriteOnly(UMat m) |
static KernelArg |
KernelArg.WriteOnly(UMat m,
int wscale,
int iwscale) |
static KernelArg |
KernelArg.WriteOnlyNoSize(UMat m) |
static KernelArg |
KernelArg.WriteOnlyNoSize(UMat m,
int wscale,
int iwscale) |
Constructor and Description |
---|
GpuMat(UMat arr) |
GpuMat(UMat arr,
GpuMat.Allocator allocator) |
HostMem(UMat arr) |
HostMem(UMat arr,
int alloc_type) |
Image2D(UMat src) |
Image2D(UMat src,
boolean norm,
boolean alias) |
KernelArg(int _flags,
UMat _m) |
KernelArg(int _flags,
UMat _m,
int wscale,
int iwscale,
Pointer _obj,
long _sz) |
LDA(GpuMatVector src,
UMat labels) |
LDA(GpuMatVector src,
UMat labels,
int num_components) |
LDA(MatVector src,
UMat labels) |
LDA(MatVector src,
UMat labels,
int num_components) |
LDA(UMatVector src,
UMat labels) |
LDA(UMatVector src,
UMat labels,
int num_components) |
PCA(UMat data,
UMat mean,
int flags) |
PCA(UMat data,
UMat mean,
int flags,
double retainedVariance) |
PCA(UMat data,
UMat mean,
int flags,
int maxComponents) |
SVD(UMat src) |
SVD(UMat src,
int flags) |
UMat(UMat m)
copy constructor
|
UMat(UMat m,
Range rowRange) |
UMat(UMat m,
Range rowRange,
Range colRange)
creates a matrix header for a part of the bigger matrix
|
UMat(UMat m,
Rect roi) |
UMatBytePairVector(UMat[] firstValue,
byte[] secondValue) |
UMatVector(UMat... array) |
UMatVector(UMat value) |
Modifier and Type | Method and Description |
---|---|
void |
DFT.compute(UMat image,
UMat result) |
void |
DFT.compute(UMat image,
UMat result,
Stream stream) |
void |
Convolution.convolve(UMat image,
UMat templ,
UMat result) |
void |
Convolution.convolve(UMat image,
UMat templ,
UMat result,
boolean ccorr,
Stream stream) |
void |
LookUpTable.transform(UMat src,
UMat dst) |
void |
LookUpTable.transform(UMat src,
UMat dst,
Stream stream) |
Modifier and Type | Method and Description |
---|---|
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(UMat backgroundImage,
Stream stream) |
void |
BackgroundSubtractorMOG2.getBackgroundImage(UMat backgroundImage,
Stream stream) |
Modifier and Type | Method and Description |
---|---|
void |
VideoWriter.write(UMat frame) |
void |
VideoWriter.write(UMat frame,
boolean lastFrame) |
Modifier and Type | Method and Description |
---|---|
void |
Feature2DAsync.computeAsync(UMat image,
UMat keypoints,
UMat descriptors) |
void |
Feature2DAsync.computeAsync(UMat image,
UMat keypoints,
UMat descriptors,
Stream stream) |
void |
Feature2DAsync.convert(UMat gpu_keypoints,
KeyPointVector keypoints) |
void |
Feature2DAsync.detectAndComputeAsync(UMat image,
UMat mask,
UMat keypoints,
UMat descriptors) |
void |
Feature2DAsync.detectAndComputeAsync(UMat image,
UMat mask,
UMat keypoints,
UMat descriptors,
boolean useProvidedKeypoints,
Stream stream) |
void |
Feature2DAsync.detectAsync(UMat image,
UMat keypoints) |
void |
Feature2DAsync.detectAsync(UMat image,
UMat keypoints,
UMat mask,
Stream stream) |
void |
DescriptorMatcher.knnMatch(UMat queryDescriptors,
DMatchVectorVector matches,
int k) |
void |
DescriptorMatcher.knnMatch(UMat queryDescriptors,
DMatchVectorVector matches,
int k,
GpuMatVector masks,
boolean compactResult) |
void |
DescriptorMatcher.knnMatch(UMat queryDescriptors,
UMat trainDescriptors,
DMatchVectorVector matches,
int k) |
void |
DescriptorMatcher.knnMatch(UMat queryDescriptors,
UMat trainDescriptors,
DMatchVectorVector matches,
int k,
UMat mask,
boolean compactResult) |
void |
DescriptorMatcher.knnMatchAsync(UMat queryDescriptors,
UMat matches,
int k) |
void |
DescriptorMatcher.knnMatchAsync(UMat queryDescriptors,
UMat matches,
int k,
GpuMatVector masks,
Stream stream) |
void |
DescriptorMatcher.knnMatchAsync(UMat queryDescriptors,
UMat trainDescriptors,
UMat matches,
int k) |
void |
DescriptorMatcher.knnMatchAsync(UMat queryDescriptors,
UMat trainDescriptors,
UMat matches,
int k,
UMat mask,
Stream stream) |
void |
DescriptorMatcher.knnMatchConvert(UMat gpu_matches,
DMatchVectorVector matches) |
void |
DescriptorMatcher.knnMatchConvert(UMat gpu_matches,
DMatchVectorVector matches,
boolean compactResult) |
void |
DescriptorMatcher.match(UMat queryDescriptors,
DMatchVector matches) |
void |
DescriptorMatcher.match(UMat queryDescriptors,
DMatchVector matches,
GpuMatVector masks) |
void |
DescriptorMatcher.match(UMat queryDescriptors,
UMat trainDescriptors,
DMatchVector matches) |
void |
DescriptorMatcher.match(UMat queryDescriptors,
UMat trainDescriptors,
DMatchVector matches,
UMat mask) |
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.matchConvert(UMat gpu_matches,
DMatchVector matches) |
void |
DescriptorMatcher.radiusMatch(UMat queryDescriptors,
DMatchVectorVector matches,
float maxDistance) |
void |
DescriptorMatcher.radiusMatch(UMat queryDescriptors,
DMatchVectorVector matches,
float maxDistance,
GpuMatVector masks,
boolean compactResult) |
void |
DescriptorMatcher.radiusMatch(UMat queryDescriptors,
UMat trainDescriptors,
DMatchVectorVector matches,
float maxDistance) |
void |
DescriptorMatcher.radiusMatch(UMat queryDescriptors,
UMat trainDescriptors,
DMatchVectorVector matches,
float maxDistance,
UMat mask,
boolean compactResult) |
void |
DescriptorMatcher.radiusMatchAsync(UMat queryDescriptors,
UMat matches,
float maxDistance) |
void |
DescriptorMatcher.radiusMatchAsync(UMat queryDescriptors,
UMat matches,
float maxDistance,
GpuMatVector masks,
Stream stream) |
void |
DescriptorMatcher.radiusMatchAsync(UMat queryDescriptors,
UMat trainDescriptors,
UMat matches,
float maxDistance) |
void |
DescriptorMatcher.radiusMatchAsync(UMat queryDescriptors,
UMat trainDescriptors,
UMat matches,
float maxDistance,
UMat mask,
Stream stream) |
void |
DescriptorMatcher.radiusMatchConvert(UMat gpu_matches,
DMatchVectorVector matches) |
void |
DescriptorMatcher.radiusMatchConvert(UMat gpu_matches,
DMatchVectorVector matches,
boolean compactResult) |
Modifier and Type | Method and Description |
---|---|
void |
Filter.apply(UMat src,
UMat dst) |
void |
Filter.apply(UMat src,
UMat dst,
Stream stream) |
Modifier and Type | Method and Description |
---|---|
void |
CudaCLAHE.apply(UMat src,
UMat dst,
Stream stream) |
void |
CornernessCriteria.compute(UMat src,
UMat dst) |
void |
CornernessCriteria.compute(UMat src,
UMat dst,
Stream stream) |
void |
HoughLinesDetector.detect(UMat src,
UMat lines) |
void |
CannyEdgeDetector.detect(UMat image,
UMat edges) |
void |
HoughSegmentDetector.detect(UMat src,
UMat lines) |
void |
CornersDetector.detect(UMat image,
UMat corners) |
void |
HoughCirclesDetector.detect(UMat src,
UMat circles) |
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) |
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(UMat d_lines,
UMat h_lines) |
void |
HoughLinesDetector.downloadResults(UMat d_lines,
UMat h_lines,
UMat h_votes,
Stream stream) |
void |
TemplateMatching.match(UMat image,
UMat templ,
UMat result) |
void |
TemplateMatching.match(UMat image,
UMat templ,
UMat result,
Stream stream) |
Modifier and Type | Method and Description |
---|---|
void |
HOG.compute(UMat img,
UMat descriptors) |
void |
HOG.compute(UMat img,
UMat descriptors,
Stream stream) |
void |
CudaCascadeClassifier.convert(UMat gpu_objects,
RectVector objects) |
void |
HOG.detect(UMat img,
PointVector found_locations) |
void |
HOG.detect(UMat img,
PointVector found_locations,
double[] confidences) |
void |
HOG.detect(UMat img,
PointVector found_locations,
DoubleBuffer confidences) |
void |
HOG.detect(UMat img,
PointVector found_locations,
DoublePointer confidences) |
void |
HOG.detectMultiScale(UMat img,
RectVector found_locations) |
void |
HOG.detectMultiScale(UMat img,
RectVector found_locations,
double[] confidences) |
void |
HOG.detectMultiScale(UMat img,
RectVector found_locations,
DoubleBuffer confidences) |
void |
HOG.detectMultiScale(UMat img,
RectVector found_locations,
DoublePointer confidences) |
void |
CudaCascadeClassifier.detectMultiScale(UMat image,
UMat objects) |
void |
CudaCascadeClassifier.detectMultiScale(UMat image,
UMat objects,
Stream stream) |
void |
HOG.detectMultiScaleWithoutConf(UMat img,
RectVector found_locations) |
void |
HOG.detectWithoutConf(UMat img,
PointVector found_locations) |
void |
HOG.setSVMDetector(UMat detector) |
Modifier and Type | Method and Description |
---|---|
void |
DenseOpticalFlow.calc(UMat I0,
UMat I1,
UMat flow) |
void |
NvidiaHWOpticalFlow.calc(UMat inputImage,
UMat referenceImage,
UMat flow) |
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) |
void |
SparseOpticalFlow.calc(UMat prevImg,
UMat nextImg,
UMat prevPts,
UMat nextPts,
UMat status,
UMat err,
Stream stream) |
void |
NvidiaOpticalFlow_1_0.upSampler(UMat flow,
int width,
int height,
int gridSize,
UMat upsampledFlow) |
Modifier and Type | Method and Description |
---|---|
void |
DisparityBilateralFilter.apply(UMat disparity,
UMat image,
UMat dst) |
void |
DisparityBilateralFilter.apply(UMat disparity,
UMat image,
UMat dst,
Stream stream) |
void |
StereoBeliefPropagation.compute(UMat data,
UMat disparity) |
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) |
Modifier and Type | Method and Description |
---|---|
IntFloatPair |
ClassificationModel.classify(UMat frame) |
void |
ClassificationModel.classify(UMat frame,
int[] classId,
float[] conf) |
void |
ClassificationModel.classify(UMat frame,
IntBuffer classId,
FloatBuffer conf) |
void |
ClassificationModel.classify(UMat frame,
IntPointer classId,
FloatPointer conf) |
void |
DetectionModel.detect(UMat frame,
int[] classIds,
float[] confidences,
RectVector boxes) |
void |
DetectionModel.detect(UMat frame,
int[] classIds,
float[] confidences,
RectVector boxes,
float confThreshold,
float nmsThreshold) |
void |
DetectionModel.detect(UMat frame,
IntBuffer classIds,
FloatBuffer confidences,
RectVector boxes) |
void |
DetectionModel.detect(UMat frame,
IntBuffer classIds,
FloatBuffer confidences,
RectVector boxes,
float confThreshold,
float nmsThreshold) |
void |
DetectionModel.detect(UMat frame,
IntPointer classIds,
FloatPointer confidences,
RectVector boxes) |
void |
DetectionModel.detect(UMat frame,
IntPointer classIds,
FloatPointer confidences,
RectVector boxes,
float confThreshold,
float nmsThreshold) |
Point2fVector |
KeypointsModel.estimate(UMat frame) |
Point2fVector |
KeypointsModel.estimate(UMat frame,
float thresh) |
void |
Model.predict(UMat frame,
GpuMatVector outs) |
void |
Model.predict(UMat frame,
MatVector outs) |
void |
Model.predict(UMat frame,
UMatVector outs) |
void |
SegmentationModel.segment(UMat frame,
UMat mask) |
void |
Net.setInput(UMat blob) |
void |
Net.setInput(UMat blob,
BytePointer name,
double scalefactor,
Scalar mean) |
void |
Net.setInput(UMat blob,
String name,
double scalefactor,
Scalar mean) |
Modifier and Type | Method and Description |
---|---|
void |
DnnSuperResImpl.upsample(UMat img,
UMat result) |
void |
DnnSuperResImpl.upsampleMultioutput(UMat img,
MatVector imgs_new,
int[] scale_factors,
StringVector node_names) |
void |
DnnSuperResImpl.upsampleMultioutput(UMat img,
MatVector imgs_new,
IntBuffer scale_factors,
StringVector node_names) |
void |
DnnSuperResImpl.upsampleMultioutput(UMat img,
MatVector imgs_new,
IntPointer scale_factors,
StringVector node_names) |
Modifier and Type | Method and Description |
---|---|
void |
FaceRecognizer.predict_collect(UMat src,
PredictCollector collector) |
int |
FaceRecognizer.predict_label(UMat src) |
void |
FaceRecognizer.predict(UMat src,
int[] label,
double[] confidence) |
void |
FaceRecognizer.predict(UMat src,
IntBuffer label,
DoubleBuffer confidence) |
void |
FaceRecognizer.predict(UMat src,
IntPointer label,
DoublePointer confidence) |
void |
FaceRecognizer.train(GpuMatVector src,
UMat labels) |
void |
FaceRecognizer.train(MatVector src,
UMat labels) |
void |
FaceRecognizer.train(UMatVector src,
UMat labels) |
void |
FaceRecognizer.update(GpuMatVector src,
UMat labels) |
void |
FaceRecognizer.update(MatVector src,
UMat labels) |
void |
FaceRecognizer.update(UMatVector src,
UMat labels) |
Modifier and Type | Method and Description |
---|---|
void |
BOWImgDescriptorExtractor.compute(UMat image,
KeyPointVector keypoints,
UMat imgDescriptor) |
void |
Feature2D.compute(UMat image,
KeyPointVector keypoints,
UMat descriptors) |
void |
BOWImgDescriptorExtractor.compute(UMat image,
KeyPointVector keypoints,
UMat imgDescriptor,
IntVectorVector pointIdxsOfClusters,
Mat descriptors) |
void |
BOWImgDescriptorExtractor.compute(UMat keypointDescriptors,
UMat imgDescriptor) |
void |
BOWImgDescriptorExtractor.compute(UMat keypointDescriptors,
UMat imgDescriptor,
IntVectorVector pointIdxsOfClusters) |
void |
Feature2D.detect(UMat image,
KeyPointVector keypoints) |
void |
Feature2D.detect(UMat image,
KeyPointVector keypoints,
UMat mask) |
void |
Feature2D.detectAndCompute(UMat image,
UMat mask,
KeyPointVector keypoints,
UMat descriptors) |
void |
Feature2D.detectAndCompute(UMat image,
UMat mask,
KeyPointVector keypoints,
UMat descriptors,
boolean useProvidedKeypoints) |
void |
MSER.detectRegions(UMat image,
PointVectorVector msers,
RectVector bboxes) |
void |
DescriptorMatcher.knnMatch(UMat queryDescriptors,
DMatchVectorVector matches,
int k) |
void |
DescriptorMatcher.knnMatch(UMat queryDescriptors,
DMatchVectorVector matches,
int k,
GpuMatVector masks,
boolean compactResult) |
void |
DescriptorMatcher.knnMatch(UMat queryDescriptors,
DMatchVectorVector matches,
int k,
MatVector masks,
boolean compactResult) |
void |
DescriptorMatcher.knnMatch(UMat queryDescriptors,
DMatchVectorVector matches,
int k,
UMatVector masks,
boolean compactResult) |
void |
DescriptorMatcher.knnMatch(UMat queryDescriptors,
UMat trainDescriptors,
DMatchVectorVector matches,
int k) |
void |
DescriptorMatcher.knnMatch(UMat queryDescriptors,
UMat trainDescriptors,
DMatchVectorVector matches,
int k,
UMat mask,
boolean compactResult) |
void |
DescriptorMatcher.match(UMat queryDescriptors,
DMatchVector matches) |
void |
DescriptorMatcher.match(UMat queryDescriptors,
DMatchVector matches,
GpuMatVector masks) |
void |
DescriptorMatcher.match(UMat queryDescriptors,
DMatchVector matches,
MatVector masks) |
void |
DescriptorMatcher.match(UMat queryDescriptors,
DMatchVector matches,
UMatVector masks) |
void |
DescriptorMatcher.match(UMat queryDescriptors,
UMat trainDescriptors,
DMatchVector matches) |
void |
DescriptorMatcher.match(UMat queryDescriptors,
UMat trainDescriptors,
DMatchVector matches,
UMat mask) |
void |
DescriptorMatcher.radiusMatch(UMat queryDescriptors,
DMatchVectorVector matches,
float maxDistance) |
void |
DescriptorMatcher.radiusMatch(UMat queryDescriptors,
DMatchVectorVector matches,
float maxDistance,
GpuMatVector masks,
boolean compactResult) |
void |
DescriptorMatcher.radiusMatch(UMat queryDescriptors,
DMatchVectorVector matches,
float maxDistance,
MatVector masks,
boolean compactResult) |
void |
DescriptorMatcher.radiusMatch(UMat queryDescriptors,
DMatchVectorVector matches,
float maxDistance,
UMatVector masks,
boolean compactResult) |
void |
DescriptorMatcher.radiusMatch(UMat queryDescriptors,
UMat trainDescriptors,
DMatchVectorVector matches,
float maxDistance) |
void |
DescriptorMatcher.radiusMatch(UMat queryDescriptors,
UMat trainDescriptors,
DMatchVectorVector matches,
float maxDistance,
UMat mask,
boolean compactResult) |
Modifier and Type | Method and Description |
---|---|
void |
Index.build(UMat features,
IndexParams params) |
void |
Index.build(UMat features,
IndexParams params,
int distType) |
void |
Index.knnSearch(UMat query,
UMat indices,
UMat dists,
int knn) |
void |
Index.knnSearch(UMat query,
UMat indices,
UMat dists,
int knn,
SearchParams params) |
boolean |
Index.load(UMat features,
BytePointer filename) |
boolean |
Index.load(UMat features,
String filename) |
int |
Index.radiusSearch(UMat query,
UMat indices,
UMat dists,
double radius,
int maxResults) |
int |
Index.radiusSearch(UMat query,
UMat indices,
UMat dists,
double radius,
int maxResults,
SearchParams params) |
Constructor and Description |
---|
Index(UMat features,
IndexParams params) |
Index(UMat features,
IndexParams params,
int distType) |
Modifier and Type | Method and Description |
---|---|
double |
ImgHashBase.compare(UMat hashOne,
UMat hashTwo) |
void |
ImgHashBase.compute(UMat inputArr,
UMat outputArr) |
Modifier and Type | Method and Description |
---|---|
void |
CLAHE.apply(UMat src,
UMat dst) |
int |
LineSegmentDetector.compareSegments(Size size,
UMat lines1,
UMat lines2) |
int |
LineSegmentDetector.compareSegments(Size size,
UMat lines1,
UMat lines2,
UMat _image) |
void |
LineSegmentDetector.detect(UMat _image,
UMat _lines) |
void |
GeneralizedHough.detect(UMat image,
UMat positions) |
void |
GeneralizedHough.detect(UMat image,
UMat positions,
UMat votes) |
void |
GeneralizedHough.detect(UMat edges,
UMat dx,
UMat dy,
UMat positions) |
void |
LineSegmentDetector.detect(UMat _image,
UMat _lines,
UMat width,
UMat prec,
UMat nfa) |
void |
GeneralizedHough.detect(UMat edges,
UMat dx,
UMat dy,
UMat positions,
UMat votes) |
void |
LineSegmentDetector.drawSegments(UMat _image,
UMat lines) |
void |
GeneralizedHough.setTemplate(UMat templ) |
void |
GeneralizedHough.setTemplate(UMat templ,
Point templCenter) |
void |
GeneralizedHough.setTemplate(UMat edges,
UMat dx,
UMat dy) |
void |
GeneralizedHough.setTemplate(UMat edges,
UMat dx,
UMat dy,
Point templCenter) |
Modifier and Type | Method and Description |
---|---|
float |
StatModel.calcError(TrainData data,
boolean test,
UMat resp) |
static TrainData |
TrainData.create(UMat samples,
int layout,
UMat responses) |
static TrainData |
TrainData.create(UMat samples,
int layout,
UMat responses,
UMat varIdx,
UMat sampleIdx,
UMat sampleWeights,
UMat varType) |
float |
KNearest.findNearest(UMat samples,
int k,
UMat results) |
float |
KNearest.findNearest(UMat samples,
int k,
UMat results,
UMat neighborResponses,
UMat dist) |
double |
SVM.getDecisionFunction(int i,
UMat alpha,
UMat svidx) |
void |
TrainData.getNormCatValues(int vi,
UMat sidx,
int[] values) |
void |
TrainData.getNormCatValues(int vi,
UMat sidx,
IntBuffer values) |
void |
TrainData.getNormCatValues(int vi,
UMat sidx,
IntPointer values) |
void |
TrainData.getSample(UMat varIdx,
int sidx,
float[] buf) |
void |
TrainData.getSample(UMat varIdx,
int sidx,
FloatBuffer buf) |
void |
TrainData.getSample(UMat varIdx,
int sidx,
FloatPointer buf) |
void |
TrainData.getValues(int vi,
UMat sidx,
float[] values) |
void |
TrainData.getValues(int vi,
UMat sidx,
FloatBuffer values) |
void |
TrainData.getValues(int vi,
UMat sidx,
FloatPointer values) |
void |
RTrees.getVotes(UMat samples,
UMat results,
int flags) |
float |
LogisticRegression.predict(UMat samples) |
float |
EM.predict(UMat samples) |
float |
StatModel.predict(UMat samples) |
float |
LogisticRegression.predict(UMat samples,
UMat results,
int flags) |
float |
EM.predict(UMat samples,
UMat results,
int flags) |
float |
StatModel.predict(UMat samples,
UMat results,
int flags) |
Point2d |
EM.predict2(UMat sample,
UMat probs) |
float |
NormalBayesClassifier.predictProb(UMat inputs,
UMat outputs,
UMat outputProbs) |
float |
NormalBayesClassifier.predictProb(UMat inputs,
UMat outputs,
UMat outputProbs,
int flags) |
void |
ANN_MLP.setLayerSizes(UMat _layer_sizes) |
boolean |
StatModel.train(UMat samples,
int layout,
UMat responses) |
boolean |
SVM.trainAuto(UMat samples,
int layout,
UMat responses) |
boolean |
SVM.trainAuto(UMat samples,
int layout,
UMat responses,
int kFold,
ParamGrid Cgrid,
ParamGrid gammaGrid,
ParamGrid pGrid,
ParamGrid nuGrid,
ParamGrid coeffGrid,
ParamGrid degreeGrid,
boolean balanced) |
boolean |
EM.trainE(UMat samples,
UMat means0) |
boolean |
EM.trainE(UMat samples,
UMat means0,
UMat covs0,
UMat weights0,
UMat logLikelihoods,
UMat labels,
UMat probs) |
boolean |
EM.trainEM(UMat samples) |
boolean |
EM.trainEM(UMat samples,
UMat logLikelihoods,
UMat labels,
UMat probs) |
boolean |
EM.trainM(UMat samples,
UMat probs0) |
boolean |
EM.trainM(UMat samples,
UMat probs0,
UMat logLikelihoods,
UMat labels,
UMat probs) |
Modifier and Type | Method and Description |
---|---|
UMat |
HOGDescriptor.oclSvmDetector()
coefficients for the linear SVM classifier used when OpenCL is enabled
|
Modifier and Type | Method and Description |
---|---|
void |
HOGDescriptor.compute(UMat img,
float[] descriptors) |
void |
HOGDescriptor.compute(UMat img,
float[] descriptors,
Size winStride,
Size padding,
PointVector locations) |
void |
HOGDescriptor.compute(UMat img,
FloatBuffer descriptors) |
void |
HOGDescriptor.compute(UMat img,
FloatBuffer descriptors,
Size winStride,
Size padding,
PointVector locations) |
void |
HOGDescriptor.compute(UMat img,
FloatPointer descriptors) |
void |
HOGDescriptor.compute(UMat img,
FloatPointer descriptors,
Size winStride,
Size padding,
PointVector locations) |
void |
HOGDescriptor.computeGradient(UMat img,
UMat grad,
UMat angleOfs) |
void |
HOGDescriptor.computeGradient(UMat img,
UMat grad,
UMat angleOfs,
Size paddingTL,
Size paddingBR) |
String |
QRCodeDetector.decode(UMat img,
UMat points) |
String |
QRCodeDetector.decode(UMat img,
UMat points,
UMat straight_qrcode) |
boolean |
QRCodeDetector.decodeMulti(UMat img,
UMat points,
StringVector decoded_info) |
boolean |
QRCodeDetector.decodeMulti(UMat img,
UMat points,
StringVector decoded_info,
GpuMatVector straight_qrcode) |
boolean |
QRCodeDetector.decodeMulti(UMat img,
UMat points,
StringVector decoded_info,
MatVector straight_qrcode) |
boolean |
QRCodeDetector.decodeMulti(UMat img,
UMat points,
StringVector decoded_info,
UMatVector straight_qrcode) |
void |
HOGDescriptor.detect(UMat img,
PointVector foundLocations) |
void |
HOGDescriptor.detect(UMat img,
PointVector foundLocations,
double[] weights) |
void |
HOGDescriptor.detect(UMat img,
PointVector foundLocations,
double[] weights,
double hitThreshold,
Size winStride,
Size padding,
PointVector searchLocations) |
void |
HOGDescriptor.detect(UMat img,
PointVector foundLocations,
DoubleBuffer weights) |
void |
HOGDescriptor.detect(UMat img,
PointVector foundLocations,
DoubleBuffer weights,
double hitThreshold,
Size winStride,
Size padding,
PointVector searchLocations) |
void |
HOGDescriptor.detect(UMat img,
PointVector foundLocations,
DoublePointer weights) |
void |
HOGDescriptor.detect(UMat img,
PointVector foundLocations,
DoublePointer weights,
double hitThreshold,
Size winStride,
Size padding,
PointVector searchLocations) |
void |
HOGDescriptor.detect(UMat img,
PointVector foundLocations,
double hitThreshold,
Size winStride,
Size padding,
PointVector searchLocations) |
boolean |
QRCodeDetector.detect(UMat img,
UMat points) |
String |
QRCodeDetector.detectAndDecode(UMat img) |
String |
QRCodeDetector.detectAndDecode(UMat img,
UMat points,
UMat straight_qrcode) |
boolean |
QRCodeDetector.detectAndDecodeMulti(UMat img,
StringVector decoded_info) |
boolean |
QRCodeDetector.detectAndDecodeMulti(UMat img,
StringVector decoded_info,
UMat points,
GpuMatVector straight_qrcode) |
boolean |
QRCodeDetector.detectAndDecodeMulti(UMat img,
StringVector decoded_info,
UMat points,
MatVector straight_qrcode) |
boolean |
QRCodeDetector.detectAndDecodeMulti(UMat img,
StringVector decoded_info,
UMat points,
UMatVector straight_qrcode) |
boolean |
QRCodeDetector.detectMulti(UMat img,
UMat points) |
void |
CascadeClassifier.detectMultiScale(UMat image,
RectVector objects) |
void |
HOGDescriptor.detectMultiScale(UMat img,
RectVector foundLocations) |
void |
HOGDescriptor.detectMultiScale(UMat img,
RectVector foundLocations,
double[] foundWeights) |
void |
HOGDescriptor.detectMultiScale(UMat img,
RectVector foundLocations,
double[] foundWeights,
double hitThreshold,
Size winStride,
Size padding,
double scale,
double finalThreshold,
boolean useMeanshiftGrouping) |
void |
HOGDescriptor.detectMultiScale(UMat img,
RectVector foundLocations,
DoubleBuffer foundWeights) |
void |
HOGDescriptor.detectMultiScale(UMat img,
RectVector foundLocations,
DoubleBuffer foundWeights,
double hitThreshold,
Size winStride,
Size padding,
double scale,
double finalThreshold,
boolean useMeanshiftGrouping) |
void |
CascadeClassifier.detectMultiScale(UMat image,
RectVector objects,
double scaleFactor,
int minNeighbors,
int flags,
Size minSize,
Size maxSize) |
void |
BaseCascadeClassifier.detectMultiScale(UMat image,
RectVector objects,
double scaleFactor,
int minNeighbors,
int flags,
Size minSize,
Size maxSize) |
void |
HOGDescriptor.detectMultiScale(UMat img,
RectVector foundLocations,
DoublePointer foundWeights) |
void |
HOGDescriptor.detectMultiScale(UMat img,
RectVector foundLocations,
DoublePointer foundWeights,
double hitThreshold,
Size winStride,
Size padding,
double scale,
double finalThreshold,
boolean useMeanshiftGrouping) |
void |
HOGDescriptor.detectMultiScale(UMat img,
RectVector foundLocations,
double hitThreshold,
Size winStride,
Size padding,
double scale,
double finalThreshold,
boolean useMeanshiftGrouping) |
void |
BaseCascadeClassifier.detectMultiScale(UMat image,
RectVector objects,
int[] rejectLevels,
double[] levelWeights,
double scaleFactor,
int minNeighbors,
int flags,
Size minSize,
Size maxSize,
boolean outputRejectLevels) |
void |
BaseCascadeClassifier.detectMultiScale(UMat image,
RectVector objects,
int[] numDetections,
double scaleFactor,
int minNeighbors,
int flags,
Size minSize,
Size maxSize) |
void |
BaseCascadeClassifier.detectMultiScale(UMat image,
RectVector objects,
IntBuffer rejectLevels,
DoubleBuffer levelWeights,
double scaleFactor,
int minNeighbors,
int flags,
Size minSize,
Size maxSize,
boolean outputRejectLevels) |
void |
BaseCascadeClassifier.detectMultiScale(UMat image,
RectVector objects,
IntBuffer numDetections,
double scaleFactor,
int minNeighbors,
int flags,
Size minSize,
Size maxSize) |
void |
BaseCascadeClassifier.detectMultiScale(UMat image,
RectVector objects,
IntPointer numDetections,
double scaleFactor,
int minNeighbors,
int flags,
Size minSize,
Size maxSize) |
void |
BaseCascadeClassifier.detectMultiScale(UMat image,
RectVector objects,
IntPointer rejectLevels,
DoublePointer levelWeights,
double scaleFactor,
int minNeighbors,
int flags,
Size minSize,
Size maxSize,
boolean outputRejectLevels) |
void |
CascadeClassifier.detectMultiScale2(UMat image,
RectVector objects,
int[] numDetections) |
void |
CascadeClassifier.detectMultiScale2(UMat image,
RectVector objects,
int[] numDetections,
double scaleFactor,
int minNeighbors,
int flags,
Size minSize,
Size maxSize) |
void |
CascadeClassifier.detectMultiScale2(UMat image,
RectVector objects,
IntBuffer numDetections) |
void |
CascadeClassifier.detectMultiScale2(UMat image,
RectVector objects,
IntBuffer numDetections,
double scaleFactor,
int minNeighbors,
int flags,
Size minSize,
Size maxSize) |
void |
CascadeClassifier.detectMultiScale2(UMat image,
RectVector objects,
IntPointer numDetections) |
void |
CascadeClassifier.detectMultiScale2(UMat image,
RectVector objects,
IntPointer numDetections,
double scaleFactor,
int minNeighbors,
int flags,
Size minSize,
Size maxSize) |
void |
CascadeClassifier.detectMultiScale3(UMat image,
RectVector objects,
int[] rejectLevels,
double[] levelWeights) |
void |
CascadeClassifier.detectMultiScale3(UMat image,
RectVector objects,
int[] rejectLevels,
double[] levelWeights,
double scaleFactor,
int minNeighbors,
int flags,
Size minSize,
Size maxSize,
boolean outputRejectLevels) |
void |
CascadeClassifier.detectMultiScale3(UMat image,
RectVector objects,
IntBuffer rejectLevels,
DoubleBuffer levelWeights) |
void |
CascadeClassifier.detectMultiScale3(UMat image,
RectVector objects,
IntBuffer rejectLevels,
DoubleBuffer levelWeights,
double scaleFactor,
int minNeighbors,
int flags,
Size minSize,
Size maxSize,
boolean outputRejectLevels) |
void |
CascadeClassifier.detectMultiScale3(UMat image,
RectVector objects,
IntPointer rejectLevels,
DoublePointer levelWeights) |
void |
CascadeClassifier.detectMultiScale3(UMat image,
RectVector objects,
IntPointer rejectLevels,
DoublePointer levelWeights,
double scaleFactor,
int minNeighbors,
int flags,
Size minSize,
Size maxSize,
boolean outputRejectLevels) |
void |
HOGDescriptor.detectMultiScaleROI(UMat img,
RectVector foundLocations,
DetectionROI locations) |
void |
HOGDescriptor.detectMultiScaleROI(UMat img,
RectVector foundLocations,
DetectionROI locations,
double hitThreshold,
int groupThreshold) |
void |
HOGDescriptor.detectROI(UMat img,
PointVector locations,
PointVector foundLocations,
double[] confidences) |
void |
HOGDescriptor.detectROI(UMat img,
PointVector locations,
PointVector foundLocations,
double[] confidences,
double hitThreshold,
Size winStride,
Size padding) |
void |
HOGDescriptor.detectROI(UMat img,
PointVector locations,
PointVector foundLocations,
DoubleBuffer confidences) |
void |
HOGDescriptor.detectROI(UMat img,
PointVector locations,
PointVector foundLocations,
DoubleBuffer confidences,
double hitThreshold,
Size winStride,
Size padding) |
void |
HOGDescriptor.detectROI(UMat img,
PointVector locations,
PointVector foundLocations,
DoublePointer confidences) |
void |
HOGDescriptor.detectROI(UMat img,
PointVector locations,
PointVector foundLocations,
DoublePointer confidences,
double hitThreshold,
Size winStride,
Size padding) |
HOGDescriptor |
HOGDescriptor.oclSvmDetector(UMat setter) |
void |
HOGDescriptor.setSVMDetector(UMat svmdetector) |
Modifier and Type | Method and Description |
---|---|
void |
HistogramPhaseUnwrapping.getInverseReliabilityMap(UMat reliabilityMap) |
void |
PhaseUnwrapping.unwrapPhaseMap(UMat wrappedPhaseMap,
UMat unwrappedPhaseMap) |
void |
PhaseUnwrapping.unwrapPhaseMap(UMat wrappedPhaseMap,
UMat unwrappedPhaseMap,
UMat shadowMask) |
Modifier and Type | Method and Description |
---|---|
Point |
AlignMTB.calculateShift(UMat img0,
UMat img1) |
void |
AlignMTB.computeBitmaps(UMat img,
UMat tb,
UMat eb) |
void |
AlignMTB.process(GpuMatVector src,
MatVector dst,
UMat times,
UMat response) |
void |
AlignExposures.process(GpuMatVector src,
MatVector dst,
UMat times,
UMat response) |
void |
MergeMertens.process(GpuMatVector src,
UMat dst) |
void |
CalibrateCRF.process(GpuMatVector src,
UMat dst,
UMat times) |
void |
MergeDebevec.process(GpuMatVector src,
UMat dst,
UMat times) |
void |
MergeRobertson.process(GpuMatVector src,
UMat dst,
UMat times) |
void |
MergeDebevec.process(GpuMatVector src,
UMat dst,
UMat times,
UMat response) |
void |
MergeRobertson.process(GpuMatVector src,
UMat dst,
UMat times,
UMat response) |
void |
MergeExposures.process(GpuMatVector src,
UMat dst,
UMat times,
UMat response) |
void |
MergeMertens.process(GpuMatVector src,
UMat dst,
UMat times,
UMat response) |
void |
AlignMTB.process(MatVector src,
MatVector dst,
UMat times,
UMat response) |
void |
AlignExposures.process(MatVector src,
MatVector dst,
UMat times,
UMat response) |
void |
MergeMertens.process(MatVector src,
UMat dst) |
void |
CalibrateCRF.process(MatVector src,
UMat dst,
UMat times) |
void |
MergeDebevec.process(MatVector src,
UMat dst,
UMat times) |
void |
MergeRobertson.process(MatVector src,
UMat dst,
UMat times) |
void |
MergeDebevec.process(MatVector src,
UMat dst,
UMat times,
UMat response) |
void |
MergeRobertson.process(MatVector src,
UMat dst,
UMat times,
UMat response) |
void |
MergeExposures.process(MatVector src,
UMat dst,
UMat times,
UMat response) |
void |
MergeMertens.process(MatVector src,
UMat dst,
UMat times,
UMat response) |
void |
Tonemap.process(UMat src,
UMat dst) |
void |
AlignMTB.process(UMatVector src,
MatVector dst,
UMat times,
UMat response) |
void |
AlignExposures.process(UMatVector src,
MatVector dst,
UMat times,
UMat response) |
void |
MergeMertens.process(UMatVector src,
UMat dst) |
void |
CalibrateCRF.process(UMatVector src,
UMat dst,
UMat times) |
void |
MergeDebevec.process(UMatVector src,
UMat dst,
UMat times) |
void |
MergeRobertson.process(UMatVector src,
UMat dst,
UMat times) |
void |
MergeDebevec.process(UMatVector src,
UMat dst,
UMat times,
UMat response) |
void |
MergeRobertson.process(UMatVector src,
UMat dst,
UMat times,
UMat response) |
void |
MergeExposures.process(UMatVector src,
UMat dst,
UMat times,
UMat response) |
void |
MergeMertens.process(UMatVector src,
UMat dst,
UMat times,
UMat response) |
void |
AlignMTB.shiftMat(UMat src,
UMat dst,
Point shift) |
Modifier and Type | Method and Description |
---|---|
static Plot2d |
Plot2d.create(UMat data) |
static Plot2d |
Plot2d.create(UMat dataX,
UMat dataY) |
void |
Plot2d.render(UMat _plotResult) |
Modifier and Type | Method and Description |
---|---|
Scalar |
QualityPSNR.compute(UMat cmp) |
Scalar |
QualityGMSD.compute(UMat cmp) |
Scalar |
QualityBRISQUE.compute(UMat img) |
Scalar |
QualityBase.compute(UMat img) |
Scalar |
QualitySSIM.compute(UMat cmp) |
Scalar |
QualityMSE.compute(UMat cmpImgs) |
static Scalar |
QualityBRISQUE.compute(UMat img,
BytePointer model_file_path,
BytePointer range_file_path) |
static Scalar |
QualityBRISQUE.compute(UMat img,
String model_file_path,
String range_file_path) |
static Scalar |
QualityPSNR.compute(UMat ref,
UMat cmp,
UMat qualityMap) |
static Scalar |
QualityGMSD.compute(UMat ref,
UMat cmp,
UMat qualityMap) |
static Scalar |
QualitySSIM.compute(UMat ref,
UMat cmp,
UMat qualityMap) |
static Scalar |
QualityMSE.compute(UMat ref,
UMat cmp,
UMat qualityMap) |
static Scalar |
QualityPSNR.compute(UMat ref,
UMat cmp,
UMat qualityMap,
double maxPixelValue) |
static void |
QualityBRISQUE.computeFeatures(UMat img,
UMat features) |
static QualityPSNR |
QualityPSNR.create(UMat ref) |
static QualityGMSD |
QualityGMSD.create(UMat ref) |
static QualitySSIM |
QualitySSIM.create(UMat ref) |
static QualityMSE |
QualityMSE.create(UMat ref) |
static QualityPSNR |
QualityPSNR.create(UMat ref,
double maxPixelValue) |
void |
QualityBase.getQualityMap(UMat dst) |
Modifier and Type | Method and Description |
---|---|
boolean |
StaticSaliency.computeBinaryMap(UMat _saliencyMap,
UMat _binaryMap) |
boolean |
StaticSaliencySpectralResidual.computeSaliency(UMat image,
UMat saliencyMap) |
boolean |
StaticSaliencyFineGrained.computeSaliency(UMat image,
UMat saliencyMap) |
boolean |
Saliency.computeSaliency(UMat image,
UMat saliencyMap) |
boolean |
MotionSaliencyBinWangApr2014.computeSaliency(UMat image,
UMat saliencyMap) |
boolean |
ObjectnessBING.computeSaliency(UMat image,
UMat saliencyMap) |
Modifier and Type | Method and Description |
---|---|
float |
ShapeTransformer.applyTransformation(UMat input) |
float |
ShapeTransformer.applyTransformation(UMat input,
UMat output) |
void |
HistogramCostExtractor.buildCostMatrix(UMat descriptors1,
UMat descriptors2,
UMat costMatrix) |
float |
ShapeDistanceExtractor.computeDistance(UMat contour1,
UMat contour2) |
void |
ShapeTransformer.estimateTransformation(UMat transformingShape,
UMat targetShape,
DMatchVector matches) |
void |
ShapeContextDistanceExtractor.getImages(UMat image1,
UMat image2) |
void |
ShapeContextDistanceExtractor.setImages(UMat image1,
UMat image2) |
void |
ShapeTransformer.warpImage(UMat transformingImage,
UMat output) |
void |
ShapeTransformer.warpImage(UMat transformingImage,
UMat output,
int flags,
int borderMode,
Scalar borderValue) |
Modifier and Type | Method and Description |
---|---|
UMat |
ImageFeatures.descriptors() |
UMat |
Timelapser.getDst() |
UMat |
Stitcher.matchingMask() |
UMat |
Stitcher.resultMask() |
Modifier and Type | Method and Description |
---|---|
void |
BestOf2NearestRangeMatcher.apply(ImageFeatures features,
MatchesInfo pairwise_matches,
UMat mask) |
void |
NoExposureCompensator.apply(int arg0,
Point arg1,
UMat arg2,
UMat arg3) |
void |
GainCompensator.apply(int index,
Point corner,
UMat image,
UMat mask) |
void |
ExposureCompensator.apply(int index,
Point corner,
UMat image,
UMat mask) |
void |
BlocksCompensator.apply(int index,
Point corner,
UMat image,
UMat mask) |
void |
BlocksGainCompensator.apply(int index,
Point corner,
UMat image,
UMat mask) |
void |
ChannelsCompensator.apply(int index,
Point corner,
UMat image,
UMat mask) |
void |
FeaturesMatcher.apply2(ImageFeatures features,
MatchesInfo pairwise_matches,
UMat mask)
\brief Performs images matching.
|
void |
Blender.blend(UMat dst,
UMat dst_mask) |
void |
MultiBandBlender.blend(UMat dst,
UMat dst_mask) |
void |
FeatherBlender.blend(UMat dst,
UMat dst_mask) |
Rect |
DetailPlaneWarperGpu.buildMaps(Size src_size,
UMat K,
UMat R,
GpuMat xmap,
GpuMat ymap) |
Rect |
DetailCylindricalWarperGpu.buildMaps(Size src_size,
UMat K,
UMat R,
GpuMat xmap,
GpuMat ymap) |
Rect |
DetailSphericalWarperGpu.buildMaps(Size src_size,
UMat K,
UMat R,
GpuMat xmap,
GpuMat ymap) |
Rect |
DetailPlaneWarperGpu.buildMaps(Size src_size,
UMat K,
UMat R,
UMat T,
GpuMat xmap,
GpuMat ymap) |
Rect |
PyRotationWarper.buildMaps(Size src_size,
UMat K,
UMat R,
UMat xmap,
UMat ymap) |
Rect |
DetailCylindricalWarper.buildMaps(Size src_size,
UMat K,
UMat R,
UMat xmap,
UMat ymap) |
Rect |
RotationWarper.buildMaps(Size src_size,
UMat K,
UMat R,
UMat xmap,
UMat ymap) |
Rect |
AffineWarper.buildMaps(Size src_size,
UMat K,
UMat H,
UMat xmap,
UMat ymap) |
Rect |
DetailPlaneWarperGpu.buildMaps(Size src_size,
UMat K,
UMat R,
UMat xmap,
UMat ymap) |
Rect |
DetailSphericalWarper.buildMaps(Size src_size,
UMat K,
UMat R,
UMat xmap,
UMat ymap) |
Rect |
DetailCylindricalWarperGpu.buildMaps(Size src_size,
UMat K,
UMat R,
UMat xmap,
UMat ymap) |
Rect |
DetailSphericalWarperGpu.buildMaps(Size src_size,
UMat K,
UMat R,
UMat xmap,
UMat ymap) |
Rect |
DetailPlaneWarper.buildMaps(Size src_size,
UMat K,
UMat R,
UMat xmap,
UMat ymap) |
Rect |
DetailPlaneWarperGpu.buildMaps(Size src_size,
UMat K,
UMat R,
UMat T,
UMat xmap,
UMat ymap) |
Rect |
DetailPlaneWarper.buildMaps(Size src_size,
UMat K,
UMat R,
UMat T,
UMat xmap,
UMat ymap) |
int |
Stitcher.composePanorama(GpuMatVector images,
UMat pano) |
int |
Stitcher.composePanorama(MatVector images,
UMat pano) |
int |
Stitcher.composePanorama(UMat pano) |
int |
Stitcher.composePanorama(UMatVector images,
UMat pano) |
ImageFeatures |
ImageFeatures.descriptors(UMat setter) |
void |
Blender.feed(UMat img,
UMat mask,
Point tl) |
void |
MultiBandBlender.feed(UMat img,
UMat mask,
Point tl) |
void |
FeatherBlender.feed(UMat img,
UMat mask,
Point tl) |
void |
Timelapser.process(UMat img,
UMat mask,
Point tl) |
void |
ProjectorBase.setCameraParams(UMat K,
UMat R,
UMat T) |
void |
Stitcher.setMatchingMask(UMat mask) |
int |
Stitcher.stitch(GpuMatVector images,
GpuMatVector masks,
UMat pano) |
int |
Stitcher.stitch(GpuMatVector images,
UMat pano) |
int |
Stitcher.stitch(MatVector images,
MatVector masks,
UMat pano) |
int |
Stitcher.stitch(MatVector images,
UMat pano) |
int |
Stitcher.stitch(UMatVector images,
UMat pano) |
int |
Stitcher.stitch(UMatVector images,
UMatVector masks,
UMat pano) |
Point |
DetailPlaneWarperGpu.warp(GpuMat src,
UMat K,
UMat R,
int interp_mode,
int border_mode,
GpuMat dst) |
Point |
DetailCylindricalWarperGpu.warp(GpuMat src,
UMat K,
UMat R,
int interp_mode,
int border_mode,
GpuMat dst) |
Point |
DetailSphericalWarperGpu.warp(GpuMat src,
UMat K,
UMat R,
int interp_mode,
int border_mode,
GpuMat dst) |
Point |
DetailPlaneWarperGpu.warp(GpuMat src,
UMat K,
UMat R,
UMat T,
int interp_mode,
int border_mode,
GpuMat dst) |
Point |
PyRotationWarper.warp(UMat src,
UMat K,
UMat R,
int interp_mode,
int border_mode,
UMat dst) |
Point |
DetailCylindricalWarper.warp(UMat src,
UMat K,
UMat R,
int interp_mode,
int border_mode,
UMat dst) |
Point |
RotationWarper.warp(UMat src,
UMat K,
UMat R,
int interp_mode,
int border_mode,
UMat dst) |
Point |
AffineWarper.warp(UMat src,
UMat K,
UMat H,
int interp_mode,
int border_mode,
UMat dst) |
Point |
DetailPlaneWarperGpu.warp(UMat src,
UMat K,
UMat R,
int interp_mode,
int border_mode,
UMat dst) |
Point |
DetailSphericalWarper.warp(UMat src,
UMat K,
UMat R,
int interp_mode,
int border_mode,
UMat dst) |
Point |
DetailCylindricalWarperGpu.warp(UMat src,
UMat K,
UMat R,
int interp_mode,
int border_mode,
UMat dst) |
Point |
DetailSphericalWarperGpu.warp(UMat src,
UMat K,
UMat R,
int interp_mode,
int border_mode,
UMat dst) |
Point |
DetailPlaneWarper.warp(UMat src,
UMat K,
UMat R,
int interp_mode,
int border_mode,
UMat dst) |
Point |
DetailPlaneWarperGpu.warp(UMat src,
UMat K,
UMat R,
UMat T,
int interp_mode,
int border_mode,
UMat dst) |
Point |
DetailPlaneWarper.warp(UMat src,
UMat K,
UMat R,
UMat T,
int interp_mode,
int border_mode,
UMat dst) |
void |
PyRotationWarper.warpBackward(UMat src,
UMat K,
UMat R,
int interp_mode,
int border_mode,
Size dst_size,
UMat dst) |
void |
RotationWarper.warpBackward(UMat src,
UMat K,
UMat R,
int interp_mode,
int border_mode,
Size dst_size,
UMat dst) |
Point2f |
PyRotationWarper.warpPoint(Point2f pt,
UMat K,
UMat R) |
Point2f |
RotationWarper.warpPoint(Point2f pt,
UMat K,
UMat R) |
Point2f |
AffineWarper.warpPoint(Point2f pt,
UMat K,
UMat H) |
Point2f |
DetailPlaneWarper.warpPoint(Point2f pt,
UMat K,
UMat R) |
Point2f |
DetailPlaneWarper.warpPoint(Point2f pt,
UMat K,
UMat R,
UMat T) |
Rect |
PyRotationWarper.warpRoi(Size src_size,
UMat K,
UMat R) |
Rect |
RotationWarper.warpRoi(Size src_size,
UMat K,
UMat R) |
Rect |
AffineWarper.warpRoi(Size src_size,
UMat K,
UMat H) |
Rect |
DetailPlaneWarper.warpRoi(Size src_size,
UMat K,
UMat R) |
Rect |
DetailPlaneWarper.warpRoi(Size src_size,
UMat K,
UMat R,
UMat T) |
Modifier and Type | Method and Description |
---|---|
void |
SinusoidalPattern.computeDataModulationTerm(GpuMatVector patternImages,
UMat dataModulationTerm,
UMat shadowMask) |
void |
SinusoidalPattern.computeDataModulationTerm(MatVector patternImages,
UMat dataModulationTerm,
UMat shadowMask) |
void |
SinusoidalPattern.computeDataModulationTerm(UMatVector patternImages,
UMat dataModulationTerm,
UMat shadowMask) |
void |
SinusoidalPattern.computePhaseMap(GpuMatVector patternImages,
UMat wrappedPhaseMap) |
void |
SinusoidalPattern.computePhaseMap(GpuMatVector patternImages,
UMat wrappedPhaseMap,
UMat shadowMask,
UMat fundamental) |
void |
SinusoidalPattern.computePhaseMap(MatVector patternImages,
UMat wrappedPhaseMap) |
void |
SinusoidalPattern.computePhaseMap(MatVector patternImages,
UMat wrappedPhaseMap,
UMat shadowMask,
UMat fundamental) |
void |
SinusoidalPattern.computePhaseMap(UMatVector patternImages,
UMat wrappedPhaseMap) |
void |
SinusoidalPattern.computePhaseMap(UMatVector patternImages,
UMat wrappedPhaseMap,
UMat shadowMask,
UMat fundamental) |
boolean |
StructuredLightPattern.decode(MatVectorVector patternImages,
UMat disparityMap) |
boolean |
StructuredLightPattern.decode(MatVectorVector patternImages,
UMat disparityMap,
GpuMatVector blackImages,
GpuMatVector whiteImages,
int flags) |
boolean |
StructuredLightPattern.decode(MatVectorVector patternImages,
UMat disparityMap,
MatVector blackImages,
MatVector whiteImages,
int flags) |
boolean |
StructuredLightPattern.decode(MatVectorVector patternImages,
UMat disparityMap,
UMatVector blackImages,
UMatVector whiteImages,
int flags) |
void |
SinusoidalPattern.findProCamMatches(UMat projUnwrappedPhaseMap,
UMat camUnwrappedPhaseMap,
GpuMatVector matches) |
void |
SinusoidalPattern.findProCamMatches(UMat projUnwrappedPhaseMap,
UMat camUnwrappedPhaseMap,
MatVector matches) |
void |
SinusoidalPattern.findProCamMatches(UMat projUnwrappedPhaseMap,
UMat camUnwrappedPhaseMap,
UMatVector matches) |
void |
GrayCodePattern.getImagesForShadowMasks(UMat blackImage,
UMat whiteImage) |
void |
SinusoidalPattern.unwrapPhaseMap(UMat wrappedPhaseMap,
UMat unwrappedPhaseMap,
Size camSize) |
void |
SinusoidalPattern.unwrapPhaseMap(UMat wrappedPhaseMap,
UMat unwrappedPhaseMap,
Size camSize,
UMat shadowMask) |
Modifier and Type | Method and Description |
---|---|
void |
DenseOpticalFlowExt.calc(UMat frame0,
UMat frame1,
UMat flow1) |
void |
DenseOpticalFlowExt.calc(UMat frame0,
UMat frame1,
UMat flow1,
UMat flow2) |
void |
FrameSource.nextFrame(UMat frame) |
void |
SuperResolution.nextFrame(UMat frame) |
Modifier and Type | Method and Description |
---|---|
static OCRHMMDecoder |
OCRHMMDecoder.create(BytePointer filename,
BytePointer vocabulary,
UMat transition_probabilities_table,
UMat emission_probabilities_table) |
static OCRBeamSearchDecoder |
OCRBeamSearchDecoder.create(BytePointer filename,
BytePointer vocabulary,
UMat transition_probabilities_table,
UMat emission_probabilities_table,
int mode,
int beam_size) |
static OCRHMMDecoder |
OCRHMMDecoder.create(BytePointer filename,
BytePointer vocabulary,
UMat transition_probabilities_table,
UMat emission_probabilities_table,
int mode,
int classifier) |
static OCRBeamSearchDecoder |
OCRBeamSearchDecoder.create(OCRBeamSearchDecoder.ClassifierCallback classifier,
BytePointer vocabulary,
UMat transition_probabilities_table,
UMat emission_probabilities_table,
int mode,
int beam_size) |
static OCRBeamSearchDecoder |
OCRBeamSearchDecoder.create(OCRBeamSearchDecoder.ClassifierCallback classifier,
String vocabulary,
UMat transition_probabilities_table,
UMat emission_probabilities_table,
int mode,
int beam_size) |
static OCRHMMDecoder |
OCRHMMDecoder.create(OCRHMMDecoder.ClassifierCallback classifier,
BytePointer vocabulary,
UMat transition_probabilities_table,
UMat emission_probabilities_table) |
static OCRHMMDecoder |
OCRHMMDecoder.create(OCRHMMDecoder.ClassifierCallback classifier,
BytePointer vocabulary,
UMat transition_probabilities_table,
UMat emission_probabilities_table,
int mode) |
static OCRHMMDecoder |
OCRHMMDecoder.create(OCRHMMDecoder.ClassifierCallback classifier,
String vocabulary,
UMat transition_probabilities_table,
UMat emission_probabilities_table) |
static OCRHMMDecoder |
OCRHMMDecoder.create(OCRHMMDecoder.ClassifierCallback classifier,
String vocabulary,
UMat transition_probabilities_table,
UMat emission_probabilities_table,
int mode) |
static OCRHMMDecoder |
OCRHMMDecoder.create(String filename,
String vocabulary,
UMat transition_probabilities_table,
UMat emission_probabilities_table) |
static OCRBeamSearchDecoder |
OCRBeamSearchDecoder.create(String filename,
String vocabulary,
UMat transition_probabilities_table,
UMat emission_probabilities_table,
int mode,
int beam_size) |
static OCRHMMDecoder |
OCRHMMDecoder.create(String filename,
String vocabulary,
UMat transition_probabilities_table,
UMat emission_probabilities_table,
int mode,
int classifier) |
void |
TextDetectorCNN.detect(UMat inputImage,
RectVector Bbox,
FloatVector confidence) |
void |
TextDetector.detect(UMat inputImage,
RectVector Bbox,
FloatVector confidence) |
void |
OCRBeamSearchDecoder.ClassifierCallback.eval(UMat image,
DoubleVector recognition_probabilities,
IntVector oversegmentation) |
void |
OCRHMMDecoder.ClassifierCallback.eval(UMat image,
IntVector out_class,
DoubleVector out_confidence) |
void |
ERFilter.run(UMat image,
ERStatVector regions) |
String |
OCRBeamSearchDecoder.run(UMat image,
int min_confidence) |
String |
OCRTesseract.run(UMat image,
int min_confidence) |
String |
OCRHMMDecoder.run(UMat image,
int min_confidence) |
String |
OCRBeamSearchDecoder.run(UMat image,
int min_confidence,
int component_level) |
String |
OCRTesseract.run(UMat image,
int min_confidence,
int component_level) |
String |
OCRHMMDecoder.run(UMat image,
int min_confidence,
int component_level) |
String |
OCRBeamSearchDecoder.run(UMat image,
UMat mask,
int min_confidence) |
String |
OCRTesseract.run(UMat image,
UMat mask,
int min_confidence) |
String |
OCRHMMDecoder.run(UMat image,
UMat mask,
int min_confidence) |
String |
OCRBeamSearchDecoder.run(UMat image,
UMat mask,
int min_confidence,
int component_level) |
String |
OCRTesseract.run(UMat image,
UMat mask,
int min_confidence,
int component_level) |
String |
OCRHMMDecoder.run(UMat image,
UMat mask,
int min_confidence,
int component_level) |
Modifier and Type | Method and Description |
---|---|
boolean |
MultiTracker.add(Tracker newTracker,
UMat image,
Rect2d boundingBox) |
boolean |
MultiTracker.add(TrackerVector newTrackers,
UMat image,
Rect2dVector boundingBox) |
boolean |
MultiTracker_Alt.addTarget(UMat image,
Rect2d boundingBox,
Tracker tracker_algorithm) |
Mat |
UnscentedKalmanFilter.correct(UMat measurement) |
boolean |
Tracker.init(UMat image,
Rect2d boundingBox) |
Mat |
UnscentedKalmanFilter.predict(UMat control) |
void |
TrackerCSRT.setInitialMask(UMat mask) |
boolean |
MultiTrackerTLD.update_opt(UMat image) |
boolean |
MultiTracker_Alt.update(UMat image) |
boolean |
MultiTracker.update(UMat image) |
boolean |
Tracker.update(UMat image,
Rect2d boundingBox) |
boolean |
MultiTracker.update(UMat image,
Rect2dVector boundingBox) |
Modifier and Type | Method and Description |
---|---|
void |
BackgroundSubtractor.apply(UMat image,
UMat fgmask) |
void |
BackgroundSubtractorMOG2.apply(UMat image,
UMat fgmask) |
void |
BackgroundSubtractor.apply(UMat image,
UMat fgmask,
double learningRate) |
void |
BackgroundSubtractorMOG2.apply(UMat image,
UMat fgmask,
double learningRate) |
void |
DenseOpticalFlow.calc(UMat I0,
UMat I1,
UMat flow) |
void |
SparseOpticalFlow.calc(UMat prevImg,
UMat nextImg,
UMat prevPts,
UMat nextPts,
UMat status) |
void |
SparseOpticalFlow.calc(UMat prevImg,
UMat nextImg,
UMat prevPts,
UMat nextPts,
UMat status,
UMat err) |
void |
VariationalRefinement.calcUV(UMat I0,
UMat I1,
UMat flow_u,
UMat flow_v) |
void |
BackgroundSubtractor.getBackgroundImage(UMat backgroundImage) |
Modifier and Type | Method and Description |
---|---|
boolean |
VideoCapture.read(UMat image) |
boolean |
VideoCapture.retrieve(UMat image) |
boolean |
VideoCapture.retrieve(UMat image,
int flag) |
VideoWriter |
VideoWriter.shiftLeft(UMat image)
\overload
|
VideoCapture |
VideoCapture.shiftRight(UMat image)
\overload
|
void |
VideoWriter.write(UMat image) |
Modifier and Type | Method and Description |
---|---|
Mat |
MotionEstimatorBase.estimate(UMat points0,
UMat points1) |
Mat |
MotionEstimatorL1.estimate(UMat points0,
UMat points1) |
Mat |
KeypointBasedMotionEstimator.estimate(UMat frame0,
UMat frame1) |
Mat |
MotionEstimatorRansacL2.estimate(UMat points0,
UMat points1) |
Mat |
MotionEstimatorBase.estimate(UMat points0,
UMat points1,
boolean[] ok) |
Mat |
MotionEstimatorL1.estimate(UMat points0,
UMat points1,
boolean[] ok) |
Mat |
KeypointBasedMotionEstimator.estimate(UMat frame0,
UMat frame1,
boolean[] ok) |
Mat |
MotionEstimatorRansacL2.estimate(UMat points0,
UMat points1,
boolean[] ok) |
Mat |
MotionEstimatorBase.estimate(UMat points0,
UMat points1,
BoolPointer ok) |
Mat |
MotionEstimatorL1.estimate(UMat points0,
UMat points1,
BoolPointer ok) |
Mat |
KeypointBasedMotionEstimator.estimate(UMat frame0,
UMat frame1,
BoolPointer ok) |
Mat |
MotionEstimatorRansacL2.estimate(UMat points0,
UMat points1,
BoolPointer ok) |
void |
TranslationBasedLocalOutlierRejector.process(Size frameSize,
UMat points0,
UMat points1,
UMat mask) |
void |
IOutlierRejector.process(Size frameSize,
UMat points0,
UMat points1,
UMat mask) |
void |
NullOutlierRejector.process(Size frameSize,
UMat points0,
UMat points1,
UMat mask) |
void |
IDenseOptFlowEstimator.run(UMat frame0,
UMat frame1,
UMat flowX,
UMat flowY,
UMat errors) |
void |
ISparseOptFlowEstimator.run(UMat frame0,
UMat frame1,
UMat points0,
UMat points1,
UMat status,
UMat errors) |
void |
SparsePyrLkOptFlowEstimator.run(UMat frame0,
UMat frame1,
UMat points0,
UMat points1,
UMat status,
UMat errors) |
void |
KeypointBasedMotionEstimator.setFrameMask(UMat mask) |
void |
ToFileMotionWriter.setFrameMask(UMat mask) |
void |
ImageMotionEstimatorBase.setFrameMask(UMat mask) |
Modifier and Type | Method and Description |
---|---|
void |
DAISY.compute(UMat image,
KeyPointVector keypoints,
UMat descriptors) |
void |
DAISY.compute(UMat image,
Rect roi,
UMat descriptors) |
void |
DAISY.compute(UMat image,
UMat descriptors) |
float |
PCTSignaturesSQFD.computeQuadraticFormDistance(UMat _signature0,
UMat _signature1) |
void |
PCTSignatures.computeSignature(UMat image,
UMat signature) |
static DAISY |
DAISY.create(float radius,
int q_radius,
int q_theta,
int q_hist,
int norm,
UMat H,
boolean interpolation,
boolean use_orientation) |
void |
AffineFeature2D.detect(UMat image,
Elliptic_KeyPoint keypoints) |
void |
AffineFeature2D.detect(UMat image,
Elliptic_KeyPoint keypoints,
UMat mask) |
void |
AffineFeature2D.detectAndCompute(UMat image,
UMat mask,
Elliptic_KeyPoint keypoints,
UMat descriptors) |
void |
AffineFeature2D.detectAndCompute(UMat image,
UMat mask,
Elliptic_KeyPoint keypoints,
UMat descriptors,
boolean useProvidedKeypoints) |
static void |
PCTSignatures.drawSignature(UMat source,
UMat signature,
UMat result) |
static void |
PCTSignatures.drawSignature(UMat source,
UMat signature,
UMat result,
float radiusToShorterSideRatio,
int borderThickness) |
Modifier and Type | Method and Description |
---|---|
void |
SelectiveSearchSegmentation.addImage(UMat img) |
void |
StructuredEdgeDetection.computeOrientation(UMat _src,
UMat _dst) |
void |
StructuredEdgeDetection.detectEdges(UMat _src,
UMat _dst) |
void |
StructuredEdgeDetection.edgesNms(UMat edge_image,
UMat orientation_image,
UMat _dst) |
void |
StructuredEdgeDetection.edgesNms(UMat edge_image,
UMat orientation_image,
UMat _dst,
int r,
int s,
float m,
boolean isParallel) |
void |
AdaptiveManifoldFilter.filter(UMat src,
UMat dst) |
void |
GuidedFilter.filter(UMat src,
UMat dst) |
void |
DTFilter.filter(UMat src,
UMat dst) |
void |
FastGlobalSmootherFilter.filter(UMat src,
UMat dst) |
void |
GuidedFilter.filter(UMat src,
UMat dst,
int dDepth) |
void |
DTFilter.filter(UMat src,
UMat dst,
int dDepth) |
void |
AdaptiveManifoldFilter.filter(UMat src,
UMat dst,
UMat joint) |
void |
FastBilateralSolverFilter.filter(UMat src,
UMat confidence,
UMat dst) |
void |
DisparityFilter.filter(UMat disparity_map_left,
UMat left_view,
UMat filtered_disparity_map) |
void |
DisparityFilter.filter(UMat disparity_map_left,
UMat left_view,
UMat filtered_disparity_map,
UMat disparity_map_right,
Rect ROI,
UMat right_view) |
void |
SuperpixelSLIC.getLabelContourMask(UMat image) |
void |
SuperpixelLSC.getLabelContourMask(UMat image) |
void |
SuperpixelSEEDS.getLabelContourMask(UMat image) |
void |
SuperpixelSLIC.getLabelContourMask(UMat image,
boolean thick_line) |
void |
SuperpixelLSC.getLabelContourMask(UMat image,
boolean thick_line) |
void |
SuperpixelSEEDS.getLabelContourMask(UMat image,
boolean thick_line) |
void |
SuperpixelSLIC.getLabels(UMat labels_out) |
void |
SuperpixelLSC.getLabels(UMat labels_out) |
void |
SuperpixelSEEDS.getLabels(UMat labels_out) |
void |
SparseMatchInterpolator.interpolate(UMat from_image,
UMat from_points,
UMat to_image,
UMat to_points,
UMat dense_flow) |
void |
SuperpixelSEEDS.iterate(UMat img) |
void |
SuperpixelSEEDS.iterate(UMat img,
int num_iterations) |
void |
GraphSegmentation.processImage(UMat src,
UMat dst) |
void |
SelectiveSearchSegmentation.setBaseImage(UMat img) |
void |
SelectiveSearchSegmentationStrategy.setImage(UMat img,
UMat regions,
UMat sizes) |
void |
SelectiveSearchSegmentationStrategy.setImage(UMat img,
UMat regions,
UMat sizes,
int image_id) |
Modifier and Type | Method and Description |
---|---|
void |
WhiteBalancer.balanceWhite(UMat src,
UMat dst) |
void |
LearningBasedWB.extractSimpleFeatures(UMat src,
UMat dst) |
Copyright © 2020. All rights reserved.