Uses of Class org.bytedeco.opencv.opencv_core.Mat (JavaCPP Presets for OpenCV 4.5.3-1.5.6 API)

Packages that use Mat
Package	Description
org.bytedeco.opencv.global
org.bytedeco.opencv.opencv_aruco
org.bytedeco.opencv.opencv_barcode
org.bytedeco.opencv.opencv_bgsegm
org.bytedeco.opencv.opencv_bioinspired
org.bytedeco.opencv.opencv_calib3d
org.bytedeco.opencv.opencv_core
org.bytedeco.opencv.opencv_cudaarithm
org.bytedeco.opencv.opencv_cudabgsegm
org.bytedeco.opencv.opencv_cudacodec
org.bytedeco.opencv.opencv_cudafeatures2d
org.bytedeco.opencv.opencv_cudafilters
org.bytedeco.opencv.opencv_cudaimgproc
org.bytedeco.opencv.opencv_cudaobjdetect
org.bytedeco.opencv.opencv_cudaoptflow
org.bytedeco.opencv.opencv_cudastereo
org.bytedeco.opencv.opencv_dnn
org.bytedeco.opencv.opencv_dnn_superres
org.bytedeco.opencv.opencv_face
org.bytedeco.opencv.opencv_features2d
org.bytedeco.opencv.opencv_flann
org.bytedeco.opencv.opencv_img_hash
org.bytedeco.opencv.opencv_imgproc
org.bytedeco.opencv.opencv_mcc
org.bytedeco.opencv.opencv_ml
org.bytedeco.opencv.opencv_objdetect
org.bytedeco.opencv.opencv_phase_unwrapping
org.bytedeco.opencv.opencv_photo
org.bytedeco.opencv.opencv_plot
org.bytedeco.opencv.opencv_quality
org.bytedeco.opencv.opencv_rapid
org.bytedeco.opencv.opencv_saliency
org.bytedeco.opencv.opencv_shape
org.bytedeco.opencv.opencv_stitching
org.bytedeco.opencv.opencv_structured_light
org.bytedeco.opencv.opencv_superres
org.bytedeco.opencv.opencv_text
org.bytedeco.opencv.opencv_tracking
org.bytedeco.opencv.opencv_video
org.bytedeco.opencv.opencv_videoio
org.bytedeco.opencv.opencv_videostab
org.bytedeco.opencv.opencv_wechat_qrcode
org.bytedeco.opencv.opencv_xfeatures2d
org.bytedeco.opencv.opencv_ximgproc
org.bytedeco.opencv.opencv_xphoto

Uses of Mat in org.bytedeco.opencv.global

Methods in org.bytedeco.opencv.global that return Mat
Modifier and Type	Method and Description
`static Mat`	opencv_core.`addPut(Mat a, Mat b)` \cond IGNORED
`static Mat`	opencv_core.`addPut(Mat a, Scalar b)`
`static Mat`	opencv_core.`andPut(Mat a, Mat b)`
`static Mat`	opencv_core.`andPut(Mat a, Scalar b)`
`static Mat`	opencv_dnn.`blobFromImage(GpuMat image)`
`static Mat`	opencv_dnn.`blobFromImage(GpuMat image, double scalefactor, Size size, Scalar mean, boolean swapRB, boolean crop, int ddepth)`
`static Mat`	opencv_dnn.`blobFromImage(Mat image)`
`static Mat`	opencv_dnn.`blobFromImage(Mat image, double scalefactor, Size size, Scalar mean, boolean swapRB, boolean crop, int ddepth)` \brief Creates 4-dimensional blob from image.
`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 Mat`	opencv_dnn.`blobFromImages(GpuMatVector images)`
`static Mat`	opencv_dnn.`blobFromImages(GpuMatVector images, double scalefactor, Size size, Scalar mean, boolean swapRB, boolean crop, int ddepth)`
`static Mat`	opencv_dnn.`blobFromImages(MatVector images)`
`static Mat`	opencv_dnn.`blobFromImages(MatVector images, double scalefactor, Size size, Scalar mean, boolean swapRB, boolean crop, int ddepth)` \brief Creates 4-dimensional blob from series of images.
`static Mat`	opencv_dnn.`blobFromImages(UMatVector images)`
`static Mat`	opencv_dnn.`blobFromImages(UMatVector images, double scalefactor, Size size, Scalar mean, boolean swapRB, boolean crop, int ddepth)`
`static Mat`	opencv_text.`createOCRHMMTransitionsTable(BytePointer vocabulary, StringVector lexicon)`
`static Mat`	opencv_text.`createOCRHMMTransitionsTable(String vocabulary, StringVector lexicon)`
`static Mat`	opencv_core.`cvarrToMat(CvArr arr)`
`static Mat`	opencv_core.`cvarrToMat(CvArr arr, boolean copyData, boolean allowND, int coiMode, Pointer buf)` \addtogroup core_c_glue \{
`static Mat`	opencv_core.`cvarrToMatND(CvArr arr)`
`static Mat`	opencv_core.`cvarrToMatND(CvArr arr, boolean copyData, int coiMode)`
`static Mat`	opencv_core.`dividePut(Mat a, double b)`
`static Mat`	opencv_core.`dividePut(Mat a, Mat b)`
`static Mat`	opencv_videostab.`ensureInclusionConstraint(Mat M, Size size, float trimRatio)` \}
`static Mat`	opencv_calib3d.`estimateAffine2D(GpuMat from, GpuMat to)`
`static Mat`	opencv_calib3d.`estimateAffine2D(GpuMat from, GpuMat to, GpuMat inliers, int method, double ransacReprojThreshold, long maxIters, double confidence, long refineIters)`
`static Mat`	opencv_calib3d.`estimateAffine2D(GpuMat pts1, GpuMat pts2, GpuMat inliers, UsacParams params)`
`static Mat`	opencv_calib3d.`estimateAffine2D(Mat from, Mat to)`
`static Mat`	opencv_calib3d.`estimateAffine2D(Mat from, Mat to, Mat inliers, int method, double ransacReprojThreshold, long maxIters, double confidence, long refineIters)` \brief Computes an optimal affine transformation between two 2D point sets.
`static Mat`	opencv_calib3d.`estimateAffine2D(Mat pts1, Mat pts2, Mat inliers, UsacParams params)`
`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 Mat`	opencv_calib3d.`estimateAffine2D(UMat pts1, UMat pts2, UMat inliers, UsacParams params)`
`static Mat`	opencv_calib3d.`estimateAffine3D(GpuMat src, GpuMat dst)`
`static Mat`	opencv_calib3d.`estimateAffine3D(GpuMat src, GpuMat dst, double[] scale, boolean force_rotation)`
`static Mat`	opencv_calib3d.`estimateAffine3D(GpuMat src, GpuMat dst, DoubleBuffer scale, boolean force_rotation)`
`static Mat`	opencv_calib3d.`estimateAffine3D(GpuMat src, GpuMat dst, DoublePointer scale, boolean force_rotation)`
`static Mat`	opencv_calib3d.`estimateAffine3D(Mat src, Mat dst)`
`static Mat`	opencv_calib3d.`estimateAffine3D(Mat src, Mat dst, double[] scale, boolean force_rotation)`
`static Mat`	opencv_calib3d.`estimateAffine3D(Mat src, Mat dst, DoubleBuffer scale, boolean force_rotation)`
`static Mat`	opencv_calib3d.`estimateAffine3D(Mat src, Mat dst, DoublePointer scale, boolean force_rotation)` \brief Computes an optimal affine transformation between two 3D point sets.
`static Mat`	opencv_calib3d.`estimateAffine3D(UMat src, UMat dst)`
`static Mat`	opencv_calib3d.`estimateAffine3D(UMat src, UMat dst, double[] scale, boolean force_rotation)`
`static Mat`	opencv_calib3d.`estimateAffine3D(UMat src, UMat dst, DoubleBuffer scale, boolean force_rotation)`
`static Mat`	opencv_calib3d.`estimateAffine3D(UMat src, UMat dst, DoublePointer scale, boolean force_rotation)`
`static Mat`	opencv_calib3d.`estimateAffinePartial2D(GpuMat from, GpuMat to)`
`static Mat`	opencv_calib3d.`estimateAffinePartial2D(GpuMat from, GpuMat to, GpuMat inliers, int method, double ransacReprojThreshold, long maxIters, double confidence, long refineIters)`
`static Mat`	opencv_calib3d.`estimateAffinePartial2D(Mat from, Mat to)`
`static Mat`	opencv_calib3d.`estimateAffinePartial2D(Mat from, Mat to, Mat inliers, int method, double ransacReprojThreshold, long maxIters, double confidence, long refineIters)` \brief Computes an optimal limited affine transformation with 4 degrees of freedom between two 2D point sets.
`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 Mat`	opencv_videostab.`estimateGlobalMotionLeastSquares(GpuMat points0, GpuMat points1)`
`static Mat`	opencv_videostab.`estimateGlobalMotionLeastSquares(GpuMat points0, GpuMat points1, int model, float[] rmse)`
`static Mat`	opencv_videostab.`estimateGlobalMotionLeastSquares(GpuMat points0, GpuMat points1, int model, FloatBuffer rmse)`
`static Mat`	opencv_videostab.`estimateGlobalMotionLeastSquares(GpuMat points0, GpuMat points1, int model, FloatPointer rmse)`
`static Mat`	opencv_videostab.`estimateGlobalMotionLeastSquares(Mat points0, Mat points1)`
`static Mat`	opencv_videostab.`estimateGlobalMotionLeastSquares(Mat points0, Mat points1, int model, float[] rmse)`
`static Mat`	opencv_videostab.`estimateGlobalMotionLeastSquares(Mat points0, Mat points1, int model, FloatBuffer rmse)`
`static Mat`	opencv_videostab.`estimateGlobalMotionLeastSquares(Mat points0, Mat points1, int model, FloatPointer rmse)` \addtogroup videostab_motion \{
`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(GpuMat points0, GpuMat points1)`
`static Mat`	opencv_videostab.`estimateGlobalMotionRansac(GpuMat points0, GpuMat points1, int model, RansacParams params, float[] rmse, int[] ninliers)`
`static Mat`	opencv_videostab.`estimateGlobalMotionRansac(GpuMat points0, GpuMat points1, int model, RansacParams params, FloatBuffer rmse, IntBuffer ninliers)`
`static Mat`	opencv_videostab.`estimateGlobalMotionRansac(GpuMat points0, GpuMat points1, int model, RansacParams params, FloatPointer rmse, IntPointer ninliers)`
`static Mat`	opencv_videostab.`estimateGlobalMotionRansac(Mat points0, Mat points1)`
`static Mat`	opencv_videostab.`estimateGlobalMotionRansac(Mat points0, Mat points1, int model, RansacParams params, float[] rmse, int[] ninliers)`
`static Mat`	opencv_videostab.`estimateGlobalMotionRansac(Mat points0, Mat points1, int model, RansacParams params, FloatBuffer rmse, IntBuffer ninliers)`
`static Mat`	opencv_videostab.`estimateGlobalMotionRansac(Mat points0, Mat points1, int model, RansacParams params, FloatPointer rmse, IntPointer ninliers)` \brief Estimates best global motion between two 2D point clouds robustly (using RANSAC method).
`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 Mat`	opencv_video.`estimateRigidTransform(GpuMat src, GpuMat dst, boolean fullAffine)` Deprecated.
`static Mat`	opencv_video.`estimateRigidTransform(Mat src, Mat dst, boolean fullAffine)` Deprecated. Use cv::estimateAffine2D, cv::estimateAffinePartial2D instead. If you are using this function with images, extract points using cv::calcOpticalFlowPyrLK and then use the estimation functions.
`static Mat`	opencv_video.`estimateRigidTransform(UMat src, UMat dst, boolean fullAffine)` Deprecated.
`static Mat`	opencv_calib3d.`findEssentialMat(GpuMat points1, GpuMat points2)`
`static Mat`	opencv_calib3d.`findEssentialMat(GpuMat points1, GpuMat points2, double focal, Point2d pp, int method, double prob, double threshold, GpuMat mask)`
`static Mat`	opencv_calib3d.`findEssentialMat(GpuMat points1, GpuMat points2, double focal, Point2d pp, int method, double prob, double threshold, int maxIters, GpuMat mask)`
`static Mat`	opencv_calib3d.`findEssentialMat(GpuMat points1, GpuMat points2, GpuMat cameraMatrix)`
`static Mat`	opencv_calib3d.`findEssentialMat(GpuMat points1, GpuMat points2, GpuMat cameraMatrix1, GpuMat distCoeffs1, GpuMat cameraMatrix2, GpuMat distCoeffs2)`
`static Mat`	opencv_calib3d.`findEssentialMat(GpuMat points1, GpuMat points2, GpuMat cameraMatrix1, GpuMat cameraMatrix2, GpuMat dist_coeff1, GpuMat dist_coeff2, GpuMat mask, UsacParams params)`
`static Mat`	opencv_calib3d.`findEssentialMat(GpuMat points1, GpuMat points2, GpuMat cameraMatrix1, GpuMat distCoeffs1, GpuMat cameraMatrix2, GpuMat distCoeffs2, int method, double prob, double threshold, GpuMat mask)`
`static Mat`	opencv_calib3d.`findEssentialMat(GpuMat points1, GpuMat points2, GpuMat cameraMatrix, int method, double prob, double threshold, GpuMat mask)`
`static Mat`	opencv_calib3d.`findEssentialMat(GpuMat points1, GpuMat points2, GpuMat cameraMatrix, int method, double prob, double threshold, int maxIters, GpuMat mask)`
`static Mat`	opencv_calib3d.`findEssentialMat(Mat points1, Mat points2)`
`static Mat`	opencv_calib3d.`findEssentialMat(Mat points1, Mat points2, double focal, Point2d pp, int method, double prob, double threshold, int maxIters, Mat mask)` \overload
`static Mat`	opencv_calib3d.`findEssentialMat(Mat points1, Mat points2, double focal, Point2d pp, int method, double prob, double threshold, Mat mask)` \overload
`static Mat`	opencv_calib3d.`findEssentialMat(Mat points1, Mat points2, Mat cameraMatrix)`
`static Mat`	opencv_calib3d.`findEssentialMat(Mat points1, Mat points2, Mat cameraMatrix, int method, double prob, double threshold, int maxIters, Mat mask)` \brief Calculates an essential matrix from the corresponding points in two images.
`static Mat`	opencv_calib3d.`findEssentialMat(Mat points1, Mat points2, Mat cameraMatrix, int method, double prob, double threshold, Mat mask)` \overload
`static Mat`	opencv_calib3d.`findEssentialMat(Mat points1, Mat points2, Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2)`
`static Mat`	opencv_calib3d.`findEssentialMat(Mat points1, Mat points2, Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, int method, double prob, double threshold, Mat mask)` \brief Calculates an essential matrix from the corresponding points in two images from potentially two different cameras.
`static Mat`	opencv_calib3d.`findEssentialMat(Mat points1, Mat points2, Mat cameraMatrix1, Mat cameraMatrix2, Mat dist_coeff1, Mat dist_coeff2, Mat mask, UsacParams params)`
`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, int maxIters, UMat mask)`
`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, int maxIters, UMat mask)`
`static Mat`	opencv_calib3d.`findEssentialMat(UMat points1, UMat points2, UMat cameraMatrix, int method, double prob, double threshold, UMat mask)`
`static Mat`	opencv_calib3d.`findEssentialMat(UMat points1, UMat points2, UMat cameraMatrix1, UMat distCoeffs1, UMat cameraMatrix2, UMat distCoeffs2)`
`static Mat`	opencv_calib3d.`findEssentialMat(UMat points1, UMat points2, UMat cameraMatrix1, UMat distCoeffs1, UMat cameraMatrix2, UMat distCoeffs2, int method, double prob, double threshold, UMat mask)`
`static Mat`	opencv_calib3d.`findEssentialMat(UMat points1, UMat points2, UMat cameraMatrix1, UMat cameraMatrix2, UMat dist_coeff1, UMat dist_coeff2, UMat mask, UsacParams params)`
`static Mat`	opencv_calib3d.`findFundamentalMat(GpuMat points1, GpuMat points2)`
`static Mat`	opencv_calib3d.`findFundamentalMat(GpuMat points1, GpuMat points2, GpuMat mask)`
`static Mat`	opencv_calib3d.`findFundamentalMat(GpuMat points1, GpuMat points2, GpuMat mask, int method, double ransacReprojThreshold, double confidence)`
`static Mat`	opencv_calib3d.`findFundamentalMat(GpuMat points1, GpuMat points2, GpuMat mask, UsacParams params)`
`static Mat`	opencv_calib3d.`findFundamentalMat(GpuMat points1, GpuMat points2, int method, double ransacReprojThreshold, double confidence, GpuMat mask)`
`static Mat`	opencv_calib3d.`findFundamentalMat(GpuMat points1, GpuMat points2, int method, double ransacReprojThreshold, double confidence, int maxIters)`
`static Mat`	opencv_calib3d.`findFundamentalMat(GpuMat points1, GpuMat points2, int method, double ransacReprojThreshold, double confidence, int maxIters, GpuMat mask)`
`static Mat`	opencv_calib3d.`findFundamentalMat(Mat points1, Mat points2)`
`static Mat`	opencv_calib3d.`findFundamentalMat(Mat points1, Mat points2, int method, double ransacReprojThreshold, double confidence, int maxIters)`
`static Mat`	opencv_calib3d.`findFundamentalMat(Mat points1, Mat points2, int method, double ransacReprojThreshold, double confidence, int maxIters, Mat mask)` \brief Calculates a fundamental matrix from the corresponding points in two images.
`static Mat`	opencv_calib3d.`findFundamentalMat(Mat points1, Mat points2, int method, double ransacReprojThreshold, double confidence, Mat mask)` \overload
`static Mat`	opencv_calib3d.`findFundamentalMat(Mat points1, Mat points2, Mat mask)`
`static Mat`	opencv_calib3d.`findFundamentalMat(Mat points1, Mat points2, Mat mask, int method, double ransacReprojThreshold, double confidence)` \overload
`static Mat`	opencv_calib3d.`findFundamentalMat(Mat points1, Mat points2, Mat mask, UsacParams params)`
`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.`findFundamentalMat(UMat points1, UMat points2, UMat mask, UsacParams params)`
`static Mat`	opencv_calib3d.`findHomography(GpuMat srcPoints, GpuMat dstPoints)`
`static Mat`	opencv_calib3d.`findHomography(GpuMat srcPoints, GpuMat dstPoints, GpuMat mask)`
`static Mat`	opencv_calib3d.`findHomography(GpuMat srcPoints, GpuMat dstPoints, GpuMat mask, int method, double ransacReprojThreshold)`
`static Mat`	opencv_calib3d.`findHomography(GpuMat srcPoints, GpuMat dstPoints, GpuMat mask, UsacParams params)`
`static Mat`	opencv_calib3d.`findHomography(GpuMat srcPoints, GpuMat dstPoints, int method, double ransacReprojThreshold, GpuMat mask, int maxIters, double confidence)`
`static Mat`	opencv_calib3d.`findHomography(Mat srcPoints, Mat dstPoints)`
`static Mat`	opencv_calib3d.`findHomography(Mat srcPoints, Mat dstPoints, int method, double ransacReprojThreshold, Mat mask, int maxIters, double confidence)` \brief Finds a perspective transformation between two planes.
`static Mat`	opencv_calib3d.`findHomography(Mat srcPoints, Mat dstPoints, Mat mask)`
`static Mat`	opencv_calib3d.`findHomography(Mat srcPoints, Mat dstPoints, Mat mask, int method, double ransacReprojThreshold)` \overload
`static Mat`	opencv_calib3d.`findHomography(Mat srcPoints, Mat dstPoints, Mat mask, UsacParams params)`
`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 Mat`	opencv_calib3d.`findHomography(UMat srcPoints, UMat dstPoints, UMat mask, UsacParams params)`
`static Mat`	opencv_quality.`get_column_range(Mat data)`
`static Mat`	opencv_imgproc.`getAffineTransform(GpuMat src, GpuMat dst)`
`static Mat`	opencv_imgproc.`getAffineTransform(Mat src, Mat dst)`
`static Mat`	opencv_imgproc.`getAffineTransform(Point2f src, Point2f dst)` \brief Calculates an affine transform from three pairs of the corresponding points.
`static Mat`	opencv_imgproc.`getAffineTransform(UMat src, UMat dst)`
`static Mat`	opencv_calib3d.`getDefaultNewCameraMatrix(GpuMat cameraMatrix)`
`static Mat`	opencv_calib3d.`getDefaultNewCameraMatrix(GpuMat cameraMatrix, Size imgsize, boolean centerPrincipalPoint)`
`static Mat`	opencv_calib3d.`getDefaultNewCameraMatrix(Mat cameraMatrix)`
`static Mat`	opencv_calib3d.`getDefaultNewCameraMatrix(Mat cameraMatrix, Size imgsize, boolean centerPrincipalPoint)` \brief Returns the default new camera matrix.
`static Mat`	opencv_calib3d.`getDefaultNewCameraMatrix(UMat cameraMatrix)`
`static Mat`	opencv_calib3d.`getDefaultNewCameraMatrix(UMat cameraMatrix, Size imgsize, boolean centerPrincipalPoint)`
`static Mat`	opencv_imgproc.`getGaborKernel(Size ksize, double sigma, double theta, double lambd, double gamma)`
`static Mat`	opencv_imgproc.`getGaborKernel(Size ksize, double sigma, double theta, double lambd, double gamma, double psi, int ktype)` \brief Returns Gabor filter coefficients.
`static Mat`	opencv_imgproc.`getGaussianKernel(int ksize, double sigma)`
`static Mat`	opencv_imgproc.`getGaussianKernel(int ksize, double sigma, int ktype)` \} imgproc_feature
`static Mat`	opencv_videostab.`getMotion(int from, int to, MatVector motions)` \brief Computes motion between two frames assuming that all the intermediate motions are known.
`static Mat`	opencv_calib3d.`getOptimalNewCameraMatrix(GpuMat cameraMatrix, GpuMat distCoeffs, Size imageSize, double alpha)`
`static Mat`	opencv_calib3d.`getOptimalNewCameraMatrix(GpuMat cameraMatrix, GpuMat distCoeffs, Size imageSize, double alpha, Size newImgSize, Rect validPixROI, boolean centerPrincipalPoint)`
`static Mat`	opencv_calib3d.`getOptimalNewCameraMatrix(Mat cameraMatrix, Mat distCoeffs, Size imageSize, double alpha)`
`static Mat`	opencv_calib3d.`getOptimalNewCameraMatrix(Mat cameraMatrix, Mat distCoeffs, Size imageSize, double alpha, Size newImgSize, Rect validPixROI, boolean centerPrincipalPoint)` \brief Returns the new camera intrinsic matrix based on the free scaling parameter.
`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(GpuMat src, GpuMat dst)`
`static Mat`	opencv_imgproc.`getPerspectiveTransform(GpuMat src, GpuMat dst, int solveMethod)`
`static Mat`	opencv_imgproc.`getPerspectiveTransform(Mat src, Mat dst)`
`static Mat`	opencv_imgproc.`getPerspectiveTransform(Mat src, Mat dst, int solveMethod)` \brief Calculates a perspective transform from four pairs of the corresponding points.
`static Mat`	opencv_imgproc.`getPerspectiveTransform(Point2f src, Point2f dst)`
`static Mat`	opencv_imgproc.`getPerspectiveTransform(Point2f src, Point2f dst, int solveMethod)` \overload
`static Mat`	opencv_imgproc.`getPerspectiveTransform(UMat src, UMat dst)`
`static Mat`	opencv_imgproc.`getPerspectiveTransform(UMat src, UMat dst, int solveMethod)`
`static Mat`	opencv_dnn.`getPlane(Mat m, int n, int cn)`
`static Mat`	opencv_imgproc.`getRotationMatrix2D(Point2f center, double angle, double scale)` \brief Calculates an affine matrix of 2D rotation.
`static Mat`	opencv_imgproc.`getStructuringElement(int shape, Size ksize)`
`static Mat`	opencv_ximgproc.`getStructuringElement(int shape, Size ksize)` \brief Returns a run length encoded structuring element of the specified size and shape.
`static Mat`	opencv_imgproc.`getStructuringElement(int shape, Size ksize, Point anchor)` \brief Returns a structuring element of the specified size and shape for morphological operations.
`static Mat`	opencv_imgcodecs.`imdecode(GpuMat buf, int flags)`
`static Mat`	opencv_imgcodecs.`imdecode(GpuMat buf, int flags, Mat dst)`
`static Mat`	opencv_imgcodecs.`imdecode(Mat buf, int flags)` \brief Reads an image from a buffer in memory.
`static Mat`	opencv_imgcodecs.`imdecode(Mat buf, int flags, Mat dst)` \overload
`static Mat`	opencv_imgcodecs.`imdecode(UMat buf, int flags)`
`static Mat`	opencv_imgcodecs.`imdecode(UMat buf, int flags, Mat dst)`
`static Mat`	opencv_imgcodecs.`imread(BytePointer filename)`
`static Mat`	opencv_imgcodecs.`imread(BytePointer filename, int flags)` \} imgcodecs_flags
`static Mat`	opencv_imgcodecs.`imread(String filename)`
`static Mat`	opencv_imgcodecs.`imread(String filename, int flags)`
`static Mat`	opencv_calib3d.`initCameraMatrix2D(Point3fVectorVector objectPoints, Point2fVectorVector imagePoints, Size imageSize)`
`static Mat`	opencv_calib3d.`initCameraMatrix2D(Point3fVectorVector objectPoints, Point2fVectorVector imagePoints, Size imageSize, double aspectRatio)` \brief Finds an initial camera intrinsic matrix from 3D-2D point correspondences.
`static Mat`	opencv_core.`multiplyPut(Mat a, double b)`
`static Mat`	opencv_core.`multiplyPut(Mat a, Mat b)`
`static Mat`	opencv_core.`noArray()` Helper to wrap custom types.
`static Mat`	opencv_core.`orPut(Mat a, Mat b)`
`static Mat`	opencv_core.`orPut(Mat a, Scalar b)`
`static Mat`	opencv_video.`readOpticalFlow(BytePointer path)` \brief Read a .flo file
`static Mat`	opencv_video.`readOpticalFlow(String path)`
`static Mat`	opencv_dnn.`readTensorFromONNX(BytePointer path)` \brief Creates blob from .pb file.
`static Mat`	opencv_dnn.`readTensorFromONNX(String path)`
`static Mat`	opencv_dnn.`readTorchBlob(BytePointer filename)`
`static Mat`	opencv_dnn.`readTorchBlob(BytePointer filename, boolean isBinary)` \brief Loads blob which was serialized as torch.Tensor object of Torch7 framework.
`static Mat`	opencv_dnn.`readTorchBlob(String filename)`
`static Mat`	opencv_dnn.`readTorchBlob(String filename, boolean isBinary)`
`static Mat`	opencv_core.`repeat(Mat src, int ny, int nx)` \overload
`static Mat`	opencv_dnn.`slice(Mat m, _Range r0, _Range r1, _Range r2, _Range r3)`
`static Mat`	opencv_dnn.`slice(Mat m, _Range r0, _Range r1, _Range r2)`
`static Mat`	opencv_dnn.`slice(Mat m, _Range r0, _Range r1)`
`static Mat`	opencv_dnn.`slice(Mat m, _Range r0)` \} \}
`static Mat`	opencv_core.`subtractPut(Mat a, Mat b)`
`static Mat`	opencv_core.`subtractPut(Mat a, Scalar b)`
`static Mat`	opencv_core.`xorPut(Mat a, Mat b)`
`static Mat`	opencv_core.`xorPut(Mat a, Scalar b)`

Methods in org.bytedeco.opencv.global with parameters of type Mat
Modifier and Type	Method and Description
`static MatExpr`	opencv_core.`abs(Mat m)` \brief Calculates an absolute value of each matrix element.
`static void`	opencv_cudaarithm.`abs(Mat src, Mat dst)`
`static void`	opencv_cudaarithm.`abs(Mat src, Mat dst, Stream stream)` \brief Computes an absolute value of each matrix element.
`static void`	opencv_core.`absdiff(Mat src1, Mat src2, Mat dst)` \brief Calculates the per-element absolute difference between two arrays or between an array and a scalar.
`static void`	opencv_cudaarithm.`absdiff(Mat src1, Mat src2, Mat dst)`
`static void`	opencv_cudaarithm.`absdiff(Mat src1, Mat src2, Mat dst, Stream stream)` \brief Computes per-element absolute difference of two matrices (or of a matrix and scalar).
`static Scalar`	opencv_cudaarithm.`absSum(Mat src)`
`static Scalar`	opencv_cudaarithm.`absSum(Mat src, Mat mask)` \brief Returns the sum of absolute values for matrix elements.
`static void`	opencv_imgproc.`accumulate(Mat src, Mat dst)`
`static void`	opencv_imgproc.`accumulate(Mat src, Mat dst, Mat mask)` \} imgproc_misc
`static void`	opencv_imgproc.`accumulateProduct(Mat src1, Mat src2, Mat dst)`
`static void`	opencv_imgproc.`accumulateProduct(Mat src1, Mat src2, Mat dst, Mat mask)` \brief Adds the per-element product of two input images to the accumulator image.
`static void`	opencv_imgproc.`accumulateSquare(Mat src, Mat dst)`
`static void`	opencv_imgproc.`accumulateSquare(Mat src, Mat dst, Mat mask)` \brief Adds the square of a source image to the accumulator image.
`static void`	opencv_imgproc.`accumulateWeighted(Mat src, Mat dst, double alpha)`
`static void`	opencv_imgproc.`accumulateWeighted(Mat src, Mat dst, double alpha, Mat mask)` \brief Updates a running average.
`static void`	opencv_imgproc.`adaptiveThreshold(Mat src, Mat dst, double maxValue, int adaptiveMethod, int thresholdType, int blockSize, double C)` \brief Applies an adaptive threshold to an array.
`static MatExpr`	opencv_core.`add(MatExpr e, Mat m)`
`static MatExpr`	opencv_core.`add(Mat a, Mat b)` \} core_basic
`static MatExpr`	opencv_core.`add(Mat m, MatExpr e)`
`static void`	opencv_core.`add(Mat src1, Mat src2, Mat dst)`
`static void`	opencv_cudaarithm.`add(Mat src1, Mat src2, Mat dst)`
`static void`	opencv_core.`add(Mat src1, Mat src2, Mat dst, Mat mask, int dtype)` \brief Calculates the per-element sum of two arrays or an array and a scalar.
`static void`	opencv_cudaarithm.`add(Mat src1, Mat src2, Mat dst, Mat mask, int dtype, Stream stream)` \addtogroup cudaarithm \{
`static MatExpr`	opencv_core.`add(Mat a, Scalar s)`
`static MatExpr`	opencv_core.`add(Scalar s, Mat a)`
`static Mat`	opencv_core.`addPut(Mat a, Mat b)` \cond IGNORED
`static Mat`	opencv_core.`addPut(Mat a, Scalar b)`
`static void`	opencv_highgui.`addText(Mat img, BytePointer text, Point org, BytePointer nameFont)`
`static void`	opencv_highgui.`addText(Mat img, BytePointer text, Point org, BytePointer nameFont, int pointSize, Scalar color, int weight, int style, int spacing)` \brief Draws a text on the image.
`static void`	opencv_highgui.`addText(Mat img, BytePointer text, Point org, QtFont font)` \brief Draws a text on the image.
`static void`	opencv_highgui.`addText(Mat img, String text, Point org, QtFont font)`
`static void`	opencv_highgui.`addText(Mat img, String text, Point org, String nameFont)`
`static void`	opencv_highgui.`addText(Mat img, String text, Point org, String nameFont, int pointSize, Scalar color, int weight, int style, int spacing)`
`static void`	opencv_core.`addWeighted(Mat src1, double alpha, Mat src2, double beta, double gamma, Mat dst)`
`static void`	opencv_cudaarithm.`addWeighted(Mat src1, double alpha, Mat src2, double beta, double gamma, Mat dst)`
`static void`	opencv_core.`addWeighted(Mat src1, double alpha, Mat src2, double beta, double gamma, Mat dst, int dtype)` \brief Calculates the weighted sum of two arrays.
`static void`	opencv_cudaarithm.`addWeighted(Mat src1, double alpha, Mat src2, double beta, double gamma, Mat dst, int dtype, Stream stream)` \brief Computes the weighted sum of two arrays.
`static void`	opencv_features2d.`AGAST(Mat image, KeyPointVector keypoints, int threshold)`
`static void`	opencv_features2d.`AGAST(Mat image, KeyPointVector keypoints, int threshold, boolean nonmaxSuppression)` \overload
`static void`	opencv_features2d.`AGAST(Mat image, KeyPointVector keypoints, int threshold, boolean nonmaxSuppression, int type)` \brief Detects corners using the AGAST algorithm
`static void`	opencv_cudaimgproc.`alphaComp(Mat img1, Mat img2, Mat dst, int alpha_op)`
`static void`	opencv_cudaimgproc.`alphaComp(Mat img1, Mat img2, Mat dst, int alpha_op, Stream stream)` \brief Composites two images using alpha opacity values contained in each image.
`static void`	opencv_ximgproc.`amFilter(Mat joint, Mat src, Mat dst, double sigma_s, double sigma_r)`
`static void`	opencv_ximgproc.`amFilter(Mat joint, Mat src, Mat dst, double sigma_s, double sigma_r, boolean adjust_outliers)` \brief Simple one-line Adaptive Manifold Filter call.
`static MatExpr`	opencv_core.`and(Mat a, Mat b)`
`static MatExpr`	opencv_core.`and(Mat a, Scalar s)`
`static MatExpr`	opencv_core.`and(Scalar s, Mat a)`
`static Mat`	opencv_core.`andPut(Mat a, Mat b)`
`static Mat`	opencv_core.`andPut(Mat a, Scalar b)`
`static void`	opencv_ximgproc.`anisotropicDiffusion(Mat src, Mat dst, float alpha, float K, int niters)` \brief Performs anisotropic diffusion on an image.
`static void`	opencv_xphoto.`applyChannelGains(Mat src, Mat dst, float gainB, float gainG, float gainR)` \brief Implements an efficient fixed-point approximation for applying channel gains, which is the last step of multiple white balance algorithms.
`static void`	opencv_imgproc.`applyColorMap(Mat src, Mat dst, int colormap)` \brief Applies a GNU Octave/MATLAB equivalent colormap on a given image.
`static void`	opencv_imgproc.`applyColorMap(Mat src, Mat dst, Mat userColor)` \brief Applies a user colormap on a given image.
`static void`	opencv_imgproc.`approxPolyDP(Mat curve, Mat approxCurve, double epsilon, boolean closed)` \brief Approximates a polygonal curve(s) with the specified precision.
`static double`	opencv_imgproc.`arcLength(Mat curve, boolean closed)` \brief Calculates a contour perimeter or a curve length.
`static void`	opencv_imgproc.`arrowedLine(Mat img, Point pt1, Point pt2, Scalar color)`
`static void`	opencv_imgproc.`arrowedLine(Mat img, Point pt1, Point pt2, Scalar color, int thickness, int line_type, int shift, double tipLength)` \brief Draws a arrow segment pointing from the first point to the second one.
`static void`	opencv_intensity_transform.`autoscaling(Mat input, Mat output)` \brief Given an input bgr or grayscale image, apply autoscaling on domain [0, 255] to increase the contrast of the input image and return the resulting image.
`static void`	opencv_img_hash.`averageHash(Mat inputArr, Mat outputArr)` \brief Calculates img_hash::AverageHash in one call
`static void`	opencv_core.`batchDistance(Mat src1, Mat src2, Mat dist, int dtype, Mat nidx)`
`static void`	opencv_core.`batchDistance(Mat src1, Mat src2, Mat dist, int dtype, Mat nidx, int normType, int K, Mat mask, int update, boolean crosscheck)` \brief naive nearest neighbor finder
`static void`	opencv_imgproc.`bilateralFilter(Mat src, Mat dst, int d, double sigmaColor, double sigmaSpace)`
`static void`	opencv_imgproc.`bilateralFilter(Mat src, Mat dst, int d, double sigmaColor, double sigmaSpace, int borderType)` \brief Applies the bilateral filter to an image.
`static void`	opencv_cudaimgproc.`bilateralFilter(Mat src, Mat dst, int kernel_size, float sigma_color, float sigma_spatial)`
`static void`	opencv_cudaimgproc.`bilateralFilter(Mat src, Mat dst, int kernel_size, float sigma_color, float sigma_spatial, int borderMode, Stream stream)` \brief Performs bilateral filtering of passed image
`static void`	opencv_ximgproc.`bilateralTextureFilter(Mat src, Mat dst)`
`static void`	opencv_ximgproc.`bilateralTextureFilter(Mat src, Mat dst, int fr, int numIter, double sigmaAlpha, double sigmaAvg)` \brief Applies the bilateral texture filter to an image.
`static void`	opencv_intensity_transform.`BIMEF(Mat input, Mat output)`
`static void`	opencv_intensity_transform.`BIMEF(Mat input, Mat output, float mu, float a, float b)` \brief Given an input color image, enhance low-light images using the BIMEF method (\cite ying2017bio \cite ying2017new).
`static void`	opencv_intensity_transform.`BIMEF2(Mat input, Mat output, float k, float mu, float a, float b)` \brief Given an input color image, enhance low-light images using the BIMEF method (\cite ying2017bio \cite ying2017new).
`static void`	opencv_core.`bitwise_and(Mat src1, Mat src2, Mat dst)`
`static void`	opencv_cudaarithm.`bitwise_and(Mat src1, Mat src2, Mat dst)`
`static void`	opencv_core.`bitwise_and(Mat src1, Mat src2, Mat dst, Mat mask)` \brief computes bitwise conjunction of the two arrays (dst = src1 & src2) Calculates the per-element bit-wise conjunction of two arrays or an array and a scalar.
`static void`	opencv_cudaarithm.`bitwise_and(Mat src1, Mat src2, Mat dst, Mat mask, Stream stream)` \brief Performs a per-element bitwise conjunction of two matrices (or of matrix and scalar).
`static void`	opencv_core.`bitwise_not(Mat src, Mat dst)`
`static void`	opencv_cudaarithm.`bitwise_not(Mat src, Mat dst)`
`static void`	opencv_core.`bitwise_not(Mat src, Mat dst, Mat mask)` \brief Inverts every bit of an array.
`static void`	opencv_cudaarithm.`bitwise_not(Mat src, Mat dst, Mat mask, Stream stream)` \brief Performs a per-element bitwise inversion.
`static void`	opencv_core.`bitwise_or(Mat src1, Mat src2, Mat dst)`
`static void`	opencv_cudaarithm.`bitwise_or(Mat src1, Mat src2, Mat dst)`
`static void`	opencv_core.`bitwise_or(Mat src1, Mat src2, Mat dst, Mat mask)` \brief Calculates the per-element bit-wise disjunction of two arrays or an array and a scalar.
`static void`	opencv_cudaarithm.`bitwise_or(Mat src1, Mat src2, Mat dst, Mat mask, Stream stream)` \brief Performs a per-element bitwise disjunction of two matrices (or of matrix and scalar).
`static void`	opencv_core.`bitwise_xor(Mat src1, Mat src2, Mat dst)`
`static void`	opencv_cudaarithm.`bitwise_xor(Mat src1, Mat src2, Mat dst)`
`static void`	opencv_core.`bitwise_xor(Mat src1, Mat src2, Mat dst, Mat mask)` \brief Calculates the per-element bit-wise "exclusive or" operation on two arrays or an array and a scalar.
`static void`	opencv_cudaarithm.`bitwise_xor(Mat src1, Mat src2, Mat dst, Mat mask, Stream stream)` \brief Performs a per-element bitwise exclusive or operation of two matrices (or of matrix and scalar).
`static void`	opencv_imgproc.`blendLinear(Mat src1, Mat src2, Mat weights1, Mat weights2, Mat dst)` Performs linear blending of two images:
`static void`	opencv_cudaimgproc.`blendLinear(Mat img1, Mat img2, Mat weights1, Mat weights2, Mat result)`
`static void`	opencv_cudaimgproc.`blendLinear(Mat img1, Mat img2, Mat weights1, Mat weights2, Mat result, Stream stream)` \brief Performs linear blending of two images.
`static Mat`	opencv_dnn.`blobFromImage(Mat image)`
`static Mat`	opencv_dnn.`blobFromImage(Mat image, double scalefactor, Size size, Scalar mean, boolean swapRB, boolean crop, int ddepth)` \brief Creates 4-dimensional blob from image.
`static void`	opencv_dnn.`blobFromImage(Mat image, Mat blob)`
`static void`	opencv_dnn.`blobFromImage(Mat image, Mat blob, double scalefactor, Size size, Scalar mean, boolean swapRB, boolean crop, int ddepth)` \brief Creates 4-dimensional blob from image.
`static void`	opencv_dnn.`blobFromImages(GpuMatVector images, Mat blob)`
`static void`	opencv_dnn.`blobFromImages(GpuMatVector images, Mat blob, double scalefactor, Size size, Scalar mean, boolean swapRB, boolean crop, int ddepth)`
`static void`	opencv_dnn.`blobFromImages(MatVector images, Mat blob)`
`static void`	opencv_dnn.`blobFromImages(MatVector images, Mat blob, double scalefactor, Size size, Scalar mean, boolean swapRB, boolean crop, int ddepth)` \brief Creates 4-dimensional blob from series of images.
`static void`	opencv_dnn.`blobFromImages(UMatVector images, Mat blob)`
`static void`	opencv_dnn.`blobFromImages(UMatVector images, Mat blob, double scalefactor, Size size, Scalar mean, boolean swapRB, boolean crop, int ddepth)`
`static void`	opencv_img_hash.`blockMeanHash(Mat inputArr, Mat outputArr)`
`static void`	opencv_img_hash.`blockMeanHash(Mat inputArr, Mat outputArr, int mode)` \brief Computes block mean hash of the input image
`static void`	opencv_imgproc.`blur(Mat src, Mat dst, Size ksize)`
`static void`	opencv_imgproc.`blur(Mat src, Mat dst, Size ksize, Point anchor, int borderType)` \brief Blurs an image using the normalized box filter.
`static void`	opencv_xphoto.`bm3dDenoising(Mat src, Mat dst)`
`static void`	opencv_xphoto.`bm3dDenoising(Mat src, Mat dst, float h, int templateWindowSize, int searchWindowSize, int blockMatchingStep1, int blockMatchingStep2, int groupSize, int slidingStep, float beta, int normType, int step, int transformType)` \brief Performs image denoising using the Block-Matching and 3D-filtering algorithm with several computational optimizations.
`static void`	opencv_xphoto.`bm3dDenoising(Mat src, Mat dstStep1, Mat dstStep2)`
`static void`	opencv_xphoto.`bm3dDenoising(Mat src, Mat dstStep1, Mat dstStep2, float h, int templateWindowSize, int searchWindowSize, int blockMatchingStep1, int blockMatchingStep2, int groupSize, int slidingStep, float beta, int normType, int step, int transformType)` \brief Performs image denoising using the Block-Matching and 3D-filtering algorithm with several computational optimizations.
`static Rect`	opencv_imgproc.`boundingRect(Mat array)` \brief Calculates the up-right bounding rectangle of a point set or non-zero pixels of gray-scale image.
`static void`	opencv_imgproc.`boxFilter(Mat src, Mat dst, int ddepth, Size ksize)`
`static void`	opencv_imgproc.`boxFilter(Mat src, Mat dst, int ddepth, Size ksize, Point anchor, boolean normalize, int borderType)` \brief Blurs an image using the box filter.
`static void`	opencv_imgproc.`boxPoints(RotatedRect box, Mat points)` \brief Finds the four vertices of a rotated rect.
`static void`	opencv_ximgproc.`BrightEdges(Mat _original, Mat _edgeview)`
`static void`	opencv_ximgproc.`BrightEdges(Mat _original, Mat _edgeview, int contrast, int shortrange, int longrange)` \}
`static int`	opencv_video.`buildOpticalFlowPyramid(Mat img, GpuMatVector pyramid, Size winSize, int maxLevel)`
`static int`	opencv_video.`buildOpticalFlowPyramid(Mat img, GpuMatVector pyramid, Size winSize, int maxLevel, boolean withDerivatives, int pyrBorder, int derivBorder, boolean tryReuseInputImage)`
`static int`	opencv_video.`buildOpticalFlowPyramid(Mat img, MatVector pyramid, Size winSize, int maxLevel)`
`static int`	opencv_video.`buildOpticalFlowPyramid(Mat img, MatVector pyramid, Size winSize, int maxLevel, boolean withDerivatives, int pyrBorder, int derivBorder, boolean tryReuseInputImage)` \brief Constructs the image pyramid which can be passed to calcOpticalFlowPyrLK.
`static int`	opencv_video.`buildOpticalFlowPyramid(Mat img, UMatVector pyramid, Size winSize, int maxLevel)`
`static int`	opencv_video.`buildOpticalFlowPyramid(Mat img, UMatVector pyramid, Size winSize, int maxLevel, boolean withDerivatives, int pyrBorder, int derivBorder, boolean tryReuseInputImage)`
`static void`	opencv_core.`buildOptionsAddMatrixDescription(BytePointer buildOptions, BytePointer name, Mat _m)`
`static void`	opencv_core.`buildOptionsAddMatrixDescription(String buildOptions, String name, Mat _m)`
`static void`	opencv_imgproc.`buildPyramid(Mat src, GpuMatVector dst, int maxlevel)`
`static void`	opencv_imgproc.`buildPyramid(Mat src, GpuMatVector dst, int maxlevel, int borderType)`
`static void`	opencv_imgproc.`buildPyramid(Mat src, MatVector dst, int maxlevel)`
`static void`	opencv_imgproc.`buildPyramid(Mat src, MatVector dst, int maxlevel, int borderType)` \brief Constructs the Gaussian pyramid for an image.
`static void`	opencv_imgproc.`buildPyramid(Mat src, UMatVector dst, int maxlevel)`
`static void`	opencv_imgproc.`buildPyramid(Mat src, UMatVector dst, int maxlevel, int borderType)`
`static void`	opencv_cudawarping.`buildWarpAffineMaps(Mat M, boolean inverse, Size dsize, GpuMat xmap, GpuMat ymap)`
`static void`	opencv_cudawarping.`buildWarpAffineMaps(Mat M, boolean inverse, Size dsize, GpuMat xmap, GpuMat ymap, Stream stream)`
`static void`	opencv_cudawarping.`buildWarpAffineMaps(Mat M, boolean inverse, Size dsize, Mat xmap, Mat ymap)`
`static void`	opencv_cudawarping.`buildWarpAffineMaps(Mat M, boolean inverse, Size dsize, Mat xmap, Mat ymap, Stream stream)` \brief Builds transformation maps for affine transformation.
`static void`	opencv_cudawarping.`buildWarpPerspectiveMaps(Mat M, boolean inverse, Size dsize, GpuMat xmap, GpuMat ymap)`
`static void`	opencv_cudawarping.`buildWarpPerspectiveMaps(Mat M, boolean inverse, Size dsize, GpuMat xmap, GpuMat ymap, Stream stream)`
`static void`	opencv_cudawarping.`buildWarpPerspectiveMaps(Mat M, boolean inverse, Size dsize, Mat xmap, Mat ymap)`
`static void`	opencv_cudawarping.`buildWarpPerspectiveMaps(Mat M, boolean inverse, Size dsize, Mat xmap, Mat ymap, Stream stream)` \brief Builds transformation maps for perspective transformation.
`static void`	opencv_cudaarithm.`calcAbsSum(Mat src, Mat dst)`
`static void`	opencv_cudaarithm.`calcAbsSum(Mat src, Mat dst, Mat mask, Stream stream)` \overload
`static void`	opencv_imgproc.`calcBackProject(GpuMatVector images, int[] channels, Mat hist, Mat dst, float[] ranges, double scale)`
`static void`	opencv_imgproc.`calcBackProject(Mat images, int nimages, int[] channels, GpuMat hist, GpuMat backProject, float[] ranges)`
`static void`	opencv_imgproc.`calcBackProject(Mat images, int nimages, int[] channels, GpuMat hist, GpuMat backProject, float[] ranges, double scale, boolean uniform)`
`static void`	opencv_imgproc.`calcBackProject(Mat images, int nimages, int[] channels, Mat hist, Mat backProject, float[] ranges)`
`static void`	opencv_imgproc.`calcBackProject(Mat images, int nimages, int[] channels, Mat hist, Mat backProject, float[] ranges, double scale, boolean uniform)`
`static void`	opencv_imgproc.`calcBackProject(Mat images, int nimages, int[] channels, SparseMat hist, GpuMat backProject, float[] ranges)`
`static void`	opencv_imgproc.`calcBackProject(Mat images, int nimages, int[] channels, SparseMat hist, GpuMat backProject, float[] ranges, double scale, boolean uniform)`
`static void`	opencv_imgproc.`calcBackProject(Mat images, int nimages, int[] channels, SparseMat hist, Mat backProject, float[] ranges)`
`static void`	opencv_imgproc.`calcBackProject(Mat images, int nimages, int[] channels, SparseMat hist, Mat backProject, float[] ranges, double scale, boolean uniform)`
`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, GpuMat hist, GpuMat backProject, FloatBuffer ranges)`
`static void`	opencv_imgproc.`calcBackProject(Mat images, int nimages, IntBuffer channels, GpuMat hist, GpuMat backProject, FloatBuffer ranges, double scale, boolean uniform)`
`static void`	opencv_imgproc.`calcBackProject(Mat images, int nimages, IntBuffer channels, Mat hist, Mat backProject, FloatBuffer ranges)`
`static void`	opencv_imgproc.`calcBackProject(Mat images, int nimages, IntBuffer channels, Mat hist, Mat backProject, FloatBuffer ranges, double scale, boolean uniform)`
`static void`	opencv_imgproc.`calcBackProject(Mat images, int nimages, IntBuffer channels, SparseMat hist, GpuMat backProject, FloatBuffer ranges)`
`static void`	opencv_imgproc.`calcBackProject(Mat images, int nimages, IntBuffer channels, SparseMat hist, GpuMat backProject, FloatBuffer ranges, double scale, boolean uniform)`
`static void`	opencv_imgproc.`calcBackProject(Mat images, int nimages, IntBuffer channels, SparseMat hist, Mat backProject, FloatBuffer ranges)`
`static void`	opencv_imgproc.`calcBackProject(Mat images, int nimages, IntBuffer channels, SparseMat hist, Mat backProject, FloatBuffer 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, GpuMat hist, GpuMat backProject, FloatPointer ranges)`
`static void`	opencv_imgproc.`calcBackProject(Mat images, int nimages, IntPointer channels, GpuMat hist, GpuMat backProject, FloatPointer ranges, double scale, boolean uniform)`
`static void`	opencv_imgproc.`calcBackProject(Mat images, int nimages, IntPointer channels, Mat hist, Mat backProject, FloatPointer ranges)`
`static void`	opencv_imgproc.`calcBackProject(Mat images, int nimages, IntPointer channels, Mat hist, Mat backProject, FloatPointer ranges, double scale, boolean uniform)`
`static void`	opencv_imgproc.`calcBackProject(Mat images, int nimages, IntPointer channels, Mat hist, Mat backProject, PointerPointer ranges, double scale, boolean uniform)` \brief Calculates the back projection of a histogram.
`static void`	opencv_imgproc.`calcBackProject(Mat images, int nimages, IntPointer channels, SparseMat hist, GpuMat backProject, FloatPointer ranges)`
`static void`	opencv_imgproc.`calcBackProject(Mat images, int nimages, IntPointer channels, SparseMat hist, GpuMat backProject, FloatPointer ranges, double scale, boolean uniform)`
`static void`	opencv_imgproc.`calcBackProject(Mat images, int nimages, IntPointer channels, SparseMat hist, Mat backProject, FloatPointer ranges)`
`static void`	opencv_imgproc.`calcBackProject(Mat images, int nimages, IntPointer channels, SparseMat hist, Mat backProject, FloatPointer ranges, double scale, boolean uniform)`
`static void`	opencv_imgproc.`calcBackProject(Mat images, int nimages, IntPointer channels, SparseMat hist, Mat backProject, PointerPointer ranges, double scale, boolean uniform)` \overload
`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, Mat hist, Mat dst, FloatPointer ranges, double scale)` \overload
`static void`	opencv_imgproc.`calcBackProject(UMatVector images, IntBuffer channels, Mat hist, Mat dst, FloatBuffer ranges, double scale)`
`static float`	opencv_videostab.`calcBlurriness(Mat frame)` \addtogroup videostab \{
`static void`	opencv_core.`calcCovarMatrix(Mat samples, int nsamples, Mat covar, Mat mean, int flags)`
`static void`	opencv_core.`calcCovarMatrix(Mat samples, int nsamples, Mat covar, Mat mean, int flags, int ctype)` \brief Calculates the covariance matrix of a set of vectors.
`static void`	opencv_core.`calcCovarMatrix(Mat samples, Mat covar, Mat mean, int flags)`
`static void`	opencv_core.`calcCovarMatrix(Mat samples, Mat covar, Mat mean, int flags, int ctype)` \overload \note use #COVAR_ROWS or #COVAR_COLS flag
`static void`	opencv_videostab.`calcFlowMask(Mat flowX, Mat flowY, Mat errors, float maxError, Mat mask0, Mat mask1, Mat flowMask)` \}
`static double`	opencv_optflow.`calcGlobalOrientation(Mat orientation, Mat mask, Mat mhi, double timestamp, double duration)` \brief Calculates a global motion orientation in a selected region.
`static void`	opencv_imgproc.`calcHist(GpuMatVector images, int[] channels, Mat mask, Mat hist, int[] histSize, float[] ranges)`
`static void`	opencv_imgproc.`calcHist(GpuMatVector images, int[] channels, Mat mask, Mat hist, int[] histSize, float[] ranges, boolean accumulate)`
`static void`	opencv_imgproc.`calcHist(Mat images, int nimages, int[] channels, GpuMat mask, GpuMat hist, int dims, int[] histSize, float[] ranges)`
`static void`	opencv_imgproc.`calcHist(Mat images, int nimages, int[] channels, GpuMat mask, GpuMat hist, int dims, int[] histSize, float[] ranges, boolean uniform, boolean accumulate)`
`static void`	opencv_imgproc.`calcHist(Mat images, int nimages, int[] channels, GpuMat mask, SparseMat hist, int dims, int[] histSize, float[] ranges)`
`static void`	opencv_imgproc.`calcHist(Mat images, int nimages, int[] channels, GpuMat mask, SparseMat hist, int dims, int[] histSize, float[] ranges, boolean uniform, boolean accumulate)`
`static void`	opencv_imgproc.`calcHist(Mat images, int nimages, int[] channels, Mat mask, Mat hist, int dims, int[] histSize, float[] ranges)`
`static void`	opencv_imgproc.`calcHist(Mat images, int nimages, int[] channels, Mat mask, Mat hist, int dims, int[] histSize, float[] ranges, boolean uniform, boolean accumulate)`
`static void`	opencv_imgproc.`calcHist(Mat images, int nimages, int[] channels, Mat mask, SparseMat hist, int dims, int[] histSize, float[] ranges)`
`static void`	opencv_imgproc.`calcHist(Mat images, int nimages, int[] channels, Mat 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, 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, GpuMat mask, GpuMat hist, int dims, IntBuffer histSize, FloatBuffer ranges)`
`static void`	opencv_imgproc.`calcHist(Mat images, int nimages, IntBuffer channels, GpuMat mask, GpuMat hist, int dims, IntBuffer histSize, FloatBuffer ranges, boolean uniform, boolean accumulate)`
`static void`	opencv_imgproc.`calcHist(Mat images, int nimages, IntBuffer channels, GpuMat mask, SparseMat hist, int dims, IntBuffer histSize, FloatBuffer ranges)`
`static void`	opencv_imgproc.`calcHist(Mat images, int nimages, IntBuffer channels, GpuMat mask, SparseMat hist, int dims, IntBuffer histSize, FloatBuffer ranges, boolean uniform, boolean accumulate)`
`static void`	opencv_imgproc.`calcHist(Mat images, int nimages, IntBuffer channels, Mat mask, Mat hist, int dims, IntBuffer histSize, FloatBuffer ranges)`
`static void`	opencv_imgproc.`calcHist(Mat images, int nimages, IntBuffer channels, Mat mask, Mat hist, int dims, IntBuffer histSize, FloatBuffer ranges, boolean uniform, boolean accumulate)`
`static void`	opencv_imgproc.`calcHist(Mat images, int nimages, IntBuffer channels, Mat mask, SparseMat hist, int dims, IntBuffer histSize, FloatBuffer ranges)`
`static void`	opencv_imgproc.`calcHist(Mat images, int nimages, IntBuffer channels, Mat 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, 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, GpuMat mask, GpuMat hist, int dims, IntPointer histSize, FloatPointer ranges)`
`static void`	opencv_imgproc.`calcHist(Mat images, int nimages, IntPointer channels, GpuMat mask, GpuMat hist, int dims, IntPointer histSize, FloatPointer ranges, boolean uniform, boolean accumulate)`
`static void`	opencv_imgproc.`calcHist(Mat images, int nimages, IntPointer channels, GpuMat mask, SparseMat hist, int dims, IntPointer histSize, FloatPointer ranges)`
`static void`	opencv_imgproc.`calcHist(Mat images, int nimages, IntPointer channels, GpuMat mask, SparseMat hist, int dims, IntPointer histSize, FloatPointer ranges, boolean uniform, boolean accumulate)`
`static void`	opencv_imgproc.`calcHist(Mat images, int nimages, IntPointer channels, Mat mask, Mat hist, int dims, IntPointer histSize, FloatPointer ranges)`
`static void`	opencv_imgproc.`calcHist(Mat images, int nimages, IntPointer channels, Mat mask, Mat hist, int dims, IntPointer histSize, FloatPointer ranges, boolean uniform, boolean accumulate)`
`static void`	opencv_imgproc.`calcHist(Mat images, int nimages, IntPointer channels, Mat mask, Mat hist, int dims, IntPointer histSize, PointerPointer ranges, boolean uniform, boolean accumulate)` \brief Calculates a histogram of a set of arrays.
`static void`	opencv_imgproc.`calcHist(Mat images, int nimages, IntPointer channels, Mat mask, SparseMat hist, int dims, IntPointer histSize, FloatPointer ranges)`
`static void`	opencv_imgproc.`calcHist(Mat images, int nimages, IntPointer channels, Mat mask, SparseMat hist, int dims, IntPointer histSize, FloatPointer ranges, boolean uniform, boolean accumulate)`
`static void`	opencv_imgproc.`calcHist(Mat images, int nimages, IntPointer channels, Mat mask, SparseMat hist, int dims, IntPointer histSize, PointerPointer ranges, boolean uniform, boolean accumulate)` \overload
`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_cudaimgproc.`calcHist(Mat src, Mat hist)`
`static void`	opencv_cudaimgproc.`calcHist(Mat src, Mat mask, Mat hist)`
`static void`	opencv_cudaimgproc.`calcHist(Mat src, Mat mask, Mat hist, Stream stream)` \brief Calculates histogram for one channel 8-bit image confined in given mask.
`static void`	opencv_cudaimgproc.`calcHist(Mat src, Mat hist, Stream stream)` \} cudaimgproc_color
`static void`	opencv_imgproc.`calcHist(MatVector images, IntPointer channels, Mat mask, Mat hist, IntPointer histSize, FloatPointer ranges)`
`static void`	opencv_imgproc.`calcHist(MatVector images, IntPointer channels, Mat mask, Mat hist, IntPointer histSize, FloatPointer ranges, boolean accumulate)` \overload
`static void`	opencv_imgproc.`calcHist(UMatVector images, IntBuffer channels, Mat mask, Mat hist, IntBuffer histSize, FloatBuffer ranges)`
`static void`	opencv_imgproc.`calcHist(UMatVector images, IntBuffer channels, Mat mask, Mat hist, IntBuffer histSize, FloatBuffer ranges, boolean accumulate)`
`static void`	opencv_optflow.`calcMotionGradient(Mat mhi, Mat mask, Mat orientation, double delta1, double delta2)`
`static void`	opencv_optflow.`calcMotionGradient(Mat mhi, Mat mask, Mat orientation, double delta1, double delta2, int apertureSize)` \brief Calculates a gradient orientation of a motion history image.
`static void`	opencv_cudaarithm.`calcNorm(Mat src, Mat dst, int normType)`
`static void`	opencv_cudaarithm.`calcNorm(Mat src, Mat dst, int normType, Mat mask, Stream stream)` \overload
`static void`	opencv_cudaarithm.`calcNormDiff(Mat src1, Mat src2, Mat dst)`
`static void`	opencv_cudaarithm.`calcNormDiff(Mat src1, Mat src2, Mat dst, int normType, Stream stream)` \overload
`static void`	opencv_video.`calcOpticalFlowFarneback(Mat prev, Mat next, Mat flow, double pyr_scale, int levels, int winsize, int iterations, int poly_n, double poly_sigma, int flags)` \brief Computes a dense optical flow using the Gunnar Farneback's algorithm.
`static void`	opencv_video.`calcOpticalFlowPyrLK(Mat prevImg, Mat nextImg, Mat prevPts, Mat nextPts, Mat status, Mat err)`
`static void`	opencv_video.`calcOpticalFlowPyrLK(Mat prevImg, Mat nextImg, Mat prevPts, Mat nextPts, Mat status, Mat err, Size winSize, int maxLevel, TermCriteria criteria, int flags, double minEigThreshold)` \brief Calculates an optical flow for a sparse feature set using the iterative Lucas-Kanade method with pyramids.
`static void`	opencv_optflow.`calcOpticalFlowSF(Mat from, Mat to, Mat flow, int layers, int averaging_block_size, int max_flow)` \addtogroup optflow \{
`static void`	opencv_optflow.`calcOpticalFlowSF(Mat from, Mat to, Mat 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)` \brief Calculate an optical flow using "SimpleFlow" algorithm.
`static void`	opencv_optflow.`calcOpticalFlowSparseToDense(Mat from, Mat to, Mat flow)`
`static void`	opencv_optflow.`calcOpticalFlowSparseToDense(Mat from, Mat to, Mat flow, int grid_step, int k, float sigma, boolean use_post_proc, float fgs_lambda, float fgs_sigma)` \brief Fast dense optical flow based on PyrLK sparse matches interpolation.
`static void`	opencv_cudaarithm.`calcSqrSum(Mat src, Mat dst)`
`static void`	opencv_cudaarithm.`calcSqrSum(Mat src, Mat dst, Mat mask, Stream stream)` \overload
`static void`	opencv_cudaarithm.`calcSum(Mat src, Mat dst)`
`static void`	opencv_cudaarithm.`calcSum(Mat src, Mat dst, Mat mask, Stream stream)` \overload
`static double`	opencv_calib3d.`calibrate(GpuMatVector objectPoints, GpuMatVector imagePoints, Size image_size, Mat K, Mat D, GpuMatVector rvecs, GpuMatVector tvecs)`
`static double`	opencv_calib3d.`calibrate(GpuMatVector objectPoints, GpuMatVector imagePoints, Size image_size, Mat K, Mat D, GpuMatVector rvecs, GpuMatVector tvecs, int flags, TermCriteria criteria)`
`static double`	opencv_calib3d.`calibrate(MatVector objectPoints, MatVector imagePoints, Size image_size, Mat K, Mat D, MatVector rvecs, MatVector tvecs)`
`static double`	opencv_calib3d.`calibrate(MatVector objectPoints, MatVector imagePoints, Size image_size, Mat K, Mat D, MatVector rvecs, MatVector tvecs, int flags, TermCriteria criteria)` \brief Performs camera calibaration
`static double`	opencv_calib3d.`calibrate(UMatVector objectPoints, UMatVector imagePoints, Size image_size, Mat K, Mat D, UMatVector rvecs, UMatVector tvecs)`
`static double`	opencv_calib3d.`calibrate(UMatVector objectPoints, UMatVector imagePoints, Size image_size, Mat K, Mat D, UMatVector rvecs, UMatVector tvecs, int flags, TermCriteria criteria)`
`static double`	opencv_calib3d.`calibrateCamera(Point3fVectorVector objectPoints, Point2fVectorVector imagePoints, Size imageSize, Mat cameraMatrix, Mat distCoeffs, MatVector rvecs, MatVector tvecs)`
`static double`	opencv_calib3d.`calibrateCamera(Point3fVectorVector objectPoints, Point2fVectorVector imagePoints, Size imageSize, Mat cameraMatrix, Mat distCoeffs, MatVector rvecs, MatVector tvecs, int flags, TermCriteria criteria)`
`static double`	opencv_aruco.`calibrateCameraAruco(GpuMatVector corners, Mat ids, Mat counter, Board board, Size imageSize, Mat cameraMatrix, Mat distCoeffs)`
`static double`	opencv_aruco.`calibrateCameraAruco(GpuMatVector corners, Mat ids, Mat counter, Board board, Size imageSize, Mat cameraMatrix, Mat distCoeffs, GpuMatVector rvecs, GpuMatVector tvecs, int flags, TermCriteria criteria)`
`static double`	opencv_aruco.`calibrateCameraAruco(MatVector corners, Mat ids, Mat counter, Board board, Size imageSize, Mat cameraMatrix, Mat distCoeffs)`
`static double`	opencv_aruco.`calibrateCameraAruco(MatVector corners, Mat ids, Mat counter, Board board, Size imageSize, Mat cameraMatrix, Mat distCoeffs, MatVector rvecs, MatVector tvecs, int flags, TermCriteria criteria)` \brief It's the same function as #calibrateCameraAruco but without calibration error estimation.
`static double`	opencv_aruco.`calibrateCameraAruco(UMatVector corners, Mat ids, Mat counter, Board board, Size imageSize, Mat cameraMatrix, Mat distCoeffs)`
`static double`	opencv_aruco.`calibrateCameraAruco(UMatVector corners, Mat ids, Mat counter, Board board, Size imageSize, Mat cameraMatrix, Mat distCoeffs, UMatVector rvecs, UMatVector tvecs, int flags, TermCriteria criteria)`
`static double`	opencv_aruco.`calibrateCameraArucoExtended(GpuMatVector corners, Mat ids, Mat counter, Board board, Size imageSize, Mat cameraMatrix, Mat distCoeffs, GpuMatVector rvecs, GpuMatVector tvecs, Mat stdDeviationsIntrinsics, Mat stdDeviationsExtrinsics, Mat perViewErrors)`
`static double`	opencv_aruco.`calibrateCameraArucoExtended(GpuMatVector corners, Mat ids, Mat counter, Board board, Size imageSize, Mat cameraMatrix, Mat distCoeffs, GpuMatVector rvecs, GpuMatVector tvecs, Mat stdDeviationsIntrinsics, Mat stdDeviationsExtrinsics, Mat perViewErrors, int flags, TermCriteria criteria)`
`static double`	opencv_aruco.`calibrateCameraArucoExtended(MatVector corners, Mat ids, Mat counter, Board board, Size imageSize, Mat cameraMatrix, Mat distCoeffs, MatVector rvecs, MatVector tvecs, Mat stdDeviationsIntrinsics, Mat stdDeviationsExtrinsics, Mat perViewErrors)`
`static double`	opencv_aruco.`calibrateCameraArucoExtended(MatVector corners, Mat ids, Mat counter, Board board, Size imageSize, Mat cameraMatrix, Mat distCoeffs, MatVector rvecs, MatVector tvecs, Mat stdDeviationsIntrinsics, Mat stdDeviationsExtrinsics, Mat perViewErrors, int flags, TermCriteria criteria)` \brief Calibrate a camera using aruco markers
`static double`	opencv_aruco.`calibrateCameraArucoExtended(UMatVector corners, Mat ids, Mat counter, Board board, Size imageSize, Mat cameraMatrix, Mat distCoeffs, UMatVector rvecs, UMatVector tvecs, Mat stdDeviationsIntrinsics, Mat stdDeviationsExtrinsics, Mat perViewErrors)`
`static double`	opencv_aruco.`calibrateCameraArucoExtended(UMatVector corners, Mat ids, Mat counter, Board board, Size imageSize, Mat cameraMatrix, Mat distCoeffs, UMatVector rvecs, UMatVector tvecs, Mat stdDeviationsIntrinsics, Mat stdDeviationsExtrinsics, Mat perViewErrors, int flags, TermCriteria criteria)`
`static double`	opencv_aruco.`calibrateCameraCharuco(GpuMatVector charucoCorners, GpuMatVector charucoIds, CharucoBoard board, Size imageSize, Mat cameraMatrix, Mat distCoeffs)`
`static double`	opencv_aruco.`calibrateCameraCharuco(GpuMatVector charucoCorners, GpuMatVector charucoIds, CharucoBoard board, Size imageSize, Mat cameraMatrix, Mat distCoeffs, GpuMatVector rvecs, GpuMatVector tvecs, int flags, TermCriteria criteria)`
`static double`	opencv_aruco.`calibrateCameraCharuco(MatVector charucoCorners, MatVector charucoIds, CharucoBoard board, Size imageSize, Mat cameraMatrix, Mat distCoeffs)`
`static double`	opencv_aruco.`calibrateCameraCharuco(MatVector charucoCorners, MatVector charucoIds, CharucoBoard board, Size imageSize, Mat cameraMatrix, Mat distCoeffs, MatVector rvecs, MatVector tvecs, int flags, TermCriteria criteria)` \brief It's the same function as #calibrateCameraCharuco but without calibration error estimation.
`static double`	opencv_aruco.`calibrateCameraCharuco(UMatVector charucoCorners, UMatVector charucoIds, CharucoBoard board, Size imageSize, Mat cameraMatrix, Mat distCoeffs)`
`static double`	opencv_aruco.`calibrateCameraCharuco(UMatVector charucoCorners, UMatVector charucoIds, CharucoBoard board, Size imageSize, Mat cameraMatrix, Mat distCoeffs, UMatVector rvecs, UMatVector tvecs, int flags, TermCriteria criteria)`
`static double`	opencv_aruco.`calibrateCameraCharucoExtended(GpuMatVector charucoCorners, GpuMatVector charucoIds, CharucoBoard board, Size imageSize, Mat cameraMatrix, Mat distCoeffs, GpuMatVector rvecs, GpuMatVector tvecs, Mat stdDeviationsIntrinsics, Mat stdDeviationsExtrinsics, Mat perViewErrors)`
`static double`	opencv_aruco.`calibrateCameraCharucoExtended(GpuMatVector charucoCorners, GpuMatVector charucoIds, CharucoBoard board, Size imageSize, Mat cameraMatrix, Mat distCoeffs, GpuMatVector rvecs, GpuMatVector tvecs, Mat stdDeviationsIntrinsics, Mat stdDeviationsExtrinsics, Mat perViewErrors, int flags, TermCriteria criteria)`
`static double`	opencv_aruco.`calibrateCameraCharucoExtended(MatVector charucoCorners, MatVector charucoIds, CharucoBoard board, Size imageSize, Mat cameraMatrix, Mat distCoeffs, MatVector rvecs, MatVector tvecs, Mat stdDeviationsIntrinsics, Mat stdDeviationsExtrinsics, Mat perViewErrors)`
`static double`	opencv_aruco.`calibrateCameraCharucoExtended(MatVector charucoCorners, MatVector charucoIds, CharucoBoard board, Size imageSize, Mat cameraMatrix, Mat distCoeffs, MatVector rvecs, MatVector tvecs, Mat stdDeviationsIntrinsics, Mat stdDeviationsExtrinsics, Mat perViewErrors, int flags, TermCriteria criteria)` \brief Calibrate a camera using Charuco corners
`static double`	opencv_aruco.`calibrateCameraCharucoExtended(UMatVector charucoCorners, UMatVector charucoIds, CharucoBoard board, Size imageSize, Mat cameraMatrix, Mat distCoeffs, UMatVector rvecs, UMatVector tvecs, Mat stdDeviationsIntrinsics, Mat stdDeviationsExtrinsics, Mat perViewErrors)`
`static double`	opencv_aruco.`calibrateCameraCharucoExtended(UMatVector charucoCorners, UMatVector charucoIds, CharucoBoard board, Size imageSize, Mat cameraMatrix, Mat distCoeffs, UMatVector rvecs, UMatVector tvecs, Mat stdDeviationsIntrinsics, Mat stdDeviationsExtrinsics, Mat perViewErrors, int flags, TermCriteria criteria)`
`static double`	opencv_calib3d.`calibrateCameraExtended(Point3fVectorVector objectPoints, Point2fVectorVector imagePoints, Size imageSize, Mat cameraMatrix, Mat distCoeffs, MatVector rvecs, MatVector tvecs, Mat stdDeviationsIntrinsics, Mat stdDeviationsExtrinsics, Mat perViewErrors)`
`static double`	opencv_calib3d.`calibrateCameraExtended(Point3fVectorVector objectPoints, Point2fVectorVector imagePoints, Size imageSize, Mat cameraMatrix, Mat distCoeffs, MatVector rvecs, MatVector tvecs, Mat stdDeviationsIntrinsics, Mat stdDeviationsExtrinsics, Mat perViewErrors, int flags, TermCriteria criteria)` \brief Finds the camera intrinsic and extrinsic parameters from several views of a calibration pattern.
`static double`	opencv_calib3d.`calibrateCameraRO(Point3fVectorVector objectPoints, Point2fVectorVector imagePoints, Size imageSize, int iFixedPoint, Mat cameraMatrix, Mat distCoeffs, MatVector rvecs, MatVector tvecs, Mat newObjPoints)`
`static double`	opencv_calib3d.`calibrateCameraRO(Point3fVectorVector objectPoints, Point2fVectorVector imagePoints, Size imageSize, int iFixedPoint, Mat cameraMatrix, Mat distCoeffs, MatVector rvecs, MatVector tvecs, Mat newObjPoints, int flags, TermCriteria criteria)`
`static double`	opencv_calib3d.`calibrateCameraROExtended(Point3fVectorVector objectPoints, Point2fVectorVector imagePoints, Size imageSize, int iFixedPoint, Mat cameraMatrix, Mat distCoeffs, MatVector rvecs, MatVector tvecs, Mat newObjPoints, Mat stdDeviationsIntrinsics, Mat stdDeviationsExtrinsics, Mat stdDeviationsObjPoints, Mat perViewErrors)`
`static double`	opencv_calib3d.`calibrateCameraROExtended(Point3fVectorVector objectPoints, Point2fVectorVector imagePoints, Size imageSize, int iFixedPoint, Mat cameraMatrix, Mat distCoeffs, MatVector rvecs, MatVector tvecs, Mat newObjPoints, Mat stdDeviationsIntrinsics, Mat stdDeviationsExtrinsics, Mat stdDeviationsObjPoints, Mat perViewErrors, int flags, TermCriteria criteria)` \brief Finds the camera intrinsic and extrinsic parameters from several views of a calibration pattern.
`static void`	opencv_calib3d.`calibrateHandEye(GpuMatVector R_gripper2base, GpuMatVector t_gripper2base, GpuMatVector R_target2cam, GpuMatVector t_target2cam, Mat R_cam2gripper, Mat t_cam2gripper)`
`static void`	opencv_calib3d.`calibrateHandEye(GpuMatVector R_gripper2base, GpuMatVector t_gripper2base, GpuMatVector R_target2cam, GpuMatVector t_target2cam, Mat R_cam2gripper, Mat t_cam2gripper, int method)`
`static void`	opencv_calib3d.`calibrateHandEye(MatVector R_gripper2base, MatVector t_gripper2base, MatVector R_target2cam, MatVector t_target2cam, Mat R_cam2gripper, Mat t_cam2gripper)`
`static void`	opencv_calib3d.`calibrateHandEye(MatVector R_gripper2base, MatVector t_gripper2base, MatVector R_target2cam, MatVector t_target2cam, Mat R_cam2gripper, Mat t_cam2gripper, int method)` \brief Computes Hand-Eye calibration: `_{}^{g}\textrm{T}_c`
`static void`	opencv_calib3d.`calibrateHandEye(UMatVector R_gripper2base, UMatVector t_gripper2base, UMatVector R_target2cam, UMatVector t_target2cam, Mat R_cam2gripper, Mat t_cam2gripper)`
`static void`	opencv_calib3d.`calibrateHandEye(UMatVector R_gripper2base, UMatVector t_gripper2base, UMatVector R_target2cam, UMatVector t_target2cam, Mat R_cam2gripper, Mat t_cam2gripper, int method)`
`static void`	opencv_calib3d.`calibrateRobotWorldHandEye(GpuMatVector R_world2cam, GpuMatVector t_world2cam, GpuMatVector R_base2gripper, GpuMatVector t_base2gripper, Mat R_base2world, Mat t_base2world, Mat R_gripper2cam, Mat t_gripper2cam)`
`static void`	opencv_calib3d.`calibrateRobotWorldHandEye(GpuMatVector R_world2cam, GpuMatVector t_world2cam, GpuMatVector R_base2gripper, GpuMatVector t_base2gripper, Mat R_base2world, Mat t_base2world, Mat R_gripper2cam, Mat t_gripper2cam, int method)`
`static void`	opencv_calib3d.`calibrateRobotWorldHandEye(MatVector R_world2cam, MatVector t_world2cam, MatVector R_base2gripper, MatVector t_base2gripper, Mat R_base2world, Mat t_base2world, Mat R_gripper2cam, Mat t_gripper2cam)`
`static void`	opencv_calib3d.`calibrateRobotWorldHandEye(MatVector R_world2cam, MatVector t_world2cam, MatVector R_base2gripper, MatVector t_base2gripper, Mat R_base2world, Mat t_base2world, Mat R_gripper2cam, Mat t_gripper2cam, int method)` \brief Computes Robot-World/Hand-Eye calibration: `_{}^{w}\textrm{T}_b` and `_{}^{c}\textrm{T}_g`
`static void`	opencv_calib3d.`calibrateRobotWorldHandEye(UMatVector R_world2cam, UMatVector t_world2cam, UMatVector R_base2gripper, UMatVector t_base2gripper, Mat R_base2world, Mat t_base2world, Mat R_gripper2cam, Mat t_gripper2cam)`
`static void`	opencv_calib3d.`calibrateRobotWorldHandEye(UMatVector R_world2cam, UMatVector t_world2cam, UMatVector R_base2gripper, UMatVector t_base2gripper, Mat R_base2world, Mat t_base2world, Mat R_gripper2cam, Mat t_gripper2cam, int method)`
`static boolean`	opencv_stitching.`calibrateRotatingCamera(MatVector Hs, Mat K)`
`static void`	opencv_calib3d.`calibrationMatrixValues(Mat cameraMatrix, Size imageSize, double apertureWidth, double apertureHeight, double[] fovx, double[] fovy, double[] focalLength, Point2d principalPoint, double[] aspectRatio)`
`static void`	opencv_calib3d.`calibrationMatrixValues(Mat cameraMatrix, Size imageSize, double apertureWidth, double apertureHeight, DoubleBuffer fovx, DoubleBuffer fovy, DoubleBuffer focalLength, Point2d principalPoint, DoubleBuffer aspectRatio)`
`static void`	opencv_calib3d.`calibrationMatrixValues(Mat cameraMatrix, Size imageSize, double apertureWidth, double apertureHeight, DoublePointer fovx, DoublePointer fovy, DoublePointer focalLength, Point2d principalPoint, DoublePointer aspectRatio)` \brief Computes useful camera characteristics from the camera intrinsic matrix.
`static RotatedRect`	opencv_video.`CamShift(Mat probImage, Rect window, TermCriteria criteria)` \brief Finds an object center, size, and orientation.
`static void`	opencv_imgproc.`Canny(Mat image, Mat edges, double threshold1, double threshold2)`
`static void`	opencv_imgproc.`Canny(Mat image, Mat edges, double threshold1, double threshold2, int apertureSize, boolean L2gradient)` \brief Finds edges in an image using the Canny algorithm \cite Canny86 .
`static void`	opencv_imgproc.`Canny(Mat dx, Mat dy, Mat edges, double threshold1, double threshold2)`
`static void`	opencv_imgproc.`Canny(Mat dx, Mat dy, Mat edges, double threshold1, double threshold2, boolean L2gradient)` \overload
`static void`	opencv_core.`cartToPolar(Mat x, Mat y, Mat magnitude, Mat angle)`
`static void`	opencv_cudaarithm.`cartToPolar(Mat x, Mat y, Mat magnitude, Mat angle)`
`static void`	opencv_core.`cartToPolar(Mat x, Mat y, Mat magnitude, Mat angle, boolean angleInDegrees)` \brief Calculates the magnitude and angle of 2D vectors.
`static void`	opencv_cudaarithm.`cartToPolar(Mat x, Mat y, Mat magnitude, Mat angle, boolean angleInDegrees, Stream stream)` \brief Converts Cartesian coordinates into polar.
`static boolean`	opencv_calib3d.`checkChessboard(Mat img, Size size)`
`static int`	opencv_core.`checkOptimalVectorWidth(int[] vectorWidths, Mat src1)`
`static int`	opencv_core.`checkOptimalVectorWidth(int[] vectorWidths, Mat src1, Mat src2, Mat src3, Mat src4, Mat src5, Mat src6, Mat src7, Mat src8, Mat src9, int strat)`
`static int`	opencv_core.`checkOptimalVectorWidth(IntBuffer vectorWidths, Mat src1)`
`static int`	opencv_core.`checkOptimalVectorWidth(IntBuffer vectorWidths, Mat src1, Mat src2, Mat src3, Mat src4, Mat src5, Mat src6, Mat src7, Mat src8, Mat src9, int strat)`
`static int`	opencv_core.`checkOptimalVectorWidth(IntPointer vectorWidths, Mat src1)`
`static int`	opencv_core.`checkOptimalVectorWidth(IntPointer vectorWidths, Mat src1, Mat src2, Mat src3, Mat src4, Mat src5, Mat src6, Mat src7, Mat src8, Mat src9, int strat)`
`static boolean`	opencv_core.`checkRange(Mat a)`
`static boolean`	opencv_core.`checkRange(Mat a, boolean quiet, Point pos, double minVal, double maxVal)` \brief Checks every element of an input array for invalid values.
`static void`	opencv_imgproc.`circle(Mat img, Point center, int radius, Scalar color)`
`static void`	opencv_imgproc.`circle(Mat img, Point center, int radius, Scalar color, int thickness, int lineType, int shift)` \brief Draws a circle.
`static void`	opencv_photo.`colorChange(Mat src, Mat mask, Mat dst)`
`static void`	opencv_photo.`colorChange(Mat src, Mat mask, Mat dst, float red_mul, float green_mul, float blue_mul)` \brief Given an original color image, two differently colored versions of this image can be mixed seamlessly.
`static void`	opencv_ximgproc.`colorMatchTemplate(Mat img, Mat templ, Mat result)` \brief Compares a color template against overlapped color image regions.
`static void`	opencv_img_hash.`colorMomentHash(Mat inputArr, Mat outputArr)` \brief Computes color moment hash of the input, the algorithm is come from the paper "Perceptual Hashing for Color Images Using Invariant Moments"
`static void`	opencv_core.`compare(Mat src1, Mat src2, Mat dst, int cmpop)` \brief Performs the per-element comparison of two arrays or an array and scalar value.
`static void`	opencv_cudaarithm.`compare(Mat src1, Mat src2, Mat dst, int cmpop)`
`static void`	opencv_cudaarithm.`compare(Mat src1, Mat src2, Mat dst, int cmpop, Stream stream)` \brief Compares elements of two matrices (or of a matrix and scalar).
`static double`	opencv_imgproc.`compareHist(Mat H1, Mat H2, int method)` \brief Compares two histograms.
`static void`	opencv_videostab.`completeFrameAccordingToFlow(Mat flowMask, Mat flowX, Mat flowY, Mat frame1, Mat mask1, float distThresh, Mat frame0, Mat mask0)`
`static void`	opencv_core.`completeSymm(Mat m)`
`static void`	opencv_core.`completeSymm(Mat m, boolean lowerToUpper)` \brief Copies the lower or the upper half of a square matrix to its another half.
`static void`	opencv_calib3d.`composeRT(Mat rvec1, Mat tvec1, Mat rvec2, Mat tvec2, Mat rvec3, Mat tvec3)`
`static void`	opencv_calib3d.`composeRT(Mat rvec1, Mat tvec1, Mat rvec2, Mat tvec2, Mat rvec3, Mat tvec3, Mat dr3dr1, Mat dr3dt1, Mat dr3dr2, Mat dr3dt2, Mat dt3dr1, Mat dt3dt1, Mat dt3dr2, Mat dt3dt2)` \brief Combines two rotation-and-shift transformations.
`static double`	opencv_ximgproc.`computeBadPixelPercent(Mat GT, Mat src, Rect ROI)`
`static double`	opencv_ximgproc.`computeBadPixelPercent(Mat GT, Mat src, Rect ROI, int thresh)` \brief Function for computing the percent of "bad" pixels in the disparity map (pixels where error is higher than a specified threshold)
`static void`	opencv_calib3d.`computeCorrespondEpilines(Mat points, int whichImage, Mat F, Mat lines)` \brief For points in an image of a stereo pair, computes the corresponding epilines in the other image.
`static double`	opencv_video.`computeECC(Mat templateImage, Mat inputImage)`
`static double`	opencv_video.`computeECC(Mat templateImage, Mat inputImage, Mat inputMask)` \brief Computes the Enhanced Correlation Coefficient value between two images \cite EP08 .
`static void`	opencv_stitching.`computeImageFeatures2(Feature2D featuresFinder, Mat image, ImageFeatures features)`
`static void`	opencv_stitching.`computeImageFeatures2(Feature2D featuresFinder, Mat image, ImageFeatures features, Mat mask)` \brief
`static double`	opencv_ximgproc.`computeMSE(Mat GT, Mat src, Rect ROI)` \brief Function for computing mean square error for disparity maps
`static void`	opencv_text.`computeNMChannels(Mat _src, GpuMatVector _channels)`
`static void`	opencv_text.`computeNMChannels(Mat _src, GpuMatVector _channels, int _mode)`
`static void`	opencv_text.`computeNMChannels(Mat _src, MatVector _channels)`
`static void`	opencv_text.`computeNMChannels(Mat _src, MatVector _channels, int _mode)` \brief Compute the different channels to be processed independently in the N&M algorithm \cite Neumann12.
`static void`	opencv_text.`computeNMChannels(Mat _src, UMatVector _channels)`
`static void`	opencv_text.`computeNMChannels(Mat _src, UMatVector _channels, int _mode)`
`static int`	opencv_imgproc.`connectedComponents(Mat image, Mat labels)`
`static int`	opencv_imgproc.`connectedComponents(Mat image, Mat labels, int connectivity, int ltype)` \overload
`static int`	opencv_imgproc.`connectedComponentsWithAlgorithm(Mat image, Mat labels, int connectivity, int ltype, int ccltype)` \brief computes the connected components labeled image of boolean image
`static int`	opencv_imgproc.`connectedComponentsWithStats(Mat image, Mat labels, Mat stats, Mat centroids)`
`static int`	opencv_imgproc.`connectedComponentsWithStats(Mat image, Mat labels, Mat stats, Mat centroids, int connectivity, int ltype)` \overload
`static int`	opencv_imgproc.`connectedComponentsWithStatsWithAlgorithm(Mat image, Mat labels, Mat stats, Mat centroids, int connectivity, int ltype, int ccltype)` \brief computes the connected components labeled image of boolean image and also produces a statistics output for each label
`static double`	opencv_imgproc.`contourArea(Mat contour)`
`static double`	opencv_imgproc.`contourArea(Mat contour, boolean oriented)` \brief Calculates a contour area.
`static void`	opencv_ximgproc.`contourSampling(Mat src, Mat out, int nbElt)` \brief Contour sampling .
`static void`	opencv_intensity_transform.`contrastStretching(Mat input, Mat output, int r1, int s1, int r2, int s2)` \brief Given an input bgr or grayscale image, apply linear contrast stretching on domain [0, 255] and return the resulting image.
`static void`	opencv_rapid.`convertCorrespondencies(Mat cols, Mat srcLocations, Mat pts2d)`
`static void`	opencv_rapid.`convertCorrespondencies(Mat cols, Mat srcLocations, Mat pts2d, Mat pts3d, Mat mask)` Collect corresponding 2d and 3d points based on correspondencies and mask
`static void`	opencv_core.`convertFp16(Mat src, Mat dst)` \brief Converts an array to half precision floating number.
`static void`	opencv_imgproc.`convertMaps(Mat map1, Mat map2, Mat dstmap1, Mat dstmap2, int dstmap1type)`
`static void`	opencv_imgproc.`convertMaps(Mat map1, Mat map2, Mat dstmap1, Mat dstmap2, int dstmap1type, boolean nninterpolation)` \brief Converts image transformation maps from one representation to another.
`static void`	opencv_calib3d.`convertPointsFromHomogeneous(Mat src, Mat dst)` \brief Converts points from homogeneous to Euclidean space.
`static void`	opencv_calib3d.`convertPointsHomogeneous(Mat src, Mat dst)` \brief Converts points to/from homogeneous coordinates.
`static void`	opencv_calib3d.`convertPointsToHomogeneous(Mat src, Mat dst)` \brief Converts points from Euclidean to homogeneous space.
`static void`	opencv_core.`convertScaleAbs(Mat src, Mat dst)`
`static void`	opencv_core.`convertScaleAbs(Mat src, Mat dst, double alpha, double beta)` \brief Scales, calculates absolute values, and converts the result to 8-bit.
`static void`	opencv_imgproc.`convexHull(Mat points, Mat hull)`
`static void`	opencv_imgproc.`convexHull(Mat points, Mat hull, boolean clockwise, boolean returnPoints)` \brief Finds the convex hull of a point set.
`static void`	opencv_imgproc.`convexityDefects(Mat contour, Mat convexhull, Mat convexityDefects)` \brief Finds the convexity defects of a contour.
`static void`	opencv_core.`copyMakeBorder(Mat src, Mat dst, int top, int bottom, int left, int right, int borderType)`
`static void`	opencv_cudaarithm.`copyMakeBorder(Mat src, Mat dst, int top, int bottom, int left, int right, int borderType)`
`static void`	opencv_core.`copyMakeBorder(Mat src, Mat dst, int top, int bottom, int left, int right, int borderType, Scalar value)` \brief Forms a border around an image.
`static void`	opencv_cudaarithm.`copyMakeBorder(Mat src, Mat dst, int top, int bottom, int left, int right, int borderType, Scalar value, Stream stream)` \brief Forms a border around an image.
`static void`	opencv_core.`copyTo(Mat src, Mat dst, Mat mask)` \brief This is an overloaded member function, provided for convenience (python) Copies the matrix to another one.
`static void`	opencv_imgproc.`cornerEigenValsAndVecs(Mat src, Mat dst, int blockSize, int ksize)`
`static void`	opencv_imgproc.`cornerEigenValsAndVecs(Mat src, Mat dst, int blockSize, int ksize, int borderType)` \brief Calculates eigenvalues and eigenvectors of image blocks for corner detection.
`static void`	opencv_imgproc.`cornerHarris(Mat src, Mat dst, int blockSize, int ksize, double k)`
`static void`	opencv_imgproc.`cornerHarris(Mat src, Mat dst, int blockSize, int ksize, double k, int borderType)` \brief Harris corner detector.
`static void`	opencv_imgproc.`cornerMinEigenVal(Mat src, Mat dst, int blockSize)`
`static void`	opencv_imgproc.`cornerMinEigenVal(Mat src, Mat dst, int blockSize, int ksize, int borderType)` \brief Calculates the minimal eigenvalue of gradient matrices for corner detection.
`static void`	opencv_imgproc.`cornerSubPix(Mat image, Mat corners, Size winSize, Size zeroZone, TermCriteria criteria)` \brief Refines the corner locations.
`static void`	opencv_calib3d.`correctMatches(Mat F, Mat points1, Mat points2, Mat newPoints1, Mat newPoints2)` \brief Refines coordinates of corresponding points.
`static int`	opencv_core.`countNonZero(Mat src)` \brief Counts non-zero array elements.
`static int`	opencv_cudaarithm.`countNonZero(Mat src)` \brief Counts non-zero matrix elements.
`static void`	opencv_cudaarithm.`countNonZero(Mat src, Mat dst)`
`static void`	opencv_cudaarithm.`countNonZero(Mat src, Mat dst, Stream stream)` \overload
`static void`	opencv_ximgproc.`covarianceEstimation(Mat src, Mat dst, int windowRows, int windowCols)` \brief Computes the estimated covariance matrix of an image using the sliding window forumlation.
`static void`	opencv_ml.`createConcentricSpheresTestSet(int nsamples, int nfeatures, int nclasses, Mat samples, Mat responses)` \brief Creates test set
`static void`	opencv_core.`createContinuous(int rows, int cols, int type, Mat arr)` \brief Creates a continuous matrix.
`static DTFilter`	opencv_ximgproc.`createDTFilter(Mat guide, double sigmaSpatial, double sigmaColor)`
`static DTFilter`	opencv_ximgproc.`createDTFilter(Mat guide, double sigmaSpatial, double sigmaColor, int mode, int numIters)` \brief Factory method, create instance of DTFilter and produce initialization routines.
`static FastBilateralSolverFilter`	opencv_ximgproc.`createFastBilateralSolverFilter(Mat guide, double sigma_spatial, double sigma_luma, double sigma_chroma)`
`static FastBilateralSolverFilter`	opencv_ximgproc.`createFastBilateralSolverFilter(Mat guide, double sigma_spatial, double sigma_luma, double sigma_chroma, double lambda, int num_iter, double max_tol)` \brief Factory method, create instance of FastBilateralSolverFilter and execute the initialization routines.
`static FastGlobalSmootherFilter`	opencv_ximgproc.`createFastGlobalSmootherFilter(Mat guide, double lambda, double sigma_color)`
`static FastGlobalSmootherFilter`	opencv_ximgproc.`createFastGlobalSmootherFilter(Mat guide, double lambda, double sigma_color, double lambda_attenuation, int num_iter)` \brief Factory method, create instance of FastGlobalSmootherFilter and execute the initialization routines.
`static GuidedFilter`	opencv_ximgproc.`createGuidedFilter(Mat guide, int radius, double eps)` \brief Factory method, create instance of GuidedFilter and produce initialization routines.
`static void`	opencv_imgproc.`createHanningWindow(Mat dst, Size winSize, int type)` \brief This function computes a Hanning window coefficients in two dimensions.
`static void`	opencv_stitching.`createLaplacePyr(Mat img, int num_levels, UMatVector pyr)`
`static void`	opencv_stitching.`createLaplacePyrGpu(Mat img, int num_levels, UMatVector pyr)`
`static Filter`	opencv_cudafilters.`createLinearFilter(int srcType, int dstType, Mat kernel)`
`static Filter`	opencv_cudafilters.`createLinearFilter(int srcType, int dstType, Mat kernel, Point anchor, int borderMode, Scalar borderVal)` \brief Creates a non-separable linear 2D filter.
`static LookUpTable`	opencv_cudaarithm.`createLookUpTable(Mat lut)` \brief Creates implementation for cuda::LookUpTable .
`static Filter`	opencv_cudafilters.`createMorphologyFilter(int op, int srcType, Mat kernel)`
`static Filter`	opencv_cudafilters.`createMorphologyFilter(int op, int srcType, Mat kernel, Point anchor, int iterations)` \brief Creates a 2D morphological filter.
`static void`	opencv_text.`createOCRHMMTransitionsTable(BytePointer vocabulary, StringVector lexicon, Mat transition_probabilities_table)` \}
`static void`	opencv_ximgproc.`createQuaternionImage(Mat img, Mat qimg)` \addtogroup ximgproc_filters \{
`static void`	opencv_ximgproc.`createRLEImage(Point3iVector runs, Mat res)`
`static void`	opencv_ximgproc.`createRLEImage(Point3iVector runs, Mat res, Size size)` \brief Creates a run-length encoded image from a vector of runs (column begin, column end, row)
`static Filter`	opencv_cudafilters.`createSeparableLinearFilter(int srcType, int dstType, Mat rowKernel, Mat columnKernel)`
`static Filter`	opencv_cudafilters.`createSeparableLinearFilter(int srcType, int dstType, Mat rowKernel, Mat columnKernel, Point anchor, int rowBorderMode, int columnBorderMode)` \brief Creates a separable linear filter.
`static SuperpixelLSC`	opencv_ximgproc.`createSuperpixelLSC(Mat image)`
`static SuperpixelLSC`	opencv_ximgproc.`createSuperpixelLSC(Mat image, int region_size, float ratio)` \brief Class implementing the LSC (Linear Spectral Clustering) superpixels
`static SuperpixelSLIC`	opencv_ximgproc.`createSuperpixelSLIC(Mat image)`
`static SuperpixelSLIC`	opencv_ximgproc.`createSuperpixelSLIC(Mat image, int algorithm, int region_size, float ruler)` \brief Initialize a SuperpixelSLIC object
`static SyntheticSequenceGenerator`	opencv_bgsegm.`createSyntheticSequenceGenerator(Mat background, Mat object)`
`static SyntheticSequenceGenerator`	opencv_bgsegm.`createSyntheticSequenceGenerator(Mat background, Mat object, double amplitude, double wavelength, double wavespeed, double objspeed)` \brief Creates an instance of SyntheticSequenceGenerator.
`static void`	opencv_stitching.`createWeightMap(Mat mask, float sharpness, Mat weight)`
`static IplImage`	opencv_core.`cvIplImage(Mat m)`
`static CvMat`	opencv_core.`cvMat(Mat m)`
`static CvMatND`	opencv_core.`cvMatND(Mat m)`
`static void`	opencv_imgproc.`cvtColor(Mat src, Mat dst, int code)`
`static void`	opencv_cudaimgproc.`cvtColor(Mat src, Mat dst, int code)`
`static void`	opencv_imgproc.`cvtColor(Mat src, Mat dst, int code, int dstCn)` \} imgproc_misc
`static void`	opencv_cudaimgproc.`cvtColor(Mat src, Mat dst, int code, int dcn, Stream stream)` \addtogroup cudaimgproc \{
`static void`	opencv_imgproc.`cvtColorTwoPlane(Mat src1, Mat src2, Mat dst, int code)` \brief Converts an image from one color space to another where the source image is stored in two planes.
`static void`	opencv_core.`dct(Mat src, Mat dst)`
`static void`	opencv_core.`dct(Mat src, Mat dst, int flags)` \brief Performs a forward or inverse discrete Cosine transform of 1D or 2D array.
`static void`	opencv_xphoto.`dctDenoising(Mat src, Mat dst, double sigma)`
`static void`	opencv_xphoto.`dctDenoising(Mat src, Mat dst, double sigma, int psize)` \addtogroup xphoto \{
`static void`	opencv_photo.`decolor(Mat src, Mat grayscale, Mat color_boost)` \} photo_hdr
`static void`	opencv_calib3d.`decomposeEssentialMat(Mat E, Mat R1, Mat R2, Mat t)` \brief Decompose an essential matrix to possible rotations and translation.
`static int`	opencv_calib3d.`decomposeHomographyMat(Mat H, Mat K, GpuMatVector rotations, GpuMatVector translations, GpuMatVector normals)`
`static int`	opencv_calib3d.`decomposeHomographyMat(Mat H, Mat K, MatVector rotations, MatVector translations, MatVector normals)` \brief Decompose a homography matrix to rotation(s), translation(s) and plane normal(s).
`static int`	opencv_calib3d.`decomposeHomographyMat(Mat H, Mat K, UMatVector rotations, UMatVector translations, UMatVector normals)`
`static void`	opencv_calib3d.`decomposeProjectionMatrix(Mat projMatrix, Mat cameraMatrix, Mat rotMatrix, Mat transVect)`
`static void`	opencv_calib3d.`decomposeProjectionMatrix(Mat projMatrix, Mat cameraMatrix, Mat rotMatrix, Mat transVect, Mat rotMatrixX, Mat rotMatrixY, Mat rotMatrixZ, Mat eulerAngles)` \brief Decomposes a projection matrix into a rotation matrix and a camera intrinsic matrix.
`static void`	opencv_imgproc.`demosaicing(Mat src, Mat dst, int code)`
`static void`	opencv_cudaimgproc.`demosaicing(Mat src, Mat dst, int code)`
`static void`	opencv_imgproc.`demosaicing(Mat src, Mat dst, int code, int dstCn)` \brief main function for all demosaicing processes
`static void`	opencv_cudaimgproc.`demosaicing(Mat src, Mat dst, int code, int dcn, Stream stream)` \brief Converts an image from Bayer pattern to RGB or grayscale.
`static void`	opencv_photo.`denoise_TVL1(MatVector observations, Mat result)`
`static void`	opencv_photo.`denoise_TVL1(MatVector observations, Mat result, double lambda, int niters)` \brief Primal-dual algorithm is an algorithm for solving special types of variational problems (that is, finding a function to minimize some functional).
`static void`	opencv_photo.`detailEnhance(Mat src, Mat dst)`
`static void`	opencv_photo.`detailEnhance(Mat src, Mat dst, float sigma_s, float sigma_r)` \brief This filter enhances the details of a particular image.
`static void`	opencv_aruco.`detectCharucoDiamond(Mat image, GpuMatVector markerCorners, Mat markerIds, float squareMarkerLengthRate, GpuMatVector diamondCorners, Mat diamondIds)`
`static void`	opencv_aruco.`detectCharucoDiamond(Mat image, GpuMatVector markerCorners, Mat markerIds, float squareMarkerLengthRate, GpuMatVector diamondCorners, Mat diamondIds, Mat cameraMatrix, Mat distCoeffs)`
`static void`	opencv_aruco.`detectCharucoDiamond(Mat image, MatVector markerCorners, Mat markerIds, float squareMarkerLengthRate, MatVector diamondCorners, Mat diamondIds)`
`static void`	opencv_aruco.`detectCharucoDiamond(Mat image, MatVector markerCorners, Mat markerIds, float squareMarkerLengthRate, MatVector diamondCorners, Mat diamondIds, Mat cameraMatrix, Mat distCoeffs)` \brief Detect ChArUco Diamond markers
`static void`	opencv_aruco.`detectCharucoDiamond(Mat image, UMatVector markerCorners, Mat markerIds, float squareMarkerLengthRate, UMatVector diamondCorners, Mat diamondIds)`
`static void`	opencv_aruco.`detectCharucoDiamond(Mat image, UMatVector markerCorners, Mat markerIds, float squareMarkerLengthRate, UMatVector diamondCorners, Mat diamondIds, Mat cameraMatrix, Mat distCoeffs)`
`static void`	opencv_aruco.`detectMarkers(Mat image, Dictionary dictionary, GpuMatVector corners, Mat ids)`
`static void`	opencv_aruco.`detectMarkers(Mat image, Dictionary dictionary, GpuMatVector corners, Mat ids, DetectorParameters parameters, GpuMatVector rejectedImgPoints, Mat cameraMatrix, Mat distCoeff)`
`static void`	opencv_aruco.`detectMarkers(Mat image, Dictionary dictionary, MatVector corners, Mat ids)`
`static void`	opencv_aruco.`detectMarkers(Mat image, Dictionary dictionary, MatVector corners, Mat ids, DetectorParameters parameters, MatVector rejectedImgPoints, Mat cameraMatrix, Mat distCoeff)` \brief Basic marker detection
`static void`	opencv_aruco.`detectMarkers(Mat image, Dictionary dictionary, UMatVector corners, Mat ids)`
`static void`	opencv_aruco.`detectMarkers(Mat image, Dictionary dictionary, UMatVector corners, Mat ids, DetectorParameters parameters, UMatVector rejectedImgPoints, Mat cameraMatrix, Mat distCoeff)`
`static void`	opencv_text.`detectRegions(Mat image, ERFilter er_filter1, ERFilter er_filter2, PointVectorVector regions)`
`static void`	opencv_text.`detectRegions(Mat image, ERFilter er_filter1, ERFilter er_filter2, RectVector groups_rects)`
`static void`	opencv_text.`detectRegions(Mat image, ERFilter er_filter1, ERFilter er_filter2, RectVector groups_rects, int method, BytePointer filename, float minProbability)` \brief Extracts text regions from image.
`static void`	opencv_text.`detectRegions(Mat image, ERFilter er_filter1, ERFilter er_filter2, RectVector groups_rects, int method, String filename, float minProbability)`
`static double`	opencv_core.`determinant(Mat mtx)` \brief Returns the determinant of a square floating-point matrix.
`static void`	opencv_core.`dft(Mat src, Mat dst)`
`static void`	opencv_core.`dft(Mat src, Mat dst, int flags, int nonzeroRows)` \brief Performs a forward or inverse Discrete Fourier transform of a 1D or 2D floating-point array.
`static void`	opencv_cudaarithm.`dft(Mat src, Mat dst, Size dft_size)`
`static void`	opencv_cudaarithm.`dft(Mat src, Mat dst, Size dft_size, int flags, Stream stream)` \brief Performs a forward or inverse discrete Fourier transform (1D or 2D) of the floating point matrix.
`static void`	opencv_imgproc.`dilate(Mat src, Mat dst, Mat kernel)`
`static void`	opencv_ximgproc.`dilate(Mat rlSrc, Mat rlDest, Mat rlKernel)`
`static void`	opencv_ximgproc.`dilate(Mat rlSrc, Mat rlDest, Mat rlKernel, Point anchor)` \brief Dilates an run-length encoded binary image by using a specific structuring element.
`static void`	opencv_imgproc.`dilate(Mat src, Mat dst, Mat kernel, Point anchor, int iterations, int borderType, Scalar borderValue)` \brief Dilates an image by using a specific structuring element.
`static void`	opencv_imgproc.`distanceTransform(Mat src, Mat dst, int distanceType, int maskSize)`
`static void`	opencv_imgproc.`distanceTransform(Mat src, Mat dst, int distanceType, int maskSize, int dstType)` \overload
`static void`	opencv_imgproc.`distanceTransformWithLabels(Mat src, Mat dst, Mat labels, int distanceType, int maskSize)`
`static void`	opencv_imgproc.`distanceTransformWithLabels(Mat src, Mat dst, Mat labels, int distanceType, int maskSize, int labelType)` \brief Calculates the distance to the closest zero pixel for each pixel of the source image.
`static void`	opencv_calib3d.`distortPoints(Mat undistorted, Mat distorted, Mat K, Mat D)`
`static void`	opencv_calib3d.`distortPoints(Mat undistorted, Mat distorted, Mat K, Mat D, double alpha)` \brief Distorts 2D points using fisheye model.
`static MatExpr`	opencv_core.`divide(double s, Mat a)`
`static void`	opencv_core.`divide(double scale, Mat src2, Mat dst)`
`static void`	opencv_core.`divide(double scale, Mat src2, Mat dst, int dtype)` \overload
`static MatExpr`	opencv_core.`divide(Mat a, double s)`
`static MatExpr`	opencv_core.`divide(MatExpr e, Mat m)`
`static MatExpr`	opencv_core.`divide(Mat a, Mat b)`
`static MatExpr`	opencv_core.`divide(Mat m, MatExpr e)`
`static void`	opencv_core.`divide(Mat src1, Mat src2, Mat dst)`
`static void`	opencv_cudaarithm.`divide(Mat src1, Mat src2, Mat dst)`
`static void`	opencv_core.`divide(Mat src1, Mat src2, Mat dst, double scale, int dtype)` \brief Performs per-element division of two arrays or a scalar by an array.
`static void`	opencv_cudaarithm.`divide(Mat src1, Mat src2, Mat dst, double scale, int dtype, Stream stream)` \brief Computes a matrix-matrix or matrix-scalar division.
`static Mat`	opencv_core.`dividePut(Mat a, double b)`
`static Mat`	opencv_core.`dividePut(Mat a, Mat b)`
`static void`	opencv_imgproc.`divSpectrums(Mat a, Mat b, Mat c, int flags)`
`static void`	opencv_imgproc.`divSpectrums(Mat a, Mat b, Mat c, int flags, boolean conjB)` \brief Performs the per-element division of the first Fourier spectrum by the second Fourier spectrum.
`static void`	opencv_aruco.`drawAxis(Mat image, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec, float length)` Deprecated. use cv::drawFrameAxes
`static void`	opencv_aruco.`drawCharucoDiamond(Dictionary dictionary, Scalar4i ids, int squareLength, int markerLength, Mat img)`
`static void`	opencv_aruco.`drawCharucoDiamond(Dictionary dictionary, Scalar4i ids, int squareLength, int markerLength, Mat img, int marginSize, int borderBits)` \brief Draw a ChArUco Diamond marker
`static void`	opencv_calib3d.`drawChessboardCorners(Mat image, Size patternSize, Mat corners, boolean patternWasFound)` \brief Renders the detected chessboard corners.
`static void`	opencv_cudastereo.`drawColorDisp(Mat src_disp, Mat dst_disp, int ndisp)`
`static void`	opencv_cudastereo.`drawColorDisp(Mat src_disp, Mat dst_disp, int ndisp, Stream stream)` \brief Colors a disparity image.
`static void`	opencv_imgproc.`drawContours(Mat image, GpuMatVector contours, int contourIdx, Scalar color)`
`static void`	opencv_imgproc.`drawContours(Mat image, GpuMatVector contours, int contourIdx, Scalar color, int thickness, int lineType, Mat hierarchy, int maxLevel, Point offset)`
`static void`	opencv_imgproc.`drawContours(Mat image, MatVector contours, int contourIdx, Scalar color)`
`static void`	opencv_imgproc.`drawContours(Mat image, MatVector contours, int contourIdx, Scalar color, int thickness, int lineType, Mat hierarchy, int maxLevel, Point offset)` \brief Draws contours outlines or filled contours.
`static void`	opencv_imgproc.`drawContours(Mat image, UMatVector contours, int contourIdx, Scalar color)`
`static void`	opencv_imgproc.`drawContours(Mat image, UMatVector contours, int contourIdx, Scalar color, int thickness, int lineType, Mat hierarchy, int maxLevel, Point offset)`
`static void`	opencv_rapid.`drawCorrespondencies(Mat bundle, Mat cols)`
`static void`	opencv_rapid.`drawCorrespondencies(Mat bundle, Mat cols, Mat colors)` \addtogroup rapid \{
`static void`	opencv_aruco.`drawDetectedCornersCharuco(Mat image, Mat charucoCorners)`
`static void`	opencv_aruco.`drawDetectedCornersCharuco(Mat image, Mat charucoCorners, Mat charucoIds, Scalar cornerColor)` \brief Draws a set of Charuco corners
`static void`	opencv_aruco.`drawDetectedDiamonds(Mat image, GpuMatVector diamondCorners)`
`static void`	opencv_aruco.`drawDetectedDiamonds(Mat image, GpuMatVector diamondCorners, Mat diamondIds, Scalar borderColor)`
`static void`	opencv_aruco.`drawDetectedDiamonds(Mat image, MatVector diamondCorners)`
`static void`	opencv_aruco.`drawDetectedDiamonds(Mat image, MatVector diamondCorners, Mat diamondIds, Scalar borderColor)` \brief Draw a set of detected ChArUco Diamond markers
`static void`	opencv_aruco.`drawDetectedDiamonds(Mat image, UMatVector diamondCorners)`
`static void`	opencv_aruco.`drawDetectedDiamonds(Mat image, UMatVector diamondCorners, Mat diamondIds, Scalar borderColor)`
`static void`	opencv_aruco.`drawDetectedMarkers(Mat image, GpuMatVector corners)`
`static void`	opencv_aruco.`drawDetectedMarkers(Mat image, GpuMatVector corners, Mat ids, Scalar borderColor)`
`static void`	opencv_aruco.`drawDetectedMarkers(Mat image, MatVector corners)`
`static void`	opencv_aruco.`drawDetectedMarkers(Mat image, MatVector corners, Mat ids, Scalar borderColor)` \brief Draw detected markers in image
`static void`	opencv_aruco.`drawDetectedMarkers(Mat image, UMatVector corners)`
`static void`	opencv_aruco.`drawDetectedMarkers(Mat image, UMatVector corners, Mat ids, Scalar borderColor)`
`static void`	opencv_face.`drawFacemarks(Mat image, Point2fVector points, Scalar color)` \brief Utility to draw the detected facial landmark points
`static void`	opencv_calib3d.`drawFrameAxes(Mat image, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec, float length)`
`static void`	opencv_calib3d.`drawFrameAxes(Mat image, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec, float length, int thickness)` \brief Draw axes of the world/object coordinate system from pose estimation.
`static void`	opencv_features2d.`drawKeypoints(Mat image, KeyPointVector keypoints, Mat outImage)`
`static void`	opencv_features2d.`drawKeypoints(Mat image, KeyPointVector keypoints, Mat outImage, Scalar color, int flags)` \brief Draws keypoints.
`static void`	opencv_aruco.`drawMarker(Dictionary dictionary, int id, int sidePixels, Mat img)`
`static void`	opencv_aruco.`drawMarker(Dictionary dictionary, int id, int sidePixels, Mat img, int borderBits)` \brief Draw a canonical marker image
`static void`	opencv_imgproc.`drawMarker(Mat img, Point _position, Scalar color)`
`static void`	opencv_imgproc.`drawMarker(Mat img, Point _position, Scalar color, int markerType, int markerSize, int thickness, int line_type)` \brief Draws a marker on a predefined position in an image.
`static void`	opencv_features2d.`drawMatches(Mat img1, KeyPointVector keypoints1, Mat img2, KeyPointVector keypoints2, DMatchVector matches1to2, Mat outImg)`
`static void`	opencv_features2d.`drawMatches(Mat img1, KeyPointVector keypoints1, Mat img2, KeyPointVector keypoints2, DMatchVector matches1to2, Mat outImg, int matchesThickness)`
`static void`	opencv_features2d.`drawMatches(Mat img1, KeyPointVector keypoints1, Mat img2, KeyPointVector keypoints2, DMatchVector matches1to2, Mat outImg, int matchesThickness, Scalar matchColor, Scalar singlePointColor, byte[] matchesMask, int flags)`
`static void`	opencv_features2d.`drawMatches(Mat img1, KeyPointVector keypoints1, Mat img2, KeyPointVector keypoints2, DMatchVector matches1to2, Mat outImg, int matchesThickness, Scalar matchColor, Scalar singlePointColor, ByteBuffer matchesMask, int flags)`
`static void`	opencv_features2d.`drawMatches(Mat img1, KeyPointVector keypoints1, Mat img2, KeyPointVector keypoints2, DMatchVector matches1to2, Mat outImg, int matchesThickness, Scalar matchColor, Scalar singlePointColor, BytePointer matchesMask, int flags)` \overload
`static void`	opencv_features2d.`drawMatches(Mat img1, KeyPointVector keypoints1, Mat img2, KeyPointVector keypoints2, DMatchVector matches1to2, Mat outImg, Scalar matchColor, Scalar singlePointColor, byte[] matchesMask, int flags)`
`static void`	opencv_features2d.`drawMatches(Mat img1, KeyPointVector keypoints1, Mat img2, KeyPointVector keypoints2, DMatchVector matches1to2, Mat outImg, Scalar matchColor, Scalar singlePointColor, ByteBuffer matchesMask, int flags)`
`static void`	opencv_features2d.`drawMatches(Mat img1, KeyPointVector keypoints1, Mat img2, KeyPointVector keypoints2, DMatchVector matches1to2, Mat outImg, Scalar matchColor, Scalar singlePointColor, BytePointer matchesMask, int flags)` \brief Draws the found matches of keypoints from two images.
`static void`	opencv_features2d.`drawMatchesKnn(Mat img1, KeyPointVector keypoints1, Mat img2, KeyPointVector keypoints2, DMatchVectorVector matches1to2, Mat outImg)`
`static void`	opencv_features2d.`drawMatchesKnn(Mat img1, KeyPointVector keypoints1, Mat img2, KeyPointVector keypoints2, DMatchVectorVector matches1to2, Mat outImg, Scalar matchColor, Scalar singlePointColor, ByteVectorVector matchesMask, int flags)`
`static void`	opencv_aruco.`drawPlanarBoard(Board board, Size outSize, Mat img)`
`static void`	opencv_aruco.`drawPlanarBoard(Board board, Size outSize, Mat img, int marginSize, int borderBits)` \brief Draw a planar board
`static void`	opencv_rapid.`drawSearchLines(Mat img, Mat locations, Scalar color)` Debug draw search lines onto an image
`static void`	opencv_rapid.`drawWireframe(Mat img, Mat pts2d, Mat tris, Scalar color)`
`static void`	opencv_rapid.`drawWireframe(Mat img, Mat pts2d, Mat tris, Scalar color, int type, boolean cullBackface)` Draw a wireframe of a triangle mesh
`static void`	opencv_ximgproc.`dtFilter(Mat guide, Mat src, Mat dst, double sigmaSpatial, double sigmaColor)`
`static void`	opencv_ximgproc.`dtFilter(Mat guide, Mat src, Mat dst, double sigmaSpatial, double sigmaColor, int mode, int numIters)` \brief Simple one-line Domain Transform filter call.
`static void`	opencv_photo.`edgePreservingFilter(Mat src, Mat dst)`
`static void`	opencv_ximgproc.`edgePreservingFilter(Mat src, Mat dst, int d, double threshold)` \addtogroup ximgproc \{
`static void`	opencv_photo.`edgePreservingFilter(Mat src, Mat dst, int flags, float sigma_s, float sigma_r)` \brief Filtering is the fundamental operation in image and video processing.
`static boolean`	opencv_core.`eigen(Mat src, Mat eigenvalues)`
`static boolean`	opencv_core.`eigen(Mat src, Mat eigenvalues, Mat eigenvectors)` \brief Calculates eigenvalues and eigenvectors of a symmetric matrix.
`static void`	opencv_core.`eigenNonSymmetric(Mat src, Mat eigenvalues, Mat eigenvectors)` \brief Calculates eigenvalues and eigenvectors of a non-symmetric matrix (real eigenvalues only).
`static void`	opencv_imgproc.`ellipse(Mat img, Point center, Size axes, double angle, double startAngle, double endAngle, Scalar color)`
`static void`	opencv_imgproc.`ellipse(Mat img, Point center, Size axes, double angle, double startAngle, double endAngle, Scalar color, int thickness, int lineType, int shift)` \brief Draws a simple or thick elliptic arc or fills an ellipse sector.
`static void`	opencv_imgproc.`ellipse(Mat img, RotatedRect box, Scalar color)`
`static void`	opencv_imgproc.`ellipse(Mat img, RotatedRect box, Scalar color, int thickness, int lineType)` \overload
`static float`	opencv_imgproc.`EMD(Mat signature1, Mat signature2, int distType)`
`static float`	opencv_imgproc.`EMD(Mat signature1, Mat signature2, int distType, Mat cost, float[] lowerBound, Mat flow)`
`static float`	opencv_imgproc.`EMD(Mat signature1, Mat signature2, int distType, Mat cost, FloatBuffer lowerBound, Mat flow)`
`static float`	opencv_imgproc.`EMD(Mat signature1, Mat signature2, int distType, Mat cost, FloatPointer lowerBound, Mat flow)` \brief Computes the "minimal work" distance between two weighted point configurations.
`static float`	opencv_shape.`EMDL1(Mat signature1, Mat signature2)` \addtogroup shape /** \{
`static Mat`	opencv_videostab.`ensureInclusionConstraint(Mat M, Size size, float trimRatio)` \}
`static void`	opencv_core.`ensureSizeIsEnough(int rows, int cols, int type, Mat arr)` \brief Ensures that the size of a matrix is big enough and the matrix has a proper type.
`static void`	opencv_imgproc.`equalizeHist(Mat src, Mat dst)` \brief Equalizes the histogram of a grayscale image.
`static void`	opencv_cudaimgproc.`equalizeHist(Mat src, Mat dst)`
`static void`	opencv_cudaimgproc.`equalizeHist(Mat src, Mat dst, Stream stream)` \brief Equalizes the histogram of a grayscale image.
`static MatExpr`	opencv_core.`equals(double s, Mat a)`
`static MatExpr`	opencv_core.`equals(Mat a, double s)`
`static MatExpr`	opencv_core.`equals(Mat a, Mat b)`
`static void`	opencv_text.`erGrouping(Mat img, GpuMatVector channels, ERStatVectorVector regions, PointVectorVector groups, RectVector groups_rects)`
`static void`	opencv_text.`erGrouping(Mat img, GpuMatVector channels, ERStatVectorVector regions, PointVectorVector groups, RectVector groups_rects, int method, BytePointer filename, float minProbablity)`
`static void`	opencv_text.`erGrouping(Mat img, GpuMatVector channels, ERStatVectorVector regions, PointVectorVector groups, RectVector groups_rects, int method, String filename, float minProbablity)`
`static void`	opencv_text.`erGrouping(Mat image, Mat channel, PointVectorVector regions, RectVector groups_rects)`
`static void`	opencv_text.`erGrouping(Mat image, Mat channel, PointVectorVector regions, RectVector groups_rects, int method, BytePointer filename, float minProbablity)`
`static void`	opencv_text.`erGrouping(Mat image, Mat channel, PointVectorVector regions, RectVector groups_rects, int method, String filename, float minProbablity)`
`static void`	opencv_text.`erGrouping(Mat img, MatVector channels, ERStatVectorVector regions, PointVectorVector groups, RectVector groups_rects)`
`static void`	opencv_text.`erGrouping(Mat img, MatVector channels, ERStatVectorVector regions, PointVectorVector groups, RectVector groups_rects, int method, BytePointer filename, float minProbablity)` \brief Find groups of Extremal Regions that are organized as text blocks.
`static void`	opencv_text.`erGrouping(Mat img, MatVector channels, ERStatVectorVector regions, PointVectorVector groups, RectVector groups_rects, int method, String filename, float minProbablity)`
`static void`	opencv_text.`erGrouping(Mat img, UMatVector channels, ERStatVectorVector regions, PointVectorVector groups, RectVector groups_rects)`
`static void`	opencv_text.`erGrouping(Mat img, UMatVector channels, ERStatVectorVector regions, PointVectorVector groups, RectVector groups_rects, int method, BytePointer filename, float minProbablity)`
`static void`	opencv_text.`erGrouping(Mat img, UMatVector channels, ERStatVectorVector regions, PointVectorVector groups, RectVector groups_rects, int method, String filename, float minProbablity)`
`static void`	opencv_imgproc.`erode(Mat src, Mat dst, Mat kernel)`
`static void`	opencv_ximgproc.`erode(Mat rlSrc, Mat rlDest, Mat rlKernel)`
`static void`	opencv_ximgproc.`erode(Mat rlSrc, Mat rlDest, Mat rlKernel, boolean bBoundaryOn, Point anchor)` \brief Erodes an run-length encoded binary image by using a specific structuring element.
`static void`	opencv_imgproc.`erode(Mat src, Mat dst, Mat kernel, Point anchor, int iterations, int borderType, Scalar borderValue)` \brief Erodes an image by using a specific structuring element.
`static Mat`	opencv_calib3d.`estimateAffine2D(Mat from, Mat to)`
`static Mat`	opencv_calib3d.`estimateAffine2D(Mat from, Mat to, Mat inliers, int method, double ransacReprojThreshold, long maxIters, double confidence, long refineIters)` \brief Computes an optimal affine transformation between two 2D point sets.
`static Mat`	opencv_calib3d.`estimateAffine2D(Mat pts1, Mat pts2, Mat inliers, UsacParams params)`
`static Mat`	opencv_calib3d.`estimateAffine3D(Mat src, Mat dst)`
`static Mat`	opencv_calib3d.`estimateAffine3D(Mat src, Mat dst, double[] scale, boolean force_rotation)`
`static Mat`	opencv_calib3d.`estimateAffine3D(Mat src, Mat dst, DoubleBuffer scale, boolean force_rotation)`
`static Mat`	opencv_calib3d.`estimateAffine3D(Mat src, Mat dst, DoublePointer scale, boolean force_rotation)` \brief Computes an optimal affine transformation between two 3D point sets.
`static int`	opencv_calib3d.`estimateAffine3D(Mat src, Mat dst, Mat out, Mat inliers)`
`static int`	opencv_calib3d.`estimateAffine3D(Mat src, Mat dst, Mat out, Mat inliers, double ransacThreshold, double confidence)` \brief Computes an optimal affine transformation between two 3D point sets.
`static Mat`	opencv_calib3d.`estimateAffinePartial2D(Mat from, Mat to)`
`static Mat`	opencv_calib3d.`estimateAffinePartial2D(Mat from, Mat to, Mat inliers, int method, double ransacReprojThreshold, long maxIters, double confidence, long refineIters)` \brief Computes an optimal limited affine transformation with 4 degrees of freedom between two 2D point sets.
`static Scalar`	opencv_calib3d.`estimateChessboardSharpness(Mat image, Size patternSize, Mat corners)`
`static Scalar`	opencv_calib3d.`estimateChessboardSharpness(Mat image, Size patternSize, Mat corners, float rise_distance, boolean vertical, Mat sharpness)` \brief Estimates the sharpness of a detected chessboard.
`static Mat`	opencv_videostab.`estimateGlobalMotionLeastSquares(Mat points0, Mat points1)`
`static Mat`	opencv_videostab.`estimateGlobalMotionLeastSquares(Mat points0, Mat points1, int model, float[] rmse)`
`static Mat`	opencv_videostab.`estimateGlobalMotionLeastSquares(Mat points0, Mat points1, int model, FloatBuffer rmse)`
`static Mat`	opencv_videostab.`estimateGlobalMotionLeastSquares(Mat points0, Mat points1, int model, FloatPointer rmse)` \addtogroup videostab_motion \{
`static Mat`	opencv_videostab.`estimateGlobalMotionRansac(Mat points0, Mat points1)`
`static Mat`	opencv_videostab.`estimateGlobalMotionRansac(Mat points0, Mat points1, int model, RansacParams params, float[] rmse, int[] ninliers)`
`static Mat`	opencv_videostab.`estimateGlobalMotionRansac(Mat points0, Mat points1, int model, RansacParams params, FloatBuffer rmse, IntBuffer ninliers)`
`static Mat`	opencv_videostab.`estimateGlobalMotionRansac(Mat points0, Mat points1, int model, RansacParams params, FloatPointer rmse, IntPointer ninliers)` \brief Estimates best global motion between two 2D point clouds robustly (using RANSAC method).
`static void`	opencv_calib3d.`estimateNewCameraMatrixForUndistortRectify(Mat K, Mat D, Size image_size, Mat R, Mat P)`
`static void`	opencv_calib3d.`estimateNewCameraMatrixForUndistortRectify(Mat K, Mat D, Size image_size, Mat R, Mat P, double balance, Size new_size, double fov_scale)` \brief Estimates new camera intrinsic matrix for undistortion or rectification.
`static float`	opencv_videostab.`estimateOptimalTrimRatio(Mat M, Size size)`
`static int`	opencv_aruco.`estimatePoseBoard(GpuMatVector corners, Mat ids, Board board, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec)`
`static int`	opencv_aruco.`estimatePoseBoard(GpuMatVector corners, Mat ids, Board board, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec, boolean useExtrinsicGuess)`
`static int`	opencv_aruco.`estimatePoseBoard(MatVector corners, Mat ids, Board board, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec)`
`static int`	opencv_aruco.`estimatePoseBoard(MatVector corners, Mat ids, Board board, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec, boolean useExtrinsicGuess)` \brief Pose estimation for a board of markers
`static int`	opencv_aruco.`estimatePoseBoard(UMatVector corners, Mat ids, Board board, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec)`
`static int`	opencv_aruco.`estimatePoseBoard(UMatVector corners, Mat ids, Board board, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec, boolean useExtrinsicGuess)`
`static boolean`	opencv_aruco.`estimatePoseCharucoBoard(Mat charucoCorners, Mat charucoIds, CharucoBoard board, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec)`
`static boolean`	opencv_aruco.`estimatePoseCharucoBoard(Mat charucoCorners, Mat charucoIds, CharucoBoard board, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec, boolean useExtrinsicGuess)` \brief Pose estimation for a ChArUco board given some of their corners
`static void`	opencv_aruco.`estimatePoseSingleMarkers(GpuMatVector corners, float markerLength, Mat cameraMatrix, Mat distCoeffs, Mat rvecs, Mat tvecs)`
`static void`	opencv_aruco.`estimatePoseSingleMarkers(GpuMatVector corners, float markerLength, Mat cameraMatrix, Mat distCoeffs, Mat rvecs, Mat tvecs, Mat _objPoints)`
`static void`	opencv_aruco.`estimatePoseSingleMarkers(MatVector corners, float markerLength, Mat cameraMatrix, Mat distCoeffs, Mat rvecs, Mat tvecs)`
`static void`	opencv_aruco.`estimatePoseSingleMarkers(MatVector corners, float markerLength, Mat cameraMatrix, Mat distCoeffs, Mat rvecs, Mat tvecs, Mat _objPoints)` \brief Pose estimation for single markers
`static void`	opencv_aruco.`estimatePoseSingleMarkers(UMatVector corners, float markerLength, Mat cameraMatrix, Mat distCoeffs, Mat rvecs, Mat tvecs)`
`static void`	opencv_aruco.`estimatePoseSingleMarkers(UMatVector corners, float markerLength, Mat cameraMatrix, Mat distCoeffs, Mat rvecs, Mat tvecs, Mat _objPoints)`
`static Mat`	opencv_video.`estimateRigidTransform(Mat src, Mat dst, boolean fullAffine)` Deprecated. Use cv::estimateAffine2D, cv::estimateAffinePartial2D instead. If you are using this function with images, extract points using cv::calcOpticalFlowPyrLK and then use the estimation functions.
`static int`	opencv_calib3d.`estimateTranslation3D(Mat src, Mat dst, Mat out, Mat inliers)`
`static int`	opencv_calib3d.`estimateTranslation3D(Mat src, Mat dst, Mat out, Mat inliers, double ransacThreshold, double confidence)` \brief Computes an optimal translation between two 3D point sets.
`static void`	opencv_features2d.`evaluateFeatureDetector(Mat img1, Mat img2, Mat H1to2, KeyPointVector keypoints1, KeyPointVector keypoints2, float[] repeatability, int[] correspCount)`
`static void`	opencv_features2d.`evaluateFeatureDetector(Mat img1, Mat img2, Mat H1to2, KeyPointVector keypoints1, KeyPointVector keypoints2, float[] repeatability, int[] correspCount, Feature2D fdetector)`
`static void`	opencv_features2d.`evaluateFeatureDetector(Mat img1, Mat img2, Mat H1to2, KeyPointVector keypoints1, KeyPointVector keypoints2, FloatBuffer repeatability, IntBuffer correspCount)`
`static void`	opencv_features2d.`evaluateFeatureDetector(Mat img1, Mat img2, Mat H1to2, KeyPointVector keypoints1, KeyPointVector keypoints2, FloatBuffer repeatability, IntBuffer correspCount, Feature2D fdetector)`
`static void`	opencv_features2d.`evaluateFeatureDetector(Mat img1, Mat img2, Mat H1to2, KeyPointVector keypoints1, KeyPointVector keypoints2, FloatPointer repeatability, IntPointer correspCount)`
`static void`	opencv_features2d.`evaluateFeatureDetector(Mat img1, Mat img2, Mat H1to2, KeyPointVector keypoints1, KeyPointVector keypoints2, FloatPointer repeatability, IntPointer correspCount, Feature2D fdetector)` \} features2d_draw
`static void`	opencv_cudaimgproc.`evenLevels(Mat levels, int nLevels, int lowerLevel, int upperLevel)`
`static void`	opencv_cudaimgproc.`evenLevels(Mat levels, int nLevels, int lowerLevel, int upperLevel, Stream stream)` \brief Computes levels with even distribution.
`static void`	opencv_core.`exp(Mat src, Mat dst)` \brief Calculates the exponent of every array element.
`static void`	opencv_cudaarithm.`exp(Mat src, Mat dst)`
`static void`	opencv_cudaarithm.`exp(Mat src, Mat dst, Stream stream)` \brief Computes an exponent of each matrix element.
`static void`	opencv_core.`extractChannel(Mat src, Mat dst, int coi)` \brief Extracts a single channel from src (coi is 0-based index)
`static void`	opencv_rapid.`extractControlPoints(int num, int len, Mat pts3d, Mat rvec, Mat tvec, Mat K, Size imsize, Mat tris, Mat ctl2d, Mat ctl3d)` Extract control points from the projected silhouette of a mesh see \cite drummond2002real Sec 2.1, Step b
`static void`	opencv_core.`extractImageCOI(CvArr arr, Mat coiimg)`
`static void`	opencv_core.`extractImageCOI(CvArr arr, Mat coiimg, int coi)` extracts Channel of Interest from CvMat or IplImage and makes cv::Mat out of it.
`static void`	opencv_rapid.`extractLineBundle(int len, Mat ctl2d, Mat img, Mat bundle, Mat srcLocations)` Extract the line bundle from an image
`static void`	opencv_features2d.`FAST(Mat image, KeyPointVector keypoints, int threshold)`
`static void`	opencv_features2d.`FAST(Mat image, KeyPointVector keypoints, int threshold, boolean nonmaxSuppression)` \overload
`static void`	opencv_features2d.`FAST(Mat image, KeyPointVector keypoints, int threshold, boolean nonmaxSuppression, int type)` \brief Detects corners using the FAST algorithm
`static void`	opencv_ximgproc.`fastBilateralSolverFilter(Mat guide, Mat src, Mat confidence, Mat dst)`
`static void`	opencv_ximgproc.`fastBilateralSolverFilter(Mat guide, Mat src, Mat confidence, Mat dst, double sigma_spatial, double sigma_luma, double sigma_chroma, double lambda, int num_iter, double max_tol)` \brief Simple one-line Fast Bilateral Solver filter call.
`static void`	opencv_xfeatures2d.`FASTForPointSet(Mat image, KeyPointVector keypoints, int threshold)`
`static void`	opencv_xfeatures2d.`FASTForPointSet(Mat image, KeyPointVector keypoints, int threshold, boolean nonmaxSuppression, int type)` \brief Estimates cornerness for prespecified KeyPoints using the FAST algorithm
`static void`	opencv_ximgproc.`fastGlobalSmootherFilter(Mat guide, Mat src, Mat dst, double lambda, double sigma_color)`
`static void`	opencv_ximgproc.`fastGlobalSmootherFilter(Mat guide, Mat src, Mat dst, double lambda, double sigma_color, double lambda_attenuation, int num_iter)` \brief Simple one-line Fast Global Smoother filter call.
`static void`	opencv_ximgproc.`FastHoughTransform(Mat src, Mat dst, int dstMatDepth)`
`static void`	opencv_ximgproc.`FastHoughTransform(Mat src, Mat dst, int dstMatDepth, int angleRange, int op, int makeSkew)` \brief Calculates 2D Fast Hough transform of an image.
`static void`	opencv_photo.`fastNlMeansDenoising(Mat src, Mat dst)`
`static void`	opencv_photo.`fastNlMeansDenoising(Mat src, Mat dst, float h)`
`static void`	opencv_photo.`fastNlMeansDenoising(Mat src, Mat dst, float[] h)`
`static void`	opencv_photo.`fastNlMeansDenoising(Mat src, Mat dst, float[] h, int templateWindowSize, int searchWindowSize, int normType)`
`static void`	opencv_photo.`fastNlMeansDenoising(Mat src, Mat dst, FloatBuffer h)`
`static void`	opencv_photo.`fastNlMeansDenoising(Mat src, Mat dst, FloatBuffer h, int templateWindowSize, int searchWindowSize, int normType)`
`static void`	opencv_photo.`fastNlMeansDenoising(Mat src, Mat dst, float h, int templateWindowSize, int searchWindowSize)` \} photo_inpaint
`static void`	opencv_photo.`fastNlMeansDenoising(Mat src, Mat dst, float h, int search_window, int block_size, Stream stream)` \brief Perform image denoising using Non-local Means Denoising algorithm with several computational optimizations.
`static void`	opencv_photo.`fastNlMeansDenoising(Mat src, Mat dst, FloatPointer h)`
`static void`	opencv_photo.`fastNlMeansDenoising(Mat src, Mat dst, FloatPointer h, int templateWindowSize, int searchWindowSize, int normType)` \brief Perform image denoising using Non-local Means Denoising algorithm with several computational optimizations.
`static void`	opencv_photo.`fastNlMeansDenoisingColored(Mat src, Mat dst)`
`static void`	opencv_photo.`fastNlMeansDenoisingColored(Mat src, Mat dst, float h_luminance, float photo_render)`
`static void`	opencv_photo.`fastNlMeansDenoisingColored(Mat src, Mat dst, float h, float hColor, int templateWindowSize, int searchWindowSize)` \brief Modification of fastNlMeansDenoising function for colored images
`static void`	opencv_photo.`fastNlMeansDenoisingColored(Mat src, Mat dst, float h_luminance, float photo_render, int search_window, int block_size, Stream stream)` \brief Modification of fastNlMeansDenoising function for colored images
`static void`	opencv_photo.`fastNlMeansDenoisingColoredMulti(GpuMatVector srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize)`
`static void`	opencv_photo.`fastNlMeansDenoisingColoredMulti(GpuMatVector srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize, float h, float hColor, int templateWindowSize, int searchWindowSize)`
`static void`	opencv_photo.`fastNlMeansDenoisingColoredMulti(MatVector srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize)`
`static void`	opencv_photo.`fastNlMeansDenoisingColoredMulti(MatVector srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize, float h, float hColor, int templateWindowSize, int searchWindowSize)` \brief Modification of fastNlMeansDenoisingMulti function for colored images sequences
`static void`	opencv_photo.`fastNlMeansDenoisingColoredMulti(UMatVector srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize)`
`static void`	opencv_photo.`fastNlMeansDenoisingColoredMulti(UMatVector srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize, float h, float hColor, int templateWindowSize, int searchWindowSize)`
`static void`	opencv_photo.`fastNlMeansDenoisingMulti(GpuMatVector srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize)`
`static void`	opencv_photo.`fastNlMeansDenoisingMulti(GpuMatVector srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize, float[] h)`
`static void`	opencv_photo.`fastNlMeansDenoisingMulti(GpuMatVector srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize, float[] h, int templateWindowSize, int searchWindowSize, int normType)`
`static void`	opencv_photo.`fastNlMeansDenoisingMulti(GpuMatVector srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize, float h, int templateWindowSize, int searchWindowSize)`
`static void`	opencv_photo.`fastNlMeansDenoisingMulti(MatVector srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize)`
`static void`	opencv_photo.`fastNlMeansDenoisingMulti(MatVector srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize, float h, int templateWindowSize, int searchWindowSize)` \brief Modification of fastNlMeansDenoising function for images sequence where consecutive images have been captured in small period of time.
`static void`	opencv_photo.`fastNlMeansDenoisingMulti(MatVector srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize, FloatPointer h)`
`static void`	opencv_photo.`fastNlMeansDenoisingMulti(MatVector srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize, FloatPointer h, int templateWindowSize, int searchWindowSize, int normType)` \brief Modification of fastNlMeansDenoising function for images sequence where consecutive images have been captured in small period of time.
`static void`	opencv_photo.`fastNlMeansDenoisingMulti(UMatVector srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize)`
`static void`	opencv_photo.`fastNlMeansDenoisingMulti(UMatVector srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize, FloatBuffer h)`
`static void`	opencv_photo.`fastNlMeansDenoisingMulti(UMatVector srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize, FloatBuffer h, int templateWindowSize, int searchWindowSize, int normType)`
`static void`	opencv_photo.`fastNlMeansDenoisingMulti(UMatVector srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize, float h, int templateWindowSize, int searchWindowSize)`
`static void`	opencv_imgproc.`fillConvexPoly(Mat img, Mat points, Scalar color)`
`static void`	opencv_imgproc.`fillConvexPoly(Mat img, Mat points, Scalar color, int lineType, int shift)` \brief Fills a convex polygon.
`static void`	opencv_imgproc.`fillConvexPoly(Mat img, Point pts, int npts, Scalar color)`
`static void`	opencv_imgproc.`fillConvexPoly(Mat img, Point pts, int npts, Scalar color, int lineType, int shift)` \overload
`static void`	opencv_imgproc.`fillPoly(Mat img, GpuMatVector pts, Scalar color)`
`static void`	opencv_imgproc.`fillPoly(Mat img, GpuMatVector pts, Scalar color, int lineType, int shift, Point offset)`
`static void`	opencv_imgproc.`fillPoly(Mat img, MatVector pts, Scalar color)`
`static void`	opencv_imgproc.`fillPoly(Mat img, MatVector pts, Scalar color, int lineType, int shift, Point offset)` \brief Fills the area bounded by one or more polygons.
`static void`	opencv_imgproc.`fillPoly(Mat img, PointerPointer pts, IntPointer npts, int ncontours, Scalar color, int lineType, int shift, Point offset)` \overload
`static void`	opencv_imgproc.`fillPoly(Mat img, Point pts, int[] npts, int ncontours, Scalar color)`
`static void`	opencv_imgproc.`fillPoly(Mat img, Point pts, int[] npts, int ncontours, Scalar color, int lineType, int shift, Point offset)`
`static void`	opencv_imgproc.`fillPoly(Mat img, Point pts, IntBuffer npts, int ncontours, Scalar color)`
`static void`	opencv_imgproc.`fillPoly(Mat img, Point pts, IntBuffer npts, int ncontours, Scalar color, int lineType, int shift, Point offset)`
`static void`	opencv_imgproc.`fillPoly(Mat img, Point pts, IntPointer npts, int ncontours, Scalar color)`
`static void`	opencv_imgproc.`fillPoly(Mat img, Point pts, IntPointer npts, int ncontours, Scalar color, int lineType, int shift, Point offset)`
`static void`	opencv_imgproc.`fillPoly(Mat img, UMatVector pts, Scalar color)`
`static void`	opencv_imgproc.`fillPoly(Mat img, UMatVector pts, Scalar color, int lineType, int shift, Point offset)`
`static void`	opencv_imgproc.`filter2D(Mat src, Mat dst, int ddepth, Mat kernel)`
`static void`	opencv_imgproc.`filter2D(Mat src, Mat dst, int ddepth, Mat kernel, Point anchor, double delta, int borderType)` \brief Convolves an image with the kernel.
`static void`	opencv_calib3d.`filterHomographyDecompByVisibleRefpoints(GpuMatVector rotations, GpuMatVector normals, Mat beforePoints, Mat afterPoints, Mat possibleSolutions)`
`static void`	opencv_calib3d.`filterHomographyDecompByVisibleRefpoints(GpuMatVector rotations, GpuMatVector normals, Mat beforePoints, Mat afterPoints, Mat possibleSolutions, Mat pointsMask)`
`static void`	opencv_calib3d.`filterHomographyDecompByVisibleRefpoints(MatVector rotations, MatVector normals, Mat beforePoints, Mat afterPoints, Mat possibleSolutions)`
`static void`	opencv_calib3d.`filterHomographyDecompByVisibleRefpoints(MatVector rotations, MatVector normals, Mat beforePoints, Mat afterPoints, Mat possibleSolutions, Mat pointsMask)` \brief Filters homography decompositions based on additional information.
`static void`	opencv_calib3d.`filterHomographyDecompByVisibleRefpoints(UMatVector rotations, UMatVector normals, Mat beforePoints, Mat afterPoints, Mat possibleSolutions)`
`static void`	opencv_calib3d.`filterHomographyDecompByVisibleRefpoints(UMatVector rotations, UMatVector normals, Mat beforePoints, Mat afterPoints, Mat possibleSolutions, Mat pointsMask)`
`static void`	opencv_calib3d.`filterSpeckles(Mat img, double newVal, int maxSpeckleSize, double maxDiff)`
`static void`	opencv_calib3d.`filterSpeckles(Mat img, double newVal, int maxSpeckleSize, double maxDiff, Mat buf)` \brief Filters off small noise blobs (speckles) in the disparity map
`static boolean`	opencv_calib3d.`find4QuadCornerSubpix(Mat img, Mat corners, Size region_size)` finds subpixel-accurate positions of the chessboard corners
`static boolean`	opencv_calib3d.`findChessboardCorners(Mat image, Size patternSize, Mat corners)`
`static boolean`	opencv_calib3d.`findChessboardCorners(Mat image, Size patternSize, Mat corners, int flags)` \brief Finds the positions of internal corners of the chessboard.
`static boolean`	opencv_calib3d.`findChessboardCornersSB(Mat image, Size patternSize, Mat corners)`
`static boolean`	opencv_calib3d.`findChessboardCornersSB(Mat image, Size patternSize, Mat corners, int flags)` \overload
`static boolean`	opencv_calib3d.`findChessboardCornersSBWithMeta(Mat image, Size patternSize, Mat corners, int flags, Mat meta)` \brief Finds the positions of internal corners of the chessboard using a sector based approach.
`static boolean`	opencv_calib3d.`findCirclesGrid(Mat image, Size patternSize, Mat centers)`
`static boolean`	opencv_calib3d.`findCirclesGrid(Mat image, Size patternSize, Mat centers, int flags, Feature2D blobDetector)` \overload
`static boolean`	opencv_calib3d.`findCirclesGrid(Mat image, Size patternSize, Mat centers, int flags, Feature2D blobDetector, CirclesGridFinderParameters parameters)` \brief Finds centers in the grid of circles.
`static void`	opencv_imgproc.`findContours(Mat image, GpuMatVector contours, int mode, int method)`
`static void`	opencv_imgproc.`findContours(Mat image, GpuMatVector contours, int mode, int method, Point offset)`
`static void`	opencv_imgproc.`findContours(Mat image, GpuMatVector contours, Mat hierarchy, int mode, int method)`
`static void`	opencv_imgproc.`findContours(Mat image, GpuMatVector contours, Mat hierarchy, int mode, int method, Point offset)`
`static void`	opencv_imgproc.`findContours(Mat image, MatVector contours, int mode, int method)`
`static void`	opencv_imgproc.`findContours(Mat image, MatVector contours, int mode, int method, Point offset)` \overload
`static void`	opencv_imgproc.`findContours(Mat image, MatVector contours, Mat hierarchy, int mode, int method)`
`static void`	opencv_imgproc.`findContours(Mat image, MatVector contours, Mat hierarchy, int mode, int method, Point offset)` \brief Finds contours in a binary image.
`static void`	opencv_imgproc.`findContours(Mat image, UMatVector contours, int mode, int method)`
`static void`	opencv_imgproc.`findContours(Mat image, UMatVector contours, int mode, int method, Point offset)`
`static void`	opencv_imgproc.`findContours(Mat image, UMatVector contours, Mat hierarchy, int mode, int method)`
`static void`	opencv_imgproc.`findContours(Mat image, UMatVector contours, Mat hierarchy, int mode, int method, Point offset)`
`static void`	opencv_rapid.`findCorrespondencies(Mat bundle, Mat cols)`
`static void`	opencv_rapid.`findCorrespondencies(Mat bundle, Mat cols, Mat response)` Find corresponding image locations by searching for a maximal sobel edge along the search line (a single row in the bundle)
`static Mat`	opencv_calib3d.`findEssentialMat(Mat points1, Mat points2)`
`static Mat`	opencv_calib3d.`findEssentialMat(Mat points1, Mat points2, double focal, Point2d pp, int method, double prob, double threshold, int maxIters, Mat mask)` \overload
`static Mat`	opencv_calib3d.`findEssentialMat(Mat points1, Mat points2, double focal, Point2d pp, int method, double prob, double threshold, Mat mask)` \overload
`static Mat`	opencv_calib3d.`findEssentialMat(Mat points1, Mat points2, Mat cameraMatrix)`
`static Mat`	opencv_calib3d.`findEssentialMat(Mat points1, Mat points2, Mat cameraMatrix, int method, double prob, double threshold, int maxIters, Mat mask)` \brief Calculates an essential matrix from the corresponding points in two images.
`static Mat`	opencv_calib3d.`findEssentialMat(Mat points1, Mat points2, Mat cameraMatrix, int method, double prob, double threshold, Mat mask)` \overload
`static Mat`	opencv_calib3d.`findEssentialMat(Mat points1, Mat points2, Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2)`
`static Mat`	opencv_calib3d.`findEssentialMat(Mat points1, Mat points2, Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, int method, double prob, double threshold, Mat mask)` \brief Calculates an essential matrix from the corresponding points in two images from potentially two different cameras.
`static Mat`	opencv_calib3d.`findEssentialMat(Mat points1, Mat points2, Mat cameraMatrix1, Mat cameraMatrix2, Mat dist_coeff1, Mat dist_coeff2, Mat mask, UsacParams params)`
`static Mat`	opencv_calib3d.`findFundamentalMat(Mat points1, Mat points2)`
`static Mat`	opencv_calib3d.`findFundamentalMat(Mat points1, Mat points2, int method, double ransacReprojThreshold, double confidence, int maxIters)`
`static Mat`	opencv_calib3d.`findFundamentalMat(Mat points1, Mat points2, int method, double ransacReprojThreshold, double confidence, int maxIters, Mat mask)` \brief Calculates a fundamental matrix from the corresponding points in two images.
`static Mat`	opencv_calib3d.`findFundamentalMat(Mat points1, Mat points2, int method, double ransacReprojThreshold, double confidence, Mat mask)` \overload
`static Mat`	opencv_calib3d.`findFundamentalMat(Mat points1, Mat points2, Mat mask)`
`static Mat`	opencv_calib3d.`findFundamentalMat(Mat points1, Mat points2, Mat mask, int method, double ransacReprojThreshold, double confidence)` \overload
`static Mat`	opencv_calib3d.`findFundamentalMat(Mat points1, Mat points2, Mat mask, UsacParams params)`
`static Mat`	opencv_calib3d.`findHomography(Mat srcPoints, Mat dstPoints)`
`static Mat`	opencv_calib3d.`findHomography(Mat srcPoints, Mat dstPoints, int method, double ransacReprojThreshold, Mat mask, int maxIters, double confidence)` \brief Finds a perspective transformation between two planes.
`static Mat`	opencv_calib3d.`findHomography(Mat srcPoints, Mat dstPoints, Mat mask)`
`static Mat`	opencv_calib3d.`findHomography(Mat srcPoints, Mat dstPoints, Mat mask, int method, double ransacReprojThreshold)` \overload
`static Mat`	opencv_calib3d.`findHomography(Mat srcPoints, Mat dstPoints, Mat mask, UsacParams params)`
`static void`	opencv_cudaarithm.`findMinMax(Mat src, Mat dst)`
`static void`	opencv_cudaarithm.`findMinMax(Mat src, Mat dst, Mat mask, Stream stream)` \overload
`static void`	opencv_cudaarithm.`findMinMaxLoc(Mat src, Mat minMaxVals, Mat loc)`
`static void`	opencv_cudaarithm.`findMinMaxLoc(Mat src, Mat minMaxVals, Mat loc, Mat mask, Stream stream)` \overload
`static void`	opencv_core.`findNonZero(Mat src, Mat idx)` \brief Returns the list of locations of non-zero pixels
`static double`	opencv_video.`findTransformECC(Mat templateImage, Mat inputImage, Mat warpMatrix)`
`static double`	opencv_video.`findTransformECC(Mat templateImage, Mat inputImage, Mat warpMatrix, int motionType, TermCriteria criteria, Mat inputMask)` \overload
`static double`	opencv_video.`findTransformECC(Mat templateImage, Mat inputImage, Mat warpMatrix, int motionType, TermCriteria criteria, Mat inputMask, int gaussFiltSize)` \brief Finds the geometric transform (warp) between two images in terms of the ECC criterion \cite EP08 .
`static RotatedRect`	opencv_imgproc.`fitEllipse(Mat points)` \brief Fits an ellipse around a set of 2D points.
`static RotatedRect`	opencv_imgproc.`fitEllipseAMS(Mat points)` \brief Fits an ellipse around a set of 2D points.
`static RotatedRect`	opencv_imgproc.`fitEllipseDirect(Mat points)` \brief Fits an ellipse around a set of 2D points.
`static void`	opencv_imgproc.`fitLine(Mat points, Mat line, int distType, double param, double reps, double aeps)` \brief Fits a line to a 2D or 3D point set.
`static void`	opencv_core.`flip(Mat src, Mat dst, int flipCode)` \brief Flips a 2D array around vertical, horizontal, or both axes.
`static void`	opencv_cudaarithm.`flip(Mat src, Mat dst, int flipCode)`
`static void`	opencv_cudaarithm.`flip(Mat src, Mat dst, int flipCode, Stream stream)` \brief Flips a 2D matrix around vertical, horizontal, or both axes.
`static int`	opencv_imgproc.`floodFill(Mat image, Mat mask, Point seedPoint, Scalar newVal)`
`static int`	opencv_imgproc.`floodFill(Mat image, Mat mask, Point seedPoint, Scalar newVal, Rect rect, Scalar loDiff, Scalar upDiff, int flags)` \brief Fills a connected component with the given color.
`static int`	opencv_imgproc.`floodFill(Mat image, Point seedPoint, Scalar newVal)`
`static int`	opencv_imgproc.`floodFill(Mat image, Point seedPoint, Scalar newVal, Rect rect, Scalar loDiff, Scalar upDiff, int flags)` \overload
`static void`	opencv_stitching.`focalsFromHomography(Mat H, double[] f0, double[] f1, boolean[] f0_ok, boolean[] f1_ok)`
`static void`	opencv_stitching.`focalsFromHomography(Mat H, double[] f0, double[] f1, BoolPointer f0_ok, BoolPointer f1_ok)`
`static void`	opencv_stitching.`focalsFromHomography(Mat H, DoubleBuffer f0, DoubleBuffer f1, boolean[] f0_ok, boolean[] f1_ok)`
`static void`	opencv_stitching.`focalsFromHomography(Mat H, DoubleBuffer f0, DoubleBuffer f1, BoolPointer f0_ok, BoolPointer f1_ok)`
`static void`	opencv_stitching.`focalsFromHomography(Mat H, DoublePointer f0, DoublePointer f1, boolean[] f0_ok, boolean[] f1_ok)`
`static void`	opencv_stitching.`focalsFromHomography(Mat H, DoublePointer f0, DoublePointer f1, BoolPointer f0_ok, BoolPointer f1_ok)` \addtogroup stitching_autocalib \{
`static Formatted`	opencv_core.`format(Mat mtx, int fmt)`
`static void`	opencv_ximgproc.`fourierDescriptor(Mat src, Mat dst)`
`static void`	opencv_ximgproc.`fourierDescriptor(Mat src, Mat dst, int nbElt, int nbFD)` \brief Fourier descriptors for planed closed curves For more details about this implementation, please see \cite PersoonFu1977
`static void`	opencv_cudaimgproc.`gammaCorrection(Mat src, Mat dst)`
`static void`	opencv_cudaimgproc.`gammaCorrection(Mat src, Mat dst, boolean forward, Stream stream)` \brief Routines for correcting image color gamma.
`static void`	opencv_intensity_transform.`gammaCorrection(Mat input, Mat output, float gamma)` \brief Given an input bgr or grayscale image and constant gamma, apply power-law transformation, a.k.a.
`static void`	opencv_imgproc.`GaussianBlur(Mat src, Mat dst, Size ksize, double sigmaX)`
`static void`	opencv_imgproc.`GaussianBlur(Mat src, Mat dst, Size ksize, double sigmaX, double sigmaY, int borderType)` \brief Blurs an image using a Gaussian filter.
`static void`	opencv_core.`gemm(Mat src1, Mat src2, double alpha, Mat src3, double beta, Mat dst)`
`static void`	opencv_cudaarithm.`gemm(Mat src1, Mat src2, double alpha, Mat src3, double beta, Mat dst)`
`static void`	opencv_core.`gemm(Mat src1, Mat src2, double alpha, Mat src3, double beta, Mat dst, int flags)` \brief Performs generalized matrix multiplication.
`static void`	opencv_cudaarithm.`gemm(Mat src1, Mat src2, double alpha, Mat src3, double beta, Mat dst, int flags, Stream stream)` \} cudaarithm_reduce
`static Mat`	opencv_quality.`get_column_range(Mat data)`
`static Mat`	opencv_imgproc.`getAffineTransform(Mat src, Mat dst)`
`static void`	opencv_aruco.`getBoardObjectAndImagePoints(Board board, GpuMatVector detectedCorners, Mat detectedIds, Mat objPoints, Mat imgPoints)`
`static void`	opencv_aruco.`getBoardObjectAndImagePoints(Board board, MatVector detectedCorners, Mat detectedIds, Mat objPoints, Mat imgPoints)` \brief Given a board configuration and a set of detected markers, returns the corresponding image points and object points to call solvePnP
`static void`	opencv_aruco.`getBoardObjectAndImagePoints(Board board, UMatVector detectedCorners, Mat detectedIds, Mat objPoints, Mat imgPoints)`
`static Mat`	opencv_calib3d.`getDefaultNewCameraMatrix(Mat cameraMatrix)`
`static Mat`	opencv_calib3d.`getDefaultNewCameraMatrix(Mat cameraMatrix, Size imgsize, boolean centerPrincipalPoint)` \brief Returns the default new camera matrix.
`static void`	opencv_imgproc.`getDerivKernels(Mat kx, Mat ky, int dx, int dy, int ksize)`
`static void`	opencv_imgproc.`getDerivKernels(Mat kx, Mat ky, int dx, int dy, int ksize, boolean normalize, int ktype)` \brief Returns filter coefficients for computing spatial image derivatives.
`static void`	opencv_ximgproc.`getDisparityVis(Mat src, Mat dst)`
`static void`	opencv_ximgproc.`getDisparityVis(Mat src, Mat dst, double scale)` \brief Function for creating a disparity map visualization (clamped CV_8U image)
`static boolean`	opencv_face.`getFaces(Mat image, RectVector faces, CParams params)` \brief Default face detector This function is mainly utilized by the implementation of a Facemark Algorithm.
`static boolean`	opencv_face.`getFacesHAAR(Mat image, RectVector faces, String face_cascade_name)`
`static Mat`	opencv_calib3d.`getOptimalNewCameraMatrix(Mat cameraMatrix, Mat distCoeffs, Size imageSize, double alpha)`
`static Mat`	opencv_calib3d.`getOptimalNewCameraMatrix(Mat cameraMatrix, Mat distCoeffs, Size imageSize, double alpha, Size newImgSize, Rect validPixROI, boolean centerPrincipalPoint)` \brief Returns the new camera intrinsic matrix based on the free scaling parameter.
`static Mat`	opencv_imgproc.`getPerspectiveTransform(Mat src, Mat dst)`
`static Mat`	opencv_imgproc.`getPerspectiveTransform(Mat src, Mat dst, int solveMethod)` \brief Calculates a perspective transform from four pairs of the corresponding points.
`static Mat`	opencv_dnn.`getPlane(Mat m, int n, int cn)`
`static void`	opencv_imgproc.`getRectSubPix(Mat image, Size patchSize, Point2f center, Mat patch)`
`static void`	opencv_imgproc.`getRectSubPix(Mat image, Size patchSize, Point2f center, Mat patch, int patchType)` \brief Retrieves a pixel rectangle from an image with sub-pixel accuracy.
`static void`	opencv_imgproc.`goodFeaturesToTrack(Mat image, Mat corners, int maxCorners, double qualityLevel, double minDistance)`
`static void`	opencv_imgproc.`goodFeaturesToTrack(Mat image, Mat corners, int maxCorners, double qualityLevel, double minDistance, Mat mask, int blockSize, boolean useHarrisDetector, double k)` \brief Determines strong corners on an image.
`static void`	opencv_imgproc.`goodFeaturesToTrack(Mat image, Mat corners, int maxCorners, double qualityLevel, double minDistance, Mat mask, int blockSize, int gradientSize)`
`static void`	opencv_imgproc.`goodFeaturesToTrack(Mat image, Mat corners, int maxCorners, double qualityLevel, double minDistance, Mat mask, int blockSize, int gradientSize, boolean useHarrisDetector, double k)`
`static void`	opencv_imgproc.`goodFeaturesToTrackWithQuality(Mat image, Mat corners, int maxCorners, double qualityLevel, double minDistance, Mat mask, Mat cornersQuality)`
`static void`	opencv_imgproc.`goodFeaturesToTrackWithQuality(Mat image, Mat corners, int maxCorners, double qualityLevel, double minDistance, Mat mask, Mat cornersQuality, int blockSize, int gradientSize, boolean useHarrisDetector, double k)` \brief Same as above, but returns also quality measure of the detected corners.
`static void`	opencv_imgproc.`grabCut(Mat img, Mat mask, Rect rect, Mat bgdModel, Mat fgdModel, int iterCount)`
`static void`	opencv_imgproc.`grabCut(Mat img, Mat mask, Rect rect, Mat bgdModel, Mat fgdModel, int iterCount, int mode)` \brief Runs the GrabCut algorithm.
`static void`	opencv_ximgproc.`GradientDericheX(Mat op, Mat dst, double alpha, double omega)` \brief Applies X Deriche filter to an image.
`static void`	opencv_ximgproc.`GradientDericheY(Mat op, Mat dst, double alpha, double omega)` \addtogroup ximgproc_filters \{
`static void`	opencv_ximgproc.`GradientPaillouX(Mat op, Mat _dst, double alpha, double omega)`
`static void`	opencv_ximgproc.`GradientPaillouY(Mat op, Mat _dst, double alpha, double omega)` \addtogroup ximgproc_filters \{
`static MatExpr`	opencv_core.`greaterThan(double s, Mat a)`
`static MatExpr`	opencv_core.`greaterThan(Mat a, double s)`
`static MatExpr`	opencv_core.`greaterThan(Mat a, Mat b)`
`static MatExpr`	opencv_core.`greaterThanEquals(double s, Mat a)`
`static MatExpr`	opencv_core.`greaterThanEquals(Mat a, double s)`
`static MatExpr`	opencv_core.`greaterThanEquals(Mat a, Mat b)`
`static void`	opencv_ximgproc.`guidedFilter(Mat guide, Mat src, Mat dst, int radius, double eps)`
`static void`	opencv_ximgproc.`guidedFilter(Mat guide, Mat src, Mat dst, int radius, double eps, int dDepth)` \brief Simple one-line Guided Filter call.
`static void`	opencv_core.`hconcat(GpuMatVector src, Mat dst)`
`static void`	opencv_core.`hconcat(Mat src, long nsrc, GpuMat dst)`
`static void`	opencv_core.`hconcat(Mat src, long nsrc, Mat dst)` \brief Applies horizontal concatenation to given matrices.
`static void`	opencv_core.`hconcat(Mat src, long nsrc, UMat dst)`
`static void`	opencv_core.`hconcat(Mat src1, Mat src2, Mat dst)` \overload
`static void`	opencv_core.`hconcat(MatVector src, Mat dst)` \overload
`static void`	opencv_core.`hconcat(UMatVector src, Mat dst)`
`static void`	opencv_cudaimgproc.`histEven(Mat src, GpuMat hist, int[] histSize, int[] lowerLevel, int[] upperLevel)`
`static void`	opencv_cudaimgproc.`histEven(Mat src, GpuMat hist, int[] histSize, int[] lowerLevel, int[] upperLevel, Stream stream)`
`static void`	opencv_cudaimgproc.`histEven(Mat src, GpuMat hist, IntBuffer histSize, IntBuffer lowerLevel, IntBuffer upperLevel)`
`static void`	opencv_cudaimgproc.`histEven(Mat src, GpuMat hist, IntBuffer histSize, IntBuffer lowerLevel, IntBuffer upperLevel, Stream stream)`
`static void`	opencv_cudaimgproc.`histEven(Mat src, GpuMat hist, IntPointer histSize, IntPointer lowerLevel, IntPointer upperLevel)`
`static void`	opencv_cudaimgproc.`histEven(Mat src, GpuMat hist, IntPointer histSize, IntPointer lowerLevel, IntPointer upperLevel, Stream stream)` \overload
`static void`	opencv_cudaimgproc.`histEven(Mat src, Mat hist, int histSize, int lowerLevel, int upperLevel)`
`static void`	opencv_cudaimgproc.`histEven(Mat src, Mat hist, int histSize, int lowerLevel, int upperLevel, Stream stream)` \brief Calculates a histogram with evenly distributed bins.
`static void`	opencv_cudaimgproc.`histRange(Mat src, GpuMat hist, GpuMat levels)`
`static void`	opencv_cudaimgproc.`histRange(Mat src, GpuMat hist, GpuMat levels, Stream stream)` \overload
`static void`	opencv_cudaimgproc.`histRange(Mat src, Mat hist, Mat levels)`
`static void`	opencv_cudaimgproc.`histRange(Mat src, Mat hist, Mat levels, Stream stream)` \brief Calculates a histogram with bins determined by the levels array.
`static void`	opencv_imgproc.`HoughCircles(Mat image, Vec3fVector circles, int method, double dp, double minDist, double param1, double param2, int minRadius, int maxRadius)` \brief Finds circles in a grayscale image using the Hough transform.
`static void`	opencv_imgproc.`HoughCircles(Mat image, Vec4fVector circles, int method, double dp, double minDist, double param1, double param2, int minRadius, int maxRadius)`
`static void`	opencv_imgproc.`HoughLines(Mat image, Vec2fVector lines, double rho, double theta, int threshold, double srn, double stn, double min_theta, double max_theta)` \brief Finds lines in a binary image using the standard Hough transform.
`static void`	opencv_imgproc.`HoughLines(Mat image, Vec3fVector lines, double rho, double theta, int threshold, double srn, double stn, double min_theta, double max_theta)`
`static void`	opencv_imgproc.`HoughLinesP(Mat image, Vec4iVector lines, double rho, double theta, int threshold, double minLineLength, double maxLineGap)` \brief Finds line segments in a binary image using the probabilistic Hough transform.
`static void`	opencv_imgproc.`HoughLinesPointSet(Mat point, Mat lines, int lines_max, int threshold, double min_rho, double max_rho, double rho_step, double min_theta, double max_theta, double theta_step)` \brief Finds lines in a set of points using the standard Hough transform.
`static Scalar4i`	opencv_ximgproc.`HoughPoint2Line(Point houghPoint, Mat srcImgInfo)`
`static Scalar4i`	opencv_ximgproc.`HoughPoint2Line(Point houghPoint, Mat srcImgInfo, int angleRange, int makeSkew, int rules)` \brief Calculates coordinates of line segment corresponded by point in Hough space.
`static void`	opencv_imgproc.`HuMoments(Moments m, Mat hu)` \overload
`static void`	opencv_core.`idct(Mat src, Mat dst)`
`static void`	opencv_core.`idct(Mat src, Mat dst, int flags)` \brief Calculates the inverse Discrete Cosine Transform of a 1D or 2D array.
`static void`	opencv_core.`idft(Mat src, Mat dst)`
`static void`	opencv_core.`idft(Mat src, Mat dst, int flags, int nonzeroRows)` \brief Calculates the inverse Discrete Fourier Transform of a 1D or 2D array.
`static void`	opencv_photo.`illuminationChange(Mat src, Mat mask, Mat dst)`
`static void`	opencv_photo.`illuminationChange(Mat src, Mat mask, Mat dst, float alpha, float beta)` \brief Applying an appropriate non-linear transformation to the gradient field inside the selection and then integrating back with a Poisson solver, modifies locally the apparent illumination of an image.
`static void`	opencv_dnn.`imagesFromBlob(Mat blob_, GpuMatVector images_)`
`static void`	opencv_dnn.`imagesFromBlob(Mat blob_, MatVector images_)` \brief Parse a 4D blob and output the images it contains as 2D arrays through a simpler data structure (std::vector).
`static void`	opencv_dnn.`imagesFromBlob(Mat blob_, UMatVector images_)`
`static Mat`	opencv_imgcodecs.`imdecode(GpuMat buf, int flags, Mat dst)`
`static Mat`	opencv_imgcodecs.`imdecode(Mat buf, int flags)` \brief Reads an image from a buffer in memory.
`static Mat`	opencv_imgcodecs.`imdecode(Mat buf, int flags, Mat dst)` \overload
`static Mat`	opencv_imgcodecs.`imdecode(UMat buf, int flags, Mat dst)`
`static boolean`	opencv_imgcodecs.`imencode(BytePointer ext, Mat img, byte[] buf)`
`static boolean`	opencv_imgcodecs.`imencode(BytePointer ext, Mat img, byte[] buf, int[] params)`
`static boolean`	opencv_imgcodecs.`imencode(BytePointer ext, Mat img, ByteBuffer buf)`
`static boolean`	opencv_imgcodecs.`imencode(BytePointer ext, Mat img, ByteBuffer buf, IntBuffer params)`
`static boolean`	opencv_imgcodecs.`imencode(BytePointer ext, Mat img, BytePointer buf)`
`static boolean`	opencv_imgcodecs.`imencode(BytePointer ext, Mat img, BytePointer buf, IntPointer params)` \brief Encodes an image into a memory buffer.
`static boolean`	opencv_imgcodecs.`imencode(String ext, Mat img, byte[] buf)`
`static boolean`	opencv_imgcodecs.`imencode(String ext, Mat img, byte[] buf, int[] params)`
`static boolean`	opencv_imgcodecs.`imencode(String ext, Mat img, ByteBuffer buf)`
`static boolean`	opencv_imgcodecs.`imencode(String ext, Mat img, ByteBuffer buf, IntBuffer params)`
`static boolean`	opencv_imgcodecs.`imencode(String ext, Mat img, BytePointer buf)`
`static boolean`	opencv_imgcodecs.`imencode(String ext, Mat img, BytePointer buf, IntPointer params)`
`static void`	opencv_highgui.`imshow(BytePointer winname, Mat mat)` \brief Displays an image in the specified window.
`static void`	opencv_highgui.`imshow(String winname, Mat mat)`
`static boolean`	opencv_imgcodecs.`imwrite(BytePointer filename, Mat img)`
`static boolean`	opencv_imgcodecs.`imwrite(BytePointer filename, Mat img, int[] params)`
`static boolean`	opencv_imgcodecs.`imwrite(BytePointer filename, Mat img, IntBuffer params)`
`static boolean`	opencv_imgcodecs.`imwrite(BytePointer filename, Mat img, IntPointer params)` \brief Saves an image to a specified file.
`static boolean`	opencv_imgcodecs.`imwrite(String filename, Mat img)`
`static boolean`	opencv_imgcodecs.`imwrite(String filename, Mat img, int[] params)`
`static boolean`	opencv_imgcodecs.`imwrite(String filename, Mat img, IntBuffer params)`
`static boolean`	opencv_imgcodecs.`imwrite(String filename, Mat img, IntPointer params)`
`static void`	opencv_calib3d.`initInverseRectificationMap(Mat cameraMatrix, Mat distCoeffs, Mat R, Mat newCameraMatrix, Size size, int m1type, Mat map1, Mat map2)` \brief Computes the projection and inverse-rectification transformation map.
`static void`	opencv_calib3d.`initUndistortRectifyMap(Mat cameraMatrix, Mat distCoeffs, Mat R, Mat newCameraMatrix, Size size, int m1type, Mat map1, Mat map2)` \brief Computes the undistortion and rectification transformation map.
`static float`	opencv_calib3d.`initWideAngleProjMap(Mat cameraMatrix, Mat distCoeffs, Size imageSize, int destImageWidth, int m1type, Mat map1, Mat map2)`
`static float`	opencv_calib3d.`initWideAngleProjMap(Mat cameraMatrix, Mat distCoeffs, Size imageSize, int destImageWidth, int m1type, Mat map1, Mat map2, int projType)`
`static float`	opencv_calib3d.`initWideAngleProjMap(Mat cameraMatrix, Mat distCoeffs, Size imageSize, int destImageWidth, int m1type, Mat map1, Mat map2, int projType, double alpha)` initializes maps for #remap for wide-angle
`static void`	opencv_photo.`inpaint(Mat src, Mat inpaintMask, Mat dst, double inpaintRadius, int flags)` \brief Restores the selected region in an image using the region neighborhood.
`static void`	opencv_xphoto.`inpaint(Mat src, Mat mask, Mat dst, int algorithmType)` \brief The function implements different single-image inpainting algorithms.
`static void`	opencv_core.`inRange(Mat src, Mat lowerb, Mat upperb, Mat dst)` \brief Checks if array elements lie between the elements of two other arrays.
`static void`	opencv_cudaarithm.`inRange(Mat src, Scalar lowerb, Scalar upperb, Mat dst)`
`static void`	opencv_cudaarithm.`inRange(Mat src, Scalar lowerb, Scalar upperb, Mat dst, Stream stream)` \brief Checks if array elements lie between two scalars.
`static void`	opencv_core.`insertChannel(Mat src, Mat dst, int coi)` \brief Inserts a single channel to dst (coi is 0-based index)
`static void`	opencv_core.`insertImageCOI(Mat coiimg, CvArr arr)`
`static void`	opencv_core.`insertImageCOI(Mat coiimg, CvArr arr, int coi)` inserts single-channel cv::Mat into a multi-channel CvMat or IplImage
`static void`	opencv_imgproc.`integral(Mat src, Mat sum)`
`static void`	opencv_cudaarithm.`integral(Mat src, Mat sum)`
`static void`	opencv_imgproc.`integral(Mat src, Mat sum, int sdepth)` \} imgproc_transform
`static void`	opencv_cudaarithm.`integral(Mat src, Mat sum, Stream stream)` \brief Computes an integral image.
`static void`	opencv_imgproc.`integral2(Mat src, Mat sum, Mat sqsum)`
`static void`	opencv_imgproc.`integral2(Mat src, Mat sum, Mat sqsum, int sdepth, int sqdepth)` \overload
`static void`	opencv_imgproc.`integral3(Mat src, Mat sum, Mat sqsum, Mat tilted)`
`static void`	opencv_imgproc.`integral3(Mat src, Mat sum, Mat sqsum, Mat tilted, int sdepth, int sqdepth)` \brief Calculates the integral of an image.
`static int`	opencv_aruco.`interpolateCornersCharuco(GpuMatVector markerCorners, Mat markerIds, Mat image, CharucoBoard board, Mat charucoCorners, Mat charucoIds)`
`static int`	opencv_aruco.`interpolateCornersCharuco(GpuMatVector markerCorners, Mat markerIds, Mat image, CharucoBoard board, Mat charucoCorners, Mat charucoIds, Mat cameraMatrix, Mat distCoeffs, int minMarkers)`
`static int`	opencv_aruco.`interpolateCornersCharuco(MatVector markerCorners, Mat markerIds, Mat image, CharucoBoard board, Mat charucoCorners, Mat charucoIds)`
`static int`	opencv_aruco.`interpolateCornersCharuco(MatVector markerCorners, Mat markerIds, Mat image, CharucoBoard board, Mat charucoCorners, Mat charucoIds, Mat cameraMatrix, Mat distCoeffs, int minMarkers)` \brief Interpolate position of ChArUco board corners
`static int`	opencv_aruco.`interpolateCornersCharuco(UMatVector markerCorners, Mat markerIds, Mat image, CharucoBoard board, Mat charucoCorners, Mat charucoIds)`
`static int`	opencv_aruco.`interpolateCornersCharuco(UMatVector markerCorners, Mat markerIds, Mat image, CharucoBoard board, Mat charucoCorners, Mat charucoIds, Mat cameraMatrix, Mat distCoeffs, int minMarkers)`
`static float`	opencv_imgproc.`intersectConvexConvex(Mat p1, Mat p2, Mat p12)`
`static float`	opencv_imgproc.`intersectConvexConvex(Mat p1, Mat p2, Mat p12, boolean handleNested)` \brief Finds intersection of two convex polygons
`static double`	opencv_core.`invert(Mat src, Mat dst)`
`static double`	opencv_core.`invert(Mat src, Mat dst, int flags)` \brief Finds the inverse or pseudo-inverse of a matrix.
`static void`	opencv_imgproc.`invertAffineTransform(Mat M, Mat iM)` \brief Inverts an affine transformation.
`static boolean`	opencv_imgproc.`isContourConvex(Mat contour)` \brief Tests a contour convexity.
`static boolean`	opencv_ximgproc.`isRLMorphologyPossible(Mat rlStructuringElement)` \brief Check whether a custom made structuring element can be used with run length morphological operations.
`static void`	opencv_ximgproc.`jointBilateralFilter(Mat joint, Mat src, Mat dst, int d, double sigmaColor, double sigmaSpace)`
`static void`	opencv_ximgproc.`jointBilateralFilter(Mat joint, Mat src, Mat dst, int d, double sigmaColor, double sigmaSpace, int borderType)` \brief Applies the joint bilateral filter to an image.
`static BytePointer`	opencv_core.`kernelToStr(Mat _kernel)`
`static BytePointer`	opencv_core.`kernelToStr(Mat _kernel, int ddepth, BytePointer name)`
`static String`	opencv_core.`kernelToStr(Mat _kernel, int ddepth, String name)`
`static double`	opencv_core.`kmeans(Mat data, int K, Mat bestLabels, TermCriteria criteria, int attempts, int flags)`
`static double`	opencv_core.`kmeans(Mat data, int K, Mat bestLabels, TermCriteria criteria, int attempts, int flags, Mat centers)` \brief Finds centers of clusters and groups input samples around the clusters.
`static void`	opencv_ximgproc.`l0Smooth(Mat src, Mat dst)`
`static void`	opencv_ximgproc.`l0Smooth(Mat src, Mat dst, double lambda, double kappa)` \brief Global image smoothing via L0 gradient minimization.
`static void`	opencv_imgproc.`Laplacian(Mat src, Mat dst, int ddepth)`
`static void`	opencv_imgproc.`Laplacian(Mat src, Mat dst, int ddepth, int ksize, double scale, double delta, int borderType)` \brief Calculates the Laplacian of an image.
`static MatExpr`	opencv_core.`lessThan(double s, Mat a)`
`static MatExpr`	opencv_core.`lessThan(Mat a, double s)`
`static MatExpr`	opencv_core.`lessThan(Mat a, Mat b)`
`static MatExpr`	opencv_core.`lessThanEquals(double s, Mat a)`
`static MatExpr`	opencv_core.`lessThanEquals(Mat a, double s)`
`static MatExpr`	opencv_core.`lessThanEquals(Mat a, Mat b)`
`static void`	opencv_imgproc.`line(Mat img, Point pt1, Point pt2, Scalar color)`
`static void`	opencv_imgproc.`line(Mat img, Point pt1, Point pt2, Scalar color, int thickness, int lineType, int shift)` \brief Draws a line segment connecting two points.
`static void`	opencv_imgproc.`linearPolar(Mat src, Mat dst, Point2f center, double maxRadius, int flags)` Deprecated. This function produces same result as cv::warpPolar(src, dst, src.size(), center, maxRadius, flags) \internal Transform the source image using the following transformation (See \ref polar_remaps_reference_image "Polar remaps reference image c)"): `\[\begin{array}{l} dst( \rho , \phi ) = src(x,y) \\ dst.size() \leftarrow src.size() \end{array}\]` where `\[\begin{array}{l} I = (dx,dy) = (x - center.x,y - center.y) \\ \rho = Kmag \cdot \texttt{magnitude} (I) ,\\ \phi = angle \cdot \texttt{angle} (I) \end{array}\]` and `\[\begin{array}{l} Kx = src.cols / maxRadius \\ Ky = src.rows / 2\Pi \end{array}\]`
`static void`	opencv_core.`log(Mat src, Mat dst)` \brief Calculates the natural logarithm of every array element.
`static void`	opencv_cudaarithm.`log(Mat src, Mat dst)`
`static void`	opencv_cudaarithm.`log(Mat src, Mat dst, Stream stream)` \brief Computes a natural logarithm of absolute value of each matrix element.
`static void`	opencv_imgproc.`logPolar(Mat src, Mat dst, Point2f center, double M, int flags)` Deprecated. This function produces same result as cv::warpPolar(src, dst, src.size(), center, maxRadius, flags+WARP_POLAR_LOG); \internal Transform the source image using the following transformation (See \ref polar_remaps_reference_image "Polar remaps reference image d)"): `\[\begin{array}{l} dst( \rho , \phi ) = src(x,y) \\ dst.size() \leftarrow src.size() \end{array}\]` where `\[\begin{array}{l} I = (dx,dy) = (x - center.x,y - center.y) \\ \rho = M \cdot log_e(\texttt{magnitude} (I)) ,\\ \phi = Kangle \cdot \texttt{angle} (I) \\ \end{array}\]` and `\[\begin{array}{l} M = src.cols / log_e(maxRadius) \\ Kangle = src.rows / 2\Pi \\ \end{array}\]` The function emulates the human "foveal" vision and can be used for fast scale and rotation-invariant template matching, for object tracking and so forth.
`static void`	opencv_intensity_transform.`logTransform(Mat input, Mat output)` \addtogroup intensity_transform \{
`static void`	opencv_cudaarithm.`lshift(Mat src, Scalar4i val, Mat dst)`
`static void`	opencv_cudaarithm.`lshift(Mat src, Scalar4i val, Mat dst, Stream stream)` \brief Performs pixel by pixel right left of an image by a constant value.
`static void`	opencv_cudaarithm.`lshift(Mat src, Scalar val, Mat dst)`
`static void`	opencv_cudaarithm.`lshift(Mat src, Scalar val, Mat dst, Stream stream)`
`static void`	opencv_core.`LUT(Mat src, Mat lut, Mat dst)` \brief Performs a look-up table transform of an array.
`static void`	opencv_cudaarithm.`magnitude(Mat xy, Mat magnitude)`
`static void`	opencv_core.`magnitude(Mat x, Mat y, Mat magnitude)` \brief Calculates the magnitude of 2D vectors.
`static void`	opencv_cudaarithm.`magnitude(Mat x, Mat y, Mat magnitude)`
`static void`	opencv_cudaarithm.`magnitude(Mat x, Mat y, Mat magnitude, Stream stream)` \overload computes magnitude of each (x(i), y(i)) vector supports only floating-point source
`static void`	opencv_cudaarithm.`magnitude(Mat xy, Mat magnitude, Stream stream)` \brief Computes magnitudes of complex matrix elements.
`static void`	opencv_cudaarithm.`magnitudeSqr(Mat xy, Mat magnitude)`
`static void`	opencv_cudaarithm.`magnitudeSqr(Mat x, Mat y, Mat magnitude)`
`static void`	opencv_cudaarithm.`magnitudeSqr(Mat x, Mat y, Mat magnitude, Stream stream)` \overload computes squared magnitude of each (x(i), y(i)) vector supports only floating-point source
`static void`	opencv_cudaarithm.`magnitudeSqr(Mat xy, Mat magnitude, Stream stream)` \brief Computes squared magnitudes of complex matrix elements.
`static double`	opencv_core.`Mahalanobis(Mat v1, Mat v2, Mat icovar)` \brief Calculates the Mahalanobis distance between two vectors.
`static void`	opencv_img_hash.`marrHildrethHash(Mat inputArr, Mat outputArr)`
`static void`	opencv_img_hash.`marrHildrethHash(Mat inputArr, Mat outputArr, float alpha, float scale)` \brief Computes average hash value of the input image
`static double`	opencv_imgproc.`matchShapes(Mat contour1, Mat contour2, int method, double parameter)` \brief Compares two shapes.
`static void`	opencv_imgproc.`matchTemplate(Mat image, Mat templ, Mat result, int method)`
`static void`	opencv_imgproc.`matchTemplate(Mat image, Mat templ, Mat result, int method, Mat mask)` \brief Compares a template against overlapped image regions.
`static void`	opencv_calib3d.`matMulDeriv(Mat A, Mat B, Mat dABdA, Mat dABdB)` \brief Computes partial derivatives of the matrix product for each multiplied matrix.
`static MatExpr`	opencv_core.`max(double s, Mat a)`
`static MatExpr`	opencv_core.`max(Mat a, double s)`
`static MatExpr`	opencv_core.`max(Mat a, Mat b)`
`static void`	opencv_core.`max(Mat src1, Mat src2, Mat dst)` \overload needed to avoid conflicts with const _Tp& std::min(const _Tp&, const _Tp&, _Compare)
`static void`	opencv_cudaarithm.`max(Mat src1, Mat src2, Mat dst)`
`static void`	opencv_cudaarithm.`max(Mat src1, Mat src2, Mat dst, Stream stream)` \brief Computes the per-element maximum of two matrices (or a matrix and a scalar).
`static Scalar`	opencv_core.`mean(Mat src)`
`static Scalar`	opencv_core.`mean(Mat src, Mat mask)` \brief Calculates an average (mean) of array elements.
`static int`	opencv_video.`meanShift(Mat probImage, Rect window, TermCriteria criteria)` \brief Finds an object on a back projection image.
`static void`	opencv_cudaimgproc.`meanShiftFiltering(Mat src, Mat dst, int sp, int sr)`
`static void`	opencv_cudaimgproc.`meanShiftFiltering(Mat src, Mat dst, int sp, int sr, TermCriteria criteria, Stream stream)` \} cudaimgproc_feature
`static void`	opencv_cudaimgproc.`meanShiftProc(Mat src, Mat dstr, Mat dstsp, int sp, int sr)`
`static void`	opencv_cudaimgproc.`meanShiftProc(Mat src, Mat dstr, Mat dstsp, int sp, int sr, TermCriteria criteria, Stream stream)` \brief Performs a mean-shift procedure and stores information about processed points (their colors and positions) in two images.
`static void`	opencv_cudaimgproc.`meanShiftSegmentation(Mat src, Mat dst, int sp, int sr, int minsize)`
`static void`	opencv_cudaimgproc.`meanShiftSegmentation(Mat src, Mat dst, int sp, int sr, int minsize, TermCriteria criteria, Stream stream)` \brief Performs a mean-shift segmentation of the source image and eliminates small segments.
`static void`	opencv_cudaarithm.`meanStdDev(Mat mtx, Mat dst)`
`static void`	opencv_core.`meanStdDev(Mat src, Mat mean, Mat stddev)`
`static void`	opencv_core.`meanStdDev(Mat src, Mat mean, Mat stddev, Mat mask)` Calculates a mean and standard deviation of array elements.
`static void`	opencv_cudaarithm.`meanStdDev(Mat mtx, Mat dst, Stream stream)` \overload
`static void`	opencv_cudaarithm.`meanStdDev(Mat mtx, Scalar mean, Scalar stddev)` \brief Computes a mean value and a standard deviation of matrix elements.
`static void`	opencv_imgproc.`medianBlur(Mat src, Mat dst, int ksize)` \brief Blurs an image using the median filter.
`static void`	opencv_cudaarithm.`merge(GpuMat src, long n, Mat dst)`
`static void`	opencv_cudaarithm.`merge(GpuMat src, long n, Mat dst, Stream stream)` \} cudaarithm_elem
`static void`	opencv_core.`merge(GpuMatVector mv, Mat dst)`
`static void`	opencv_cudaarithm.`merge(GpuMatVector src, Mat dst)`
`static void`	opencv_cudaarithm.`merge(GpuMatVector src, Mat dst, Stream stream)` \overload
`static void`	opencv_core.`merge(Mat mv, long count, GpuMat dst)`
`static void`	opencv_core.`merge(Mat mv, long count, Mat dst)` \brief Creates one multi-channel array out of several single-channel ones.
`static void`	opencv_core.`merge(Mat mv, long count, UMat dst)`
`static void`	opencv_core.`merge(MatVector mv, Mat dst)` \overload
`static void`	opencv_core.`merge(UMatVector mv, Mat dst)`
`static MatExpr`	opencv_core.`min(double s, Mat a)`
`static MatExpr`	opencv_core.`min(Mat a, double s)`
`static MatExpr`	opencv_core.`min(Mat a, Mat b)`
`static void`	opencv_core.`min(Mat src1, Mat src2, Mat dst)` \overload needed to avoid conflicts with const _Tp& std::min(const _Tp&, const _Tp&, _Compare)
`static void`	opencv_cudaarithm.`min(Mat src1, Mat src2, Mat dst)`
`static void`	opencv_cudaarithm.`min(Mat src1, Mat src2, Mat dst, Stream stream)` \brief Computes the per-element minimum of two matrices (or a matrix and a scalar).
`static RotatedRect`	opencv_imgproc.`minAreaRect(Mat points)` \brief Finds a rotated rectangle of the minimum area enclosing the input 2D point set.
`static void`	opencv_imgproc.`minEnclosingCircle(Mat points, Point2f center, float[] radius)`
`static void`	opencv_imgproc.`minEnclosingCircle(Mat points, Point2f center, FloatBuffer radius)`
`static void`	opencv_imgproc.`minEnclosingCircle(Mat points, Point2f center, FloatPointer radius)` \brief Finds a circle of the minimum area enclosing a 2D point set.
`static double`	opencv_imgproc.`minEnclosingTriangle(Mat points, Mat triangle)` \brief Finds a triangle of minimum area enclosing a 2D point set and returns its area.
`static void`	opencv_cudaarithm.`minMax(Mat src, double[] minVal, double[] maxVal)`
`static void`	opencv_cudaarithm.`minMax(Mat src, double[] minVal, double[] maxVal, Mat mask)`
`static void`	opencv_cudaarithm.`minMax(Mat src, DoubleBuffer minVal, DoubleBuffer maxVal)`
`static void`	opencv_cudaarithm.`minMax(Mat src, DoubleBuffer minVal, DoubleBuffer maxVal, Mat mask)`
`static void`	opencv_cudaarithm.`minMax(Mat src, DoublePointer minVal, DoublePointer maxVal)`
`static void`	opencv_cudaarithm.`minMax(Mat src, DoublePointer minVal, DoublePointer maxVal, Mat mask)` \brief Finds global minimum and maximum matrix elements and returns their values.
`static void`	opencv_core.`minMaxIdx(Mat src, double[] minVal)`
`static void`	opencv_core.`minMaxIdx(Mat src, double[] minVal, double[] maxVal, int[] minIdx, int[] maxIdx, Mat mask)`
`static void`	opencv_core.`minMaxIdx(Mat src, DoubleBuffer minVal)`
`static void`	opencv_core.`minMaxIdx(Mat src, DoubleBuffer minVal, DoubleBuffer maxVal, IntBuffer minIdx, IntBuffer maxIdx, Mat mask)`
`static void`	opencv_core.`minMaxIdx(Mat src, DoublePointer minVal)`
`static void`	opencv_core.`minMaxIdx(Mat src, DoublePointer minVal, DoublePointer maxVal, IntPointer minIdx, IntPointer maxIdx, Mat mask)` \brief Finds the global minimum and maximum in an array
`static void`	opencv_core.`minMaxLoc(Mat src, double[] minVal)`
`static void`	opencv_cudaarithm.`minMaxLoc(Mat src, double[] minVal, double[] maxVal, Point minLoc, Point maxLoc)`
`static void`	opencv_core.`minMaxLoc(Mat src, double[] minVal, double[] maxVal, Point minLoc, Point maxLoc, Mat mask)`
`static void`	opencv_cudaarithm.`minMaxLoc(Mat src, double[] minVal, double[] maxVal, Point minLoc, Point maxLoc, Mat mask)`
`static void`	opencv_core.`minMaxLoc(Mat src, DoubleBuffer minVal)`
`static void`	opencv_cudaarithm.`minMaxLoc(Mat src, DoubleBuffer minVal, DoubleBuffer maxVal, Point minLoc, Point maxLoc)`
`static void`	opencv_core.`minMaxLoc(Mat src, DoubleBuffer minVal, DoubleBuffer maxVal, Point minLoc, Point maxLoc, Mat mask)`
`static void`	opencv_cudaarithm.`minMaxLoc(Mat src, DoubleBuffer minVal, DoubleBuffer maxVal, Point minLoc, Point maxLoc, Mat mask)`
`static void`	opencv_core.`minMaxLoc(Mat src, DoublePointer minVal)`
`static void`	opencv_cudaarithm.`minMaxLoc(Mat src, DoublePointer minVal, DoublePointer maxVal, Point minLoc, Point maxLoc)`
`static void`	opencv_core.`minMaxLoc(Mat src, DoublePointer minVal, DoublePointer maxVal, Point minLoc, Point maxLoc, Mat mask)` \brief Finds the global minimum and maximum in an array.
`static void`	opencv_cudaarithm.`minMaxLoc(Mat src, DoublePointer minVal, DoublePointer maxVal, Point minLoc, Point maxLoc, Mat mask)` \brief Finds global minimum and maximum matrix elements and returns their values with locations.
`static void`	opencv_core.`mixChannels(Mat src, long nsrcs, Mat dst, long ndsts, int[] fromTo, long npairs)`
`static void`	opencv_core.`mixChannels(Mat src, long nsrcs, Mat dst, long ndsts, IntBuffer fromTo, long npairs)`
`static void`	opencv_core.`mixChannels(Mat src, long nsrcs, Mat dst, long ndsts, IntPointer fromTo, long npairs)` \brief Copies specified channels from input arrays to the specified channels of output arrays.
`static Moments`	opencv_imgproc.`moments(Mat array)`
`static Moments`	opencv_imgproc.`moments(Mat array, boolean binaryImage)` \} imgproc_color_conversions
`static void`	opencv_imgproc.`morphologyEx(Mat src, Mat dst, int op, Mat kernel)`
`static void`	opencv_ximgproc.`morphologyEx(Mat rlSrc, Mat rlDest, int op, Mat rlKernel)`
`static void`	opencv_ximgproc.`morphologyEx(Mat rlSrc, Mat rlDest, int op, Mat rlKernel, boolean bBoundaryOnForErosion, Point anchor)` \brief Applies a morphological operation to a run-length encoded binary image.
`static void`	opencv_imgproc.`morphologyEx(Mat src, Mat dst, int op, Mat kernel, Point anchor, int iterations, int borderType, Scalar borderValue)` \brief Performs advanced morphological transformations.
`static void`	opencv_text.`MSERsToERStats(Mat image, PointVectorVector contours, ERStatVectorVector regions)` \brief Converts MSER contours (vector\) to ERStat regions.
`static void`	opencv_cudaarithm.`mulAndScaleSpectrums(Mat src1, Mat src2, Mat dst, int flags, float scale)`
`static void`	opencv_cudaarithm.`mulAndScaleSpectrums(Mat src1, Mat src2, Mat dst, int flags, float scale, boolean conjB, Stream stream)` \brief Performs a per-element multiplication of two Fourier spectrums and scales the result.
`static void`	opencv_core.`mulSpectrums(Mat a, Mat b, Mat c, int flags)`
`static void`	opencv_cudaarithm.`mulSpectrums(Mat src1, Mat src2, Mat dst, int flags)`
`static void`	opencv_core.`mulSpectrums(Mat a, Mat b, Mat c, int flags, boolean conjB)` \brief Performs the per-element multiplication of two Fourier spectrums.
`static void`	opencv_cudaarithm.`mulSpectrums(Mat src1, Mat src2, Mat dst, int flags, boolean conjB, Stream stream)` \brief Performs a per-element multiplication of two Fourier spectrums.
`static MatExpr`	opencv_core.`multiply(double s, Mat a)`
`static MatExpr`	opencv_core.`multiply(Mat a, double s)`
`static MatExpr`	opencv_core.`multiply(MatExpr e, Mat m)`
`static MatExpr`	opencv_core.`multiply(Mat a, Mat b)`
`static MatExpr`	opencv_core.`multiply(Mat m, MatExpr e)`
`static void`	opencv_core.`multiply(Mat src1, Mat src2, Mat dst)`
`static void`	opencv_cudaarithm.`multiply(Mat src1, Mat src2, Mat dst)`
`static void`	opencv_core.`multiply(Mat src1, Mat src2, Mat dst, double scale, int dtype)` \brief Calculates the per-element scaled product of two arrays.
`static void`	opencv_cudaarithm.`multiply(Mat src1, Mat src2, Mat dst, double scale, int dtype, Stream stream)` \brief Computes a matrix-matrix or matrix-scalar per-element product.
`static Mat`	opencv_core.`multiplyPut(Mat a, double b)`
`static Mat`	opencv_core.`multiplyPut(Mat a, Mat b)`
`static void`	opencv_core.`mulTransposed(Mat src, Mat dst, boolean aTa)`
`static void`	opencv_core.`mulTransposed(Mat src, Mat dst, boolean aTa, Mat delta, double scale, int dtype)` \brief Calculates the product of a matrix and its transposition.
`static void`	opencv_ximgproc.`niBlackThreshold(Mat _src, Mat _dst, double maxValue, int type, int blockSize, double k)`
`static void`	opencv_ximgproc.`niBlackThreshold(Mat _src, Mat _dst, double maxValue, int type, int blockSize, double k, int binarizationMethod, double r)` \addtogroup ximgproc \{
`static void`	opencv_photo.`nonLocalMeans(Mat src, Mat dst, float h)`
`static void`	opencv_photo.`nonLocalMeans(Mat src, Mat dst, float h, int search_window, int block_size, int borderMode, Stream stream)` \addtogroup photo_denoise \{
`static double`	opencv_core.`norm(Mat src1)`
`static double`	opencv_cudaarithm.`norm(Mat src1, int normType)`
`static double`	opencv_core.`norm(Mat src1, int normType, Mat mask)` \brief Calculates the absolute norm of an array.
`static double`	opencv_cudaarithm.`norm(Mat src1, int normType, Mat mask)` \} cudaarithm_core
`static double`	opencv_core.`norm(Mat src1, Mat src2)`
`static double`	opencv_cudaarithm.`norm(Mat src1, Mat src2)`
`static double`	opencv_cudaarithm.`norm(Mat src1, Mat src2, int normType)` \brief Returns the difference of two matrices.
`static double`	opencv_core.`norm(Mat src1, Mat src2, int normType, Mat mask)` \brief Calculates an absolute difference norm or a relative difference norm.
`static void`	opencv_core.`normalize(Mat src, Mat dst)`
`static void`	opencv_cudaarithm.`normalize(Mat src, Mat dst, double alpha, double beta, int norm_type, int dtype)`
`static void`	opencv_core.`normalize(Mat src, Mat dst, double alpha, double beta, int norm_type, int dtype, Mat mask)` \brief Normalizes the norm or value range of an array.
`static void`	opencv_cudaarithm.`normalize(Mat src, Mat dst, double alpha, double beta, int norm_type, int dtype, Mat mask, Stream stream)` \brief Normalizes the norm or value range of an array.
`static void`	opencv_stitching.`normalizeUsingWeightMap(Mat weight, Mat src)` \}
`static MatExpr`	opencv_core.`not(Mat m)`
`static MatExpr`	opencv_core.`notEquals(double s, Mat a)`
`static MatExpr`	opencv_core.`notEquals(Mat a, double s)`
`static MatExpr`	opencv_core.`notEquals(Mat a, Mat b)`
`static void`	opencv_xphoto.`oilPainting(Mat src, Mat dst, int size, int dynRatio)` \brief oilPainting See the book \cite Holzmann1988 for details.
`static void`	opencv_xphoto.`oilPainting(Mat src, Mat dst, int size, int dynRatio, int code)` \addtogroup xphoto \{
`static MatExpr`	opencv_core.`or(Mat a, Mat b)`
`static MatExpr`	opencv_core.`or(Mat a, Scalar s)`
`static MatExpr`	opencv_core.`or(Scalar s, Mat a)`
`static Mat`	opencv_core.`orPut(Mat a, Mat b)`
`static Mat`	opencv_core.`orPut(Mat a, Scalar b)`
`static void`	opencv_ximgproc.`paint(Mat image, Mat rlSrc, Scalar value)` \brief Paint run length encoded binary image into an image.
`static void`	opencv_core.`patchNaNs(Mat a)`
`static void`	opencv_core.`patchNaNs(Mat a, double val)` \brief converts NaNs to the given number
`static void`	opencv_core.`PCABackProject(Mat data, Mat mean, Mat eigenvectors, Mat result)` wrap PCA::backProject
`static void`	opencv_core.`PCACompute(Mat data, Mat mean, Mat eigenvectors)`
`static void`	opencv_core.`PCACompute(Mat data, Mat mean, Mat eigenvectors, double retainedVariance)` wrap PCA::operator()
`static void`	opencv_core.`PCACompute(Mat data, Mat mean, Mat eigenvectors, int maxComponents)` wrap PCA::operator()
`static void`	opencv_core.`PCACompute2(Mat data, Mat mean, Mat eigenvectors, Mat eigenvalues)`
`static void`	opencv_core.`PCACompute2(Mat data, Mat mean, Mat eigenvectors, Mat eigenvalues, double retainedVariance)` wrap PCA::operator() and add eigenvalues output parameter
`static void`	opencv_core.`PCACompute2(Mat data, Mat mean, Mat eigenvectors, Mat eigenvalues, int maxComponents)` wrap PCA::operator() and add eigenvalues output parameter
`static void`	opencv_core.`PCAProject(Mat data, Mat mean, Mat eigenvectors, Mat result)` wrap PCA::project
`static DoublePointer`	opencv_ximgproc.`PeiLinNormalization(Mat I)` \addtogroup ximgproc \{
`static void`	opencv_ximgproc.`PeiLinNormalization(Mat I, Mat T)` \overload
`static void`	opencv_photo.`pencilSketch(Mat src, Mat dst1, Mat dst2)`
`static void`	opencv_photo.`pencilSketch(Mat src, Mat dst1, Mat dst2, float sigma_s, float sigma_r, float shade_factor)` \brief Pencil-like non-photorealistic line drawing
`static void`	opencv_core.`perspectiveTransform(Mat src, Mat dst, Mat m)` \brief Performs the perspective matrix transformation of vectors.
`static void`	opencv_core.`phase(Mat x, Mat y, Mat angle)`
`static void`	opencv_cudaarithm.`phase(Mat x, Mat y, Mat angle)`
`static void`	opencv_core.`phase(Mat x, Mat y, Mat angle, boolean angleInDegrees)` \brief Calculates the rotation angle of 2D vectors.
`static void`	opencv_cudaarithm.`phase(Mat x, Mat y, Mat angle, boolean angleInDegrees, Stream stream)` \brief Computes polar angles of complex matrix elements.
`static Point2d`	opencv_imgproc.`phaseCorrelate(Mat src1, Mat src2)`
`static Point2d`	opencv_imgproc.`phaseCorrelate(Mat src1, Mat src2, Mat window, double[] response)`
`static Point2d`	opencv_imgproc.`phaseCorrelate(Mat src1, Mat src2, Mat window, DoubleBuffer response)`
`static Point2d`	opencv_imgproc.`phaseCorrelate(Mat src1, Mat src2, Mat window, DoublePointer response)` \brief The function is used to detect translational shifts that occur between two images.
`static void`	opencv_img_hash.`pHash(Mat inputArr, Mat outputArr)` \brief Computes pHash value of the input image
`static double`	opencv_imgproc.`pointPolygonTest(Mat contour, Point2f pt, boolean measureDist)` \brief Performs a point-in-contour test.
`static void`	opencv_core.`polarToCart(Mat magnitude, Mat angle, Mat x, Mat y)`
`static void`	opencv_cudaarithm.`polarToCart(Mat magnitude, Mat angle, Mat x, Mat y)`
`static void`	opencv_core.`polarToCart(Mat magnitude, Mat angle, Mat x, Mat y, boolean angleInDegrees)` \brief Calculates x and y coordinates of 2D vectors from their magnitude and angle.
`static void`	opencv_cudaarithm.`polarToCart(Mat magnitude, Mat angle, Mat x, Mat y, boolean angleInDegrees, Stream stream)` \brief Converts polar coordinates into Cartesian.
`static void`	opencv_imgproc.`polylines(Mat img, GpuMatVector pts, boolean isClosed, Scalar color)`
`static void`	opencv_imgproc.`polylines(Mat img, GpuMatVector pts, boolean isClosed, Scalar color, int thickness, int lineType, int shift)`
`static void`	opencv_imgproc.`polylines(Mat img, MatVector pts, boolean isClosed, Scalar color)`
`static void`	opencv_imgproc.`polylines(Mat img, MatVector pts, boolean isClosed, Scalar color, int thickness, int lineType, int shift)` \brief Draws several polygonal curves.
`static void`	opencv_imgproc.`polylines(Mat img, PointerPointer pts, IntPointer npts, int ncontours, boolean isClosed, Scalar color, int thickness, int lineType, int shift)` \overload
`static void`	opencv_imgproc.`polylines(Mat img, Point pts, int[] npts, int ncontours, boolean isClosed, Scalar color)`
`static void`	opencv_imgproc.`polylines(Mat img, Point pts, int[] npts, int ncontours, boolean isClosed, Scalar color, int thickness, int lineType, int shift)`
`static void`	opencv_imgproc.`polylines(Mat img, Point pts, IntBuffer npts, int ncontours, boolean isClosed, Scalar color)`
`static void`	opencv_imgproc.`polylines(Mat img, Point pts, IntBuffer npts, int ncontours, boolean isClosed, Scalar color, int thickness, int lineType, int shift)`
`static void`	opencv_imgproc.`polylines(Mat img, Point pts, IntPointer npts, int ncontours, boolean isClosed, Scalar color)`
`static void`	opencv_imgproc.`polylines(Mat img, Point pts, IntPointer npts, int ncontours, boolean isClosed, Scalar color, int thickness, int lineType, int shift)`
`static void`	opencv_imgproc.`polylines(Mat img, UMatVector pts, boolean isClosed, Scalar color)`
`static void`	opencv_imgproc.`polylines(Mat img, UMatVector pts, boolean isClosed, Scalar color, int thickness, int lineType, int shift)`
`static void`	opencv_core.`pow(Mat src, double power, Mat dst)` \brief Raises every array element to a power.
`static void`	opencv_cudaarithm.`pow(Mat src, double power, Mat dst)`
`static void`	opencv_cudaarithm.`pow(Mat src, double power, Mat dst, Stream stream)` \brief Raises every matrix element to a power.
`static void`	opencv_imgproc.`preCornerDetect(Mat src, Mat dst, int ksize)`
`static void`	opencv_imgproc.`preCornerDetect(Mat src, Mat dst, int ksize, int borderType)` \brief Calculates a feature map for corner detection.
`static int`	opencv_core.`predictOptimalVectorWidth(Mat src1)`
`static int`	opencv_core.`predictOptimalVectorWidth(Mat src1, Mat src2, Mat src3, Mat src4, Mat src5, Mat src6, Mat src7, Mat src8, Mat src9, int strat)`
`static int`	opencv_core.`predictOptimalVectorWidthMax(Mat src1)`
`static int`	opencv_core.`predictOptimalVectorWidthMax(Mat src1, Mat src2, Mat src3, Mat src4, Mat src5, Mat src6, Mat src7, Mat src8, Mat src9)`
`static int`	opencv_core.`print(Mat mtx)`
`static int`	opencv_core.`print(Mat mtx, Pointer stream)`
`static void`	opencv_calib3d.`projectPoints(GpuMat objectPoints, GpuMat imagePoints, Mat affine, GpuMat K, GpuMat D)`
`static void`	opencv_calib3d.`projectPoints(GpuMat objectPoints, GpuMat imagePoints, Mat affine, GpuMat K, GpuMat D, double alpha, GpuMat jacobian)`
`static void`	opencv_calib3d.`projectPoints(Mat objectPoints, Mat imagePoints, Mat affine, Mat K, Mat D)`
`static void`	opencv_calib3d.`projectPoints(Mat objectPoints, Mat imagePoints, Mat affine, Mat K, Mat D, double alpha, Mat jacobian)` \brief Projects points using fisheye model
`static void`	opencv_calib3d.`projectPoints(Mat objectPoints, Mat rvec, Mat tvec, Mat cameraMatrix, Mat distCoeffs, Mat imagePoints)`
`static void`	opencv_calib3d.`projectPoints(Mat objectPoints, Mat imagePoints, Mat rvec, Mat tvec, Mat K, Mat D, double alpha, Mat jacobian)` \overload
`static void`	opencv_calib3d.`projectPoints(Mat objectPoints, Mat rvec, Mat tvec, Mat cameraMatrix, Mat distCoeffs, Mat imagePoints, Mat jacobian, double aspectRatio)` \brief Projects 3D points to an image plane.
`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 double`	opencv_core.`PSNR(Mat src1, Mat src2)`
`static double`	opencv_core.`PSNR(Mat src1, Mat src2, double R)` \brief Computes the Peak Signal-to-Noise Ratio (PSNR) image quality metric.
`static void`	opencv_imgproc.`putText(Mat img, BytePointer text, Point org, int fontFace, double fontScale, Scalar color)`
`static void`	opencv_imgproc.`putText(Mat img, BytePointer text, Point org, int fontFace, double fontScale, Scalar color, int thickness, int lineType, boolean bottomLeftOrigin)` \brief Draws a text string.
`static void`	opencv_imgproc.`putText(Mat img, String text, Point org, int fontFace, double fontScale, Scalar color)`
`static void`	opencv_imgproc.`putText(Mat img, String text, Point org, int fontFace, double fontScale, Scalar color, int thickness, int lineType, boolean bottomLeftOrigin)`
`static void`	opencv_imgproc.`pyrDown(Mat src, Mat dst)`
`static void`	opencv_cudawarping.`pyrDown(Mat src, Mat dst)`
`static void`	opencv_imgproc.`pyrDown(Mat src, Mat dst, Size dstsize, int borderType)` \brief Blurs an image and downsamples it.
`static void`	opencv_cudawarping.`pyrDown(Mat src, Mat dst, Stream stream)` \brief Smoothes an image and downsamples it.
`static void`	opencv_imgproc.`pyrMeanShiftFiltering(Mat src, Mat dst, double sp, double sr)`
`static void`	opencv_imgproc.`pyrMeanShiftFiltering(Mat src, Mat dst, double sp, double sr, int maxLevel, TermCriteria termcrit)` \} imgproc_segmentation
`static void`	opencv_imgproc.`pyrUp(Mat src, Mat dst)`
`static void`	opencv_cudawarping.`pyrUp(Mat src, Mat dst)`
`static void`	opencv_imgproc.`pyrUp(Mat src, Mat dst, Size dstsize, int borderType)` \brief Upsamples an image and then blurs it.
`static void`	opencv_cudawarping.`pyrUp(Mat src, Mat dst, Stream stream)` \brief Upsamples an image and then smoothes it.
`static void`	opencv_ximgproc.`qconj(Mat qimg, Mat qcimg)` \brief calculates conjugate of a quaternion image.
`static void`	opencv_ximgproc.`qdft(Mat img, Mat qimg, int flags, boolean sideLeft)` \brief Performs a forward or inverse Discrete quaternion Fourier transform of a 2D quaternion array.
`static void`	opencv_ximgproc.`qmultiply(Mat src1, Mat src2, Mat dst)` \brief Calculates the per-element quaternion product of two arrays
`static void`	opencv_ximgproc.`qunitary(Mat qimg, Mat qnimg)` \brief divides each element by its modulus.
`static void`	opencv_img_hash.`radialVarianceHash(Mat inputArr, Mat outputArr)`
`static void`	opencv_img_hash.`radialVarianceHash(Mat inputArr, Mat outputArr, double sigma, int numOfAngleLine)` \brief Computes radial variance hash of the input image
`static void`	opencv_ml.`randMVNormal(Mat mean, Mat cov, int nsamples, Mat samples)` \brief Generates _sample_ from multivariate normal distribution
`static void`	opencv_core.`randn(Mat dst, Mat mean, Mat stddev)` \brief Fills the array with normally distributed random numbers.
`static void`	opencv_core.`randShuffle(Mat dst)`
`static void`	opencv_core.`randShuffle(Mat dst, double iterFactor, RNG rng)` \brief Shuffles the array elements randomly.
`static void`	opencv_core.`randu(Mat dst, Mat low, Mat high)` \brief Generates a single uniformly-distributed random number or an array of random numbers.
`static float`	opencv_rapid.`rapid(Mat img, int num, int len, Mat pts3d, Mat tris, Mat K, Mat rvec, Mat tvec)`
`static float`	opencv_rapid.`rapid(Mat img, int num, int len, Mat pts3d, Mat tris, Mat K, Mat rvec, Mat tvec, double[] rmsd)`
`static float`	opencv_rapid.`rapid(Mat img, int num, int len, Mat pts3d, Mat tris, Mat K, Mat rvec, Mat tvec, DoubleBuffer rmsd)`
`static float`	opencv_rapid.`rapid(Mat img, int num, int len, Mat pts3d, Mat tris, Mat K, Mat rvec, Mat tvec, DoublePointer rmsd)` High level function to execute a single rapid \cite harris1990rapid iteration 1.
`static void`	opencv_core.`read(FileNode node, Mat mat)`
`static void`	opencv_core.`read(FileNode node, Mat mat, Mat default_mat)`
`static int`	opencv_ximgproc.`readGT(BytePointer src_path, Mat dst)` \brief Function for reading ground truth disparity maps.
`static int`	opencv_ximgproc.`readGT(String src_path, Mat dst)`
`static int`	opencv_calib3d.`recoverPose(Mat E, Mat points1, Mat points2, Mat R, Mat t)`
`static int`	opencv_calib3d.`recoverPose(Mat E, Mat points1, Mat points2, Mat R, Mat t, double focal, Point2d pp, Mat mask)` \overload
`static int`	opencv_calib3d.`recoverPose(Mat E, Mat points1, Mat points2, Mat cameraMatrix, Mat R, Mat t)`
`static int`	opencv_calib3d.`recoverPose(Mat E, Mat points1, Mat points2, Mat cameraMatrix, Mat R, Mat t, double distanceThresh)`
`static int`	opencv_calib3d.`recoverPose(Mat E, Mat points1, Mat points2, Mat cameraMatrix, Mat R, Mat t, double distanceThresh, Mat mask, Mat triangulatedPoints)` \overload
`static int`	opencv_calib3d.`recoverPose(Mat E, Mat points1, Mat points2, Mat cameraMatrix, Mat R, Mat t, Mat mask)` \brief Recovers the relative camera rotation and the translation from an estimated essential matrix and the corresponding points in two images, using cheirality check.
`static void`	opencv_imgproc.`rectangle(Mat img, Point pt1, Point pt2, Scalar color)`
`static void`	opencv_imgproc.`rectangle(Mat img, Point pt1, Point pt2, Scalar color, int thickness, int lineType, int shift)` \brief Draws a simple, thick, or filled up-right rectangle.
`static void`	opencv_imgproc.`rectangle(Mat img, Rect rec, Scalar color)`
`static void`	opencv_imgproc.`rectangle(Mat img, Rect rec, Scalar color, int thickness, int lineType, int shift)` \overload
`static float`	opencv_calib3d.`rectify3Collinear(Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Mat cameraMatrix3, Mat distCoeffs3, GpuMatVector imgpt1, GpuMatVector imgpt3, Size imageSize, Mat R12, Mat T12, Mat R13, Mat T13, Mat R1, Mat R2, Mat R3, Mat P1, Mat P2, Mat P3, Mat Q, double alpha, Size newImgSize, Rect roi1, Rect roi2, int flags)`
`static float`	opencv_calib3d.`rectify3Collinear(Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Mat cameraMatrix3, Mat distCoeffs3, MatVector imgpt1, MatVector imgpt3, Size imageSize, Mat R12, Mat T12, Mat R13, Mat T13, Mat R1, Mat R2, Mat R3, Mat P1, Mat P2, Mat P3, Mat Q, double alpha, Size newImgSize, Rect roi1, Rect roi2, int flags)` computes the rectification transformations for 3-head camera, where all the heads are on the same line.
`static float`	opencv_calib3d.`rectify3Collinear(Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Mat cameraMatrix3, Mat distCoeffs3, UMatVector imgpt1, UMatVector imgpt3, Size imageSize, Mat R12, Mat T12, Mat R13, Mat T13, Mat R1, Mat R2, Mat R3, Mat P1, Mat P2, Mat P3, Mat Q, double alpha, Size newImgSize, Rect roi1, Rect roi2, int flags)`
`static void`	opencv_cudaarithm.`rectStdDev(Mat src, Mat sqr, Mat dst, Rect rect)`
`static void`	opencv_cudaarithm.`rectStdDev(Mat src, Mat sqr, Mat dst, Rect rect, Stream stream)` \brief Computes a standard deviation of integral images.
`static void`	opencv_core.`reduce(Mat src, Mat dst, int dim, int rtype)`
`static void`	opencv_cudaarithm.`reduce(Mat mtx, Mat vec, int dim, int reduceOp)`
`static void`	opencv_core.`reduce(Mat src, Mat dst, int dim, int rtype, int dtype)` \brief Reduces a matrix to a vector.
`static void`	opencv_cudaarithm.`reduce(Mat mtx, Mat vec, int dim, int reduceOp, int dtype, Stream stream)` \brief Reduces a matrix to a vector.
`static void`	opencv_aruco.`refineDetectedMarkers(Mat image, Board board, GpuMatVector detectedCorners, Mat detectedIds, GpuMatVector rejectedCorners)`
`static void`	opencv_aruco.`refineDetectedMarkers(Mat image, Board board, GpuMatVector detectedCorners, Mat detectedIds, GpuMatVector rejectedCorners, Mat cameraMatrix, Mat distCoeffs, float minRepDistance, float errorCorrectionRate, boolean checkAllOrders, Mat recoveredIdxs, DetectorParameters parameters)`
`static void`	opencv_aruco.`refineDetectedMarkers(Mat image, Board board, MatVector detectedCorners, Mat detectedIds, MatVector rejectedCorners)`
`static void`	opencv_aruco.`refineDetectedMarkers(Mat image, Board board, MatVector detectedCorners, Mat detectedIds, MatVector rejectedCorners, Mat cameraMatrix, Mat distCoeffs, float minRepDistance, float errorCorrectionRate, boolean checkAllOrders, Mat recoveredIdxs, DetectorParameters parameters)` \brief Refind not detected markers based on the already detected and the board layout
`static void`	opencv_aruco.`refineDetectedMarkers(Mat image, Board board, UMatVector detectedCorners, Mat detectedIds, UMatVector rejectedCorners)`
`static void`	opencv_aruco.`refineDetectedMarkers(Mat image, Board board, UMatVector detectedCorners, Mat detectedIds, UMatVector rejectedCorners, Mat cameraMatrix, Mat distCoeffs, float minRepDistance, float errorCorrectionRate, boolean checkAllOrders, Mat recoveredIdxs, DetectorParameters parameters)`
`static void`	opencv_core.`registerPageLocked(Mat m)` \brief Page-locks the memory of matrix and maps it for the device(s).
`static void`	opencv_imgproc.`remap(Mat src, Mat dst, Mat map1, Mat map2, int interpolation)`
`static void`	opencv_cudawarping.`remap(Mat src, Mat dst, Mat xmap, Mat ymap, int interpolation)`
`static void`	opencv_imgproc.`remap(Mat src, Mat dst, Mat map1, Mat map2, int interpolation, int borderMode, Scalar borderValue)` \brief Applies a generic geometrical transformation to an image.
`static void`	opencv_cudawarping.`remap(Mat src, Mat dst, Mat xmap, Mat ymap, int interpolation, int borderMode, Scalar borderValue, Stream stream)` \addtogroup cudawarping \{
`static Mat`	opencv_core.`repeat(Mat src, int ny, int nx)` \overload
`static void`	opencv_core.`repeat(Mat src, int ny, int nx, Mat dst)` \brief Fills the output array with repeated copies of the input array.
`static void`	opencv_cudastereo.`reprojectImageTo3D(Mat disp, Mat xyzw, Mat Q)`
`static void`	opencv_calib3d.`reprojectImageTo3D(Mat disparity, Mat _3dImage, Mat Q)`
`static void`	opencv_calib3d.`reprojectImageTo3D(Mat disparity, Mat _3dImage, Mat Q, boolean handleMissingValues, int ddepth)` \brief Reprojects a disparity image to 3D space.
`static void`	opencv_cudastereo.`reprojectImageTo3D(Mat disp, Mat xyzw, Mat Q, int dst_cn, Stream stream)` \brief Reprojects a disparity image to 3D space.
`static void`	opencv_imgproc.`resize(Mat src, Mat dst, Size dsize)`
`static void`	opencv_cudawarping.`resize(Mat src, Mat dst, Size dsize)`
`static void`	opencv_imgproc.`resize(Mat src, Mat dst, Size dsize, double fx, double fy, int interpolation)` \} imgproc_filter
`static void`	opencv_cudawarping.`resize(Mat src, Mat dst, Size dsize, double fx, double fy, int interpolation, Stream stream)` \brief Resizes an image.
`static void`	opencv_calib3d.`Rodrigues(Mat src, Mat dst)`
`static void`	opencv_calib3d.`Rodrigues(Mat src, Mat dst, Mat jacobian)` \brief Converts a rotation matrix to a rotation vector or vice versa.
`static void`	opencv_ximgproc.`rollingGuidanceFilter(Mat src, Mat dst)`
`static void`	opencv_ximgproc.`rollingGuidanceFilter(Mat src, Mat dst, int d, double sigmaColor, double sigmaSpace, int numOfIter, int borderType)` \brief Applies the rolling guidance filter to an image.
`static void`	opencv_core.`rotate(Mat src, Mat dst, int rotateCode)` \brief Rotates a 2D array in multiples of 90 degrees.
`static void`	opencv_cudawarping.`rotate(Mat src, Mat dst, Size dsize, double angle)`
`static void`	opencv_cudawarping.`rotate(Mat src, Mat dst, Size dsize, double angle, double xShift, double yShift, int interpolation, Stream stream)` \brief Rotates an image around the origin (0,0) and then shifts it.
`static int`	opencv_imgproc.`rotatedRectangleIntersection(RotatedRect rect1, RotatedRect rect2, Mat intersectingRegion)` \brief Finds out if there is any intersection between two rotated rectangles.
`static Point3d`	opencv_calib3d.`RQDecomp3x3(Mat src, Mat mtxR, Mat mtxQ)`
`static Point3d`	opencv_calib3d.`RQDecomp3x3(Mat src, Mat mtxR, Mat mtxQ, Mat Qx, Mat Qy, Mat Qz)` \brief Computes an RQ decomposition of 3x3 matrices.
`static void`	opencv_cudaarithm.`rshift(Mat src, Scalar4i val, Mat dst)`
`static void`	opencv_cudaarithm.`rshift(Mat src, Scalar4i val, Mat dst, Stream stream)` \brief Performs pixel by pixel right shift of an image by a constant value.
`static void`	opencv_cudaarithm.`rshift(Mat src, Scalar val, Mat dst)`
`static void`	opencv_cudaarithm.`rshift(Mat src, Scalar val, Mat dst, Stream stream)`
`static double`	opencv_calib3d.`sampsonDistance(Mat pt1, Mat pt2, Mat F)` \brief Calculates the Sampson Distance between two points.
`static void`	opencv_core.`scaleAdd(Mat src1, double alpha, Mat src2, Mat dst)` \brief Calculates the sum of a scaled array and another array.
`static void`	opencv_cudaarithm.`scaleAdd(Mat src1, double alpha, Mat src2, Mat dst)`
`static void`	opencv_cudaarithm.`scaleAdd(Mat src1, double alpha, Mat src2, Mat dst, Stream stream)` adds scaled array to another one (dst = alpha*src1 + src2)
`static void`	opencv_imgproc.`Scharr(Mat src, Mat dst, int ddepth, int dx, int dy)`
`static void`	opencv_imgproc.`Scharr(Mat src, Mat dst, int ddepth, int dx, int dy, double scale, double delta, int borderType)` \brief Calculates the first x- or y- image derivative using Scharr operator.
`static void`	opencv_photo.`seamlessClone(Mat src, Mat dst, Mat mask, Point p, Mat blend, int flags)` \brief Image editing tasks concern either global changes (color/intensity corrections, filters, deformations) or local changes concerned to a selection.
`static void`	opencv_optflow.`segmentMotion(Mat mhi, Mat segmask, RectVector boundingRects, double timestamp, double segThresh)` \brief Splits a motion history image into a few parts corresponding to separate independent motions (for example, left hand, right hand).
`static Rect`	opencv_highgui.`selectROI(BytePointer windowName, Mat img)`
`static Rect`	opencv_highgui.`selectROI(BytePointer windowName, Mat img, boolean showCrosshair, boolean fromCenter)` \brief Allows users to select a ROI on the given image.
`static Rect`	opencv_highgui.`selectROI(Mat img)`
`static Rect`	opencv_highgui.`selectROI(Mat img, boolean showCrosshair, boolean fromCenter)` \overload
`static Rect`	opencv_highgui.`selectROI(String windowName, Mat img)`
`static Rect`	opencv_highgui.`selectROI(String windowName, Mat img, boolean showCrosshair, boolean fromCenter)`
`static void`	opencv_highgui.`selectROIs(BytePointer windowName, Mat img, RectVector boundingBoxes)`
`static void`	opencv_highgui.`selectROIs(BytePointer windowName, Mat img, RectVector boundingBoxes, boolean showCrosshair, boolean fromCenter)` \brief Allows users to select multiple ROIs on the given image.
`static void`	opencv_highgui.`selectROIs(String windowName, Mat img, RectVector boundingBoxes)`
`static void`	opencv_highgui.`selectROIs(String windowName, Mat img, RectVector boundingBoxes, boolean showCrosshair, boolean fromCenter)`
`static void`	opencv_imgproc.`sepFilter2D(Mat src, Mat dst, int ddepth, Mat kernelX, Mat kernelY)`
`static void`	opencv_imgproc.`sepFilter2D(Mat src, Mat dst, int ddepth, Mat kernelX, Mat kernelY, Point anchor, double delta, int borderType)` \brief Applies a separable linear filter to an image.
`static void`	opencv_core.`setIdentity(Mat mtx)`
`static void`	opencv_core.`setIdentity(Mat mtx, Scalar s)` \brief Initializes a scaled identity matrix.
`static IntPointer`	opencv_dnn.`shape(Mat mat)`
`static BytePointer`	opencv_core.`shiftLeft(BytePointer out, Mat mtx)`
`static String`	opencv_core.`shiftLeft(String out, Mat mtx)`
`static Mat`	opencv_dnn.`slice(Mat m, _Range r0, _Range r1, _Range r2, _Range r3)`
`static Mat`	opencv_dnn.`slice(Mat m, _Range r0, _Range r1, _Range r2)`
`static Mat`	opencv_dnn.`slice(Mat m, _Range r0, _Range r1)`
`static Mat`	opencv_dnn.`slice(Mat m, _Range r0)` \} \}
`static void`	opencv_imgproc.`Sobel(Mat src, Mat dst, int ddepth, int dx, int dy)`
`static void`	opencv_imgproc.`Sobel(Mat src, Mat dst, int ddepth, int dx, int dy, int ksize, double scale, double delta, int borderType)` \brief Calculates the first, second, third, or mixed image derivatives using an extended Sobel operator.
`static boolean`	opencv_core.`solve(Mat src1, Mat src2, Mat dst)`
`static boolean`	opencv_core.`solve(Mat src1, Mat src2, Mat dst, int flags)` \brief Solves one or more linear systems or least-squares problems.
`static int`	opencv_core.`solveCubic(Mat coeffs, Mat roots)` \brief Finds the real roots of a cubic equation.
`static int`	opencv_core.`solveLP(Mat Func, Mat Constr, Mat z)` \brief Solve given (non-integer) linear programming problem using the Simplex Algorithm (Simplex Method).
`static int`	opencv_calib3d.`solveP3P(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, GpuMatVector rvecs, GpuMatVector tvecs, int flags)`
`static int`	opencv_calib3d.`solveP3P(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, MatVector rvecs, MatVector tvecs, int flags)` \brief Finds an object pose from 3 3D-2D point correspondences.
`static int`	opencv_calib3d.`solveP3P(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, UMatVector rvecs, UMatVector tvecs, int flags)`
`static boolean`	opencv_calib3d.`solvePnP(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec)`
`static boolean`	opencv_calib3d.`solvePnP(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec, boolean useExtrinsicGuess, int flags)` \brief Finds an object pose from 3D-2D point correspondences.
`static int`	opencv_calib3d.`solvePnPGeneric(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, GpuMatVector rvecs, GpuMatVector tvecs)`
`static int`	opencv_calib3d.`solvePnPGeneric(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, GpuMatVector rvecs, GpuMatVector tvecs, boolean useExtrinsicGuess, int flags, Mat rvec, Mat tvec, Mat reprojectionError)`
`static int`	opencv_calib3d.`solvePnPGeneric(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, MatVector rvecs, MatVector tvecs)`
`static int`	opencv_calib3d.`solvePnPGeneric(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, MatVector rvecs, MatVector tvecs, boolean useExtrinsicGuess, int flags, Mat rvec, Mat tvec, Mat reprojectionError)` \brief Finds an object pose from 3D-2D point correspondences.
`static int`	opencv_calib3d.`solvePnPGeneric(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, UMatVector rvecs, UMatVector tvecs)`
`static int`	opencv_calib3d.`solvePnPGeneric(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, UMatVector rvecs, UMatVector tvecs, boolean useExtrinsicGuess, int flags, Mat rvec, Mat tvec, Mat reprojectionError)`
`static boolean`	opencv_calib3d.`solvePnPRansac(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec)`
`static boolean`	opencv_calib3d.`solvePnPRansac(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec, boolean useExtrinsicGuess, int iterationsCount, float reprojectionError, double confidence, Mat inliers, int flags)` \brief Finds an object pose from 3D-2D point correspondences using the RANSAC scheme.
`static boolean`	opencv_calib3d.`solvePnPRansac(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec, Mat inliers)`
`static boolean`	opencv_calib3d.`solvePnPRansac(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec, Mat inliers, UsacParams params)`
`static void`	opencv_calib3d.`solvePnPRefineLM(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec)`
`static void`	opencv_calib3d.`solvePnPRefineLM(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec, TermCriteria criteria)` \brief Refine a pose (the translation and the rotation that transform a 3D point expressed in the object coordinate frame to the camera coordinate frame) from a 3D-2D point correspondences and starting from an initial solution.
`static void`	opencv_calib3d.`solvePnPRefineVVS(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec)`
`static void`	opencv_calib3d.`solvePnPRefineVVS(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec, TermCriteria criteria, double VVSlambda)` \brief Refine a pose (the translation and the rotation that transform a 3D point expressed in the object coordinate frame to the camera coordinate frame) from a 3D-2D point correspondences and starting from an initial solution.
`static double`	opencv_core.`solvePoly(Mat coeffs, Mat roots)`
`static double`	opencv_core.`solvePoly(Mat coeffs, Mat roots, int maxIters)` \brief Finds the real or complex roots of a polynomial equation.
`static void`	opencv_core.`sort(Mat src, Mat dst, int flags)` \brief Sorts each row or each column of a matrix.
`static void`	opencv_core.`sortIdx(Mat src, Mat dst, int flags)` \brief Sorts each row or each column of a matrix.
`static void`	opencv_imgproc.`spatialGradient(Mat src, Mat dx, Mat dy)`
`static void`	opencv_imgproc.`spatialGradient(Mat src, Mat dx, Mat dy, int ksize, int borderType)` \brief Calculates the first order image derivative in both x and y using a Sobel operator
`static void`	opencv_cudaarithm.`split(Mat src, GpuMat dst)`
`static void`	opencv_cudaarithm.`split(Mat src, GpuMat dst, Stream stream)` \brief Copies each plane of a multi-channel matrix into an array.
`static void`	opencv_core.`split(Mat m, GpuMatVector mv)`
`static void`	opencv_cudaarithm.`split(Mat src, GpuMatVector dst)`
`static void`	opencv_cudaarithm.`split(Mat src, GpuMatVector dst, Stream stream)` \overload
`static void`	opencv_core.`split(Mat src, Mat mvbegin)` \brief Divides a multi-channel array into several single-channel arrays.
`static void`	opencv_core.`split(Mat m, MatVector mv)` \overload
`static void`	opencv_core.`split(Mat m, UMatVector mv)`
`static void`	opencv_cudaarithm.`sqr(Mat src, Mat dst)`
`static void`	opencv_cudaarithm.`sqr(Mat src, Mat dst, Stream stream)` \brief Computes a square value of each matrix element.
`static void`	opencv_imgproc.`sqrBoxFilter(Mat src, Mat dst, int ddepth, Size ksize)`
`static void`	opencv_imgproc.`sqrBoxFilter(Mat src, Mat dst, int ddepth, Size ksize, Point anchor, boolean normalize, int borderType)` \brief Calculates the normalized sum of squares of the pixel values overlapping the filter.
`static void`	opencv_cudaarithm.`sqrIntegral(Mat src, Mat sqsum)`
`static void`	opencv_cudaarithm.`sqrIntegral(Mat src, Mat sqsum, Stream stream)` \brief Computes a squared integral image.
`static Scalar`	opencv_cudaarithm.`sqrSum(Mat src)`
`static Scalar`	opencv_cudaarithm.`sqrSum(Mat src, Mat mask)` \brief Returns the squared sum of matrix elements.
`static void`	opencv_core.`sqrt(Mat src, Mat dst)` \brief Calculates a square root of array elements.
`static void`	opencv_cudaarithm.`sqrt(Mat src, Mat dst)`
`static void`	opencv_cudaarithm.`sqrt(Mat src, Mat dst, Stream stream)` \brief Computes a square root of each matrix element.
`static double`	opencv_calib3d.`stereoCalibrate(Point3fVectorVector objectPoints, Point2fVectorVector imagePoints1, Point2fVectorVector imagePoints2, Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Size imageSize, Mat R, Mat T, Mat E, Mat F)`
`static double`	opencv_calib3d.`stereoCalibrate(Point3fVectorVector objectPoints, Point2fVectorVector imagePoints1, Point2fVectorVector imagePoints2, Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Size imageSize, Mat R, Mat T, Mat E, Mat F, int flags, TermCriteria criteria)`
`static double`	opencv_calib3d.`stereoCalibrateExtended(Point3fVectorVector objectPoints, Point2fVectorVector imagePoints1, Point2fVectorVector imagePoints2, Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Size imageSize, Mat R, Mat T, Mat E, Mat F, Mat perViewErrors)`
`static double`	opencv_calib3d.`stereoCalibrateExtended(Point3fVectorVector objectPoints, Point2fVectorVector imagePoints1, Point2fVectorVector imagePoints2, Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Size imageSize, Mat R, Mat T, Mat E, Mat F, Mat perViewErrors, int flags, TermCriteria criteria)` \brief Calibrates a stereo camera set up.
`static void`	opencv_calib3d.`stereoRectify(Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Size imageSize, Mat R, Mat T, Mat R1, Mat R2, Mat P1, Mat P2, Mat Q)`
`static void`	opencv_calib3d.`stereoRectify(Mat K1, Mat D1, Mat K2, Mat D2, Size imageSize, Mat R, Mat tvec, Mat R1, Mat R2, Mat P1, Mat P2, Mat Q, int flags)`
`static void`	opencv_calib3d.`stereoRectify(Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Size imageSize, Mat R, Mat T, Mat R1, Mat R2, Mat P1, Mat P2, Mat Q, int flags, double alpha, Size newImageSize, Rect validPixROI1, Rect validPixROI2)` \brief Computes rectification transforms for each head of a calibrated stereo camera.
`static void`	opencv_calib3d.`stereoRectify(Mat K1, Mat D1, Mat K2, Mat D2, Size imageSize, Mat R, Mat tvec, Mat R1, Mat R2, Mat P1, Mat P2, Mat Q, int flags, Size newImageSize, double balance, double fov_scale)` \brief Stereo rectification for fisheye camera model
`static boolean`	opencv_calib3d.`stereoRectifyUncalibrated(Mat points1, Mat points2, Mat F, Size imgSize, Mat H1, Mat H2)`
`static boolean`	opencv_calib3d.`stereoRectifyUncalibrated(Mat points1, Mat points2, Mat F, Size imgSize, Mat H1, Mat H2, double threshold)` \brief Computes a rectification transform for an uncalibrated stereo camera.
`static void`	opencv_photo.`stylization(Mat src, Mat dst)`
`static void`	opencv_photo.`stylization(Mat src, Mat dst, float sigma_s, float sigma_r)` \brief Stylization aims to produce digital imagery with a wide variety of effects not focused on photorealism.
`static MatExpr`	opencv_core.`subtract(Mat m)`
`static MatExpr`	opencv_core.`subtract(MatExpr e, Mat m)`
`static MatExpr`	opencv_core.`subtract(Mat a, Mat b)`
`static MatExpr`	opencv_core.`subtract(Mat m, MatExpr e)`
`static void`	opencv_core.`subtract(Mat src1, Mat src2, Mat dst)`
`static void`	opencv_cudaarithm.`subtract(Mat src1, Mat src2, Mat dst)`
`static void`	opencv_core.`subtract(Mat src1, Mat src2, Mat dst, Mat mask, int dtype)` \brief Calculates the per-element difference between two arrays or array and a scalar.
`static void`	opencv_cudaarithm.`subtract(Mat src1, Mat src2, Mat dst, Mat mask, int dtype, Stream stream)` \brief Computes a matrix-matrix or matrix-scalar difference.
`static MatExpr`	opencv_core.`subtract(Mat a, Scalar s)`
`static MatExpr`	opencv_core.`subtract(Scalar s, Mat a)`
`static Mat`	opencv_core.`subtractPut(Mat a, Mat b)`
`static Mat`	opencv_core.`subtractPut(Mat a, Scalar b)`
`static Scalar`	opencv_cudaarithm.`sum(Mat src)`
`static Scalar`	opencv_cudaarithm.`sum(Mat src, Mat mask)` \brief Returns the sum of matrix elements.
`static Scalar`	opencv_core.`sumElems(Mat src)` \brief Calculates the sum of array elements.
`static void`	opencv_core.`SVBackSubst(Mat w, Mat u, Mat vt, Mat rhs, Mat dst)` wrap SVD::backSubst
`static void`	opencv_core.`SVDecomp(Mat src, Mat w, Mat u, Mat vt)`
`static void`	opencv_core.`SVDecomp(Mat src, Mat w, Mat u, Mat vt, int flags)` wrap SVD::compute
`static void`	opencv_core.`swap(Mat a, Mat b)` \} core_array
`static void`	opencv_cudaimgproc.`swapChannels(Mat image, int[] dstOrder)`
`static void`	opencv_cudaimgproc.`swapChannels(Mat image, int[] dstOrder, Stream stream)`
`static void`	opencv_cudaimgproc.`swapChannels(Mat image, IntBuffer dstOrder)`
`static void`	opencv_cudaimgproc.`swapChannels(Mat image, IntBuffer dstOrder, Stream stream)`
`static void`	opencv_cudaimgproc.`swapChannels(Mat image, IntPointer dstOrder)`
`static void`	opencv_cudaimgproc.`swapChannels(Mat image, IntPointer dstOrder, Stream stream)` \brief Exchanges the color channels of an image in-place.
`static boolean`	opencv_aruco.`testCharucoCornersCollinear(CharucoBoard _board, Mat _charucoIds)` \brief test whether the ChArUco markers are collinear
`static void`	opencv_photo.`textureFlattening(Mat src, Mat mask, Mat dst)`
`static void`	opencv_photo.`textureFlattening(Mat src, Mat mask, Mat dst, float low_threshold, float high_threshold, int kernel_size)` \brief By retaining only the gradients at edge locations, before integrating with the Poisson solver, one washes out the texture of the selected region, giving its contents a flat aspect.
`static void`	opencv_ximgproc.`thinning(Mat src, Mat dst)`
`static void`	opencv_ximgproc.`thinning(Mat src, Mat dst, int thinningType)` \brief Applies a binary blob thinning operation, to achieve a skeletization of the input image.
`static double`	opencv_imgproc.`threshold(Mat src, Mat dst, double thresh, double maxval, int type)` \} imgproc_motion
`static double`	opencv_cudaarithm.`threshold(Mat src, Mat dst, double thresh, double maxval, int type)`
`static double`	opencv_cudaarithm.`threshold(Mat src, Mat dst, double thresh, double maxval, int type, Stream stream)` \brief Applies a fixed-level threshold to each array element.
`static void`	opencv_ximgproc.`threshold(Mat src, Mat rlDest, double thresh, int type)` \addtogroup ximgproc_run_length_morphology \{
`static Scalar`	opencv_core.`trace(Mat mtx)` \brief Returns the trace of a matrix.
`static void`	opencv_core.`transform(Mat src, Mat dst, Mat m)` \brief Performs the matrix transformation of every array element.
`static void`	opencv_ximgproc.`transformFD(Mat src, Mat t, Mat dst)`
`static void`	opencv_ximgproc.`transformFD(Mat src, Mat t, Mat dst, boolean fdContour)` \brief transform a contour
`static void`	opencv_core.`transpose(Mat src, Mat dst)` \brief Transposes a matrix.
`static void`	opencv_cudaarithm.`transpose(Mat src1, Mat dst)`
`static void`	opencv_cudaarithm.`transpose(Mat src1, Mat dst, Stream stream)` \brief Transposes a matrix.
`static void`	opencv_calib3d.`triangulatePoints(Mat projMatr1, Mat projMatr2, Mat projPoints1, Mat projPoints2, Mat points4D)` \brief This function reconstructs 3-dimensional points (in homogeneous coordinates) by using their observations with a stereo camera.
`static void`	opencv_calib3d.`undistort(Mat src, Mat dst, Mat cameraMatrix, Mat distCoeffs)`
`static void`	opencv_calib3d.`undistort(Mat src, Mat dst, Mat cameraMatrix, Mat distCoeffs, Mat newCameraMatrix)` \brief Transforms an image to compensate for lens distortion.
`static void`	opencv_calib3d.`undistortImage(Mat distorted, Mat undistorted, Mat K, Mat D)`
`static void`	opencv_calib3d.`undistortImage(Mat distorted, Mat undistorted, Mat K, Mat D, Mat Knew, Size new_size)` \brief Transforms an image to compensate for fisheye lens distortion.
`static void`	opencv_calib3d.`undistortPoints(Mat src, Mat dst, Mat cameraMatrix, Mat distCoeffs)`
`static void`	opencv_calib3d.`undistortPoints(Mat src, Mat dst, Mat cameraMatrix, Mat distCoeffs, Mat R, Mat P)` \brief Computes the ideal point coordinates from the observed point coordinates.
`static void`	opencv_calib3d.`undistortPointsIter(Mat src, Mat dst, Mat cameraMatrix, Mat distCoeffs, Mat R, Mat P, TermCriteria criteria)` \overload \note Default version of #undistortPoints does 5 iterations to compute undistorted points.
`static void`	opencv_core.`unregisterPageLocked(Mat m)` \brief Unmaps the memory of matrix and makes it pageable again.
`static void`	opencv_optflow.`updateMotionHistory(Mat silhouette, Mat mhi, double timestamp, double duration)` \addtogroup optflow \{
`static void`	opencv_calib3d.`validateDisparity(Mat disparity, Mat cost, int minDisparity, int numberOfDisparities)`
`static void`	opencv_calib3d.`validateDisparity(Mat disparity, Mat cost, int minDisparity, int numberOfDisparities, int disp12MaxDisp)` validates disparity using the left-right check.
`static void`	opencv_core.`vconcat(GpuMatVector src, Mat dst)`
`static void`	opencv_core.`vconcat(Mat src, long nsrc, GpuMat dst)`
`static void`	opencv_core.`vconcat(Mat src, long nsrc, Mat dst)` \brief Applies vertical concatenation to given matrices.
`static void`	opencv_core.`vconcat(Mat src, long nsrc, UMat dst)`
`static void`	opencv_core.`vconcat(Mat src1, Mat src2, Mat dst)` \overload
`static void`	opencv_core.`vconcat(MatVector src, Mat dst)` \overload
`static void`	opencv_core.`vconcat(UMatVector src, Mat dst)`
`static void`	opencv_cudawarping.`warpAffine(GpuMat src, GpuMat dst, Mat M, Size dsize)`
`static void`	opencv_cudawarping.`warpAffine(GpuMat src, GpuMat dst, Mat M, Size dsize, int flags, int borderMode, Scalar borderValue, Stream stream)` \brief Applies an affine transformation to an image.
`static void`	opencv_imgproc.`warpAffine(Mat src, Mat dst, Mat M, Size dsize)`
`static void`	opencv_imgproc.`warpAffine(Mat src, Mat dst, Mat M, Size dsize, int flags, int borderMode, Scalar borderValue)` \brief Applies an affine transformation to an image.
`static void`	opencv_cudawarping.`warpPerspective(GpuMat src, GpuMat dst, Mat M, Size dsize)`
`static void`	opencv_cudawarping.`warpPerspective(GpuMat src, GpuMat dst, Mat M, Size dsize, int flags, int borderMode, Scalar borderValue, Stream stream)` \brief Applies a perspective transformation to an image.
`static void`	opencv_imgproc.`warpPerspective(Mat src, Mat dst, Mat M, Size dsize)`
`static void`	opencv_imgproc.`warpPerspective(Mat src, Mat dst, Mat M, Size dsize, int flags, int borderMode, Scalar borderValue)` \brief Applies a perspective transformation to an image.
`static void`	opencv_imgproc.`warpPolar(Mat src, Mat dst, Size dsize, Point2f center, double maxRadius, int flags)` \brief Remaps an image to polar or semilog-polar coordinates space
`static void`	opencv_imgproc.`watershed(Mat image, Mat markers)` \brief Performs a marker-based image segmentation using the watershed algorithm.
`static void`	opencv_ximgproc.`weightedMedianFilter(Mat joint, Mat src, Mat dst, int r)`
`static void`	opencv_ximgproc.`weightedMedianFilter(Mat joint, Mat src, Mat dst, int r, double sigma, int weightType, Mat mask)` \brief Applies weighted median filter to an image.
`static void`	opencv_core.`write(FileStorage fs, BytePointer name, Mat value)`
`static void`	opencv_core.`write(FileStorage fs, String name, Mat value)`
`static boolean`	opencv_video.`writeOpticalFlow(BytePointer path, Mat flow)` \brief Write a .flo to disk
`static boolean`	opencv_video.`writeOpticalFlow(String path, Mat flow)`
`static MatExpr`	opencv_core.`xor(Mat a, Mat b)`
`static MatExpr`	opencv_core.`xor(Mat a, Scalar s)`
`static MatExpr`	opencv_core.`xor(Scalar s, Mat a)`
`static Mat`	opencv_core.`xorPut(Mat a, Mat b)`
`static Mat`	opencv_core.`xorPut(Mat a, Scalar b)`

Uses of Mat in org.bytedeco.opencv.opencv_aruco

Methods in org.bytedeco.opencv.opencv_aruco that return Mat
Modifier and Type	Method and Description
`Mat`	Dictionary.`bytesList()`
`static Mat`	Dictionary.`getBitsFromByteList(Mat byteList, int markerSize)` \brief Transform list of bytes to matrix of bits
`static Mat`	Dictionary.`getByteListFromBits(Mat bits)` \brief Transform matrix of bits to list of bytes in the 4 rotations

Methods in org.bytedeco.opencv.opencv_aruco with parameters of type Mat
Modifier and Type	Method and Description
`Dictionary`	Dictionary.`bytesList(Mat setter)`
`static Board`	Board.`create(GpuMatVector objPoints, Dictionary dictionary, Mat ids)`
`static Board`	Board.`create(MatVector objPoints, Dictionary dictionary, Mat ids)` \brief Provide way to create Board by passing necessary data.
`static Board`	Board.`create(UMatVector objPoints, Dictionary dictionary, Mat ids)`
`void`	CharucoBoard.`draw(Size outSize, Mat img)`
`void`	GridBoard.`draw(Size outSize, Mat img)`
`void`	CharucoBoard.`draw(Size outSize, Mat img, int marginSize, int borderBits)` \brief Draw a ChArUco board
`void`	GridBoard.`draw(Size outSize, Mat img, int marginSize, int borderBits)` \brief Draw a GridBoard
`void`	Dictionary.`drawMarker(int id, int sidePixels, Mat _img)`
`void`	Dictionary.`drawMarker(int id, int sidePixels, Mat _img, int borderBits)` \brief Draw a canonical marker image
`static Mat`	Dictionary.`getBitsFromByteList(Mat byteList, int markerSize)` \brief Transform list of bytes to matrix of bits
`static Mat`	Dictionary.`getByteListFromBits(Mat bits)` \brief Transform matrix of bits to list of bytes in the 4 rotations
`int`	Dictionary.`getDistanceToId(Mat bits, int id)`
`int`	Dictionary.`getDistanceToId(Mat bits, int id, boolean allRotations)` \brief Returns the distance of the input bits to the specific id.
`boolean`	Dictionary.`identify(Mat onlyBits, int[] idx, int[] rotation, double maxCorrectionRate)`
`boolean`	Dictionary.`identify(Mat onlyBits, IntBuffer idx, IntBuffer rotation, double maxCorrectionRate)`
`boolean`	Dictionary.`identify(Mat onlyBits, IntPointer idx, IntPointer rotation, double maxCorrectionRate)` \brief Given a matrix of bits.
`void`	Board.`setIds(Mat ids)` \brief Set ids vector

Constructors in org.bytedeco.opencv.opencv_aruco with parameters of type Mat
Constructor and Description
`Dictionary(Mat _bytesList, int _markerSize, int _maxcorr)`

Uses of Mat in org.bytedeco.opencv.opencv_barcode

Methods in org.bytedeco.opencv.opencv_barcode with parameters of type Mat
Modifier and Type	Method and Description
`boolean`	BarcodeDetector.`decode(Mat img, Mat points, StringVector decoded_info, int[] decoded_type)`
`boolean`	BarcodeDetector.`decode(Mat img, Mat points, StringVector decoded_info, IntBuffer decoded_type)`
`boolean`	BarcodeDetector.`decode(Mat img, Mat points, StringVector decoded_info, IntPointer decoded_type)` \brief Decodes barcode in image once it's found by the detect() method.
`boolean`	BarcodeDetector.`detect(Mat img, Mat points)` \brief Detects Barcode in image and returns the rectangle(s) containing the code.
`boolean`	BarcodeDetector.`detectAndDecode(Mat img, StringVector decoded_info, int[] decoded_type)`
`boolean`	BarcodeDetector.`detectAndDecode(Mat img, StringVector decoded_info, int[] decoded_type, Mat points)`
`boolean`	BarcodeDetector.`detectAndDecode(Mat img, StringVector decoded_info, IntBuffer decoded_type)`
`boolean`	BarcodeDetector.`detectAndDecode(Mat img, StringVector decoded_info, IntBuffer decoded_type, Mat points)`
`boolean`	BarcodeDetector.`detectAndDecode(Mat img, StringVector decoded_info, IntPointer decoded_type)`
`boolean`	BarcodeDetector.`detectAndDecode(Mat img, StringVector decoded_info, IntPointer decoded_type, Mat points)` \brief Both detects and decodes barcode

Uses of Mat in org.bytedeco.opencv.opencv_bgsegm

Methods in org.bytedeco.opencv.opencv_bgsegm with parameters of type Mat
Modifier and Type	Method and Description
`void`	BackgroundSubtractorGSOC.`apply(Mat image, Mat fgmask)`
`void`	BackgroundSubtractorLSBP.`apply(Mat image, Mat fgmask)`
`void`	BackgroundSubtractorCNT.`apply(Mat image, Mat fgmask)`
`void`	BackgroundSubtractorGSOC.`apply(Mat image, Mat fgmask, double learningRate)`
`void`	BackgroundSubtractorLSBP.`apply(Mat image, Mat fgmask, double learningRate)`
`void`	BackgroundSubtractorCNT.`apply(Mat image, Mat fgmask, double learningRate)`
`static void`	BackgroundSubtractorLSBPDesc.`calcLocalSVDValues(GpuMat localSVDValues, Mat frame)`
`static void`	BackgroundSubtractorLSBPDesc.`calcLocalSVDValues(Mat localSVDValues, Mat frame)`
`static void`	BackgroundSubtractorLSBPDesc.`calcLocalSVDValues(UMat localSVDValues, Mat frame)`
`static void`	BackgroundSubtractorLSBPDesc.`compute(GpuMat desc, Mat frame, Point LSBPSamplePoints)`
`static void`	BackgroundSubtractorLSBPDesc.`compute(Mat desc, Mat frame, Point LSBPSamplePoints)`
`static void`	BackgroundSubtractorLSBPDesc.`compute(UMat desc, Mat frame, Point LSBPSamplePoints)`
`static void`	BackgroundSubtractorLSBPDesc.`computeFromLocalSVDValues(GpuMat desc, Mat localSVDValues, Point LSBPSamplePoints)`
`static void`	BackgroundSubtractorLSBPDesc.`computeFromLocalSVDValues(Mat desc, Mat localSVDValues, Point LSBPSamplePoints)`
`static void`	BackgroundSubtractorLSBPDesc.`computeFromLocalSVDValues(UMat desc, Mat localSVDValues, Point LSBPSamplePoints)`
`void`	BackgroundSubtractorGSOC.`getBackgroundImage(Mat backgroundImage)`
`void`	BackgroundSubtractorLSBP.`getBackgroundImage(Mat backgroundImage)`
`void`	BackgroundSubtractorCNT.`getBackgroundImage(Mat backgroundImage)`
`void`	SyntheticSequenceGenerator.`getNextFrame(Mat frame, Mat gtMask)` \brief Obtain the next frame in the sequence.

Constructors in org.bytedeco.opencv.opencv_bgsegm with parameters of type Mat
Constructor and Description
`SyntheticSequenceGenerator(Mat background, Mat object, double amplitude, double wavelength, double wavespeed, double objspeed)` \brief Creates an instance of SyntheticSequenceGenerator.

Uses of Mat in org.bytedeco.opencv.opencv_bioinspired

Methods in org.bytedeco.opencv.opencv_bioinspired that return Mat
Modifier and Type	Method and Description
`Mat`	Retina.`getMagnoRAW()` \overload
`Mat`	Retina.`getParvoRAW()` \overload

Methods in org.bytedeco.opencv.opencv_bioinspired with parameters of type Mat
Modifier and Type	Method and Description
`void`	Retina.`applyFastToneMapping(Mat inputImage, Mat outputToneMappedImage)` \brief Method which processes an image in the aim to correct its luminance correct backlight problems, enhance details in shadows.
`void`	RetinaFastToneMapping.`applyFastToneMapping(Mat inputImage, Mat outputToneMappedImage)` \brief applies a luminance correction (initially High Dynamic Range (HDR) tone mapping)
`void`	Retina.`getMagno(Mat retinaOutput_magno)` \brief Accessor of the motion channel of the retina (models peripheral vision).
`void`	Retina.`getMagnoRAW(Mat retinaOutput_magno)` \brief Accessor of the motion channel of the retina (models peripheral vision).
`void`	Retina.`getParvo(Mat retinaOutput_parvo)` \brief Accessor of the details channel of the retina (models foveal vision).
`void`	Retina.`getParvoRAW(Mat retinaOutput_parvo)` \brief Accessor of the details channel of the retina (models foveal vision).
`void`	TransientAreasSegmentationModule.`getSegmentationPicture(Mat transientAreas)` \brief access function return the last segmentation result: a boolean picture which is resampled between 0 and 255 for a display purpose
`void`	Retina.`run(Mat inputImage)` \brief Method which allows retina to be applied on an input image,
`void`	TransientAreasSegmentationModule.`run(Mat inputToSegment)`
`void`	TransientAreasSegmentationModule.`run(Mat inputToSegment, int channelIndex)` \brief main processing method, get result using methods getSegmentationPicture()

Uses of Mat in org.bytedeco.opencv.opencv_calib3d

Methods in org.bytedeco.opencv.opencv_calib3d with parameters of type Mat
Modifier and Type	Method and Description
`boolean`	LMSolver.Callback.`compute(Mat param, Mat err, Mat J)` computes error and Jacobian for the specified vector of parameters
`void`	StereoMatcher.`compute(Mat left, Mat right, Mat disparity)` \brief Computes disparity map for the specified stereo pair
`int`	LMSolver.`run(Mat param)` Runs Levenberg-Marquardt algorithm using the passed vector of parameters as the start point.

Uses of Mat in org.bytedeco.opencv.opencv_core

Fields in org.bytedeco.opencv.opencv_core declared as Mat
Modifier and Type	Field and Description
`static Mat`	AbstractMat.`EMPTY`

Methods in org.bytedeco.opencv.opencv_core that return Mat
Modifier and Type	Method and Description
`Mat`	MatExpr.`a()`
`Mat`	Mat.`adjustROI(int dtop, int dbottom, int dleft, int dright)` \brief Adjusts a submatrix size and position within the parent matrix.
`Mat`	Mat.`allocator(MatAllocator setter)`
`Mat`	Mat.`apply(Range ranges)` \overload
`Mat`	Mat.`apply(Range rowRange, Range colRange)` \brief Extracts a rectangular submatrix.
`Mat`	Mat.`apply(RangeVector ranges)` \overload
`Mat`	Mat.`apply(Rect roi)` \overload
`Mat`	NAryMatIterator.`arrays(int i)` the iterated arrays
`Mat`	MatExpr.`asMat()`
`Mat`	MatExpr.`b()`
`Mat`	PCA.`backProject(GpuMat vec)`
`Mat`	PCA.`backProject(Mat vec)` \brief Reconstructs vectors from their PC projections.
`Mat`	PCA.`backProject(UMat vec)`
`Mat`	MatExpr.`c()`
`Mat`	Mat.`clone()` \brief Creates a full copy of the array and the underlying data.
`Mat`	Mat.`col(int x)` \brief Creates a matrix header for the specified matrix column.
`Mat`	Mat.`colRange(int startcol, int endcol)` \brief Creates a matrix header for the specified column span.
`Mat`	Mat.`colRange(Range r)` \overload
`Mat`	Mat.`cols(int setter)`
`Mat`	HostMem.`createMatHeader()` returns matrix header with disabled reference counting for HostMem data.
`Mat`	Mat.`cross(GpuMat m)`
`Mat`	Mat.`cross(Mat m)` \brief Computes a cross-product of two 3-element vectors.
`Mat`	MatExpr.`cross(Mat m)`
`Mat`	Mat.`cross(UMat m)`
`Mat`	Mat.`data(BytePointer setter)`
`Mat`	Mat.`dataend(BytePointer setter)`
`Mat`	Mat.`datalimit(BytePointer setter)`
`Mat`	Mat.`datastart(BytePointer setter)`
`Mat`	Mat.`diag()`
`Mat`	Mat.`diag(int d)` \brief Extracts a diagonal from a matrix
`static Mat`	Mat.`diag(Mat d)` \brief creates a diagonal matrix
`Mat`	Mat.`dims(int setter)`
`Mat`	LDA.`eigenvalues()` Returns the eigenvalues of this LDA.
`Mat`	PCA.`eigenvalues()` eigenvalues of the covariation matrix
`Mat`	LDA.`eigenvectors()` Returns the eigenvectors of this LDA.
`Mat`	PCA.`eigenvectors()` eigenvectors of the covariation matrix
`Mat`	MatBytePairVector.`first(long i)`
`Mat`	Mat.`flags(int setter)`
`Mat[]`	MatVector.`get()`
`Mat`	MatVector.Iterator.`get()`
`Mat`	MatVector.`get(long i)`
`Mat`	UMat.`getMat(int flags)`
`Mat`	Mat.`getPointer(long i)`
`Mat`	MatConstIterator.`m()`
`Mat`	FileNode.`mat()` Simplified reading API to use with bindings.
`Mat`	PCA.`mean()` mean value subtracted before the projection and added after the back projection
`Mat`	NAryMatIterator.`planes()` the current planes
`Mat`	MatVector.`pop_back()`
`Mat`	Mat.`position(long position)`
`Mat`	LDA.`project(GpuMat src)`
`Mat`	PCA.`project(GpuMat vec)`
`Mat`	LDA.`project(Mat src)` Projects samples into the LDA subspace.
`Mat`	PCA.`project(Mat vec)` \brief Projects vector(s) to the principal component subspace.
`Mat`	LDA.`project(UMat src)`
`Mat`	PCA.`project(UMat vec)`
`Mat`	Mat.`put(Mat m)` \brief assignment operators
`Mat`	Mat.`put(MatExpr expr)` \overload
`Mat`	Mat.`put(Scalar s)` \brief Sets all or some of the array elements to the specified value.
`Mat`	LDA.`reconstruct(GpuMat src)`
`Mat`	LDA.`reconstruct(Mat src)` Reconstructs projections from the LDA subspace.
`Mat`	LDA.`reconstruct(UMat src)`
`Mat`	Mat.`reshape(int cn)`
`Mat`	Mat.`reshape(int cn, int rows)` \brief Changes the shape and/or the number of channels of a 2D matrix without copying the data.
`Mat`	Mat.`reshape(int cn, int[] newshape)`
`Mat`	Mat.`reshape(int cn, IntBuffer newshape)`
`Mat`	Mat.`reshape(int cn, int newndims, int[] newsz)`
`Mat`	Mat.`reshape(int cn, int newndims, IntBuffer newsz)`
`Mat`	Mat.`reshape(int cn, int newndims, IntPointer newsz)` \overload
`Mat`	Mat.`reshape(int cn, IntPointer newshape)` \overload
`Mat`	Mat.`row(int y)` \brief Creates a matrix header for the specified matrix row.
`Mat`	Mat.`rowRange(int startrow, int endrow)` \brief Creates a matrix header for the specified row span.
`Mat`	Mat.`rowRange(Range r)` \overload
`Mat`	Mat.`rows(int setter)`
`Mat`	Mat.`setTo(GpuMat value)`
`Mat`	Mat.`setTo(GpuMat value, GpuMat mask)`
`Mat`	Mat.`setTo(Mat value)`
`Mat`	Mat.`setTo(Mat value, Mat mask)` \brief Sets all or some of the array elements to the specified value.
`Mat`	Mat.`setTo(UMat value)`
`Mat`	Mat.`setTo(UMat value, UMat mask)`
`static Mat`	LDA.`subspaceProject(GpuMat W, GpuMat mean, GpuMat src)`
`static Mat`	LDA.`subspaceProject(Mat W, Mat mean, Mat src)`
`static Mat`	LDA.`subspaceProject(UMat W, UMat mean, UMat src)`
`static Mat`	LDA.`subspaceReconstruct(GpuMat W, GpuMat mean, GpuMat src)`
`static Mat`	LDA.`subspaceReconstruct(Mat W, Mat mean, Mat src)`
`static Mat`	LDA.`subspaceReconstruct(UMat W, UMat mean, UMat src)`
`Mat`	SVD.`u()` \todo document
`Mat`	Mat.`u(UMatData setter)`
`Mat`	SVD.`vt()`
`Mat`	SVD.`w()`

Methods in org.bytedeco.opencv.opencv_core with parameters of type Mat
Modifier and Type	Method and Description
`void`	RNG.`_fill(Mat mat, int distType, Mat a, Mat b)`
`void`	RNG.`_fill(Mat mat, int distType, Mat a, Mat b, boolean saturateRange)` \brief Fills arrays with random numbers.
`MatExpr`	MatExpr.`a(Mat setter)`
`SVD`	SVD.`apply(Mat src)`
`SVD`	SVD.`apply(Mat src, int flags)` \brief the operator that performs SVD.
`PCA`	PCA.`apply(Mat data, Mat mean, int flags)`
`PCA`	PCA.`apply(Mat data, Mat mean, int flags, double retainedVariance)` \overload
`PCA`	PCA.`apply(Mat data, Mat mean, int flags, int maxComponents)` \brief performs %PCA
`NAryMatIterator`	NAryMatIterator.`arrays(int i, Mat setter)`
`void`	MatOp.`assign(MatExpr expr, Mat m)`
`void`	MatOp.`assign(MatExpr expr, Mat m, int type)`
`void`	Mat.`assignTo(Mat m)`
`void`	Mat.`assignTo(Mat m, int type)` \brief Provides a functional form of convertTo.
`void`	MatOp.`augAssignAdd(MatExpr expr, Mat m)`
`void`	MatOp.`augAssignAnd(MatExpr expr, Mat m)`
`void`	MatOp.`augAssignDivide(MatExpr expr, Mat m)`
`void`	MatOp.`augAssignMultiply(MatExpr expr, Mat m)`
`void`	MatOp.`augAssignOr(MatExpr expr, Mat m)`
`void`	MatOp.`augAssignSubtract(MatExpr expr, Mat m)`
`void`	MatOp.`augAssignXor(MatExpr expr, Mat m)`
`MatExpr`	MatExpr.`b(Mat setter)`
`Mat`	PCA.`backProject(Mat vec)` \brief Reconstructs vectors from their PC projections.
`void`	PCA.`backProject(Mat vec, Mat result)` \overload
`void`	SVD.`backSubst(Mat rhs, Mat dst)` \brief performs a singular value back substitution.
`static void`	SVD.`backSubst(Mat w, Mat u, Mat vt, Mat rhs, Mat dst)` \brief performs back substitution
`MatExpr`	MatExpr.`c(Mat setter)`
`void`	LDA.`compute(GpuMatVector src, Mat labels)`
`static void`	SVD.`compute(Mat src, Mat w)`
`static void`	SVD.`compute(Mat src, Mat w, int flags)` \overload computes singular values of a matrix
`static void`	SVD.`compute(Mat src, Mat w, Mat u, Mat vt)`
`static void`	SVD.`compute(Mat src, Mat w, Mat u, Mat vt, int flags)` \brief decomposes matrix and stores the results to user-provided matrices
`void`	LDA.`compute(MatVector src, Mat labels)` Compute the discriminants for data in src (row aligned) and labels.
`void`	LDA.`compute(UMatVector src, Mat labels)`
`static KernelArg`	KernelArg.`Constant(Mat m)`
`void`	GpuMat.`convertTo(Mat dst, int rtype)` converts GpuMat to another datatype (Blocking call)
`void`	SparseMat.`convertTo(Mat m, int rtype)`
`void`	Mat.`convertTo(Mat m, int rtype)`
`void`	UMat.`convertTo(Mat m, int rtype)`
`void`	GpuMat.`convertTo(Mat dst, int rtype, double alpha)`
`void`	GpuMat.`convertTo(Mat dst, int rtype, double alpha, double beta)` converts GpuMat to another datatype with scaling (Blocking call)
`void`	SparseMat.`convertTo(Mat m, int rtype, double alpha, double beta)` converts sparse matrix to dense n-dim matrix with optional type conversion and scaling.
`void`	Mat.`convertTo(Mat m, int rtype, double alpha, double beta)` \brief Converts an array to another data type with optional scaling.
`void`	UMat.`convertTo(Mat m, int rtype, double alpha, double beta)` converts matrix to another datatype with optional scaling.
`void`	GpuMat.`convertTo(Mat dst, int rtype, double alpha, double beta, Stream stream)` converts GpuMat to another datatype with scaling (Non-Blocking call)
`void`	GpuMat.`convertTo(Mat dst, int rtype, double alpha, Stream stream)` converts GpuMat to another datatype with scaling (Non-Blocking call)
`void`	GpuMat.`convertTo(Mat dst, int rtype, Stream stream)` converts GpuMat to another datatype (Non-Blocking call)
`void`	Mat.`copySize(Mat m)` internal use function; properly re-allocates _size, _step arrays
`void`	GpuMat.`copyTo(Mat dst)` copies the GpuMat content to device memory (Blocking call)
`void`	SparseMat.`copyTo(Mat m)` converts sparse matrix to dense matrix.
`void`	Mat.`copyTo(Mat m)` \brief Copies the matrix to another one.
`void`	UMat.`copyTo(Mat m)` copies the matrix content to "m".
`void`	GpuMat.`copyTo(Mat dst, Mat mask)` copies those GpuMat elements to "m" that are marked with non-zero mask elements (Blocking call)
`void`	Mat.`copyTo(Mat m, Mat mask)` \overload
`void`	UMat.`copyTo(Mat m, Mat mask)` copies those matrix elements to "m" that are marked with non-zero mask elements.
`void`	GpuMat.`copyTo(Mat dst, Mat mask, Stream stream)` copies those GpuMat elements to "m" that are marked with non-zero mask elements (Non-Blocking call)
`void`	GpuMat.`copyTo(Mat dst, Stream stream)` copies the GpuMat content to device memory (Non-Blocking call)
`static DownhillSolver`	DownhillSolver.`create(MinProblemSolver.Function f, Mat initStep, TermCriteria termcrit)` \brief This function returns the reference to the ready-to-use DownhillSolver object.
`Mat`	Mat.`cross(Mat m)` \brief Computes a cross-product of two 3-element vectors.
`Mat`	MatExpr.`cross(Mat m)`
`static Mat`	Mat.`diag(Mat d)` \brief creates a diagonal matrix
`double`	Mat.`dot(Mat m)` \brief Computes a dot-product of two vectors.
`double`	UMat.`dot(Mat m)` computes dot-product
`double`	MatExpr.`dot(Mat m)`
`void`	GpuMat.`download(Mat dst)` \brief Performs data download from GpuMat (Blocking call)
`void`	GpuMatND.`download(Mat dst)`
`void`	GpuMat.`download(Mat dst, Stream stream)` \brief Performs data download from GpuMat (Non-Blocking call)
`void`	GpuMatND.`download(Mat dst, Stream stream)`
`PCA`	PCA.`eigenvalues(Mat setter)`
`PCA`	PCA.`eigenvectors(Mat setter)`
`MatBytePairVector`	MatBytePairVector.`first(long i, Mat first)`
`Formatted`	Formatter.`format(Mat mtx)`
`void`	AsyncArray.`get(Mat dst)` Fetch the result.
`boolean`	AsyncArray.`get(Mat dst, double timeoutNs)`
`boolean`	AsyncArray.`get(Mat dst, long timeoutNs)` Retrieving the result with timeout
`void`	DownhillSolver.`getInitStep(Mat step)` \brief Returns the initial step that will be used in downhill simplex algorithm.
`void`	NAryMatIterator.`init(Mat arrays, Mat planes, byte[] ptrs)`
`void`	NAryMatIterator.`init(Mat arrays, Mat planes, byte[] ptrs, int narrays)`
`void`	NAryMatIterator.`init(Mat arrays, Mat planes, ByteBuffer ptrs)`
`void`	NAryMatIterator.`init(Mat arrays, Mat planes, ByteBuffer ptrs, int narrays)`
`void`	NAryMatIterator.`init(Mat arrays, Mat planes, BytePointer ptrs)`
`void`	NAryMatIterator.`init(Mat arrays, Mat planes, BytePointer ptrs, int narrays)`
`void`	NAryMatIterator.`init(PointerPointer arrays, Mat planes, PointerPointer ptrs, int narrays)` the separate iterator initialization method
`MatVector.Iterator`	MatVector.`insert(MatVector.Iterator pos, Mat value)`
`MatConstIterator`	MatConstIterator.`m(Mat setter)`
`PCA`	PCA.`mean(Mat setter)`
`double`	MinProblemSolver.`minimize(Mat x)` \brief actually runs the algorithm and performs the minimization.
`MatExpr`	Mat.`mul(Mat m)`
`UMat`	UMat.`mul(Mat m)`
`MatExpr`	MatExpr.`mul(Mat m)`
`MatExpr`	Mat.`mul(Mat m, double scale)` \brief Performs an element-wise multiplication or division of the two matrices.
`UMat`	UMat.`mul(Mat m, double scale)` per-element matrix multiplication by means of matrix expressions
`MatExpr`	MatExpr.`mul(Mat m, double scale)`
`NAryMatIterator`	NAryMatIterator.`planes(Mat setter)`
`Mat`	LDA.`project(Mat src)` Projects samples into the LDA subspace.
`Mat`	PCA.`project(Mat vec)` \brief Projects vector(s) to the principal component subspace.
`void`	PCA.`project(Mat vec, Mat result)` \overload
`void`	Mat.`push_back(Mat m)` \overload
`MatVector`	MatVector.`push_back(Mat value)`
`MatVector`	MatVector.`put(long i, Mat value)`
`MatVector`	MatVector.`put(Mat... array)`
`SparseMat`	SparseMat.`put(Mat m)` equivalent to the corresponding constructor
`Mat`	Mat.`put(Mat m)` \brief assignment operators
`MatVector`	MatVector.`put(Mat value)`
`MatBytePairVector`	MatBytePairVector.`put(Mat[] firstValue, byte[] secondValue)`
`Mat`	LDA.`reconstruct(Mat src)` Reconstructs projections from the LDA subspace.
`void`	DownhillSolver.`setInitStep(Mat step)` \brief Sets the initial step that will be used in downhill simplex algorithm.
`Mat`	Mat.`setTo(Mat value)`
`UMat`	UMat.`setTo(Mat value)`
`Mat`	Mat.`setTo(Mat value, Mat mask)` \brief Sets all or some of the array elements to the specified value.
`UMat`	UMat.`setTo(Mat value, Mat mask)` sets some of the matrix elements to s, according to the mask
`GpuMat`	GpuMat.`setTo(Scalar s, Mat mask)` sets some of the GpuMat elements to s, according to the mask (Blocking call)
`GpuMat`	GpuMat.`setTo(Scalar s, Mat mask, Stream stream)` sets some of the GpuMat elements to s, according to the mask (Non-Blocking call)
`static void`	SVD.`solveZ(Mat src, Mat dst)` \brief solves an under-determined singular linear system
`static Mat`	LDA.`subspaceProject(Mat W, Mat mean, Mat src)`
`static Mat`	LDA.`subspaceReconstruct(Mat W, Mat mean, Mat src)`
`SVD`	SVD.`u(Mat setter)`
`void`	GpuMat.`upload(Mat arr)` \brief Performs data upload to GpuMat (Blocking call)
`void`	GpuMatND.`upload(Mat src)`
`void`	GpuMat.`upload(Mat arr, Stream stream)` \brief Performs data upload to GpuMat (Non-Blocking call)
`void`	GpuMatND.`upload(Mat src, Stream stream)`
`SVD`	SVD.`vt(Mat setter)`
`SVD`	SVD.`w(Mat setter)`
`void`	FileStorage.`write(BytePointer name, Mat val)` \overload
`void`	FileStorage.`write(String name, Mat val)`

Constructors in org.bytedeco.opencv.opencv_core with parameters of type Mat
Constructor and Description
`GpuMat(Mat arr)`
`GpuMat(Mat arr, GpuMat.Allocator allocator)` builds GpuMat from host memory (Blocking call)
`HostMem(Mat arr)`
`HostMem(Mat arr, int alloc_type)` creates from host memory with coping data
`LDA(GpuMatVector src, Mat labels)`
`LDA(GpuMatVector src, Mat labels, int num_components)`
`LDA(MatVector src, Mat labels)`
`LDA(MatVector src, Mat labels, int num_components)` Initializes and performs a Discriminant Analysis with Fisher's Optimization Criterion on given data in src and corresponding labels in labels.
`LDA(UMatVector src, Mat labels)`
`LDA(UMatVector src, Mat labels, int num_components)`
`Mat(Mat m)` \overload
`Mat(Mat m, Range rowRange)`
`Mat(Mat m, Range rowRange, Range colRange)` \overload
`Mat(Mat m, RangeVector ranges)` \overload
`Mat(Mat m, Rect roi)` \overload
`MatBytePairVector(Mat[] firstValue, byte[] secondValue)`
`MatConstIterator(Mat _m)` constructor that sets the iterator to the beginning of the matrix
`MatConstIterator(Mat _m, int _row)`
`MatConstIterator(Mat _m, int _row, int _col)` constructor that sets the iterator to the specified element of the matrix
`MatConstIterator(Mat _m, Point _pt)` constructor that sets the iterator to the specified element of the matrix
`MatExpr(Mat m)`
`MatExpr(MatOp _op, int _flags, Mat _a, Mat _b, Mat _c, double _alpha, double _beta, Scalar _s)`
`MatVector(Mat... array)`
`MatVector(Mat value)`
`NAryMatIterator(Mat arrays, byte[] ptrs)`
`NAryMatIterator(Mat arrays, byte[] ptrs, int narrays)`
`NAryMatIterator(Mat arrays, ByteBuffer ptrs)`
`NAryMatIterator(Mat arrays, ByteBuffer ptrs, int narrays)`
`NAryMatIterator(Mat arrays, BytePointer ptrs)`
`NAryMatIterator(Mat arrays, BytePointer ptrs, int narrays)`
`NAryMatIterator(Mat arrays, Mat planes)`
`NAryMatIterator(Mat arrays, Mat planes, int narrays)`
`NAryMatIterator(PointerPointer arrays, Mat planes, int narrays)` the full constructor taking arbitrary number of n-dim matrices
`PCA(Mat data, Mat mean, int flags)`
`PCA(Mat data, Mat mean, int flags, double retainedVariance)` \overload
`PCA(Mat data, Mat mean, int flags, int maxComponents)` \overload
`SparseMat(Mat m)` \overload
`SVD(Mat src)`
`SVD(Mat src, int flags)` \overload initializes an empty SVD structure and then calls SVD::operator()

Uses of Mat in org.bytedeco.opencv.opencv_cudaarithm

Methods in org.bytedeco.opencv.opencv_cudaarithm with parameters of type Mat
Modifier and Type	Method and Description
`void`	DFT.`compute(Mat image, Mat result)`
`void`	DFT.`compute(Mat image, Mat result, Stream stream)` \brief Computes an FFT of a given image.
`void`	Convolution.`convolve(Mat image, Mat templ, Mat result)`
`void`	Convolution.`convolve(Mat image, Mat templ, Mat result, boolean ccorr, Stream stream)` \brief Computes a convolution (or cross-correlation) of two images.
`void`	LookUpTable.`transform(Mat src, Mat dst)`
`void`	LookUpTable.`transform(Mat src, Mat dst, Stream stream)` \brief Transforms the source matrix into the destination matrix using the given look-up table: dst(I) = lut(src(I)) .

Uses of Mat in org.bytedeco.opencv.opencv_cudabgsegm

Methods in org.bytedeco.opencv.opencv_cudabgsegm with parameters of type Mat
Modifier and Type	Method and Description
`void`	BackgroundSubtractorMOG2.`apply(Mat image, Mat fgmask, double learningRate, Stream stream)`
`void`	BackgroundSubtractorMOG.`apply(Mat image, Mat fgmask, double learningRate, Stream stream)`
`void`	BackgroundSubtractorMOG2.`getBackgroundImage(Mat backgroundImage, Stream stream)`
`void`	BackgroundSubtractorMOG.`getBackgroundImage(Mat backgroundImage, Stream stream)`

Uses of Mat in org.bytedeco.opencv.opencv_cudacodec

Methods in org.bytedeco.opencv.opencv_cudacodec with parameters of type Mat
Modifier and Type	Method and Description
`void`	VideoWriter.`write(Mat frame)`
`void`	VideoWriter.`write(Mat frame, boolean lastFrame)` \brief Writes the next video frame.

Uses of Mat in org.bytedeco.opencv.opencv_cudafeatures2d

Methods in org.bytedeco.opencv.opencv_cudafeatures2d with parameters of type Mat
Modifier and Type	Method and Description
`void`	Feature2DAsync.`computeAsync(Mat image, Mat keypoints, Mat descriptors)`
`void`	Feature2DAsync.`computeAsync(Mat image, Mat keypoints, Mat descriptors, Stream stream)` \brief Computes the descriptors for a set of keypoints detected in an image.
`void`	Feature2DAsync.`convert(Mat gpu_keypoints, KeyPointVector keypoints)` Converts keypoints array from internal representation to standard vector.
`void`	Feature2DAsync.`detectAndComputeAsync(Mat image, Mat mask, Mat keypoints, Mat descriptors)`
`void`	Feature2DAsync.`detectAndComputeAsync(Mat image, Mat mask, Mat keypoints, Mat descriptors, boolean useProvidedKeypoints, Stream stream)` Detects keypoints and computes the descriptors.
`void`	Feature2DAsync.`detectAsync(Mat image, Mat keypoints)`
`void`	Feature2DAsync.`detectAsync(Mat image, Mat keypoints, Mat mask, Stream stream)` \brief Detects keypoints in an image.
`void`	DescriptorMatcher.`knnMatch(Mat queryDescriptors, DMatchVectorVector matches, int k)`
`void`	DescriptorMatcher.`knnMatch(Mat queryDescriptors, DMatchVectorVector matches, int k, GpuMatVector masks, boolean compactResult)` \overload
`void`	DescriptorMatcher.`knnMatch(Mat queryDescriptors, Mat trainDescriptors, DMatchVectorVector matches, int k)`
`void`	DescriptorMatcher.`knnMatch(Mat queryDescriptors, Mat trainDescriptors, DMatchVectorVector matches, int k, Mat mask, boolean compactResult)` \brief Finds the k best matches for each descriptor from a query set (blocking version).
`void`	DescriptorMatcher.`knnMatchAsync(Mat queryDescriptors, Mat matches, int k)`
`void`	DescriptorMatcher.`knnMatchAsync(Mat queryDescriptors, Mat matches, int k, GpuMatVector masks, Stream stream)` \overload
`void`	DescriptorMatcher.`knnMatchAsync(Mat queryDescriptors, Mat trainDescriptors, Mat matches, int k)`
`void`	DescriptorMatcher.`knnMatchAsync(Mat queryDescriptors, Mat trainDescriptors, Mat matches, int k, Mat mask, Stream stream)` \brief Finds the k best matches for each descriptor from a query set (asynchronous version).
`void`	DescriptorMatcher.`knnMatchConvert(Mat gpu_matches, DMatchVectorVector matches)`
`void`	DescriptorMatcher.`knnMatchConvert(Mat gpu_matches, DMatchVectorVector matches, boolean compactResult)` \brief Converts matches array from internal representation to standard matches vector.
`void`	DescriptorMatcher.`match(Mat queryDescriptors, DMatchVector matches)`
`void`	DescriptorMatcher.`match(Mat queryDescriptors, DMatchVector matches, GpuMatVector masks)` \overload
`void`	DescriptorMatcher.`match(Mat queryDescriptors, Mat trainDescriptors, DMatchVector matches)`
`void`	DescriptorMatcher.`match(Mat queryDescriptors, Mat trainDescriptors, DMatchVector matches, Mat mask)` \brief Finds the best match for each descriptor from a query set (blocking version).
`void`	DescriptorMatcher.`matchAsync(Mat queryDescriptors, Mat matches, GpuMatVector masks, Stream stream)` \overload
`void`	DescriptorMatcher.`matchAsync(Mat queryDescriptors, Mat trainDescriptors, Mat matches, Mat mask, Stream stream)` \brief Finds the best match for each descriptor from a query set (asynchronous version).
`void`	DescriptorMatcher.`matchConvert(Mat gpu_matches, DMatchVector matches)` \brief Converts matches array from internal representation to standard matches vector.
`void`	DescriptorMatcher.`radiusMatch(Mat queryDescriptors, DMatchVectorVector matches, float maxDistance)`
`void`	DescriptorMatcher.`radiusMatch(Mat queryDescriptors, DMatchVectorVector matches, float maxDistance, GpuMatVector masks, boolean compactResult)` \overload
`void`	DescriptorMatcher.`radiusMatch(Mat queryDescriptors, Mat trainDescriptors, DMatchVectorVector matches, float maxDistance)`
`void`	DescriptorMatcher.`radiusMatch(Mat queryDescriptors, Mat trainDescriptors, DMatchVectorVector matches, float maxDistance, Mat mask, boolean compactResult)` \brief For each query descriptor, finds the training descriptors not farther than the specified distance (blocking version).
`void`	DescriptorMatcher.`radiusMatchAsync(Mat queryDescriptors, Mat matches, float maxDistance)`
`void`	DescriptorMatcher.`radiusMatchAsync(Mat queryDescriptors, Mat matches, float maxDistance, GpuMatVector masks, Stream stream)` \overload
`void`	DescriptorMatcher.`radiusMatchAsync(Mat queryDescriptors, Mat trainDescriptors, Mat matches, float maxDistance)`
`void`	DescriptorMatcher.`radiusMatchAsync(Mat queryDescriptors, Mat trainDescriptors, Mat matches, float maxDistance, Mat mask, Stream stream)` \brief For each query descriptor, finds the training descriptors not farther than the specified distance (asynchronous version).
`void`	DescriptorMatcher.`radiusMatchConvert(Mat gpu_matches, DMatchVectorVector matches)`
`void`	DescriptorMatcher.`radiusMatchConvert(Mat gpu_matches, DMatchVectorVector matches, boolean compactResult)` \brief Converts matches array from internal representation to standard matches vector.

Uses of Mat in org.bytedeco.opencv.opencv_cudafilters

Methods in org.bytedeco.opencv.opencv_cudafilters with parameters of type Mat
Modifier and Type	Method and Description
`void`	Filter.`apply(Mat src, Mat dst)`
`void`	Filter.`apply(Mat src, Mat dst, Stream stream)` \brief Applies the specified filter to the image.

Uses of Mat in org.bytedeco.opencv.opencv_cudaimgproc

Methods in org.bytedeco.opencv.opencv_cudaimgproc with parameters of type Mat
Modifier and Type	Method and Description
`void`	CudaCLAHE.`apply(Mat src, Mat dst, Stream stream)` \brief Equalizes the histogram of a grayscale image using Contrast Limited Adaptive Histogram Equalization.
`void`	CornernessCriteria.`compute(Mat src, Mat dst)`
`void`	CornernessCriteria.`compute(Mat src, Mat dst, Stream stream)` \brief Computes the cornerness criteria at each image pixel.
`void`	CannyEdgeDetector.`detect(Mat image, Mat edges)`
`void`	HoughCirclesDetector.`detect(Mat src, Mat circles)`
`void`	CornersDetector.`detect(Mat image, Mat corners)`
`void`	HoughLinesDetector.`detect(Mat src, Mat lines)`
`void`	HoughSegmentDetector.`detect(Mat src, Mat lines)`
`void`	CannyEdgeDetector.`detect(Mat dx, Mat dy, Mat edges)`
`void`	CannyEdgeDetector.`detect(Mat dx, Mat dy, Mat edges, Stream stream)` \overload
`void`	CornersDetector.`detect(Mat image, Mat corners, Mat mask, Stream stream)` \brief Determines strong corners on an image.
`void`	CannyEdgeDetector.`detect(Mat image, Mat edges, Stream stream)` \brief Finds edges in an image using the \cite Canny86 algorithm.
`void`	HoughCirclesDetector.`detect(Mat src, Mat circles, Stream stream)` \brief Finds circles in a grayscale image using the Hough transform.
`void`	HoughLinesDetector.`detect(Mat src, Mat lines, Stream stream)` \brief Finds lines in a binary image using the classical Hough transform.
`void`	HoughSegmentDetector.`detect(Mat src, Mat lines, Stream stream)` \brief Finds line segments in a binary image using the probabilistic Hough transform.
`void`	HoughLinesDetector.`downloadResults(Mat d_lines, Mat h_lines)`
`void`	HoughLinesDetector.`downloadResults(Mat d_lines, Mat h_lines, Mat h_votes, Stream stream)` \brief Downloads results from cuda::HoughLinesDetector::detect to host memory.
`void`	TemplateMatching.`match(Mat image, Mat templ, Mat result)`
`void`	TemplateMatching.`match(Mat image, Mat templ, Mat result, Stream stream)` \brief Computes a proximity map for a raster template and an image where the template is searched for.

Uses of Mat in org.bytedeco.opencv.opencv_cudaobjdetect

Methods in org.bytedeco.opencv.opencv_cudaobjdetect that return Mat
Modifier and Type	Method and Description
`Mat`	HOG.`getDefaultPeopleDetector()` \brief Returns coefficients of the classifier trained for people detection.

Methods in org.bytedeco.opencv.opencv_cudaobjdetect with parameters of type Mat
Modifier and Type	Method and Description
`void`	HOG.`compute(Mat img, Mat descriptors)`
`void`	HOG.`compute(Mat img, Mat descriptors, Stream stream)` \brief Returns block descriptors computed for the whole image.
`void`	CudaCascadeClassifier.`convert(Mat gpu_objects, RectVector objects)` \brief Converts objects array from internal representation to standard vector.
`void`	HOG.`detect(Mat img, PointVector found_locations)`
`void`	HOG.`detect(Mat img, PointVector found_locations, double[] confidences)`
`void`	HOG.`detect(Mat img, PointVector found_locations, DoubleBuffer confidences)`
`void`	HOG.`detect(Mat img, PointVector found_locations, DoublePointer confidences)` \brief Performs object detection without a multi-scale window.
`void`	CudaCascadeClassifier.`detectMultiScale(Mat image, Mat objects)`
`void`	CudaCascadeClassifier.`detectMultiScale(Mat image, Mat objects, Stream stream)` \brief Detects objects of different sizes in the input image.
`void`	HOG.`detectMultiScale(Mat img, RectVector found_locations)`
`void`	HOG.`detectMultiScale(Mat img, RectVector found_locations, double[] confidences)`
`void`	HOG.`detectMultiScale(Mat img, RectVector found_locations, DoubleBuffer confidences)`
`void`	HOG.`detectMultiScale(Mat img, RectVector found_locations, DoublePointer confidences)` \brief Performs object detection with a multi-scale window.
`void`	HOG.`detectMultiScaleWithoutConf(Mat img, RectVector found_locations)` \brief Performs object detection with a multi-scale window.
`void`	HOG.`detectWithoutConf(Mat img, PointVector found_locations)` \brief Performs object detection without a multi-scale window.
`void`	HOG.`setSVMDetector(Mat detector)` \brief Sets coefficients for the linear SVM classifier.

Uses of Mat in org.bytedeco.opencv.opencv_cudaoptflow

Methods in org.bytedeco.opencv.opencv_cudaoptflow with parameters of type Mat
Modifier and Type	Method and Description
`void`	DenseOpticalFlow.`calc(Mat I0, Mat I1, Mat flow)`
`void`	NvidiaHWOpticalFlow.`calc(Mat inputImage, Mat referenceImage, Mat flow)`
`void`	SparseOpticalFlow.`calc(Mat prevImg, Mat nextImg, Mat prevPts, Mat nextPts, Mat status)`
`void`	SparseOpticalFlow.`calc(Mat prevImg, Mat nextImg, Mat prevPts, Mat nextPts, Mat status, Mat err, Stream stream)` \brief Calculates a sparse optical flow.
`void`	DenseOpticalFlow.`calc(Mat I0, Mat I1, Mat flow, Stream stream)` \brief Calculates a dense optical flow.
`void`	NvidiaHWOpticalFlow.`calc(Mat inputImage, Mat referenceImage, Mat flow, Stream stream, Mat hint, Mat cost)` \brief Calculates Optical Flow using NVIDIA Optical Flow SDK.
`void`	NvidiaOpticalFlow_2_0.`convertToFloat(Mat flow, Mat floatFlow)` \brief convertToFloat() helper function converts the hardware-generated flow vectors to floating point representation (1 flow vector for gridSize).
`void`	NvidiaOpticalFlow_1_0.`upSampler(Mat flow, Size imageSize, int gridSize, Mat upsampledFlow)` \brief The NVIDIA optical flow hardware generates flow vectors at granularity gridSize, which can be queried via function getGridSize().

Uses of Mat in org.bytedeco.opencv.opencv_cudastereo

Methods in org.bytedeco.opencv.opencv_cudastereo with parameters of type Mat
Modifier and Type	Method and Description
`void`	DisparityBilateralFilter.`apply(Mat disparity, Mat image, Mat dst)`
`void`	DisparityBilateralFilter.`apply(Mat disparity, Mat image, Mat dst, Stream stream)` \brief Refines a disparity map using joint bilateral filtering.
`void`	StereoSGM.`compute_with_stream(Mat left, Mat right, Mat disparity, Stream stream)` \brief Computes disparity map with specified CUDA Stream
`void`	StereoBeliefPropagation.`compute(Mat data, Mat disparity)`
`void`	StereoSGM.`compute(Mat left, Mat right, Mat disparity)` \brief Computes disparity map for the specified stereo pair
`void`	StereoBeliefPropagation.`compute(Mat left, Mat right, Mat disparity, Stream stream)` \overload
`void`	StereoBM.`compute(Mat left, Mat right, Mat disparity, Stream stream)`
`void`	StereoBeliefPropagation.`compute(Mat data, Mat disparity, Stream stream)` \brief Enables the stereo correspondence operator that finds the disparity for the specified data cost.

Uses of Mat in org.bytedeco.opencv.opencv_dnn

Methods in org.bytedeco.opencv.opencv_dnn that return Mat
Modifier and Type	Method and Description
`Mat`	Net.`forward()`
`Mat`	Net.`forward(BytePointer outputName)` \brief Runs forward pass to compute output of layer with name \p outputName.
`Mat`	Net.`forward(String outputName)`
`Mat[]`	MatPointerVector.`get()`
`Mat`	MatPointerVector.Iterator.`get()`
`Mat`	MatPointerVector.`get(long i)`
`Mat`	Net.`getParam(DictValue layer)`
`Mat`	Net.`getParam(DictValue layer, int numParam)` \brief Returns parameter blob of the layer.
`Mat`	MatPointerVector.`pop_back()`

Methods in org.bytedeco.opencv.opencv_dnn with parameters of type Mat
Modifier and Type	Method and Description
`IntFloatPair`	ClassificationModel.`classify(Mat frame)` \brief Given the \p input frame, create input blob, run net and return top-1 prediction.
`void`	ClassificationModel.`classify(Mat frame, int[] classId, float[] conf)`
`void`	ClassificationModel.`classify(Mat frame, IntBuffer classId, FloatBuffer conf)`
`void`	ClassificationModel.`classify(Mat frame, IntPointer classId, FloatPointer conf)` \overload
`void`	DetectionModel.`detect(Mat frame, int[] classIds, float[] confidences, RectVector boxes)`
`void`	DetectionModel.`detect(Mat frame, int[] classIds, float[] confidences, RectVector boxes, float confThreshold, float nmsThreshold)`
`void`	DetectionModel.`detect(Mat frame, IntBuffer classIds, FloatBuffer confidences, RectVector boxes)`
`void`	DetectionModel.`detect(Mat frame, IntBuffer classIds, FloatBuffer confidences, RectVector boxes, float confThreshold, float nmsThreshold)`
`void`	DetectionModel.`detect(Mat frame, IntPointer classIds, FloatPointer confidences, RectVector boxes)`
`void`	DetectionModel.`detect(Mat frame, IntPointer classIds, FloatPointer confidences, RectVector boxes, float confThreshold, float nmsThreshold)` \brief Given the \p input frame, create input blob, run net and return result detections.
`void`	TextDetectionModel.`detect(Mat frame, PointVectorVector detections)` \overload
`void`	TextDetectionModel.`detect(Mat frame, PointVectorVector detections, float[] confidences)`
`void`	TextDetectionModel.`detect(Mat frame, PointVectorVector detections, FloatBuffer confidences)`
`void`	TextDetectionModel.`detect(Mat frame, PointVectorVector detections, FloatPointer confidences)` \brief Performs detection Given the input \p frame, prepare network input, run network inference, post-process network output and return result detections.
`void`	TextDetectionModel.`detectTextRectangles(Mat frame, RotatedRect detections)` \overload
`void`	TextDetectionModel.`detectTextRectangles(Mat frame, RotatedRect detections, float[] confidences)`
`void`	TextDetectionModel.`detectTextRectangles(Mat frame, RotatedRect detections, FloatBuffer confidences)`
`void`	TextDetectionModel.`detectTextRectangles(Mat frame, RotatedRect detections, FloatPointer confidences)` \brief Performs detection Given the input \p frame, prepare network input, run network inference, post-process network output and return result detections.
`Point2fVector`	KeypointsModel.`estimate(Mat frame)`
`Point2fVector`	KeypointsModel.`estimate(Mat frame, float thresh)` \brief Given the \p input frame, create input blob, run net
`void`	Layer.`getScaleShift(Mat scale, Mat shift)` \brief Returns parameters of layers with channel-wise multiplication and addition.
`MatPointerVector.Iterator`	MatPointerVector.`insert(MatPointerVector.Iterator pos, Mat value)`
`void`	Model.`predict(Mat frame, GpuMatVector outs)`
`void`	Model.`predict(Mat frame, MatVector outs)` \brief Given the \p input frame, create input blob, run net and return the output \p blobs.
`void`	Model.`predict(Mat frame, UMatVector outs)`
`MatPointerVector`	MatPointerVector.`push_back(Mat value)`
`MatPointerVector`	MatPointerVector.`put(long i, Mat value)`
`MatPointerVector`	MatPointerVector.`put(Mat... array)`
`MatPointerVector`	MatPointerVector.`put(Mat value)`
`BytePointer`	TextRecognitionModel.`recognize(Mat frame)` \brief Given the \p input frame, create input blob, run net and return recognition result
`void`	TextRecognitionModel.`recognize(Mat frame, GpuMatVector roiRects, StringVector results)`
`void`	TextRecognitionModel.`recognize(Mat frame, MatVector roiRects, StringVector results)` \brief Given the \p input frame, create input blob, run net and return recognition result
`void`	TextRecognitionModel.`recognize(Mat frame, UMatVector roiRects, StringVector results)`
`void`	SegmentationModel.`segment(Mat frame, Mat mask)` \brief Given the \p input frame, create input blob, run net
`void`	Net.`setInput(Mat blob)`
`void`	Net.`setInput(Mat blob, BytePointer name, double scalefactor, Scalar mean)` \brief Sets the new input value for the network
`void`	Net.`setInput(Mat blob, String name, double scalefactor, Scalar mean)`
`void`	Net.`setParam(DictValue layer, int numParam, Mat blob)` \brief Sets the new value for the learned param of the layer.
`void`	LSTMLayer.`setWeights(Mat Wh, Mat Wx, Mat b)` Deprecated. Use LayerParams::blobs instead. \brief Set trained weights for LSTM layer. LSTM behavior on each step is defined by current input, previous output, previous cell state and learned weights. Let `x_t` be current input, `h_t` be current output, `c_t` be current state. Than current output and current cell state is computed as follows: `\begin{eqnarray} h_t &= o_t \odot tanh(c_t), \\ c_t &= f_t \odot c_{t-1} + i_t \odot g_t, \\ \end{eqnarray}` where `\odot` is per-element multiply operation and `i_t, f_t, o_t, g_t` is internal gates that are computed using learned weights. Gates are computed as follows: `\begin{eqnarray} i_t &= sigmoid&(W_{xi} x_t + W_{hi} h_{t-1} + b_i), \\ f_t &= sigmoid&(W_{xf} x_t + W_{hf} h_{t-1} + b_f), \\ o_t &= sigmoid&(W_{xo} x_t + W_{ho} h_{t-1} + b_o), \\ g_t &= tanh &(W_{xg} x_t + W_{hg} h_{t-1} + b_g), \\ \end{eqnarray}` where `W_{x?}`, `W_{h?}` and `b_{?}` are learned weights represented as matrices: `W_{x?} \in R^{N_h \times N_x}`, `W_{h?} \in R^{N_h \times N_h}`, `b_? \in R^{N_h}`. For simplicity and performance purposes we use `W_x = [W_{xi}; W_{xf}; W_{xo}, W_{xg}]` (i.e. `W_x` is vertical concatenation of `W_{x?}` ), `W_x \in R^{4N_h \times N_x}` . The same for `W_h = [W_{hi}; W_{hf}; W_{ho}, W_{hg}], W_h \in R^{4N_h \times N_h}` and for `b = [b_i; b_f, b_o, b_g]`, `b \in R^{4N_h}` .
`void`	RNNLayer.`setWeights(Mat Wxh, Mat bh, Mat Whh, Mat Who, Mat bo)` Setups learned weights.

Constructors in org.bytedeco.opencv.opencv_dnn with parameters of type Mat
Constructor and Description
`MatPointerVector(Mat... array)`
`MatPointerVector(Mat value)`

Uses of Mat in org.bytedeco.opencv.opencv_dnn_superres

Methods in org.bytedeco.opencv.opencv_dnn_superres with parameters of type Mat
Modifier and Type	Method and Description
`void`	DnnSuperResImpl.`upsample(Mat img, Mat result)` \brief Upsample via neural network
`void`	DnnSuperResImpl.`upsampleMultioutput(Mat img, MatVector imgs_new, int[] scale_factors, StringVector node_names)`
`void`	DnnSuperResImpl.`upsampleMultioutput(Mat img, MatVector imgs_new, IntBuffer scale_factors, StringVector node_names)`
`void`	DnnSuperResImpl.`upsampleMultioutput(Mat img, MatVector imgs_new, IntPointer scale_factors, StringVector node_names)` \brief Upsample via neural network of multiple outputs

Uses of Mat in org.bytedeco.opencv.opencv_face

Methods in org.bytedeco.opencv.opencv_face that return Mat
Modifier and Type	Method and Description
`Mat`	FacemarkAAM.Model.Texture.`A()` gray values from all face region in the dataset, projected in PCA space
`Mat`	FacemarkAAM.Model.Texture.`A0()` average of gray values from all face region in the dataset
`Mat`	FacemarkAAM.Model.Texture.`AA()` gray values from all erorded face region in the dataset, projected in PCA space
`Mat`	FacemarkAAM.Model.Texture.`AA0()` average of gray values from all erorded face region in the dataset
`Mat`	BasicFaceRecognizer.`getEigenValues()`
`Mat`	BasicFaceRecognizer.`getEigenVectors()`
`Mat`	LBPHFaceRecognizer.`getLabels()`
`Mat`	BasicFaceRecognizer.`getLabels()`
`Mat`	BasicFaceRecognizer.`getMean()`
`Mat`	FacemarkLBF.BBox.`project(Mat shape)`
`Mat`	FacemarkAAM.Model.`Q()`
`Mat`	FacemarkAAM.Config.`R()`
`Mat`	FacemarkLBF.BBox.`reproject(Mat shape)`
`Mat`	FacemarkAAM.Model.`S()` the encoded shapes from training data

Methods in org.bytedeco.opencv.opencv_face with parameters of type Mat
Modifier and Type	Method and Description
`FacemarkAAM.Model.Texture`	FacemarkAAM.Model.Texture.`A(Mat setter)`
`FacemarkAAM.Model.Texture`	FacemarkAAM.Model.Texture.`A0(Mat setter)`
`FacemarkAAM.Model.Texture`	FacemarkAAM.Model.Texture.`AA(Mat setter)`
`FacemarkAAM.Model.Texture`	FacemarkAAM.Model.Texture.`AA0(Mat setter)`
`boolean`	FacemarkTrain.`addTrainingSample(Mat image, Point2fVector landmarks)` \brief Add one training sample to the trainer.
`boolean`	Facemark.`fit(Mat image, RectVector faces, Point2fVectorVector landmarks)` \brief Detect facial landmarks from an image.
`boolean`	FacemarkAAM.`fitConfig(Mat image, RectVector roi, Point2fVectorVector _landmarks, FacemarkAAM.Config runtime_params)` overload with additional Config structures
`boolean`	FacemarkTrain.`getFaces(Mat image, RectVector faces)` \brief Detect faces from a given image using default or user defined face detector.
`boolean`	FacemarkKazemi.`getFaces(Mat image, RectVector faces)` get faces using the custom detector
`void`	FaceRecognizer.`predict_collect(Mat src, PredictCollector collector)` \brief - if implemented - send all result of prediction to collector that can be used for somehow custom result handling
`int`	FaceRecognizer.`predict_label(Mat src)` \overload
`void`	FaceRecognizer.`predict(Mat src, int[] label, double[] confidence)`
`void`	FaceRecognizer.`predict(Mat src, IntBuffer label, DoubleBuffer confidence)`
`void`	FaceRecognizer.`predict(Mat src, IntPointer label, DoublePointer confidence)` \brief Predicts a label and associated confidence (e.g.
`Mat`	FacemarkLBF.BBox.`project(Mat shape)`
`FacemarkAAM.Model`	FacemarkAAM.Model.`Q(Mat setter)`
`FacemarkAAM.Config`	FacemarkAAM.Config.`R(Mat setter)`
`Mat`	FacemarkLBF.BBox.`reproject(Mat shape)`
`FacemarkAAM.Model`	FacemarkAAM.Model.`S(Mat setter)`
`void`	FaceRecognizer.`train(GpuMatVector src, Mat labels)`
`void`	FaceRecognizer.`train(MatVector src, Mat labels)` \brief Trains a FaceRecognizer with given data and associated labels.
`void`	FaceRecognizer.`train(UMatVector src, Mat labels)`
`void`	FaceRecognizer.`update(GpuMatVector src, Mat labels)`
`void`	FaceRecognizer.`update(MatVector src, Mat labels)` \brief Updates a FaceRecognizer with given data and associated labels.
`void`	FaceRecognizer.`update(UMatVector src, Mat labels)`

Constructors in org.bytedeco.opencv.opencv_face with parameters of type Mat
Constructor and Description
`Config(Mat rot, Point2f trans, float scaling, int scale_id)`

Uses of Mat in org.bytedeco.opencv.opencv_features2d

Methods in org.bytedeco.opencv.opencv_features2d that return Mat
Modifier and Type	Method and Description
`Mat`	BOWKMeansTrainer.`cluster()`
`Mat`	BOWTrainer.`cluster()` \overload
`Mat`	BOWKMeansTrainer.`cluster(Mat descriptors)`
`Mat`	BOWTrainer.`cluster(Mat descriptors)` \brief Clusters train descriptors.
`Mat`	BOWImgDescriptorExtractor.`getVocabulary()` \brief Returns the set vocabulary.

Methods in org.bytedeco.opencv.opencv_features2d with parameters of type Mat
Modifier and Type	Method and Description
`void`	BOWTrainer.`add(Mat descriptors)` \brief Adds descriptors to a training set.
`Mat`	BOWKMeansTrainer.`cluster(Mat descriptors)`
`Mat`	BOWTrainer.`cluster(Mat descriptors)` \brief Clusters train descriptors.
`void`	BOWImgDescriptorExtractor.`compute(GpuMat image, KeyPointVector keypoints, GpuMat imgDescriptor, IntVectorVector pointIdxsOfClusters, Mat descriptors)`
`void`	Feature2D.`compute(Mat image, KeyPointVector keypoints, Mat descriptors)` \brief Computes the descriptors for a set of keypoints detected in an image (first variant) or image set (second variant).
`void`	BOWImgDescriptorExtractor.`compute(Mat image, KeyPointVector keypoints, Mat imgDescriptor)`
`void`	BOWImgDescriptorExtractor.`compute(Mat image, KeyPointVector keypoints, Mat imgDescriptor, IntVectorVector pointIdxsOfClusters, Mat descriptors)` \brief Computes an image descriptor using the set visual vocabulary.
`void`	BOWImgDescriptorExtractor.`compute(Mat keypointDescriptors, Mat imgDescriptor)`
`void`	BOWImgDescriptorExtractor.`compute(Mat keypointDescriptors, Mat imgDescriptor, IntVectorVector pointIdxsOfClusters)` \overload
`void`	BOWImgDescriptorExtractor.`compute(UMat image, KeyPointVector keypoints, UMat imgDescriptor, IntVectorVector pointIdxsOfClusters, Mat descriptors)`
`void`	Feature2D.`detect(Mat image, KeyPointVector keypoints)`
`void`	Feature2D.`detect(Mat image, KeyPointVector keypoints, Mat mask)` \brief Detects keypoints in an image (first variant) or image set (second variant).
`void`	Feature2D.`detectAndCompute(Mat image, Mat mask, KeyPointVector keypoints, Mat descriptors)`
`void`	Feature2D.`detectAndCompute(Mat image, Mat mask, KeyPointVector keypoints, Mat descriptors, boolean useProvidedKeypoints)` Detects keypoints and computes the descriptors
`void`	MSER.`detectRegions(Mat image, PointVectorVector msers, RectVector bboxes)` \brief Detect %MSER regions
`void`	DescriptorMatcher.`knnMatch(Mat queryDescriptors, DMatchVectorVector matches, int k)`
`void`	DescriptorMatcher.`knnMatch(Mat queryDescriptors, DMatchVectorVector matches, int k, GpuMatVector masks, boolean compactResult)`
`void`	DescriptorMatcher.`knnMatch(Mat queryDescriptors, DMatchVectorVector matches, int k, MatVector masks, boolean compactResult)` \overload
`void`	DescriptorMatcher.`knnMatch(Mat queryDescriptors, DMatchVectorVector matches, int k, UMatVector masks, boolean compactResult)`
`void`	DescriptorMatcher.`knnMatch(Mat queryDescriptors, Mat trainDescriptors, DMatchVectorVector matches, int k)`
`void`	DescriptorMatcher.`knnMatch(Mat queryDescriptors, Mat trainDescriptors, DMatchVectorVector matches, int k, Mat mask, boolean compactResult)` \brief Finds the k best matches for each descriptor from a query set.
`void`	DescriptorMatcher.`match(Mat queryDescriptors, DMatchVector matches)`
`void`	DescriptorMatcher.`match(Mat queryDescriptors, DMatchVector matches, GpuMatVector masks)`
`void`	DescriptorMatcher.`match(Mat queryDescriptors, DMatchVector matches, MatVector masks)` \overload
`void`	DescriptorMatcher.`match(Mat queryDescriptors, DMatchVector matches, UMatVector masks)`
`void`	DescriptorMatcher.`match(Mat queryDescriptors, Mat trainDescriptors, DMatchVector matches)`
`void`	DescriptorMatcher.`match(Mat queryDescriptors, Mat trainDescriptors, DMatchVector matches, Mat mask)` \brief Finds the best match for each descriptor from a query set.
`void`	DescriptorMatcher.`radiusMatch(Mat queryDescriptors, DMatchVectorVector matches, float maxDistance)`
`void`	DescriptorMatcher.`radiusMatch(Mat queryDescriptors, DMatchVectorVector matches, float maxDistance, GpuMatVector masks, boolean compactResult)`
`void`	DescriptorMatcher.`radiusMatch(Mat queryDescriptors, DMatchVectorVector matches, float maxDistance, MatVector masks, boolean compactResult)` \overload
`void`	DescriptorMatcher.`radiusMatch(Mat queryDescriptors, DMatchVectorVector matches, float maxDistance, UMatVector masks, boolean compactResult)`
`void`	DescriptorMatcher.`radiusMatch(Mat queryDescriptors, Mat trainDescriptors, DMatchVectorVector matches, float maxDistance)`
`void`	DescriptorMatcher.`radiusMatch(Mat queryDescriptors, Mat trainDescriptors, DMatchVectorVector matches, float maxDistance, Mat mask, boolean compactResult)` \brief For each query descriptor, finds the training descriptors not farther than the specified distance.
`static void`	KeyPointsFilter.`runByPixelsMask(KeyPointVector keypoints, Mat mask)`
`void`	BOWImgDescriptorExtractor.`setVocabulary(Mat vocabulary)` \brief Sets a visual vocabulary.

Uses of Mat in org.bytedeco.opencv.opencv_flann

Methods in org.bytedeco.opencv.opencv_flann with parameters of type Mat
Modifier and Type	Method and Description
`void`	Index.`build(Mat features, IndexParams params)`
`void`	Index.`build(Mat features, IndexParams params, int distType)`
`void`	Index.`knnSearch(Mat query, Mat indices, Mat dists, int knn)`
`void`	Index.`knnSearch(Mat query, Mat indices, Mat dists, int knn, SearchParams params)`
`boolean`	Index.`load(Mat features, BytePointer filename)`
`boolean`	Index.`load(Mat features, String filename)`
`int`	Index.`radiusSearch(Mat query, Mat indices, Mat dists, double radius, int maxResults)`
`int`	Index.`radiusSearch(Mat query, Mat indices, Mat dists, double radius, int maxResults, SearchParams params)`

Constructors in org.bytedeco.opencv.opencv_flann with parameters of type Mat
Constructor and Description
`Index(Mat features, IndexParams params)`
`Index(Mat features, IndexParams params, int distType)`

Uses of Mat in org.bytedeco.opencv.opencv_img_hash

Methods in org.bytedeco.opencv.opencv_img_hash that return Mat
Modifier and Type	Method and Description
`Mat`	RadialVarianceHash.`getHash()`
`Mat`	RadialVarianceHash.`getPixPerLine(Mat input)`
`Mat`	RadialVarianceHash.`getProjection()`

Methods in org.bytedeco.opencv.opencv_img_hash with parameters of type Mat
Modifier and Type	Method and Description
`double`	ImgHashBase.`compare(Mat hashOne, Mat hashTwo)` \brief Compare the hash value between inOne and inTwo
`void`	ImgHashBase.`compute(Mat inputArr, Mat outputArr)` \brief Computes hash of the input image
`Mat`	RadialVarianceHash.`getPixPerLine(Mat input)`

Uses of Mat in org.bytedeco.opencv.opencv_imgproc

Methods in org.bytedeco.opencv.opencv_imgproc with parameters of type Mat
Modifier and Type	Method and Description
`void`	CLAHE.`apply(Mat src, Mat dst)` \brief Equalizes the histogram of a grayscale image using Contrast Limited Adaptive Histogram Equalization.
`int`	LineSegmentDetector.`compareSegments(Size size, Mat lines1, Mat lines2)`
`int`	LineSegmentDetector.`compareSegments(Size size, Mat lines1, Mat lines2, Mat image)` \brief Draws two groups of lines in blue and red, counting the non overlapping (mismatching) pixels.
`void`	GeneralizedHough.`detect(Mat image, Mat positions)`
`void`	LineSegmentDetector.`detect(Mat image, Mat lines)`
`void`	GeneralizedHough.`detect(Mat image, Mat positions, Mat votes)` find template on image
`void`	GeneralizedHough.`detect(Mat edges, Mat dx, Mat dy, Mat positions)`
`void`	GeneralizedHough.`detect(Mat edges, Mat dx, Mat dy, Mat positions, Mat votes)`
`void`	LineSegmentDetector.`detect(Mat image, Mat lines, Mat width, Mat prec, Mat nfa)` \brief Finds lines in the input image.
`void`	LineSegmentDetector.`drawSegments(Mat image, Mat lines)` \brief Draws the line segments on a given image.
`void`	LineIterator.`init(Mat img, Rect boundingAreaRect, Point pt1, Point pt2, int connectivity, boolean leftToRight)`
`void`	GeneralizedHough.`setTemplate(Mat templ)`
`void`	GeneralizedHough.`setTemplate(Mat edges, Mat dx, Mat dy)`
`void`	GeneralizedHough.`setTemplate(Mat edges, Mat dx, Mat dy, Point templCenter)`
`void`	GeneralizedHough.`setTemplate(Mat templ, Point templCenter)` set template to search

Constructors in org.bytedeco.opencv.opencv_imgproc with parameters of type Mat
Constructor and Description
`LineIterator(Mat img, Point pt1, Point pt2)`
`LineIterator(Mat img, Point pt1, Point pt2, int connectivity, boolean leftToRight)` \brief initializes the iterator

Uses of Mat in org.bytedeco.opencv.opencv_mcc

Methods in org.bytedeco.opencv.opencv_mcc that return Mat
Modifier and Type	Method and Description
`Mat`	CChecker.`getChartsRGB()`
`Mat`	CChecker.`getChartsYCbCr()`

Methods in org.bytedeco.opencv.opencv_mcc with parameters of type Mat
Modifier and Type	Method and Description
`void`	CCheckerDraw.`draw(Mat img)` \brief Draws the checker to the given image.
`boolean`	CCheckerDetector.`process(Mat image, int chartType)`
`boolean`	CCheckerDetector.`process(Mat image, int chartType, int nc, boolean useNet, DetectorParameters params)` \brief Find the ColorCharts in the given image.
`boolean`	CCheckerDetector.`processWithROI(Mat image, int chartType, RectVector regionsOfInterest)`
`boolean`	CCheckerDetector.`processWithROI(Mat image, int chartType, RectVector regionsOfInterest, int nc, boolean useNet, DetectorParameters params)` \brief Find the ColorCharts in the given image.
`void`	CChecker.`setChartsRGB(Mat _chartsRGB)`
`void`	CChecker.`setChartsYCbCr(Mat _chartsYCbCr)`

Uses of Mat in org.bytedeco.opencv.opencv_ml

Methods in org.bytedeco.opencv.opencv_ml that return Mat
Modifier and Type	Method and Description
`Mat`	LogisticRegression.`get_learnt_thetas()` \brief This function returns the trained parameters arranged across rows.
`Mat`	TrainData.`getCatMap()`
`Mat`	TrainData.`getCatOfs()`
`Mat`	TrainData.`getClassLabels()` \brief Returns the vector of class labels
`Mat`	SVM.`getClassWeights()`
`Mat`	TrainData.`getDefaultSubstValues()`
`Mat`	ANN_MLP.`getLayerSizes()` Integer vector specifying the number of neurons in each layer including the input and output layers.
`Mat`	EM.`getMeans()` \brief Returns the cluster centers (means of the Gaussian mixture)
`Mat`	TrainData.`getMissing()`
`Mat`	TrainData.`getNormCatResponses()`
`Mat`	DTrees.`getPriors()`
`Mat`	TrainData.`getResponses()`
`Mat`	TrainData.`getSamples()`
`Mat`	TrainData.`getSampleWeights()`
`static Mat`	TrainData.`getSubMatrix(Mat matrix, Mat idx, int layout)` \brief Extract from matrix rows/cols specified by passed indexes.
`static Mat`	TrainData.`getSubVector(Mat vec, Mat idx)` \brief Extract from 1D vector elements specified by passed indexes.
`Mat`	SVM.`getSupportVectors()` \brief Retrieves all the support vectors
`Mat`	TrainData.`getTestNormCatResponses()`
`Mat`	TrainData.`getTestResponses()`
`Mat`	TrainData.`getTestSampleIdx()`
`Mat`	TrainData.`getTestSamples()` \brief Returns matrix of test samples
`Mat`	TrainData.`getTestSampleWeights()`
`Mat`	TrainData.`getTrainNormCatResponses()` \brief Returns the vector of normalized categorical responses
`Mat`	TrainData.`getTrainResponses()` \brief Returns the vector of responses
`Mat`	TrainData.`getTrainSampleIdx()`
`Mat`	TrainData.`getTrainSamples()`
`Mat`	TrainData.`getTrainSamples(int layout, boolean compressSamples, boolean compressVars)` \brief Returns matrix of train samples
`Mat`	TrainData.`getTrainSampleWeights()`
`Mat`	SVM.`getUncompressedSupportVectors()` \brief Retrieves all the uncompressed support vectors of a linear %SVM
`Mat`	TrainData.`getVarIdx()`
`Mat`	RTrees.`getVarImportance()` Returns the variable importance array.
`Mat`	TrainData.`getVarSymbolFlags()`
`Mat`	TrainData.`getVarType()`
`Mat`	SVMSGD.`getWeights()`
`Mat`	EM.`getWeights()` \brief Returns weights of the mixtures
`Mat`	ANN_MLP.`getWeights(int layerIdx)`

Methods in org.bytedeco.opencv.opencv_ml with parameters of type Mat
Modifier and Type	Method and Description
`float`	StatModel.`calcError(TrainData data, boolean test, Mat resp)` \brief Computes error on the training or test dataset
`static TrainData`	TrainData.`create(Mat samples, int layout, Mat responses)`
`static TrainData`	TrainData.`create(Mat samples, int layout, Mat responses, Mat varIdx, Mat sampleIdx, Mat sampleWeights, Mat varType)` \brief Creates training data from in-memory arrays.
`float`	KNearest.`findNearest(Mat samples, int k, Mat results)`
`float`	KNearest.`findNearest(Mat samples, int k, Mat results, Mat neighborResponses, Mat dist)` \brief Finds the neighbors and predicts responses for input vectors.
`double`	SVM.`getDecisionFunction(int i, Mat alpha, Mat svidx)` \brief Retrieves the decision function
`void`	TrainData.`getNormCatValues(int vi, Mat sidx, int[] values)`
`void`	TrainData.`getNormCatValues(int vi, Mat sidx, IntBuffer values)`
`void`	TrainData.`getNormCatValues(int vi, Mat sidx, IntPointer values)`
`void`	TrainData.`getSample(Mat varIdx, int sidx, float[] buf)`
`void`	TrainData.`getSample(Mat varIdx, int sidx, FloatBuffer buf)`
`void`	TrainData.`getSample(Mat varIdx, int sidx, FloatPointer buf)`
`static Mat`	TrainData.`getSubMatrix(Mat matrix, Mat idx, int layout)` \brief Extract from matrix rows/cols specified by passed indexes.
`static Mat`	TrainData.`getSubVector(Mat vec, Mat idx)` \brief Extract from 1D vector elements specified by passed indexes.
`void`	TrainData.`getValues(int vi, Mat sidx, float[] values)`
`void`	TrainData.`getValues(int vi, Mat sidx, FloatBuffer values)`
`void`	TrainData.`getValues(int vi, Mat sidx, FloatPointer values)`
`void`	RTrees.`getVotes(Mat samples, Mat results, int flags)` Returns the result of each individual tree in the forest.
`float`	StatModel.`predict(Mat samples)`
`float`	LogisticRegression.`predict(Mat samples)`
`float`	EM.`predict(Mat samples)`
`float`	StatModel.`predict(Mat samples, Mat results, int flags)` \brief Predicts response(s) for the provided sample(s)
`float`	LogisticRegression.`predict(Mat samples, Mat results, int flags)` \brief Predicts responses for input samples and returns a float type.
`float`	EM.`predict(Mat samples, Mat results, int flags)` \brief Returns posterior probabilities for the provided samples
`Point2d`	EM.`predict2(Mat sample, Mat probs)` \brief Returns a likelihood logarithm value and an index of the most probable mixture component for the given sample.
`float`	NormalBayesClassifier.`predictProb(Mat inputs, Mat outputs, Mat outputProbs)`
`float`	NormalBayesClassifier.`predictProb(Mat inputs, Mat outputs, Mat outputProbs, int flags)` \brief Predicts the response for sample(s).
`void`	SVM.`setClassWeights(Mat val)` \copybrief getClassWeights @see getClassWeights
`void`	ANN_MLP.`setLayerSizes(Mat _layer_sizes)` Integer vector specifying the number of neurons in each layer including the input and output layers.
`void`	DTrees.`setPriors(Mat val)` \copybrief getPriors @see getPriors
`boolean`	StatModel.`train(Mat samples, int layout, Mat responses)` \brief Trains the statistical model
`boolean`	SVM.`trainAuto(Mat samples, int layout, Mat responses)`
`boolean`	SVM.`trainAuto(Mat samples, int layout, Mat responses, int kFold, ParamGrid Cgrid, ParamGrid gammaGrid, ParamGrid pGrid, ParamGrid nuGrid, ParamGrid coeffGrid, ParamGrid degreeGrid, boolean balanced)` \brief Trains an %SVM with optimal parameters
`boolean`	EM.`trainE(Mat samples, Mat means0)`
`boolean`	EM.`trainE(Mat samples, Mat means0, Mat covs0, Mat weights0, Mat logLikelihoods, Mat labels, Mat probs)` \brief Estimate the Gaussian mixture parameters from a samples set.
`boolean`	EM.`trainEM(Mat samples)`
`boolean`	EM.`trainEM(Mat samples, Mat logLikelihoods, Mat labels, Mat probs)` \brief Estimate the Gaussian mixture parameters from a samples set.
`boolean`	EM.`trainM(Mat samples, Mat probs0)`
`boolean`	EM.`trainM(Mat samples, Mat probs0, Mat logLikelihoods, Mat labels, Mat probs)` \brief Estimate the Gaussian mixture parameters from a samples set.

Uses of Mat in org.bytedeco.opencv.opencv_objdetect

Methods in org.bytedeco.opencv.opencv_objdetect that return Mat
Modifier and Type	Method and Description
`Mat`	BaseCascadeClassifier.MaskGenerator.`generateMask(Mat src)`

Methods in org.bytedeco.opencv.opencv_objdetect with parameters of type Mat
Modifier and Type	Method and Description
`void`	HOGDescriptor.`compute(Mat img, float[] descriptors)`
`void`	HOGDescriptor.`compute(Mat img, float[] descriptors, Size winStride, Size padding, PointVector locations)`
`void`	HOGDescriptor.`compute(Mat img, FloatBuffer descriptors)`
`void`	HOGDescriptor.`compute(Mat img, FloatBuffer descriptors, Size winStride, Size padding, PointVector locations)`
`void`	HOGDescriptor.`compute(Mat img, FloatPointer descriptors)`
`void`	HOGDescriptor.`compute(Mat img, FloatPointer descriptors, Size winStride, Size padding, PointVector locations)` \brief Computes HOG descriptors of given image.
`void`	HOGDescriptor.`computeGradient(Mat img, Mat grad, Mat angleOfs)`
`void`	HOGDescriptor.`computeGradient(Mat img, Mat grad, Mat angleOfs, Size paddingTL, Size paddingBR)` \brief Computes gradients and quantized gradient orientations.
`BytePointer`	QRCodeDetector.`decode(Mat img, Mat points)`
`BytePointer`	QRCodeDetector.`decode(Mat img, Mat points, Mat straight_qrcode)` \brief Decodes QR code in image once it's found by the detect() method.
`BytePointer`	QRCodeDetector.`decodeCurved(Mat img, Mat points)`
`BytePointer`	QRCodeDetector.`decodeCurved(Mat img, Mat points, Mat straight_qrcode)` \brief Decodes QR code on a curved surface in image once it's found by the detect() method.
`boolean`	QRCodeDetector.`decodeMulti(Mat img, Mat points, StringVector decoded_info)`
`boolean`	QRCodeDetector.`decodeMulti(Mat img, Mat points, StringVector decoded_info, GpuMatVector straight_qrcode)`
`boolean`	QRCodeDetector.`decodeMulti(Mat img, Mat points, StringVector decoded_info, MatVector straight_qrcode)` \brief Decodes QR codes in image once it's found by the detect() method.
`boolean`	QRCodeDetector.`decodeMulti(Mat img, Mat points, StringVector decoded_info, UMatVector straight_qrcode)`
`boolean`	QRCodeDetector.`detect(Mat img, Mat points)` \brief Detects QR code in image and returns the quadrangle containing the code.
`void`	HOGDescriptor.`detect(Mat img, PointVector foundLocations)`
`void`	HOGDescriptor.`detect(Mat img, PointVector foundLocations, double[] weights)`
`void`	HOGDescriptor.`detect(Mat img, PointVector foundLocations, double[] weights, double hitThreshold, Size winStride, Size padding, PointVector searchLocations)`
`void`	HOGDescriptor.`detect(Mat img, PointVector foundLocations, DoubleBuffer weights)`
`void`	HOGDescriptor.`detect(Mat img, PointVector foundLocations, DoubleBuffer weights, double hitThreshold, Size winStride, Size padding, PointVector searchLocations)`
`void`	HOGDescriptor.`detect(Mat img, PointVector foundLocations, DoublePointer weights)`
`void`	HOGDescriptor.`detect(Mat img, PointVector foundLocations, DoublePointer weights, double hitThreshold, Size winStride, Size padding, PointVector searchLocations)` \brief Performs object detection without a multi-scale window.
`void`	HOGDescriptor.`detect(Mat img, PointVector foundLocations, double hitThreshold, Size winStride, Size padding, PointVector searchLocations)` \brief Performs object detection without a multi-scale window.
`void`	DetectionBasedTracker.IDetector.`detect(Mat image, RectVector objects)`
`BytePointer`	QRCodeDetector.`detectAndDecode(Mat img)`
`BytePointer`	QRCodeDetector.`detectAndDecode(Mat img, Mat points, Mat straight_qrcode)` \brief Both detects and decodes QR code
`BytePointer`	QRCodeDetector.`detectAndDecodeCurved(Mat img)`
`BytePointer`	QRCodeDetector.`detectAndDecodeCurved(Mat img, Mat points, Mat straight_qrcode)` \brief Both detects and decodes QR code on a curved surface
`boolean`	QRCodeDetector.`detectAndDecodeMulti(Mat img, StringVector decoded_info)`
`boolean`	QRCodeDetector.`detectAndDecodeMulti(Mat img, StringVector decoded_info, Mat points, GpuMatVector straight_qrcode)`
`boolean`	QRCodeDetector.`detectAndDecodeMulti(Mat img, StringVector decoded_info, Mat points, MatVector straight_qrcode)` \brief Both detects and decodes QR codes
`boolean`	QRCodeDetector.`detectAndDecodeMulti(Mat img, StringVector decoded_info, Mat points, UMatVector straight_qrcode)`
`boolean`	QRCodeDetector.`detectMulti(Mat img, Mat points)` \brief Detects QR codes in image and returns the vector of the quadrangles containing the codes.
`void`	CascadeClassifier.`detectMultiScale(Mat image, RectVector objects)`
`void`	HOGDescriptor.`detectMultiScale(Mat img, RectVector foundLocations)`
`void`	HOGDescriptor.`detectMultiScale(Mat img, RectVector foundLocations, double[] foundWeights)`
`void`	HOGDescriptor.`detectMultiScale(Mat img, RectVector foundLocations, double[] foundWeights, double hitThreshold, Size winStride, Size padding, double scale, double finalThreshold, boolean useMeanshiftGrouping)`
`void`	HOGDescriptor.`detectMultiScale(Mat img, RectVector foundLocations, DoubleBuffer foundWeights)`
`void`	HOGDescriptor.`detectMultiScale(Mat img, RectVector foundLocations, DoubleBuffer foundWeights, double hitThreshold, Size winStride, Size padding, double scale, double finalThreshold, boolean useMeanshiftGrouping)`
`void`	BaseCascadeClassifier.`detectMultiScale(Mat image, RectVector objects, double scaleFactor, int minNeighbors, int flags, Size minSize, Size maxSize)`
`void`	CascadeClassifier.`detectMultiScale(Mat image, RectVector objects, double scaleFactor, int minNeighbors, int flags, Size minSize, Size maxSize)` \brief Detects objects of different sizes in the input image.
`void`	HOGDescriptor.`detectMultiScale(Mat img, RectVector foundLocations, DoublePointer foundWeights)`
`void`	HOGDescriptor.`detectMultiScale(Mat img, RectVector foundLocations, DoublePointer foundWeights, double hitThreshold, Size winStride, Size padding, double scale, double finalThreshold, boolean useMeanshiftGrouping)` \brief Detects objects of different sizes in the input image.
`void`	HOGDescriptor.`detectMultiScale(Mat img, RectVector foundLocations, double hitThreshold, Size winStride, Size padding, double scale, double finalThreshold, boolean useMeanshiftGrouping)` \brief Detects objects of different sizes in the input image.
`void`	BaseCascadeClassifier.`detectMultiScale(Mat image, RectVector objects, int[] rejectLevels, double[] levelWeights, double scaleFactor, int minNeighbors, int flags, Size minSize, Size maxSize, boolean outputRejectLevels)`
`void`	BaseCascadeClassifier.`detectMultiScale(Mat image, RectVector objects, int[] numDetections, double scaleFactor, int minNeighbors, int flags, Size minSize, Size maxSize)`
`void`	BaseCascadeClassifier.`detectMultiScale(Mat image, RectVector objects, IntBuffer rejectLevels, DoubleBuffer levelWeights, double scaleFactor, int minNeighbors, int flags, Size minSize, Size maxSize, boolean outputRejectLevels)`
`void`	BaseCascadeClassifier.`detectMultiScale(Mat image, RectVector objects, IntBuffer numDetections, double scaleFactor, int minNeighbors, int flags, Size minSize, Size maxSize)`
`void`	BaseCascadeClassifier.`detectMultiScale(Mat image, RectVector objects, IntPointer numDetections, double scaleFactor, int minNeighbors, int flags, Size minSize, Size maxSize)`
`void`	BaseCascadeClassifier.`detectMultiScale(Mat image, RectVector objects, IntPointer rejectLevels, DoublePointer levelWeights, double scaleFactor, int minNeighbors, int flags, Size minSize, Size maxSize, boolean outputRejectLevels)`
`void`	CascadeClassifier.`detectMultiScale2(Mat image, RectVector objects, int[] numDetections)`
`void`	CascadeClassifier.`detectMultiScale2(Mat image, RectVector objects, int[] numDetections, double scaleFactor, int minNeighbors, int flags, Size minSize, Size maxSize)`
`void`	CascadeClassifier.`detectMultiScale2(Mat image, RectVector objects, IntBuffer numDetections)`
`void`	CascadeClassifier.`detectMultiScale2(Mat image, RectVector objects, IntBuffer numDetections, double scaleFactor, int minNeighbors, int flags, Size minSize, Size maxSize)`
`void`	CascadeClassifier.`detectMultiScale2(Mat image, RectVector objects, IntPointer numDetections)`
`void`	CascadeClassifier.`detectMultiScale2(Mat image, RectVector objects, IntPointer numDetections, double scaleFactor, int minNeighbors, int flags, Size minSize, Size maxSize)` \overload
`void`	CascadeClassifier.`detectMultiScale3(Mat image, RectVector objects, int[] rejectLevels, double[] levelWeights)`
`void`	CascadeClassifier.`detectMultiScale3(Mat image, RectVector objects, int[] rejectLevels, double[] levelWeights, double scaleFactor, int minNeighbors, int flags, Size minSize, Size maxSize, boolean outputRejectLevels)`
`void`	CascadeClassifier.`detectMultiScale3(Mat image, RectVector objects, IntBuffer rejectLevels, DoubleBuffer levelWeights)`
`void`	CascadeClassifier.`detectMultiScale3(Mat image, RectVector objects, IntBuffer rejectLevels, DoubleBuffer levelWeights, double scaleFactor, int minNeighbors, int flags, Size minSize, Size maxSize, boolean outputRejectLevels)`
`void`	CascadeClassifier.`detectMultiScale3(Mat image, RectVector objects, IntPointer rejectLevels, DoublePointer levelWeights)`
`void`	CascadeClassifier.`detectMultiScale3(Mat image, RectVector objects, IntPointer rejectLevels, DoublePointer levelWeights, double scaleFactor, int minNeighbors, int flags, Size minSize, Size maxSize, boolean outputRejectLevels)` \overload This function allows you to retrieve the final stage decision certainty of classification.
`void`	HOGDescriptor.`detectMultiScaleROI(Mat img, RectVector foundLocations, DetectionROI locations)`
`void`	HOGDescriptor.`detectMultiScaleROI(Mat img, RectVector foundLocations, DetectionROI locations, double hitThreshold, int groupThreshold)` \brief evaluate specified ROI and return confidence value for each location in multiple scales
`void`	HOGDescriptor.`detectROI(Mat img, PointVector locations, PointVector foundLocations, double[] confidences)`
`void`	HOGDescriptor.`detectROI(Mat img, PointVector locations, PointVector foundLocations, double[] confidences, double hitThreshold, Size winStride, Size padding)`
`void`	HOGDescriptor.`detectROI(Mat img, PointVector locations, PointVector foundLocations, DoubleBuffer confidences)`
`void`	HOGDescriptor.`detectROI(Mat img, PointVector locations, PointVector foundLocations, DoubleBuffer confidences, double hitThreshold, Size winStride, Size padding)`
`void`	HOGDescriptor.`detectROI(Mat img, PointVector locations, PointVector foundLocations, DoublePointer confidences)`
`void`	HOGDescriptor.`detectROI(Mat img, PointVector locations, PointVector foundLocations, DoublePointer confidences, double hitThreshold, Size winStride, Size padding)` \brief evaluate specified ROI and return confidence value for each location
`Mat`	BaseCascadeClassifier.MaskGenerator.`generateMask(Mat src)`
`void`	BaseCascadeClassifier.MaskGenerator.`initializeMask(Mat arg0)`
`void`	DetectionBasedTracker.`process(Mat imageGray)`
`void`	HOGDescriptor.`setSVMDetector(Mat svmdetector)` \brief Sets coefficients for the linear SVM classifier.

Uses of Mat in org.bytedeco.opencv.opencv_phase_unwrapping

Methods in org.bytedeco.opencv.opencv_phase_unwrapping with parameters of type Mat
Modifier and Type	Method and Description
`void`	HistogramPhaseUnwrapping.`getInverseReliabilityMap(Mat reliabilityMap)` \brief Get the reliability map computed from the wrapped phase map.
`void`	PhaseUnwrapping.`unwrapPhaseMap(Mat wrappedPhaseMap, Mat unwrappedPhaseMap)`
`void`	PhaseUnwrapping.`unwrapPhaseMap(Mat wrappedPhaseMap, Mat unwrappedPhaseMap, Mat shadowMask)` \brief Unwraps a 2D phase map.

Uses of Mat in org.bytedeco.opencv.opencv_photo

Methods in org.bytedeco.opencv.opencv_photo that return Mat
Modifier and Type	Method and Description
`Mat`	CalibrateRobertson.`getRadiance()`

Methods in org.bytedeco.opencv.opencv_photo with parameters of type Mat
Modifier and Type	Method and Description
`Point`	AlignMTB.`calculateShift(Mat img0, Mat img1)` \brief Calculates shift between two images, i.
`void`	AlignMTB.`computeBitmaps(Mat img, Mat tb, Mat eb)` \brief Computes median threshold and exclude bitmaps of given image.
`void`	MergeMertens.`process(GpuMatVector src, Mat dst)`
`void`	MergeDebevec.`process(GpuMatVector src, Mat dst, Mat times)`
`void`	MergeRobertson.`process(GpuMatVector src, Mat dst, Mat times)`
`void`	CalibrateCRF.`process(GpuMatVector src, Mat dst, Mat times)`
`void`	MergeDebevec.`process(GpuMatVector src, Mat dst, Mat times, Mat response)`
`void`	MergeRobertson.`process(GpuMatVector src, Mat dst, Mat times, Mat response)`
`void`	MergeExposures.`process(GpuMatVector src, Mat dst, Mat times, Mat response)`
`void`	MergeMertens.`process(GpuMatVector src, Mat dst, Mat times, Mat response)`
`void`	AlignExposures.`process(GpuMatVector src, MatVector dst, Mat times, Mat response)`
`void`	AlignMTB.`process(GpuMatVector src, MatVector dst, Mat times, Mat response)`
`void`	Tonemap.`process(Mat src, Mat dst)` \brief Tonemaps image
`void`	MergeMertens.`process(MatVector src, Mat dst)` \brief Short version of process, that doesn't take extra arguments.
`void`	MergeDebevec.`process(MatVector src, Mat dst, Mat times)`
`void`	MergeRobertson.`process(MatVector src, Mat dst, Mat times)`
`void`	CalibrateCRF.`process(MatVector src, Mat dst, Mat times)` \brief Recovers inverse camera response.
`void`	MergeDebevec.`process(MatVector src, Mat dst, Mat times, Mat response)`
`void`	MergeRobertson.`process(MatVector src, Mat dst, Mat times, Mat response)`
`void`	MergeExposures.`process(MatVector src, Mat dst, Mat times, Mat response)` \brief Merges images.
`void`	MergeMertens.`process(MatVector src, Mat dst, Mat times, Mat response)`
`void`	AlignExposures.`process(MatVector src, MatVector dst, Mat times, Mat response)` \brief Aligns images
`void`	AlignMTB.`process(MatVector src, MatVector dst, Mat times, Mat response)`
`void`	MergeMertens.`process(UMatVector src, Mat dst)`
`void`	MergeDebevec.`process(UMatVector src, Mat dst, Mat times)`
`void`	MergeRobertson.`process(UMatVector src, Mat dst, Mat times)`
`void`	CalibrateCRF.`process(UMatVector src, Mat dst, Mat times)`
`void`	MergeDebevec.`process(UMatVector src, Mat dst, Mat times, Mat response)`
`void`	MergeRobertson.`process(UMatVector src, Mat dst, Mat times, Mat response)`
`void`	MergeExposures.`process(UMatVector src, Mat dst, Mat times, Mat response)`
`void`	MergeMertens.`process(UMatVector src, Mat dst, Mat times, Mat response)`
`void`	AlignExposures.`process(UMatVector src, MatVector dst, Mat times, Mat response)`
`void`	AlignMTB.`process(UMatVector src, MatVector dst, Mat times, Mat response)`
`void`	AlignMTB.`shiftMat(Mat src, Mat dst, Point shift)` \brief Helper function, that shift Mat filling new regions with zeros.

Uses of Mat in org.bytedeco.opencv.opencv_plot

Methods in org.bytedeco.opencv.opencv_plot with parameters of type Mat
Modifier and Type	Method and Description
`static Plot2d`	Plot2d.`create(Mat data)` \brief Creates Plot2d object
`static Plot2d`	Plot2d.`create(Mat dataX, Mat dataY)` \brief Creates Plot2d object
`void`	Plot2d.`render(Mat _plotResult)`

Uses of Mat in org.bytedeco.opencv.opencv_quality

Methods in org.bytedeco.opencv.opencv_quality with parameters of type Mat
Modifier and Type	Method and Description
`Scalar`	QualityGMSD.`compute(Mat cmp)` \brief Compute GMSD
`Scalar`	QualityBRISQUE.`compute(Mat img)` \brief Computes BRISQUE quality score for input image
`Scalar`	QualitySSIM.`compute(Mat cmp)` \brief Computes SSIM
`Scalar`	QualityBase.`compute(Mat img)` \brief Compute quality score per channel with the per-channel score in each element of the resulting cv::Scalar.
`Scalar`	QualityMSE.`compute(Mat cmpImgs)` \brief Computes MSE for reference images supplied in class constructor and provided comparison images
`Scalar`	QualityPSNR.`compute(Mat cmp)` \brief Compute the PSNR
`static Scalar`	QualityBRISQUE.`compute(Mat img, BytePointer model_file_path, BytePointer range_file_path)` \brief static method for computing quality
`static Scalar`	QualityGMSD.`compute(Mat ref, Mat cmp, Mat qualityMap)` \brief static method for computing quality
`static Scalar`	QualitySSIM.`compute(Mat ref, Mat cmp, Mat qualityMap)` \brief static method for computing quality
`static Scalar`	QualityMSE.`compute(Mat ref, Mat cmp, Mat qualityMap)` \brief static method for computing quality
`static Scalar`	QualityPSNR.`compute(Mat ref, Mat cmp, Mat qualityMap)`
`static Scalar`	QualityPSNR.`compute(Mat ref, Mat cmp, Mat qualityMap, double maxPixelValue)` \brief static method for computing quality
`static Scalar`	QualityBRISQUE.`compute(Mat img, String model_file_path, String range_file_path)`
`static void`	QualityBRISQUE.`computeFeatures(Mat img, Mat features)` \brief static method for computing image features used by the BRISQUE algorithm
`static QualityGMSD`	QualityGMSD.`create(Mat ref)` \brief Create an object which calculates image quality
`static QualitySSIM`	QualitySSIM.`create(Mat ref)` \brief Create an object which calculates quality
`static QualityMSE`	QualityMSE.`create(Mat ref)` \brief Create an object which calculates quality
`static QualityPSNR`	QualityPSNR.`create(Mat ref)`
`static QualityPSNR`	QualityPSNR.`create(Mat ref, double maxPixelValue)` \brief Create an object which calculates quality
`static QualityBRISQUE`	QualityBRISQUE.`create(SVM model, Mat range)` \brief Create an object which calculates quality
`void`	QualityBase.`getQualityMap(Mat dst)` \brief Returns output quality map that was generated during computation, if supported by the algorithm

Uses of Mat in org.bytedeco.opencv.opencv_rapid

Methods in org.bytedeco.opencv.opencv_rapid with parameters of type Mat
Modifier and Type	Method and Description
`float`	Tracker.`compute(Mat img, int num, int len, Mat K, Mat rvec, Mat tvec)`
`float`	Tracker.`compute(Mat img, int num, int len, Mat K, Mat rvec, Mat tvec, TermCriteria termcrit)`
`static OLSTracker`	GOSTracker.`create(Mat pts3d, Mat tris)`
`static OLSTracker`	OLSTracker.`create(Mat pts3d, Mat tris)`
`static Rapid`	Rapid.`create(Mat pts3d, Mat tris)`
`static OLSTracker`	GOSTracker.`create(Mat pts3d, Mat tris, int histBins, byte sobelThesh)`
`static OLSTracker`	OLSTracker.`create(Mat pts3d, Mat tris, int histBins, byte sobelThesh)`

Uses of Mat in org.bytedeco.opencv.opencv_saliency

Methods in org.bytedeco.opencv.opencv_saliency with parameters of type Mat
Modifier and Type	Method and Description
`boolean`	StaticSaliency.`computeBinaryMap(Mat _saliencyMap, Mat _binaryMap)` \brief This function perform a binary map of given saliency map.
`boolean`	MotionSaliencyBinWangApr2014.`computeSaliency(Mat image, Mat saliencyMap)`
`boolean`	ObjectnessBING.`computeSaliency(Mat image, Mat saliencyMap)`
`boolean`	StaticSaliencySpectralResidual.`computeSaliency(Mat image, Mat saliencyMap)`
`boolean`	Saliency.`computeSaliency(Mat image, Mat saliencyMap)` \brief Compute the saliency
`boolean`	StaticSaliencyFineGrained.`computeSaliency(Mat image, Mat saliencyMap)`

Uses of Mat in org.bytedeco.opencv.opencv_shape

Methods in org.bytedeco.opencv.opencv_shape with parameters of type Mat
Modifier and Type	Method and Description
`float`	ShapeTransformer.`applyTransformation(Mat input)`
`float`	ShapeTransformer.`applyTransformation(Mat input, Mat output)` \brief Apply a transformation, given a pre-estimated transformation parameters.
`void`	HistogramCostExtractor.`buildCostMatrix(Mat descriptors1, Mat descriptors2, Mat costMatrix)`
`float`	ShapeDistanceExtractor.`computeDistance(Mat contour1, Mat contour2)` \brief Compute the shape distance between two shapes defined by its contours.
`void`	ShapeTransformer.`estimateTransformation(Mat transformingShape, Mat targetShape, DMatchVector matches)` \brief Estimate the transformation parameters of the current transformer algorithm, based on point matches.
`void`	ShapeContextDistanceExtractor.`getImages(Mat image1, Mat image2)`
`void`	ShapeContextDistanceExtractor.`setImages(Mat image1, Mat image2)` \brief Set the images that correspond to each shape.
`void`	ShapeTransformer.`warpImage(Mat transformingImage, Mat output)`
`void`	ShapeTransformer.`warpImage(Mat transformingImage, Mat output, int flags, int borderMode, Scalar borderValue)` \brief Apply a transformation, given a pre-estimated transformation parameters, to an Image.

Uses of Mat in org.bytedeco.opencv.opencv_stitching

Methods in org.bytedeco.opencv.opencv_stitching that return Mat
Modifier and Type	Method and Description
`Mat`	MatchesInfo.`H()` Estimated transformation
`Mat`	CameraParams.`K()`
`Mat`	CameraParams.`R()`
`Mat`	BundleAdjusterBase.`refinementMask()`
`Mat`	CameraParams.`t()`

Methods in org.bytedeco.opencv.opencv_stitching with parameters of type Mat
Modifier and Type	Method and Description
`void`	BlocksGainCompensator.`apply(int index, Point corner, Mat image, Mat mask)`
`void`	NoExposureCompensator.`apply(int arg0, Point arg1, Mat arg2, Mat arg3)`
`void`	GainCompensator.`apply(int index, Point corner, Mat image, Mat mask)`
`void`	BlocksCompensator.`apply(int index, Point corner, Mat image, Mat mask)`
`void`	ChannelsCompensator.`apply(int index, Point corner, Mat image, Mat mask)`
`void`	ExposureCompensator.`apply(int index, Point corner, Mat image, Mat mask)` \brief Compensate exposure in the specified image.
`void`	FeatherBlender.`blend(Mat dst, Mat dst_mask)`
`void`	Blender.`blend(Mat dst, Mat dst_mask)` \brief Blends and returns the final pano.
`void`	MultiBandBlender.`blend(Mat dst, Mat dst_mask)`
`Rect`	DetailSphericalWarperGpu.`buildMaps(Size src_size, Mat K, Mat R, GpuMat xmap, GpuMat ymap)`
`Rect`	DetailCylindricalWarperGpu.`buildMaps(Size src_size, Mat K, Mat R, GpuMat xmap, GpuMat ymap)`
`Rect`	DetailPlaneWarperGpu.`buildMaps(Size src_size, Mat K, Mat R, GpuMat xmap, GpuMat ymap)`
`Rect`	DetailPlaneWarperGpu.`buildMaps(Size src_size, Mat K, Mat R, Mat T, GpuMat xmap, GpuMat ymap)`
`Rect`	RotationWarper.`buildMaps(Size src_size, Mat K, Mat R, Mat xmap, Mat ymap)` \brief Builds the projection maps according to the given camera data.
`Rect`	PyRotationWarper.`buildMaps(Size src_size, Mat K, Mat R, Mat xmap, Mat ymap)` \brief Builds the projection maps according to the given camera data.
`Rect`	DetailSphericalWarperGpu.`buildMaps(Size src_size, Mat K, Mat R, Mat xmap, Mat ymap)`
`Rect`	DetailCylindricalWarperGpu.`buildMaps(Size src_size, Mat K, Mat R, Mat xmap, Mat ymap)`
`Rect`	AffineWarper.`buildMaps(Size src_size, Mat K, Mat H, Mat xmap, Mat ymap)` \brief Builds the projection maps according to the given camera data.
`Rect`	DetailCylindricalWarper.`buildMaps(Size src_size, Mat K, Mat R, Mat xmap, Mat ymap)`
`Rect`	DetailPlaneWarper.`buildMaps(Size src_size, Mat K, Mat R, Mat xmap, Mat ymap)`
`Rect`	DetailSphericalWarper.`buildMaps(Size src_size, Mat K, Mat R, Mat xmap, Mat ymap)`
`Rect`	DetailPlaneWarperGpu.`buildMaps(Size src_size, Mat K, Mat R, Mat xmap, Mat ymap)`
`Rect`	DetailPlaneWarper.`buildMaps(Size src_size, Mat K, Mat R, Mat T, Mat xmap, Mat ymap)`
`Rect`	DetailPlaneWarperGpu.`buildMaps(Size src_size, Mat K, Mat R, Mat T, Mat xmap, Mat ymap)`
`int`	Stitcher.`composePanorama(GpuMatVector images, Mat pano)`
`int`	Stitcher.`composePanorama(Mat pano)` \overload
`int`	Stitcher.`composePanorama(MatVector images, Mat pano)` \brief These functions try to compose the given images (or images stored internally from the other function calls) into the final pano under the assumption that the image transformations were estimated before.
`int`	Stitcher.`composePanorama(UMatVector images, Mat pano)`
`void`	FeatherBlender.`feed(Mat img, Mat mask, Point tl)`
`void`	Blender.`feed(Mat img, Mat mask, Point tl)` \brief Processes the image.
`void`	MultiBandBlender.`feed(Mat img, Mat mask, Point tl)`
`MatchesInfo`	MatchesInfo.`H(Mat setter)`
`void`	Timelapser.`process(Mat img, Mat mask, Point tl)`
`CameraParams`	CameraParams.`R(Mat setter)`
`void`	ProjectorBase.`setCameraParams(Mat K, Mat R, Mat T)`
`void`	BundleAdjusterBase.`setRefinementMask(Mat mask)`
`int`	Stitcher.`stitch(GpuMatVector images, GpuMatVector masks, Mat pano)`
`int`	Stitcher.`stitch(GpuMatVector images, Mat pano)`
`int`	Stitcher.`stitch(MatVector images, Mat pano)` \overload
`int`	Stitcher.`stitch(MatVector images, MatVector masks, Mat pano)` \brief These functions try to stitch the given images.
`int`	Stitcher.`stitch(UMatVector images, Mat pano)`
`int`	Stitcher.`stitch(UMatVector images, UMatVector masks, Mat pano)`
`CameraParams`	CameraParams.`t(Mat setter)`
`Point`	DetailSphericalWarperGpu.`warp(GpuMat src, Mat K, Mat R, int interp_mode, int border_mode, GpuMat dst)`
`Point`	DetailCylindricalWarperGpu.`warp(GpuMat src, Mat K, Mat R, int interp_mode, int border_mode, GpuMat dst)`
`Point`	DetailPlaneWarperGpu.`warp(GpuMat src, Mat K, Mat R, int interp_mode, int border_mode, GpuMat dst)`
`Point`	DetailPlaneWarperGpu.`warp(GpuMat src, Mat K, Mat R, Mat T, int interp_mode, int border_mode, GpuMat dst)`
`Point`	RotationWarper.`warp(Mat src, Mat K, Mat R, int interp_mode, int border_mode, Mat dst)` \brief Projects the image.
`Point`	PyRotationWarper.`warp(Mat src, Mat K, Mat R, int interp_mode, int border_mode, Mat dst)` \brief Projects the image.
`Point`	DetailSphericalWarperGpu.`warp(Mat src, Mat K, Mat R, int interp_mode, int border_mode, Mat dst)`
`Point`	DetailCylindricalWarperGpu.`warp(Mat src, Mat K, Mat R, int interp_mode, int border_mode, Mat dst)`
`Point`	AffineWarper.`warp(Mat src, Mat K, Mat H, int interp_mode, int border_mode, Mat dst)` \brief Projects the image.
`Point`	DetailCylindricalWarper.`warp(Mat src, Mat K, Mat R, int interp_mode, int border_mode, Mat dst)`
`Point`	DetailPlaneWarper.`warp(Mat src, Mat K, Mat R, int interp_mode, int border_mode, Mat dst)`
`Point`	DetailSphericalWarper.`warp(Mat src, Mat K, Mat R, int interp_mode, int border_mode, Mat dst)`
`Point`	DetailPlaneWarperGpu.`warp(Mat src, Mat K, Mat R, int interp_mode, int border_mode, Mat dst)`
`Point`	DetailPlaneWarper.`warp(Mat src, Mat K, Mat R, Mat T, int interp_mode, int border_mode, Mat dst)`
`Point`	DetailPlaneWarperGpu.`warp(Mat src, Mat K, Mat R, Mat T, int interp_mode, int border_mode, Mat dst)`
`void`	RotationWarper.`warpBackward(Mat src, Mat K, Mat R, int interp_mode, int border_mode, Size dst_size, Mat dst)` \brief Projects the image backward.
`void`	PyRotationWarper.`warpBackward(Mat src, Mat K, Mat R, int interp_mode, int border_mode, Size dst_size, Mat dst)` \brief Projects the image backward.
`Point2f`	RotationWarper.`warpPoint(Point2f pt, Mat K, Mat R)` \brief Projects the image point.
`Point2f`	PyRotationWarper.`warpPoint(Point2f pt, Mat K, Mat R)` \brief Projects the image point.
`Point2f`	AffineWarper.`warpPoint(Point2f pt, Mat K, Mat H)` \brief Projects the image point.
`Point2f`	DetailPlaneWarper.`warpPoint(Point2f pt, Mat K, Mat R)`
`Point2f`	DetailPlaneWarper.`warpPoint(Point2f pt, Mat K, Mat R, Mat T)`
`Point2f`	RotationWarper.`warpPointBackward(Point2f pt, Mat K, Mat R)` \brief Projects the image point backward.
`Point2f`	PyRotationWarper.`warpPointBackward(Point2f pt, Mat K, Mat R)` \brief Projects the image point backward.
`Point2f`	AffineWarper.`warpPointBackward(Point2f pt, Mat K, Mat H)` \brief Projects the image point backward.
`Point2f`	DetailPlaneWarper.`warpPointBackward(Point2f pt, Mat K, Mat R)`
`Point2f`	DetailPlaneWarper.`warpPointBackward(Point2f pt, Mat K, Mat R, Mat T)`
`Rect`	RotationWarper.`warpRoi(Size src_size, Mat K, Mat R)`
`Rect`	PyRotationWarper.`warpRoi(Size src_size, Mat K, Mat R)`
`Rect`	AffineWarper.`warpRoi(Size src_size, Mat K, Mat H)`
`Rect`	DetailPlaneWarper.`warpRoi(Size src_size, Mat K, Mat R)`
`Rect`	DetailPlaneWarper.`warpRoi(Size src_size, Mat K, Mat R, Mat T)`

Uses of Mat in org.bytedeco.opencv.opencv_structured_light

Methods in org.bytedeco.opencv.opencv_structured_light with parameters of type Mat
Modifier and Type	Method and Description
`void`	SinusoidalPattern.`computeDataModulationTerm(GpuMatVector patternImages, Mat dataModulationTerm, Mat shadowMask)`
`void`	SinusoidalPattern.`computeDataModulationTerm(MatVector patternImages, Mat dataModulationTerm, Mat shadowMask)` \brief compute the data modulation term.
`void`	SinusoidalPattern.`computeDataModulationTerm(UMatVector patternImages, Mat dataModulationTerm, Mat shadowMask)`
`void`	SinusoidalPattern.`computePhaseMap(GpuMatVector patternImages, Mat wrappedPhaseMap)`
`void`	SinusoidalPattern.`computePhaseMap(GpuMatVector patternImages, Mat wrappedPhaseMap, Mat shadowMask, Mat fundamental)`
`void`	SinusoidalPattern.`computePhaseMap(MatVector patternImages, Mat wrappedPhaseMap)`
`void`	SinusoidalPattern.`computePhaseMap(MatVector patternImages, Mat wrappedPhaseMap, Mat shadowMask, Mat fundamental)` \brief Compute a wrapped phase map from sinusoidal patterns.
`void`	SinusoidalPattern.`computePhaseMap(UMatVector patternImages, Mat wrappedPhaseMap)`
`void`	SinusoidalPattern.`computePhaseMap(UMatVector patternImages, Mat wrappedPhaseMap, Mat shadowMask, Mat fundamental)`
`boolean`	StructuredLightPattern.`decode(MatVectorVector patternImages, Mat disparityMap)`
`boolean`	StructuredLightPattern.`decode(MatVectorVector patternImages, Mat disparityMap, GpuMatVector blackImages, GpuMatVector whiteImages, int flags)`
`boolean`	StructuredLightPattern.`decode(MatVectorVector patternImages, Mat disparityMap, MatVector blackImages, MatVector whiteImages, int flags)` \brief Decodes the structured light pattern, generating a disparity map
`boolean`	StructuredLightPattern.`decode(MatVectorVector patternImages, Mat disparityMap, UMatVector blackImages, UMatVector whiteImages, int flags)`
`void`	SinusoidalPattern.`findProCamMatches(Mat projUnwrappedPhaseMap, Mat camUnwrappedPhaseMap, GpuMatVector matches)`
`void`	SinusoidalPattern.`findProCamMatches(Mat projUnwrappedPhaseMap, Mat camUnwrappedPhaseMap, MatVector matches)` \brief Find correspondences between the two devices thanks to unwrapped phase maps.
`void`	SinusoidalPattern.`findProCamMatches(Mat projUnwrappedPhaseMap, Mat camUnwrappedPhaseMap, UMatVector matches)`
`void`	GrayCodePattern.`getImagesForShadowMasks(Mat blackImage, Mat whiteImage)` \brief Generates the all-black and all-white images needed for shadowMasks computation.
`void`	SinusoidalPattern.`unwrapPhaseMap(Mat wrappedPhaseMap, Mat unwrappedPhaseMap, Size camSize)`
`void`	SinusoidalPattern.`unwrapPhaseMap(Mat wrappedPhaseMap, Mat unwrappedPhaseMap, Size camSize, Mat shadowMask)` \brief Unwrap the wrapped phase map to remove phase ambiguities.

Uses of Mat in org.bytedeco.opencv.opencv_superres

Methods in org.bytedeco.opencv.opencv_superres with parameters of type Mat
Modifier and Type	Method and Description
`void`	DenseOpticalFlowExt.`calc(Mat frame0, Mat frame1, Mat flow1)`
`void`	DenseOpticalFlowExt.`calc(Mat frame0, Mat frame1, Mat flow1, Mat flow2)`
`void`	FrameSource.`nextFrame(Mat frame)`
`void`	SuperResolution.`nextFrame(Mat frame)` \brief Process next frame from input and return output result.

Uses of Mat in org.bytedeco.opencv.opencv_text

Methods in org.bytedeco.opencv.opencv_text with parameters of type Mat
Modifier and Type	Method and Description
`static OCRHMMDecoder`	OCRHMMDecoder.`create(BytePointer filename, BytePointer vocabulary, Mat transition_probabilities_table, Mat emission_probabilities_table)`
`static OCRBeamSearchDecoder`	OCRBeamSearchDecoder.`create(BytePointer filename, BytePointer vocabulary, Mat transition_probabilities_table, Mat emission_probabilities_table, int mode, int beam_size)` \brief Creates an instance of the OCRBeamSearchDecoder class.
`static OCRHMMDecoder`	OCRHMMDecoder.`create(BytePointer filename, BytePointer vocabulary, Mat transition_probabilities_table, Mat emission_probabilities_table, int mode, int classifier)` \brief Creates an instance of the OCRHMMDecoder class.
`static OCRBeamSearchDecoder`	OCRBeamSearchDecoder.`create(OCRBeamSearchDecoder.ClassifierCallback classifier, BytePointer vocabulary, Mat transition_probabilities_table, Mat emission_probabilities_table, int mode, int beam_size)` \brief Creates an instance of the OCRBeamSearchDecoder class.
`static OCRBeamSearchDecoder`	OCRBeamSearchDecoder.`create(OCRBeamSearchDecoder.ClassifierCallback classifier, String vocabulary, Mat transition_probabilities_table, Mat emission_probabilities_table, int mode, int beam_size)`
`static OCRHMMDecoder`	OCRHMMDecoder.`create(OCRHMMDecoder.ClassifierCallback classifier, BytePointer vocabulary, Mat transition_probabilities_table, Mat emission_probabilities_table)`
`static OCRHMMDecoder`	OCRHMMDecoder.`create(OCRHMMDecoder.ClassifierCallback classifier, BytePointer vocabulary, Mat transition_probabilities_table, Mat emission_probabilities_table, int mode)` \brief Creates an instance of the OCRHMMDecoder class.
`static OCRHMMDecoder`	OCRHMMDecoder.`create(OCRHMMDecoder.ClassifierCallback classifier, String vocabulary, Mat transition_probabilities_table, Mat emission_probabilities_table)`
`static OCRHMMDecoder`	OCRHMMDecoder.`create(OCRHMMDecoder.ClassifierCallback classifier, String vocabulary, Mat transition_probabilities_table, Mat emission_probabilities_table, int mode)`
`static OCRHMMDecoder`	OCRHMMDecoder.`create(String filename, String vocabulary, Mat transition_probabilities_table, Mat emission_probabilities_table)`
`static OCRBeamSearchDecoder`	OCRBeamSearchDecoder.`create(String filename, String vocabulary, Mat transition_probabilities_table, Mat emission_probabilities_table, int mode, int beam_size)`
`static OCRHMMDecoder`	OCRHMMDecoder.`create(String filename, String vocabulary, Mat transition_probabilities_table, Mat emission_probabilities_table, int mode, int classifier)`
`void`	TextDetectorCNN.`detect(Mat inputImage, RectVector Bbox, FloatVector confidence)` \overload
`void`	TextDetector.`detect(Mat inputImage, RectVector Bbox, FloatVector confidence)` \brief Method that provides a quick and simple interface to detect text inside an image
`void`	OCRBeamSearchDecoder.ClassifierCallback.`eval(Mat image, DoubleVector recognition_probabilities, IntVector oversegmentation)` \brief The character classifier must return a (ranked list of) class(es) id('s)
`void`	OCRHMMDecoder.ClassifierCallback.`eval(Mat image, IntVector out_class, DoubleVector out_confidence)` \brief The character classifier must return a (ranked list of) class(es) id('s)
`void`	OCRHolisticWordRecognizer.`run(Mat image, BytePointer output_text)`
`void`	OCRBeamSearchDecoder.`run(Mat image, BytePointer output_text)`
`void`	BaseOCR.`run(Mat image, BytePointer output_text)`
`void`	OCRTesseract.`run(Mat image, BytePointer output_text)`
`void`	OCRHMMDecoder.`run(Mat image, BytePointer output_text)`
`void`	OCRHolisticWordRecognizer.`run(Mat image, BytePointer output_text, RectVector component_rects, StringVector component_texts, FloatVector component_confidences, int component_level)`
`void`	OCRBeamSearchDecoder.`run(Mat image, BytePointer output_text, RectVector component_rects, StringVector component_texts, FloatVector component_confidences, int component_level)` \brief Recognize text using Beam Search.
`void`	BaseOCR.`run(Mat image, BytePointer output_text, RectVector component_rects, StringVector component_texts, FloatVector component_confidences, int component_level)`
`void`	OCRTesseract.`run(Mat image, BytePointer output_text, RectVector component_rects, StringVector component_texts, FloatVector component_confidences, int component_level)` \brief Recognize text using the tesseract-ocr API.
`void`	OCRHMMDecoder.`run(Mat image, BytePointer output_text, RectVector component_rects, StringVector component_texts, FloatVector component_confidences, int component_level)` \brief Recognize text using HMM.
`void`	ERFilter.`run(Mat image, ERStatVector regions)` \brief The key method of ERFilter algorithm.
`BytePointer`	OCRBeamSearchDecoder.`run(Mat image, int min_confidence)`
`BytePointer`	OCRTesseract.`run(Mat image, int min_confidence)`
`BytePointer`	OCRHMMDecoder.`run(Mat image, int min_confidence)`
`BytePointer`	OCRBeamSearchDecoder.`run(Mat image, int min_confidence, int component_level)`
`BytePointer`	OCRTesseract.`run(Mat image, int min_confidence, int component_level)`
`BytePointer`	OCRHMMDecoder.`run(Mat image, int min_confidence, int component_level)`
`void`	OCRHolisticWordRecognizer.`run(Mat image, Mat mask, BytePointer output_text)`
`void`	OCRBeamSearchDecoder.`run(Mat image, Mat mask, BytePointer output_text)`
`void`	BaseOCR.`run(Mat image, Mat mask, BytePointer output_text)`
`void`	OCRTesseract.`run(Mat image, Mat mask, BytePointer output_text)`
`void`	OCRHMMDecoder.`run(Mat image, Mat mask, BytePointer output_text)`
`void`	OCRHolisticWordRecognizer.`run(Mat image, Mat mask, BytePointer output_text, RectVector component_rects, StringVector component_texts, FloatVector component_confidences, int component_level)` \brief Recognize text using a segmentation based word-spotting/classifier cnn.
`void`	OCRBeamSearchDecoder.`run(Mat image, Mat mask, BytePointer output_text, RectVector component_rects, StringVector component_texts, FloatVector component_confidences, int component_level)`
`void`	BaseOCR.`run(Mat image, Mat mask, BytePointer output_text, RectVector component_rects, StringVector component_texts, FloatVector component_confidences, int component_level)`
`void`	OCRTesseract.`run(Mat image, Mat mask, BytePointer output_text, RectVector component_rects, StringVector component_texts, FloatVector component_confidences, int component_level)`
`void`	OCRHMMDecoder.`run(Mat image, Mat mask, BytePointer output_text, RectVector component_rects, StringVector component_texts, FloatVector component_confidences, int component_level)` \brief Recognize text using HMM.
`BytePointer`	OCRBeamSearchDecoder.`run(Mat image, Mat mask, int min_confidence)`
`BytePointer`	OCRTesseract.`run(Mat image, Mat mask, int min_confidence)`
`BytePointer`	OCRHMMDecoder.`run(Mat image, Mat mask, int min_confidence)`
`BytePointer`	OCRBeamSearchDecoder.`run(Mat image, Mat mask, int min_confidence, int component_level)`
`BytePointer`	OCRTesseract.`run(Mat image, Mat mask, int min_confidence, int component_level)`
`BytePointer`	OCRHMMDecoder.`run(Mat image, Mat mask, int min_confidence, int component_level)`

Uses of Mat in org.bytedeco.opencv.opencv_tracking

Methods in org.bytedeco.opencv.opencv_tracking that return Mat
Modifier and Type	Method and Description
`Mat`	UnscentedKalmanFilter.`correct(GpuMat measurement)`
`Mat`	UnscentedKalmanFilter.`correct(Mat measurement)` The function performs correction step of the algorithm
`Mat`	UnscentedKalmanFilter.`correct(UMat measurement)`
`Mat`	Track.`descriptor_fast()` Fast descriptor.
`Mat`	Track.`descriptor_strong()` Strong descriptor (reid embedding).
`Mat`	ITrackerByMatching.`drawActiveTracks(Mat frame)` \brief Draws active tracks on a given frame.
`Mat`	UnscentedKalmanFilterParams.`errorCovInit()` State estimate cross-covariance matrix, DP x DP, default is identity.
`Mat`	CvFeatureEvaluator.`getCls()`
`Mat`	Detector.`getConfImageDisplay()`
`Mat`	UnscentedKalmanFilter.`getErrorCov()`
`Mat`	UnscentedKalmanFilter.`getMeasurementNoiseCov()`
`Mat`	UnscentedKalmanFilter.`getProcessNoiseCov()`
`Mat`	UnscentedKalmanFilter.`getState()`
`Mat`	Track.`last_image()` Image of last detected object in track.
`Mat`	UnscentedKalmanFilterParams.`measurementNoiseCov()` Measurement noise cross-covariance matrix, MP x MP.
`Mat`	UnscentedKalmanFilter.`predict()`
`Mat`	UnscentedKalmanFilter.`predict(GpuMat control)`
`Mat`	UnscentedKalmanFilter.`predict(Mat control)` The function performs prediction step of the algorithm
`Mat`	UnscentedKalmanFilter.`predict(UMat control)`
`Mat`	UnscentedKalmanFilterParams.`processNoiseCov()` Process noise cross-covariance matrix, DP x DP.
`Mat`	UnscentedKalmanFilterParams.`stateInit()` Initial state, DP x 1, default is zero.

Methods in org.bytedeco.opencv.opencv_tracking with parameters of type Mat
Modifier and Type	Method and Description
`void`	TrackerKCF.FeatureExtractorCallbackFN.`call(Mat arg0, Rect arg1, Mat arg2)`
`float`	CosDistance.`compute(Mat descr1, Mat descr2)` \brief Computes distance between two descriptors.
`void`	ResizedImageDescriptor.`compute(Mat mat, Mat descr)` \brief Computes image descriptor.
`float`	MatchTemplateDistance.`compute(Mat descr1, Mat descr2)` \brief Computes distance between image descriptors.
`void`	IImageDescriptor.`compute(Mat mat, Mat descr)` \brief Computes image descriptor.
`float`	IDescriptorDistance.`compute(Mat descr1, Mat descr2)` \brief Computes distance between two descriptors.
`Mat`	UnscentedKalmanFilter.`correct(Mat measurement)` The function performs correction step of the algorithm
`Track`	Track.`descriptor_fast(Mat setter)`
`Track`	Track.`descriptor_strong(Mat setter)`
`Mat`	ITrackerByMatching.`drawActiveTracks(Mat frame)` \brief Draws active tracks on a given frame.
`UnscentedKalmanFilterParams`	UnscentedKalmanFilterParams.`errorCovInit(Mat setter)`
`int`	BaseClassifier.`eval(Mat image)`
`float`	StrongClassifierDirectSelection.`eval(Mat response)`
`boolean`	CvHaarEvaluator.FeatureHaar.`eval(Mat image, Rect ROI, float[] result)`
`boolean`	CvHaarEvaluator.FeatureHaar.`eval(Mat image, Rect ROI, FloatBuffer result)`
`boolean`	CvHaarEvaluator.FeatureHaar.`eval(Mat image, Rect ROI, FloatPointer result)`
`Track`	Track.`last_image(Mat setter)`
`void`	UkfSystemModel.`measurementFunction(Mat x_k, Mat n_k, Mat z_k)` The function for computing the measurement from the state
`UnscentedKalmanFilterParams`	UnscentedKalmanFilterParams.`measurementNoiseCov(Mat setter)`
`Mat`	UnscentedKalmanFilter.`predict(Mat control)` The function performs prediction step of the algorithm
`void`	ITrackerByMatching.`process(Mat frame, TrackedObjectDeque detections, int timestamp)` \brief Process given frame.
`UnscentedKalmanFilterParams`	UnscentedKalmanFilterParams.`processNoiseCov(Mat setter)`
`void`	CvHaarEvaluator.`setImage(Mat img)`
`void`	CvHaarEvaluator.`setImage(Mat img, byte clsLabel, int idx)`
`void`	CvLBPEvaluator.`setImage(Mat img, byte clsLabel, int idx)`
`void`	CvHOGEvaluator.`setImage(Mat img, byte clsLabel, int idx)`
`void`	CvFeatureEvaluator.`setImage(Mat img, byte clsLabel, int idx)`
`void`	TrackerCSRT.`setInitialMask(Mat mask)`
`void`	UkfSystemModel.`stateConversionFunction(Mat x_k, Mat u_k, Mat v_k, Mat x_kplus1)` The function for computing the next state from the previous state
`UnscentedKalmanFilterParams`	UnscentedKalmanFilterParams.`stateInit(Mat setter)`
`void`	BaseClassifier.`trainClassifier(Mat image, int target, float importance, boolean[] errorMask)`
`void`	BaseClassifier.`trainClassifier(Mat image, int target, float importance, BoolPointer errorMask)`
`boolean`	StrongClassifierDirectSelection.`update(Mat image, int target)`
`boolean`	StrongClassifierDirectSelection.`update(Mat image, int target, float importance)`
`void`	CvHaarEvaluator.`writeFeatures(FileStorage fs, Mat featureMap)`
`void`	CvLBPEvaluator.`writeFeatures(FileStorage fs, Mat featureMap)`
`void`	CvHOGEvaluator.`writeFeatures(FileStorage fs, Mat featureMap)`
`void`	CvFeatureEvaluator.`writeFeatures(FileStorage fs, Mat featureMap)`

Constructors in org.bytedeco.opencv.opencv_tracking with parameters of type Mat
Constructor and Description
`Track(TrackedObjectDeque objs, Mat last_image, Mat descriptor_fast, Mat descriptor_strong)` \brief Track constructor.

Uses of Mat in org.bytedeco.opencv.opencv_video

Methods in org.bytedeco.opencv.opencv_video that return Mat
Modifier and Type	Method and Description
`Mat`	KalmanFilter.`controlMatrix()` control matrix (B) (not used if there is no control)
`Mat`	KalmanFilter.`correct(Mat measurement)` \brief Updates the predicted state from the measurement.
`Mat`	KalmanFilter.`errorCovPost()` posteriori error estimate covariance matrix (P(k)): P(k)=(I-K(k)H)P'(k)
`Mat`	KalmanFilter.`errorCovPre()` priori error estimate covariance matrix (P'(k)): P'(k)=AP(k-1)At + Q)
`Mat`	KalmanFilter.`gain()` Kalman gain matrix (K(k)): K(k)=P'(k)Htinv(HP'(k)Ht+R)
`Mat`	KalmanFilter.`measurementMatrix()` measurement matrix (H)
`Mat`	KalmanFilter.`measurementNoiseCov()` measurement noise covariance matrix (R)
`Mat`	KalmanFilter.`predict()`
`Mat`	KalmanFilter.`predict(Mat control)` \brief Computes a predicted state.
`Mat`	KalmanFilter.`processNoiseCov()` process noise covariance matrix (Q)
`Mat`	KalmanFilter.`statePost()` corrected state (x(k)): x(k)=x'(k)+K(k)(z(k)-Hx'(k))
`Mat`	KalmanFilter.`statePre()` predicted state (x'(k)): x(k)=Ax(k-1)+Bu(k)
`Mat`	KalmanFilter.`temp1()`
`Mat`	KalmanFilter.`temp2()`
`Mat`	KalmanFilter.`temp3()`
`Mat`	KalmanFilter.`temp4()`
`Mat`	KalmanFilter.`temp5()`
`Mat`	KalmanFilter.`transitionMatrix()` state transition matrix (A)

Methods in org.bytedeco.opencv.opencv_video with parameters of type Mat
Modifier and Type	Method and Description
`void`	BackgroundSubtractor.`apply(Mat image, Mat fgmask)`
`void`	BackgroundSubtractorMOG2.`apply(Mat image, Mat fgmask)`
`void`	BackgroundSubtractor.`apply(Mat image, Mat fgmask, double learningRate)` \brief Computes a foreground mask.
`void`	BackgroundSubtractorMOG2.`apply(Mat image, Mat fgmask, double learningRate)` \brief Computes a foreground mask.
`void`	DenseOpticalFlow.`calc(Mat I0, Mat I1, Mat flow)` \brief Calculates an optical flow.
`void`	SparseOpticalFlow.`calc(Mat prevImg, Mat nextImg, Mat prevPts, Mat nextPts, Mat status)`
`void`	SparseOpticalFlow.`calc(Mat prevImg, Mat nextImg, Mat prevPts, Mat nextPts, Mat status, Mat err)` \brief Calculates a sparse optical flow.
`void`	VariationalRefinement.`calcUV(Mat I0, Mat I1, Mat flow_u, Mat flow_v)` \brief \ref calc function overload to handle separate horizontal (u) and vertical (v) flow components (to avoid extra splits/merges)
`KalmanFilter`	KalmanFilter.`controlMatrix(Mat setter)`
`Mat`	KalmanFilter.`correct(Mat measurement)` \brief Updates the predicted state from the measurement.
`KalmanFilter`	KalmanFilter.`errorCovPost(Mat setter)`
`KalmanFilter`	KalmanFilter.`errorCovPre(Mat setter)`
`KalmanFilter`	KalmanFilter.`gain(Mat setter)`
`void`	BackgroundSubtractor.`getBackgroundImage(Mat backgroundImage)` \brief Computes a background image.
`void`	Tracker.`init(Mat image, Rect boundingBox)` \brief Initialize the tracker with a known bounding box that surrounded the target
`KalmanFilter`	KalmanFilter.`measurementMatrix(Mat setter)`
`KalmanFilter`	KalmanFilter.`measurementNoiseCov(Mat setter)`
`Mat`	KalmanFilter.`predict(Mat control)` \brief Computes a predicted state.
`KalmanFilter`	KalmanFilter.`processNoiseCov(Mat setter)`
`KalmanFilter`	KalmanFilter.`statePost(Mat setter)`
`KalmanFilter`	KalmanFilter.`statePre(Mat setter)`
`KalmanFilter`	KalmanFilter.`temp1(Mat setter)`
`KalmanFilter`	KalmanFilter.`temp2(Mat setter)`
`KalmanFilter`	KalmanFilter.`temp3(Mat setter)`
`KalmanFilter`	KalmanFilter.`temp4(Mat setter)`
`KalmanFilter`	KalmanFilter.`temp5(Mat setter)`
`KalmanFilter`	KalmanFilter.`transitionMatrix(Mat setter)`
`boolean`	Tracker.`update(Mat image, Rect boundingBox)` \brief Update the tracker, find the new most likely bounding box for the target

Uses of Mat in org.bytedeco.opencv.opencv_videoio

Methods in org.bytedeco.opencv.opencv_videoio with parameters of type Mat
Modifier and Type	Method and Description
`boolean`	VideoCapture.`read(Mat image)` \brief Grabs, decodes and returns the next video frame.
`boolean`	VideoCapture.`retrieve(Mat image)`
`boolean`	VideoCapture.`retrieve(Mat image, int flag)` \brief Decodes and returns the grabbed video frame.
`VideoWriter`	VideoWriter.`shiftLeft(Mat image)` \brief Stream operator to write the next video frame.
`VideoCapture`	VideoCapture.`shiftRight(Mat image)` \brief Stream operator to read the next video frame.
`void`	VideoWriter.`write(Mat image)` \brief Writes the next video frame

Uses of Mat in org.bytedeco.opencv.opencv_videostab

Methods in org.bytedeco.opencv.opencv_videostab that return Mat
Modifier and Type	Method and Description
`Mat`	FastMarchingMethod.`distanceMap()`
`Mat`	MotionEstimatorRansacL2.`estimate(GpuMat points0, GpuMat points1)`
`Mat`	MotionEstimatorBase.`estimate(GpuMat points0, GpuMat points1)`
`Mat`	MotionEstimatorL1.`estimate(GpuMat points0, GpuMat points1)`
`Mat`	KeypointBasedMotionEstimator.`estimate(GpuMat frame0, GpuMat frame1)`
`Mat`	MotionEstimatorRansacL2.`estimate(GpuMat points0, GpuMat points1, boolean[] ok)`
`Mat`	MotionEstimatorBase.`estimate(GpuMat points0, GpuMat points1, boolean[] ok)`
`Mat`	MotionEstimatorL1.`estimate(GpuMat points0, GpuMat points1, boolean[] ok)`
`Mat`	KeypointBasedMotionEstimator.`estimate(GpuMat frame0, GpuMat frame1, boolean[] ok)`
`Mat`	MotionEstimatorRansacL2.`estimate(GpuMat points0, GpuMat points1, BoolPointer ok)`
`Mat`	MotionEstimatorBase.`estimate(GpuMat points0, GpuMat points1, BoolPointer ok)`
`Mat`	MotionEstimatorL1.`estimate(GpuMat points0, GpuMat points1, BoolPointer ok)`
`Mat`	KeypointBasedMotionEstimator.`estimate(GpuMat frame0, GpuMat frame1, BoolPointer ok)`
`Mat`	MotionEstimatorRansacL2.`estimate(Mat points0, Mat points1)`
`Mat`	MotionEstimatorBase.`estimate(Mat points0, Mat points1)`
`Mat`	ToFileMotionWriter.`estimate(Mat frame0, Mat frame1)`
`Mat`	ImageMotionEstimatorBase.`estimate(Mat frame0, Mat frame1)`
`Mat`	MotionEstimatorL1.`estimate(Mat points0, Mat points1)`
`Mat`	FromFileMotionReader.`estimate(Mat frame0, Mat frame1)`
`Mat`	KeypointBasedMotionEstimator.`estimate(Mat frame0, Mat frame1)`
`Mat`	MotionEstimatorRansacL2.`estimate(Mat points0, Mat points1, boolean[] ok)`
`Mat`	MotionEstimatorBase.`estimate(Mat points0, Mat points1, boolean[] ok)`
`Mat`	ToFileMotionWriter.`estimate(Mat frame0, Mat frame1, boolean[] ok)`
`Mat`	ImageMotionEstimatorBase.`estimate(Mat frame0, Mat frame1, boolean[] ok)`
`Mat`	MotionEstimatorL1.`estimate(Mat points0, Mat points1, boolean[] ok)`
`Mat`	FromFileMotionReader.`estimate(Mat frame0, Mat frame1, boolean[] ok)`
`Mat`	KeypointBasedMotionEstimator.`estimate(Mat frame0, Mat frame1, boolean[] ok)`
`Mat`	MotionEstimatorRansacL2.`estimate(Mat points0, Mat points1, BoolPointer ok)`
`Mat`	MotionEstimatorBase.`estimate(Mat points0, Mat points1, BoolPointer ok)` \brief Estimates global motion between two 2D point clouds.
`Mat`	ToFileMotionWriter.`estimate(Mat frame0, Mat frame1, BoolPointer ok)`
`Mat`	ImageMotionEstimatorBase.`estimate(Mat frame0, Mat frame1, BoolPointer ok)`
`Mat`	MotionEstimatorL1.`estimate(Mat points0, Mat points1, BoolPointer ok)`
`Mat`	FromFileMotionReader.`estimate(Mat frame0, Mat frame1, BoolPointer ok)`
`Mat`	KeypointBasedMotionEstimator.`estimate(Mat frame0, Mat frame1, BoolPointer ok)`
`Mat`	MotionEstimatorRansacL2.`estimate(UMat points0, UMat points1)`
`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, boolean[] ok)`
`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, BoolPointer 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`	TwoPassStabilizer.`nextFrame()`
`Mat`	MaskFrameSource.`nextFrame()`
`Mat`	VideoFileSource.`nextFrame()`
`Mat`	NullFrameSource.`nextFrame()`
`Mat`	IFrameSource.`nextFrame()`
`Mat`	OnePassStabilizer.`nextFrame()`
`Mat`	GaussianMotionFilter.`stabilize(int idx, MatVector motions, Range range)`
`Mat`	MotionFilterBase.`stabilize(int idx, MatVector motions, Range range)`

Methods in org.bytedeco.opencv.opencv_videostab with parameters of type Mat
Modifier and Type	Method and Description
`void`	NullDeblurer.`deblur(int arg0, Mat arg1, Range arg2)`
`void`	DeblurerBase.`deblur(int idx, Mat frame, Range range)`
`void`	WeightingDeblurer.`deblur(int idx, Mat frame, Range range)`
`Mat`	MotionEstimatorRansacL2.`estimate(Mat points0, Mat points1)`
`Mat`	MotionEstimatorBase.`estimate(Mat points0, Mat points1)`
`Mat`	ToFileMotionWriter.`estimate(Mat frame0, Mat frame1)`
`Mat`	ImageMotionEstimatorBase.`estimate(Mat frame0, Mat frame1)`
`Mat`	MotionEstimatorL1.`estimate(Mat points0, Mat points1)`
`Mat`	FromFileMotionReader.`estimate(Mat frame0, Mat frame1)`
`Mat`	KeypointBasedMotionEstimator.`estimate(Mat frame0, Mat frame1)`
`Mat`	MotionEstimatorRansacL2.`estimate(Mat points0, Mat points1, boolean[] ok)`
`Mat`	MotionEstimatorBase.`estimate(Mat points0, Mat points1, boolean[] ok)`
`Mat`	ToFileMotionWriter.`estimate(Mat frame0, Mat frame1, boolean[] ok)`
`Mat`	ImageMotionEstimatorBase.`estimate(Mat frame0, Mat frame1, boolean[] ok)`
`Mat`	MotionEstimatorL1.`estimate(Mat points0, Mat points1, boolean[] ok)`
`Mat`	FromFileMotionReader.`estimate(Mat frame0, Mat frame1, boolean[] ok)`
`Mat`	KeypointBasedMotionEstimator.`estimate(Mat frame0, Mat frame1, boolean[] ok)`
`Mat`	MotionEstimatorRansacL2.`estimate(Mat points0, Mat points1, BoolPointer ok)`
`Mat`	MotionEstimatorBase.`estimate(Mat points0, Mat points1, BoolPointer ok)` \brief Estimates global motion between two 2D point clouds.
`Mat`	ToFileMotionWriter.`estimate(Mat frame0, Mat frame1, BoolPointer ok)`
`Mat`	ImageMotionEstimatorBase.`estimate(Mat frame0, Mat frame1, BoolPointer ok)`
`Mat`	MotionEstimatorL1.`estimate(Mat points0, Mat points1, BoolPointer ok)`
`Mat`	FromFileMotionReader.`estimate(Mat frame0, Mat frame1, BoolPointer ok)`
`Mat`	KeypointBasedMotionEstimator.`estimate(Mat frame0, Mat frame1, BoolPointer ok)`
`void`	ConsistentMosaicInpainter.`inpaint(int idx, Mat frame, Mat mask)`
`void`	ColorAverageInpainter.`inpaint(int idx, Mat frame, Mat mask)`
`void`	ColorInpainter.`inpaint(int idx, Mat frame, Mat mask)`
`void`	InpainterBase.`inpaint(int idx, Mat frame, Mat mask)`
`void`	InpaintingPipeline.`inpaint(int idx, Mat frame, Mat mask)`
`void`	NullInpainter.`inpaint(int arg0, Mat arg1, Mat arg2)`
`void`	MotionInpainter.`inpaint(int idx, Mat frame, Mat mask)`
`void`	TranslationBasedLocalOutlierRejector.`process(Size frameSize, Mat points0, Mat points1, Mat mask)`
`void`	NullOutlierRejector.`process(Size frameSize, Mat points0, Mat points1, Mat mask)`
`void`	IOutlierRejector.`process(Size frameSize, Mat points0, Mat points1, Mat mask)`
`void`	IDenseOptFlowEstimator.`run(Mat frame0, Mat frame1, Mat flowX, Mat flowY, Mat errors)`
`void`	SparsePyrLkOptFlowEstimator.`run(Mat frame0, Mat frame1, Mat points0, Mat points1, Mat status, Mat errors)`
`void`	ISparseOptFlowEstimator.`run(Mat frame0, Mat frame1, Mat points0, Mat points1, Mat status, Mat errors)`
`void`	ToFileMotionWriter.`setFrameMask(Mat mask)`
`void`	ImageMotionEstimatorBase.`setFrameMask(Mat mask)`
`void`	KeypointBasedMotionEstimator.`setFrameMask(Mat mask)`
`void`	LpMotionStabilizer.`stabilize(int size, MatVector motions, Range range, Mat stabilizationMotions)`
`void`	MotionStabilizationPipeline.`stabilize(int size, MatVector motions, Range range, Mat stabilizationMotions)`
`void`	IMotionStabilizer.`stabilize(int size, MatVector motions, Range range, Mat stabilizationMotions)` assumes that [0, size-1) is in or equals to [range.first, range.second)
`void`	MotionFilterBase.`stabilize(int size, MatVector motions, Range range, Mat stabilizationMotions)`
`void`	NullWobbleSuppressor.`suppress(int idx, Mat frame, Mat result)`
`void`	MoreAccurateMotionWobbleSuppressor.`suppress(int idx, Mat frame, Mat result)`
`void`	WobbleSuppressorBase.`suppress(int idx, Mat frame, Mat result)`

Uses of Mat in org.bytedeco.opencv.opencv_wechat_qrcode

Methods in org.bytedeco.opencv.opencv_wechat_qrcode with parameters of type Mat
Modifier and Type	Method and Description
`StringVector`	WeChatQRCode.`detectAndDecode(Mat img)`
`StringVector`	WeChatQRCode.`detectAndDecode(Mat img, GpuMatVector points)`
`StringVector`	WeChatQRCode.`detectAndDecode(Mat img, MatVector points)` \brief Both detects and decodes QR code.
`StringVector`	WeChatQRCode.`detectAndDecode(Mat img, UMatVector points)`

Uses of Mat in org.bytedeco.opencv.opencv_xfeatures2d

Methods in org.bytedeco.opencv.opencv_xfeatures2d with parameters of type Mat
Modifier and Type	Method and Description
`void`	DAISY.`compute(Mat image, KeyPointVector keypoints, Mat descriptors)` \overload
`void`	DAISY.`compute(Mat image, Mat descriptors)` \overload
`void`	DAISY.`compute(Mat image, Rect roi, Mat descriptors)` \overload
`float`	PCTSignaturesSQFD.`computeQuadraticFormDistance(Mat _signature0, Mat _signature1)` \brief Computes Signature Quadratic Form Distance of two signatures.
`void`	PCTSignaturesSQFD.`computeQuadraticFormDistances(Mat sourceSignature, MatVector imageSignatures, float[] distances)`
`void`	PCTSignaturesSQFD.`computeQuadraticFormDistances(Mat sourceSignature, MatVector imageSignatures, FloatBuffer distances)`
`void`	PCTSignaturesSQFD.`computeQuadraticFormDistances(Mat sourceSignature, MatVector imageSignatures, FloatPointer distances)` \brief Computes Signature Quadratic Form Distance between the reference signature and each of the other image signatures.
`void`	PCTSignatures.`computeSignature(Mat image, Mat signature)` \brief Computes signature of given image.
`static DAISY`	DAISY.`create(float radius, int q_radius, int q_theta, int q_hist, int norm, Mat H, boolean interpolation, boolean use_orientation)`
`void`	AffineFeature2D.`detect(Mat image, Elliptic_KeyPoint keypoints)`
`void`	AffineFeature2D.`detect(Mat image, Elliptic_KeyPoint keypoints, Mat mask)` \brief Detects keypoints in the image using the wrapped detector and performs affine adaptation to augment them with their elliptic regions.
`void`	AffineFeature2D.`detectAndCompute(Mat image, Mat mask, Elliptic_KeyPoint keypoints, Mat descriptors)`
`void`	AffineFeature2D.`detectAndCompute(Mat image, Mat mask, Elliptic_KeyPoint keypoints, Mat descriptors, boolean useProvidedKeypoints)` \brief Detects keypoints and computes descriptors for their surrounding regions, after warping them into circles.
`static void`	PCTSignatures.`drawSignature(Mat source, Mat signature, Mat result)`
`static void`	PCTSignatures.`drawSignature(Mat source, Mat signature, Mat result, float radiusToShorterSideRatio, int borderThickness)` \brief Draws signature in the source image and outputs the result.

Uses of Mat in org.bytedeco.opencv.opencv_ximgproc

Methods in org.bytedeco.opencv.opencv_ximgproc that return Mat
Modifier and Type	Method and Description
`Mat`	DisparityWLSFilter.`getConfidenceMap()` \brief Get the confidence map that was used in the last filter call.

Methods in org.bytedeco.opencv.opencv_ximgproc with parameters of type Mat
Modifier and Type	Method and Description
`void`	SelectiveSearchSegmentation.`addImage(Mat img)` \brief Add a new image in the list of images to process.
`void`	StructuredEdgeDetection.`computeOrientation(Mat _src, Mat _dst)` \brief The function computes orientation from edge image.
`void`	FastLineDetector.`detect(Mat image, Mat lines)` \brief Finds lines in the input image.
`void`	StructuredEdgeDetection.`detectEdges(Mat _src, Mat _dst)` \brief The function detects edges in src and draw them to dst.
`void`	FastLineDetector.`drawSegments(Mat image, Mat lines)`
`void`	FastLineDetector.`drawSegments(Mat image, Mat lines, boolean draw_arrow, Scalar linecolor, int linethickness)` \brief Draws the line segments on a given image.
`void`	StructuredEdgeDetection.`edgesNms(Mat edge_image, Mat orientation_image, Mat _dst)`
`void`	StructuredEdgeDetection.`edgesNms(Mat edge_image, Mat orientation_image, Mat _dst, int r, int s, float m, boolean isParallel)` \brief The function edgenms in edge image and suppress edges where edge is stronger in orthogonal direction.
`void`	ContourFitting.`estimateTransformation(Mat src, Mat dst, Mat alphaPhiST)`
`void`	ContourFitting.`estimateTransformation(Mat src, Mat dst, Mat alphaPhiST, double[] dist)`
`void`	ContourFitting.`estimateTransformation(Mat src, Mat dst, Mat alphaPhiST, double[] dist, boolean fdContour)`
`void`	ContourFitting.`estimateTransformation(Mat src, Mat dst, Mat alphaPhiST, DoubleBuffer dist)`
`void`	ContourFitting.`estimateTransformation(Mat src, Mat dst, Mat alphaPhiST, DoubleBuffer dist, boolean fdContour)`
`void`	ContourFitting.`estimateTransformation(Mat src, Mat dst, Mat alphaPhiST, DoublePointer dist)` \brief Fit two closed curves using fourier descriptors.
`void`	ContourFitting.`estimateTransformation(Mat src, Mat dst, Mat alphaPhiST, DoublePointer dist, boolean fdContour)` \brief Fit two closed curves using fourier descriptors.
`void`	GuidedFilter.`filter(Mat src, Mat dst)`
`void`	FastGlobalSmootherFilter.`filter(Mat src, Mat dst)` \brief Apply smoothing operation to the source image.
`void`	DTFilter.`filter(Mat src, Mat dst)`
`void`	AdaptiveManifoldFilter.`filter(Mat src, Mat dst)`
`void`	GuidedFilter.`filter(Mat src, Mat dst, int dDepth)` \brief Apply Guided Filter to the filtering image.
`void`	DTFilter.`filter(Mat src, Mat dst, int dDepth)` \brief Produce domain transform filtering operation on source image.
`void`	DisparityFilter.`filter(Mat disparity_map_left, Mat left_view, Mat filtered_disparity_map)`
`void`	FastBilateralSolverFilter.`filter(Mat src, Mat confidence, Mat dst)` \brief Apply smoothing operation to the source image.
`void`	AdaptiveManifoldFilter.`filter(Mat src, Mat dst, Mat joint)` \brief Apply high-dimensional filtering using adaptive manifolds.
`void`	DisparityFilter.`filter(Mat disparity_map_left, Mat left_view, Mat filtered_disparity_map, Mat disparity_map_right, Rect ROI, Mat right_view)` \brief Apply filtering to the disparity map.
`void`	EdgeBoxes.`getBoundingBoxes(Mat edge_map, Mat orientation_map, RectVector boxes)`
`void`	EdgeBoxes.`getBoundingBoxes(Mat edge_map, Mat orientation_map, RectVector boxes, Mat scores)` \brief Returns array containing proposal boxes.
`void`	RFFeatureGetter.`getFeatures(Mat src, Mat features, int gnrmRad, int gsmthRad, int shrink, int outNum, int gradNum)` This functions extracts feature channels from src.
`void`	SuperpixelSLIC.`getLabelContourMask(Mat image)`
`void`	SuperpixelSEEDS.`getLabelContourMask(Mat image)`
`void`	SuperpixelLSC.`getLabelContourMask(Mat image)`
`void`	SuperpixelSLIC.`getLabelContourMask(Mat image, boolean thick_line)` \brief Returns the mask of the superpixel segmentation stored in SuperpixelSLIC object.
`void`	SuperpixelSEEDS.`getLabelContourMask(Mat image, boolean thick_line)` \brief Returns the mask of the superpixel segmentation stored in SuperpixelSEEDS object.
`void`	SuperpixelLSC.`getLabelContourMask(Mat image, boolean thick_line)` \brief Returns the mask of the superpixel segmentation stored in SuperpixelLSC object.
`void`	SuperpixelSLIC.`getLabels(Mat labels_out)` \brief Returns the segmentation labeling of the image.
`void`	SuperpixelSEEDS.`getLabels(Mat labels_out)` \brief Returns the segmentation labeling of the image.
`void`	SuperpixelLSC.`getLabels(Mat labels_out)` \brief Returns the segmentation labeling of the image.
`void`	RidgeDetectionFilter.`getRidgeFilteredImage(Mat _img, Mat out)` \brief Apply Ridge detection filter on input image.
`void`	SparseMatchInterpolator.`interpolate(Mat from_image, Mat from_points, Mat to_image, Mat to_points, Mat dense_flow)` \brief Interpolate input sparse matches.
`void`	SuperpixelSEEDS.`iterate(Mat img)`
`void`	SuperpixelSEEDS.`iterate(Mat img, int num_iterations)` \brief Calculates the superpixel segmentation on a given image with the initialized parameters in the SuperpixelSEEDS object.
`void`	GraphSegmentation.`processImage(Mat src, Mat dst)` \brief Segment an image and store output in dst
`void`	SelectiveSearchSegmentation.`setBaseImage(Mat img)` \brief Set a image used by switch* functions to initialize the class
`void`	EdgeAwareInterpolator.`setCostMap(Mat _costMap)` \brief Interface to provide a more elaborated cost map, i.e.
`void`	RICInterpolator.`setCostMap(Mat costMap)` \brief Interface to provide a more elaborated cost map, i.e.
`void`	SelectiveSearchSegmentationStrategy.`setImage(Mat img, Mat regions, Mat sizes)`
`void`	SelectiveSearchSegmentationStrategy.`setImage(Mat img, Mat regions, Mat sizes, int image_id)` \brief Set a initial image, with a segmentation.

Uses of Mat in org.bytedeco.opencv.opencv_xphoto

Methods in org.bytedeco.opencv.opencv_xphoto with parameters of type Mat
Modifier and Type	Method and Description
`void`	WhiteBalancer.`balanceWhite(Mat src, Mat dst)` \brief Applies white balancing to the input image
`void`	LearningBasedWB.`extractSimpleFeatures(Mat src, Mat dst)` \brief Implements the feature extraction part of the algorithm.

Uses of Classorg.bytedeco.opencv.opencv_core.Mat

Uses of Mat in org.bytedeco.opencv.global

Uses of Mat in org.bytedeco.opencv.opencv_aruco

Uses of Mat in org.bytedeco.opencv.opencv_barcode

Uses of Mat in org.bytedeco.opencv.opencv_bgsegm

Uses of Mat in org.bytedeco.opencv.opencv_bioinspired

Uses of Mat in org.bytedeco.opencv.opencv_calib3d

Uses of Mat in org.bytedeco.opencv.opencv_core

Uses of Mat in org.bytedeco.opencv.opencv_cudaarithm

Uses of Mat in org.bytedeco.opencv.opencv_cudabgsegm

Uses of Mat in org.bytedeco.opencv.opencv_cudacodec

Uses of Mat in org.bytedeco.opencv.opencv_cudafeatures2d

Uses of Mat in org.bytedeco.opencv.opencv_cudafilters

Uses of Mat in org.bytedeco.opencv.opencv_cudaimgproc

Uses of Mat in org.bytedeco.opencv.opencv_cudaobjdetect

Uses of Mat in org.bytedeco.opencv.opencv_cudaoptflow

Uses of Mat in org.bytedeco.opencv.opencv_cudastereo

Uses of Mat in org.bytedeco.opencv.opencv_dnn

Uses of Mat in org.bytedeco.opencv.opencv_dnn_superres

Uses of Mat in org.bytedeco.opencv.opencv_face

Uses of Mat in org.bytedeco.opencv.opencv_features2d

Uses of Mat in org.bytedeco.opencv.opencv_flann

Uses of Mat in org.bytedeco.opencv.opencv_img_hash

Uses of Mat in org.bytedeco.opencv.opencv_imgproc

Uses of Mat in org.bytedeco.opencv.opencv_mcc

Uses of Mat in org.bytedeco.opencv.opencv_ml

Uses of Mat in org.bytedeco.opencv.opencv_objdetect

Uses of Mat in org.bytedeco.opencv.opencv_phase_unwrapping

Uses of Mat in org.bytedeco.opencv.opencv_photo

Uses of Mat in org.bytedeco.opencv.opencv_plot

Uses of Mat in org.bytedeco.opencv.opencv_quality

Uses of Mat in org.bytedeco.opencv.opencv_rapid

Uses of Mat in org.bytedeco.opencv.opencv_saliency

Uses of Mat in org.bytedeco.opencv.opencv_shape

Uses of Mat in org.bytedeco.opencv.opencv_stitching

Uses of Mat in org.bytedeco.opencv.opencv_structured_light

Uses of Mat in org.bytedeco.opencv.opencv_superres

Uses of Mat in org.bytedeco.opencv.opencv_text

Uses of Mat in org.bytedeco.opencv.opencv_tracking

Uses of Mat in org.bytedeco.opencv.opencv_video

Uses of Mat in org.bytedeco.opencv.opencv_videoio

Uses of Mat in org.bytedeco.opencv.opencv_videostab

Uses of Mat in org.bytedeco.opencv.opencv_wechat_qrcode

Uses of Mat in org.bytedeco.opencv.opencv_xfeatures2d

Uses of Mat in org.bytedeco.opencv.opencv_ximgproc

Uses of Mat in org.bytedeco.opencv.opencv_xphoto

Uses of Class
org.bytedeco.opencv.opencv_core.Mat