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(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(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.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,
GpuMat cameraMatrix) |
static Mat |
opencv_calib3d.findEssentialMat(GpuMat points1,
GpuMat points2,
GpuMat cameraMatrix,
int method,
double prob,
double threshold,
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,
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,
Mat mask)
\brief Calculates an essential matrix from the corresponding points in two images.
|
static Mat |
opencv_calib3d.findEssentialMat(UMat points1,
UMat points2) |
static Mat |
opencv_calib3d.findEssentialMat(UMat points1,
UMat points2,
double focal,
Point2d pp,
int method,
double prob,
double threshold,
UMat mask) |
static Mat |
opencv_calib3d.findEssentialMat(UMat points1,
UMat points2,
UMat cameraMatrix) |
static Mat |
opencv_calib3d.findEssentialMat(UMat points1,
UMat points2,
UMat cameraMatrix,
int method,
double prob,
double threshold,
UMat mask) |
static Mat |
opencv_calib3d.findFundamentalMat(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,
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(UMat points1,
UMat points2) |
static Mat |
opencv_calib3d.findFundamentalMat(UMat points1,
UMat points2,
int method,
double ransacReprojThreshold,
double confidence,
int maxIters) |
static Mat |
opencv_calib3d.findFundamentalMat(UMat points1,
UMat points2,
int method,
double ransacReprojThreshold,
double confidence,
int maxIters,
UMat mask) |
static Mat |
opencv_calib3d.findFundamentalMat(UMat points1,
UMat points2,
int method,
double ransacReprojThreshold,
double confidence,
UMat mask) |
static Mat |
opencv_calib3d.findFundamentalMat(UMat points1,
UMat points2,
UMat mask) |
static Mat |
opencv_calib3d.findFundamentalMat(UMat points1,
UMat points2,
UMat mask,
int method,
double ransacReprojThreshold,
double confidence) |
static Mat |
opencv_calib3d.findHomography(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,
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(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_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 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_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)
\brief Loads an image from a file.
|
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 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) |
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_cudaarithm.absdiff(Mat src1,
Mat src2,
Mat dst) |
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,
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_cudaarithm.add(Mat src1,
Mat src2,
Mat dst) |
static void |
opencv_core.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_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) |
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 diffusian 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_cudaarithm.bitwise_and(Mat src1,
Mat src2,
Mat dst) |
static void |
opencv_core.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_cudaarithm.bitwise_not(Mat src,
Mat dst) |
static void |
opencv_core.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_cudaarithm.bitwise_or(Mat src1,
Mat src2,
Mat dst) |
static void |
opencv_core.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_cudaarithm.bitwise_xor(Mat src1,
Mat src2,
Mat dst) |
static void |
opencv_core.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
|
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
|
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 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 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 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_cudaarithm.cartToPolar(Mat x,
Mat y,
Mat magnitude,
Mat angle) |
static void |
opencv_core.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_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_cudaarithm.compare(Mat src1,
Mat src2,
Mat dst,
int cmpop) |
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,
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_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_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_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) |
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_cudaarithm.countNonZero(Mat src)
\brief Counts non-zero matrix elements.
|
static int |
opencv_core.countNonZero(Mat src)
\brief Counts non-zero array 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 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 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_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_cudaarithm.divide(Mat src1,
Mat src2,
Mat dst) |
static void |
opencv_core.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_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 srcLocations,
Mat newLocations) |
static void |
opencv_rapid.drawCorrespondencies(Mat bundle,
Mat srcLocations,
Mat newLocations,
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,
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)
\overload
|
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_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_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 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 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 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_cudaarithm.exp(Mat src,
Mat dst) |
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,
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
|
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
|
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_rapid.filterCorrespondencies(Mat pts2d,
Mat pts3d,
Mat mask)
Filter corresponding 2d and 3d points based on mask
|
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 srcLocations,
Mat newLocations) |
static void |
opencv_rapid.findCorrespondencies(Mat bundle,
Mat srcLocations,
Mat newLocations,
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,
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,
Mat mask)
\brief Calculates an essential matrix from the corresponding points in two images.
|
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.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 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_cudaarithm.flip(Mat src,
Mat dst,
int flipCode) |
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,
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_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_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) |
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 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.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 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.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_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_cudaarithm.integral(Mat src,
Mat sum) |
static void |
opencv_imgproc.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 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)"):
where
and
|
static void |
opencv_cudaarithm.log(Mat src,
Mat dst) |
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,
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)"):
where
and
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_cudaarithm.magnitude(Mat x,
Mat y,
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,
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_cudaarithm.max(Mat src1,
Mat src2,
Mat dst) |
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,
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_cudaarithm.merge(GpuMatVector src,
Mat dst) |
static void |
opencv_core.merge(GpuMatVector mv,
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_cudaarithm.min(Mat src1,
Mat src2,
Mat dst) |
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,
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_cudaarithm.minMaxLoc(Mat src,
double[] minVal,
double[] maxVal,
Point minLoc,
Point maxLoc,
Mat mask) |
static void |
opencv_core.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_cudaarithm.minMaxLoc(Mat src,
DoubleBuffer minVal,
DoubleBuffer maxVal,
Point minLoc,
Point maxLoc,
Mat mask) |
static void |
opencv_core.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_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.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_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_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\
|
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_cudaarithm.mulSpectrums(Mat src1,
Mat src2,
Mat dst,
int flags) |
static void |
opencv_core.mulSpectrums(Mat a,
Mat b,
Mat c,
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_cudaarithm.multiply(Mat src1,
Mat src2,
Mat dst) |
static void |
opencv_core.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)
\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_cudaarithm.norm(Mat src1,
int normType,
Mat mask)
\} cudaarithm_core
|
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,
Mat src2) |
static double |
opencv_core.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_core.patchNaNs(Mat a) |
static void |
opencv_core.patchNaNs(Mat a,
double val)
\brief converts NaN's 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 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_cudaarithm.phase(Mat x,
Mat y,
Mat angle) |
static void |
opencv_core.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_cudaarithm.polarToCart(Mat magnitude,
Mat angle,
Mat x,
Mat y) |
static void |
opencv_core.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_cudaarithm.pow(Mat src,
double power,
Mat dst) |
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,
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)
\addtogroup imgproc_filter
\{
|
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_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)
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_cudaarithm.reduce(Mat mtx,
Mat vec,
int dim,
int reduceOp) |
static void |
opencv_core.reduce(Mat src,
Mat dst,
int dim,
int rtype) |
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_cudaarithm.scaleAdd(Mat src1,
double alpha,
Mat src2,
Mat dst) |
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,
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 Selects 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 Selects 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 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_cudaarithm.split(Mat src,
GpuMatVector dst) |
static void |
opencv_core.split(Mat m,
GpuMatVector mv) |
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_cudaarithm.sqrt(Mat src,
Mat dst) |
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,
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_cudaarithm.subtract(Mat src1,
Mat src2,
Mat dst) |
static void |
opencv_core.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)
\brief Swaps two matrices
|
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 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_cudaarithm.threshold(Mat src,
Mat dst,
double thresh,
double maxval,
int type) |
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,
Stream stream)
\brief Applies a fixed-level threshold to each array element.
|
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_cudaarithm.transpose(Mat src1,
Mat dst) |
static void |
opencv_core.transpose(Mat src,
Mat dst)
\brief Transposes a matrix.
|
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_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) |
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
|
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 |
GridBoard.draw(Size outSize,
Mat img) |
void |
CharucoBoard.draw(Size outSize,
Mat img) |
void |
GridBoard.draw(Size outSize,
Mat img,
int marginSize,
int borderBits)
\brief Draw a GridBoard
|
void |
CharucoBoard.draw(Size outSize,
Mat img,
int marginSize,
int borderBits)
\brief Draw a ChArUco board
|
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.
|
Constructor and Description |
---|
Dictionary(Mat _bytesList,
int _markerSize,
int _maxcorr) |
Modifier and Type | Method and Description |
---|---|
void |
BackgroundSubtractorCNT.apply(Mat image,
Mat fgmask) |
void |
BackgroundSubtractorLSBP.apply(Mat image,
Mat fgmask) |
void |
BackgroundSubtractorGSOC.apply(Mat image,
Mat fgmask) |
void |
BackgroundSubtractorCNT.apply(Mat image,
Mat fgmask,
double learningRate) |
void |
BackgroundSubtractorLSBP.apply(Mat image,
Mat fgmask,
double learningRate) |
void |
BackgroundSubtractorGSOC.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 |
BackgroundSubtractorCNT.getBackgroundImage(Mat backgroundImage) |
void |
BackgroundSubtractorLSBP.getBackgroundImage(Mat backgroundImage) |
void |
BackgroundSubtractorGSOC.getBackgroundImage(Mat backgroundImage) |
void |
SyntheticSequenceGenerator.getNextFrame(Mat frame,
Mat gtMask)
\brief Obtain the next frame in the sequence.
|
Constructor and Description |
---|
SyntheticSequenceGenerator(Mat background,
Mat object,
double amplitude,
double wavelength,
double wavespeed,
double objspeed)
\brief Creates an instance of SyntheticSequenceGenerator.
|
Modifier and Type | Method and Description |
---|---|
Mat |
Retina.getMagnoRAW()
\overload
|
Mat |
Retina.getParvoRAW()
\overload
|
Modifier and Type | Method and Description |
---|---|
void |
RetinaFastToneMapping.applyFastToneMapping(Mat inputImage,
Mat outputToneMappedImage)
\brief applies a luminance correction (initially High Dynamic Range (HDR) tone mapping)
|
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 |
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()
|
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.
|
Modifier and Type | Field and Description |
---|---|
static Mat |
AbstractMat.EMPTY |
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(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 |
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() |
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 |
Mat.convertTo(Mat m,
int rtype) |
void |
UMat.convertTo(Mat m,
int rtype) |
void |
SparseMat.convertTo(Mat m,
int rtype) |
void |
GpuMat.convertTo(Mat dst,
int rtype)
converts GpuMat to another datatype (Blocking call)
|
void |
GpuMat.convertTo(Mat dst,
int rtype,
double alpha) |
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 |
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 |
GpuMat.convertTo(Mat dst,
int rtype,
double alpha,
double beta)
converts GpuMat to another datatype with scaling (Blocking call)
|
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 |
Mat.copyTo(Mat m)
\brief Copies the matrix to another one.
|
void |
UMat.copyTo(Mat m)
copies the matrix content to "m".
|
void |
SparseMat.copyTo(Mat m)
converts sparse matrix to dense matrix.
|
void |
GpuMat.copyTo(Mat dst)
copies the GpuMat content to device memory (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)
copies those GpuMat elements to "m" that are marked with non-zero mask elements (Blocking call)
|
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 |
GpuMat.download(Mat dst,
Stream stream)
\brief Performs data download from GpuMat (Non-Blocking call)
|
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) |
Mat |
Mat.put(Mat m)
\brief assignment operators
|
SparseMat |
SparseMat.put(Mat m)
equivalent to the corresponding constructor
|
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 |
GpuMat.upload(Mat arr,
Stream stream)
\brief Performs data upload to GpuMat (Non-Blocking call)
|
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) |
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,
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()
|
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)) .
|
Modifier and Type | Method and Description |
---|---|
void |
BackgroundSubtractorMOG.apply(Mat image,
Mat fgmask,
double learningRate,
Stream stream) |
void |
BackgroundSubtractorMOG2.apply(Mat image,
Mat fgmask,
double learningRate,
Stream stream) |
void |
BackgroundSubtractorMOG.getBackgroundImage(Mat backgroundImage,
Stream stream) |
void |
BackgroundSubtractorMOG2.getBackgroundImage(Mat backgroundImage,
Stream stream) |
Modifier and Type | Method and Description |
---|---|
void |
VideoWriter.write(Mat frame) |
void |
VideoWriter.write(Mat frame,
boolean lastFrame)
\brief Writes the next video frame.
|
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.
|
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.
|
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 |
HoughLinesDetector.detect(Mat src,
Mat lines) |
void |
CannyEdgeDetector.detect(Mat image,
Mat edges) |
void |
HoughSegmentDetector.detect(Mat src,
Mat lines) |
void |
CornersDetector.detect(Mat image,
Mat corners) |
void |
HoughCirclesDetector.detect(Mat src,
Mat circles) |
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 |
HoughLinesDetector.detect(Mat src,
Mat lines,
Stream stream)
\brief Finds lines in a binary image using the classical Hough transform.
|
void |
CannyEdgeDetector.detect(Mat image,
Mat edges,
Stream stream)
\brief Finds edges in an image using the \cite Canny86 algorithm.
|
void |
HoughSegmentDetector.detect(Mat src,
Mat lines,
Stream stream)
\brief Finds line segments in a binary image using the probabilistic Hough transform.
|
void |
HoughCirclesDetector.detect(Mat src,
Mat circles,
Stream stream)
\brief Finds circles in a grayscale image using the Hough transform.
|
void |
HoughLinesDetector.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.
|
Modifier and Type | Method and Description |
---|---|
Mat |
HOG.getDefaultPeopleDetector()
\brief Returns coefficients of the classifier trained for people detection.
|
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.
|
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_1_0.upSampler(Mat flow,
int width,
int height,
int gridSize,
Mat upsampledFlow)
\brief The NVIDIA optical flow hardware generates flow vectors at granularity gridSize, which can be queried via function getGridSize().
|
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 |
StereoBeliefPropagation.compute(Mat data,
Mat disparity) |
void |
StereoBM.compute(Mat left,
Mat right,
Mat disparity,
Stream stream) |
void |
StereoBeliefPropagation.compute(Mat left,
Mat right,
Mat disparity,
Stream stream)
\overload
|
void |
StereoBeliefPropagation.compute(Mat data,
Mat disparity,
Stream stream)
\brief Enables the stereo correspondence operator that finds the disparity for the specified data cost.
|
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() |
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.
|
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) |
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
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:
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 |
void |
RNNLayer.setWeights(Mat Wxh,
Mat bh,
Mat Whh,
Mat Who,
Mat bo)
Setups learned weights.
|
Constructor and Description |
---|
MatPointerVector(Mat... array) |
MatPointerVector(Mat value) |
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
|
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
|
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 |
FacemarkKazemi.getFaces(Mat image,
RectVector faces)
get faces using the custom detector
|
boolean |
FacemarkTrain.getFaces(Mat image,
RectVector faces)
\brief Detect faces from a given image using default or user defined face 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) |
Constructor and Description |
---|
Config(Mat rot,
Point2f trans,
float scaling,
int scale_id) |
Modifier and Type | Method and Description |
---|---|
Mat |
BOWTrainer.cluster()
\overload
|
Mat |
BOWKMeansTrainer.cluster() |
Mat |
BOWTrainer.cluster(Mat descriptors)
\brief Clusters train descriptors.
|
Mat |
BOWKMeansTrainer.cluster(Mat descriptors) |
Mat |
BOWImgDescriptorExtractor.getVocabulary()
\brief Returns the set vocabulary.
|
Modifier and Type | Method and Description |
---|---|
void |
BOWTrainer.add(Mat descriptors)
\brief Adds descriptors to a training set.
|
Mat |
BOWTrainer.cluster(Mat descriptors)
\brief Clusters train descriptors.
|
Mat |
BOWKMeansTrainer.cluster(Mat descriptors) |
void |
BOWImgDescriptorExtractor.compute(GpuMat image,
KeyPointVector keypoints,
GpuMat imgDescriptor,
IntVectorVector pointIdxsOfClusters,
Mat descriptors) |
void |
BOWImgDescriptorExtractor.compute(Mat image,
KeyPointVector keypoints,
Mat imgDescriptor) |
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,
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.
|
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) |
Constructor and Description |
---|
Index(Mat features,
IndexParams params) |
Index(Mat features,
IndexParams params,
int distType) |
Modifier and Type | Method and Description |
---|---|
Mat |
RadialVarianceHash.getHash() |
Mat |
RadialVarianceHash.getPixPerLine(Mat input) |
Mat |
RadialVarianceHash.getProjection() |
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) |
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 |
LineSegmentDetector.detect(Mat _image,
Mat _lines) |
void |
GeneralizedHough.detect(Mat image,
Mat positions) |
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 |
LineSegmentDetector.detect(Mat _image,
Mat _lines,
Mat width,
Mat prec,
Mat nfa)
\brief Finds lines in the input image.
|
void |
GeneralizedHough.detect(Mat edges,
Mat dx,
Mat dy,
Mat positions,
Mat votes) |
void |
LineSegmentDetector.drawSegments(Mat _image,
Mat lines)
\brief Draws the line segments on a given image.
|
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
|
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
|
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) |
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 |
LogisticRegression.predict(Mat samples) |
float |
EM.predict(Mat samples) |
float |
StatModel.predict(Mat samples) |
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
|
float |
StatModel.predict(Mat samples,
Mat results,
int flags)
\brief Predicts response(s) for the provided sample(s)
|
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.
|
Modifier and Type | Method and Description |
---|---|
Mat |
BaseCascadeClassifier.MaskGenerator.generateMask(Mat src) |
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.
|
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
|
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 |
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 |
BaseCascadeClassifier.detectMultiScale(Mat image,
RectVector objects,
double scaleFactor,
int minNeighbors,
int flags,
Size minSize,
Size maxSize) |
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.
|
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.
|
Modifier and Type | Method and Description |
---|---|
Mat |
CalibrateRobertson.getRadiance() |
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 |
CalibrateCRF.process(GpuMatVector src,
Mat dst,
Mat times) |
void |
MergeDebevec.process(GpuMatVector src,
Mat dst,
Mat times) |
void |
MergeRobertson.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 |
AlignMTB.process(GpuMatVector src,
MatVector dst,
Mat times,
Mat response) |
void |
AlignExposures.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 |
CalibrateCRF.process(MatVector src,
Mat dst,
Mat times)
\brief Recovers inverse camera response.
|
void |
MergeDebevec.process(MatVector src,
Mat dst,
Mat times) |
void |
MergeRobertson.process(MatVector src,
Mat dst,
Mat times) |
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 |
AlignMTB.process(MatVector src,
MatVector dst,
Mat times,
Mat response) |
void |
AlignExposures.process(MatVector src,
MatVector dst,
Mat times,
Mat response)
\brief Aligns images
|
void |
MergeMertens.process(UMatVector src,
Mat dst) |
void |
CalibrateCRF.process(UMatVector src,
Mat dst,
Mat times) |
void |
MergeDebevec.process(UMatVector src,
Mat dst,
Mat times) |
void |
MergeRobertson.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 |
AlignMTB.process(UMatVector src,
MatVector dst,
Mat times,
Mat response) |
void |
AlignExposures.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.
|
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) |
Modifier and Type | Method and Description |
---|---|
Scalar |
QualityPSNR.compute(Mat cmp)
\brief Compute the PSNR
|
Scalar |
QualityGMSD.compute(Mat cmp)
\brief Compute GMSD
|
Scalar |
QualityBRISQUE.compute(Mat img)
\brief Computes BRISQUE quality score for input image
|
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 |
QualitySSIM.compute(Mat cmp)
\brief Computes SSIM
|
Scalar |
QualityMSE.compute(Mat cmpImgs)
\brief Computes MSE for reference images supplied in class constructor and provided comparison images
|
static Scalar |
QualityBRISQUE.compute(Mat img,
BytePointer model_file_path,
BytePointer range_file_path)
\brief static method for computing quality
|
static Scalar |
QualityPSNR.compute(Mat ref,
Mat cmp,
Mat qualityMap) |
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,
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 QualityPSNR |
QualityPSNR.create(Mat ref) |
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,
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
|
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 |
StaticSaliencySpectralResidual.computeSaliency(Mat image,
Mat saliencyMap) |
boolean |
StaticSaliencyFineGrained.computeSaliency(Mat image,
Mat saliencyMap) |
boolean |
Saliency.computeSaliency(Mat image,
Mat saliencyMap)
\brief Compute the saliency
|
boolean |
MotionSaliencyBinWangApr2014.computeSaliency(Mat image,
Mat saliencyMap) |
boolean |
ObjectnessBING.computeSaliency(Mat image,
Mat saliencyMap) |
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.
|
Modifier and Type | Method and Description |
---|---|
Mat |
MatchesInfo.H()
Estimated transformation
|
Mat |
CameraParams.K() |
Mat |
CameraParams.R() |
Mat |
BundleAdjusterBase.refinementMask() |
Mat |
CameraParams.t() |
Modifier and Type | Method and Description |
---|---|
void |
NoExposureCompensator.apply(int arg0,
Point arg1,
Mat arg2,
Mat arg3) |
void |
GainCompensator.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 |
BlocksCompensator.apply(int index,
Point corner,
Mat image,
Mat mask) |
void |
BlocksGainCompensator.apply(int index,
Point corner,
Mat image,
Mat mask) |
void |
ChannelsCompensator.apply(int index,
Point corner,
Mat image,
Mat mask) |
void |
Blender.blend(Mat dst,
Mat dst_mask)
\brief Blends and returns the final pano.
|
void |
MultiBandBlender.blend(Mat dst,
Mat dst_mask) |
void |
FeatherBlender.blend(Mat dst,
Mat dst_mask) |
Rect |
DetailPlaneWarperGpu.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 |
DetailSphericalWarperGpu.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 |
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 |
DetailCylindricalWarper.buildMaps(Size src_size,
Mat K,
Mat R,
Mat xmap,
Mat 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 |
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 |
DetailPlaneWarperGpu.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 |
DetailCylindricalWarperGpu.buildMaps(Size src_size,
Mat K,
Mat R,
Mat xmap,
Mat ymap) |
Rect |
DetailSphericalWarperGpu.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 |
DetailPlaneWarperGpu.buildMaps(Size src_size,
Mat K,
Mat R,
Mat T,
Mat xmap,
Mat ymap) |
Rect |
DetailPlaneWarper.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 |
Blender.feed(Mat img,
Mat mask,
Point tl)
\brief Processes the image.
|
void |
MultiBandBlender.feed(Mat img,
Mat mask,
Point tl) |
void |
FeatherBlender.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 |
DetailPlaneWarperGpu.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 |
DetailSphericalWarperGpu.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 |
PyRotationWarper.warp(Mat src,
Mat K,
Mat R,
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 |
RotationWarper.warp(Mat src,
Mat K,
Mat R,
int interp_mode,
int border_mode,
Mat dst)
\brief Projects the image.
|
Point |
AffineWarper.warp(Mat src,
Mat K,
Mat H,
int interp_mode,
int border_mode,
Mat dst)
\brief Projects the image.
|
Point |
DetailPlaneWarperGpu.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 |
DetailCylindricalWarperGpu.warp(Mat src,
Mat K,
Mat R,
int interp_mode,
int border_mode,
Mat dst) |
Point |
DetailSphericalWarperGpu.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 |
DetailPlaneWarperGpu.warp(Mat src,
Mat K,
Mat R,
Mat T,
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) |
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.
|
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.
|
Point2f |
PyRotationWarper.warpPoint(Point2f pt,
Mat K,
Mat R)
\brief Projects the image point.
|
Point2f |
RotationWarper.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) |
Rect |
PyRotationWarper.warpRoi(Size src_size,
Mat K,
Mat R) |
Rect |
RotationWarper.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) |
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.
|
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.
|
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 |
BaseOCR.run(Mat image,
BytePointer output_text) |
void |
OCRBeamSearchDecoder.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 |
BaseOCR.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 |
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 |
BaseOCR.run(Mat image,
Mat mask,
BytePointer output_text) |
void |
OCRBeamSearchDecoder.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 |
BaseOCR.run(Mat image,
Mat mask,
BytePointer output_text,
RectVector component_rects,
StringVector component_texts,
FloatVector component_confidences,
int component_level) |
void |
OCRBeamSearchDecoder.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) |
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 |
UnscentedKalmanFilterParams.errorCovInit()
State estimate cross-covariance matrix, DP x DP, default is identity.
|
Mat |
CvFeatureEvaluator.getCls() |
Mat |
Detector.getConfImageDisplay() |
Mat |
UnscentedKalmanFilter.getErrorCov() |
Mat |
TrackerStateEstimatorMILBoosting.TrackerMILTargetState.getFeatures()
\brief Get the features extracted
|
Mat |
UnscentedKalmanFilter.getMeasurementNoiseCov() |
Mat |
UnscentedKalmanFilter.getProcessNoiseCov() |
Mat |
UnscentedKalmanFilter.getState() |
Mat |
TrackerStateEstimatorAdaBoosting.TrackerAdaBoostingTargetState.getTargetResponses()
\brief Get the features extracted
|
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.
|
Modifier and Type | Method and Description |
---|---|
boolean |
MultiTracker.add(Tracker newTracker,
Mat image,
Rect2d boundingBox)
\brief Add a new object to be tracked.
|
boolean |
MultiTracker.add(TrackerVector newTrackers,
Mat image,
Rect2dVector boundingBox)
\brief Add a set of objects to be tracked.
|
boolean |
MultiTracker_Alt.addTarget(Mat image,
Rect2d boundingBox,
Tracker tracker_algorithm)
\brief Add a new target to a tracking-list and initialize the tracker with a known bounding box that surrounded the target
|
void |
TrackerKCF.Arg0_Mat_Rect_Mat.call(Mat arg0,
Rect arg1,
Mat arg2) |
FloatPointer |
ClfMilBoost.classify(Mat x) |
FloatPointer |
ClfMilBoost.classify(Mat x,
boolean logR) |
boolean |
ClfOnlineStump.classify(Mat x,
int i) |
float |
ClfOnlineStump.classifyF(Mat x,
int i) |
FloatPointer |
ClfOnlineStump.classifySetF(Mat x) |
void |
TrackerFeature.compute(MatVector images,
Mat response)
\brief Compute the features in the images collection
|
Mat |
UnscentedKalmanFilter.correct(Mat measurement)
The function performs correction step of the algorithm
|
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) |
boolean |
TrackerFeatureHAAR.extractSelected(int[] selFeatures,
MatVector images,
Mat response) |
boolean |
TrackerFeatureHAAR.extractSelected(IntBuffer selFeatures,
MatVector images,
Mat response) |
boolean |
TrackerFeatureHAAR.extractSelected(IntPointer selFeatures,
MatVector images,
Mat response)
\brief Compute the features only for the selected indices in the images collection
|
boolean |
Tracker.init(Mat image,
Rect2d boundingBox)
\brief Initialize the tracker with a known bounding box that surrounded the target
|
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
|
UnscentedKalmanFilterParams |
UnscentedKalmanFilterParams.processNoiseCov(Mat setter) |
void |
TrackerSampler.sampling(Mat image,
Rect boundingBox)
\brief Computes the regions starting from a position in an image
|
boolean |
TrackerSamplerAlgorithm.sampling(Mat image,
Rect boundingBox,
MatVector sample)
\brief Computes the regions starting from a position in an image.
|
boolean |
TrackerSamplerCS.samplingImpl(Mat image,
Rect boundingBox,
MatVector sample) |
void |
TrackerFeatureFeature2d.selection(Mat response,
int npoints) |
void |
TrackerFeatureHOG.selection(Mat response,
int npoints) |
void |
TrackerFeatureHAAR.selection(Mat response,
int npoints)
\brief Identify most effective features
|
void |
TrackerFeature.selection(Mat response,
int npoints)
\brief Identify most effective features
|
void |
TrackerFeatureLBP.selection(Mat response,
int npoints) |
void |
TrackerStateEstimatorMILBoosting.TrackerMILTargetState.setFeatures(Mat features)
\brief Set the features extracted from TrackerFeatureSet
|
void |
CvHaarEvaluator.setImage(Mat img) |
void |
CvHOGEvaluator.setImage(Mat img,
byte clsLabel,
int idx) |
void |
CvFeatureEvaluator.setImage(Mat img,
byte clsLabel,
int idx) |
void |
CvHaarEvaluator.setImage(Mat img,
byte clsLabel,
int idx) |
void |
CvLBPEvaluator.setImage(Mat img,
byte clsLabel,
int idx) |
void |
TrackerCSRT.setInitialMask(Mat mask) |
void |
TrackerStateEstimatorAdaBoosting.TrackerAdaBoostingTargetState.setTargetResponses(Mat responses)
\brief Set the features extracted from TrackerFeatureSet
|
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 |
MultiTrackerTLD.update_opt(Mat image)
\brief Update all trackers from the tracking-list, find a new most likely bounding boxes for the targets by
optimized update method using some techniques to speedup calculations specifically for MO TLD.
|
boolean |
MultiTracker_Alt.update(Mat image)
\brief Update all trackers from the tracking-list, find a new most likely bounding boxes for the targets
|
boolean |
MultiTracker.update(Mat image)
\brief Update the current tracking status.
|
boolean |
StrongClassifierDirectSelection.update(Mat image,
int target) |
boolean |
StrongClassifierDirectSelection.update(Mat image,
int target,
float importance) |
void |
ClfOnlineStump.update(Mat posx,
Mat negx) |
void |
ClfMilBoost.update(Mat posx,
Mat negx) |
boolean |
Tracker.update(Mat image,
Rect2d boundingBox)
\brief Update the tracker, find the new most likely bounding box for the target
|
boolean |
MultiTracker.update(Mat image,
Rect2dVector boundingBox)
\brief Update the current tracking status.
|
void |
CvHOGEvaluator.writeFeatures(FileStorage fs,
Mat featureMap) |
void |
CvFeatureEvaluator.writeFeatures(FileStorage fs,
Mat featureMap) |
void |
CvHaarEvaluator.writeFeatures(FileStorage fs,
Mat featureMap) |
void |
CvLBPEvaluator.writeFeatures(FileStorage fs,
Mat featureMap) |
Constructor and Description |
---|
TrackerAdaBoostingTargetState(Point2f _position,
int width,
int height,
boolean foreground,
Mat responses)
\brief Constructor
|
TrackerMILTargetState(Point2f _position,
int width,
int height,
boolean foreground,
Mat features)
\brief Constructor
|
TrackerSamplerPF(Mat chosenRect) |
TrackerSamplerPF(Mat chosenRect,
TrackerSamplerPF.Params parameters)
\brief Constructor
|
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)=A*P(k-1)*At + Q)
|
Mat |
KalmanFilter.gain()
Kalman gain matrix (K(k)): K(k)=P'(k)*Ht*inv(H*P'(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)-H*x'(k))
|
Mat |
KalmanFilter.statePre()
predicted state (x'(k)): x(k)=A*x(k-1)+B*u(k)
|
Mat |
KalmanFilter.temp1() |
Mat |
KalmanFilter.temp2() |
Mat |
KalmanFilter.temp3() |
Mat |
KalmanFilter.temp4() |
Mat |
KalmanFilter.temp5() |
Mat |
KalmanFilter.transitionMatrix()
state transition matrix (A)
|
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.
|
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) |
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
|
Modifier and Type | Method and Description |
---|---|
Mat |
FastMarchingMethod.distanceMap() |
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) |
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,
boolean[] 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(GpuMat points0,
GpuMat points1,
BoolPointer ok) |
Mat |
MotionEstimatorBase.estimate(Mat points0,
Mat points1) |
Mat |
MotionEstimatorL1.estimate(Mat points0,
Mat points1) |
Mat |
KeypointBasedMotionEstimator.estimate(Mat frame0,
Mat frame1) |
Mat |
FromFileMotionReader.estimate(Mat frame0,
Mat frame1) |
Mat |
ToFileMotionWriter.estimate(Mat frame0,
Mat frame1) |
Mat |
ImageMotionEstimatorBase.estimate(Mat frame0,
Mat frame1) |
Mat |
MotionEstimatorRansacL2.estimate(Mat points0,
Mat points1) |
Mat |
MotionEstimatorBase.estimate(Mat points0,
Mat points1,
boolean[] ok) |
Mat |
MotionEstimatorL1.estimate(Mat points0,
Mat points1,
boolean[] ok) |
Mat |
KeypointBasedMotionEstimator.estimate(Mat frame0,
Mat frame1,
boolean[] ok) |
Mat |
FromFileMotionReader.estimate(Mat frame0,
Mat frame1,
boolean[] ok) |
Mat |
ToFileMotionWriter.estimate(Mat frame0,
Mat frame1,
boolean[] ok) |
Mat |
ImageMotionEstimatorBase.estimate(Mat frame0,
Mat frame1,
boolean[] ok) |
Mat |
MotionEstimatorRansacL2.estimate(Mat points0,
Mat points1,
boolean[] ok) |
Mat |
MotionEstimatorBase.estimate(Mat points0,
Mat points1,
BoolPointer ok)
\brief Estimates global motion between two 2D point clouds.
|
Mat |
MotionEstimatorL1.estimate(Mat points0,
Mat points1,
BoolPointer ok) |
Mat |
KeypointBasedMotionEstimator.estimate(Mat frame0,
Mat frame1,
BoolPointer ok) |
Mat |
FromFileMotionReader.estimate(Mat frame0,
Mat frame1,
BoolPointer ok) |
Mat |
ToFileMotionWriter.estimate(Mat frame0,
Mat frame1,
BoolPointer ok) |
Mat |
ImageMotionEstimatorBase.estimate(Mat frame0,
Mat frame1,
BoolPointer ok) |
Mat |
MotionEstimatorRansacL2.estimate(Mat points0,
Mat points1,
BoolPointer ok) |
Mat |
MotionEstimatorBase.estimate(UMat points0,
UMat points1) |
Mat |
MotionEstimatorL1.estimate(UMat points0,
UMat points1) |
Mat |
KeypointBasedMotionEstimator.estimate(UMat frame0,
UMat frame1) |
Mat |
MotionEstimatorRansacL2.estimate(UMat points0,
UMat points1) |
Mat |
MotionEstimatorBase.estimate(UMat points0,
UMat points1,
boolean[] ok) |
Mat |
MotionEstimatorL1.estimate(UMat points0,
UMat points1,
boolean[] ok) |
Mat |
KeypointBasedMotionEstimator.estimate(UMat frame0,
UMat frame1,
boolean[] ok) |
Mat |
MotionEstimatorRansacL2.estimate(UMat points0,
UMat points1,
boolean[] ok) |
Mat |
MotionEstimatorBase.estimate(UMat points0,
UMat points1,
BoolPointer ok) |
Mat |
MotionEstimatorL1.estimate(UMat points0,
UMat points1,
BoolPointer ok) |
Mat |
KeypointBasedMotionEstimator.estimate(UMat frame0,
UMat frame1,
BoolPointer ok) |
Mat |
MotionEstimatorRansacL2.estimate(UMat points0,
UMat points1,
BoolPointer ok) |
Mat |
TwoPassStabilizer.nextFrame() |
Mat |
OnePassStabilizer.nextFrame() |
Mat |
VideoFileSource.nextFrame() |
Mat |
NullFrameSource.nextFrame() |
Mat |
IFrameSource.nextFrame() |
Mat |
MaskFrameSource.nextFrame() |
Mat |
GaussianMotionFilter.stabilize(int idx,
MatVector motions,
Range range) |
Mat |
MotionFilterBase.stabilize(int idx,
MatVector motions,
Range range) |
Modifier and Type | Method and Description |
---|---|
void |
WeightingDeblurer.deblur(int idx,
Mat frame,
Range range) |
void |
DeblurerBase.deblur(int idx,
Mat frame,
Range range) |
void |
NullDeblurer.deblur(int arg0,
Mat arg1,
Range arg2) |
Mat |
MotionEstimatorBase.estimate(Mat points0,
Mat points1) |
Mat |
MotionEstimatorL1.estimate(Mat points0,
Mat points1) |
Mat |
KeypointBasedMotionEstimator.estimate(Mat frame0,
Mat frame1) |
Mat |
FromFileMotionReader.estimate(Mat frame0,
Mat frame1) |
Mat |
ToFileMotionWriter.estimate(Mat frame0,
Mat frame1) |
Mat |
ImageMotionEstimatorBase.estimate(Mat frame0,
Mat frame1) |
Mat |
MotionEstimatorRansacL2.estimate(Mat points0,
Mat points1) |
Mat |
MotionEstimatorBase.estimate(Mat points0,
Mat points1,
boolean[] ok) |
Mat |
MotionEstimatorL1.estimate(Mat points0,
Mat points1,
boolean[] ok) |
Mat |
KeypointBasedMotionEstimator.estimate(Mat frame0,
Mat frame1,
boolean[] ok) |
Mat |
FromFileMotionReader.estimate(Mat frame0,
Mat frame1,
boolean[] ok) |
Mat |
ToFileMotionWriter.estimate(Mat frame0,
Mat frame1,
boolean[] ok) |
Mat |
ImageMotionEstimatorBase.estimate(Mat frame0,
Mat frame1,
boolean[] ok) |
Mat |
MotionEstimatorRansacL2.estimate(Mat points0,
Mat points1,
boolean[] ok) |
Mat |
MotionEstimatorBase.estimate(Mat points0,
Mat points1,
BoolPointer ok)
\brief Estimates global motion between two 2D point clouds.
|
Mat |
MotionEstimatorL1.estimate(Mat points0,
Mat points1,
BoolPointer ok) |
Mat |
KeypointBasedMotionEstimator.estimate(Mat frame0,
Mat frame1,
BoolPointer ok) |
Mat |
FromFileMotionReader.estimate(Mat frame0,
Mat frame1,
BoolPointer ok) |
Mat |
ToFileMotionWriter.estimate(Mat frame0,
Mat frame1,
BoolPointer ok) |
Mat |
ImageMotionEstimatorBase.estimate(Mat frame0,
Mat frame1,
BoolPointer ok) |
Mat |
MotionEstimatorRansacL2.estimate(Mat points0,
Mat points1,
BoolPointer ok) |
void |
MotionInpainter.inpaint(int idx,
Mat frame,
Mat mask) |
void |
NullInpainter.inpaint(int arg0,
Mat arg1,
Mat arg2) |
void |
InpaintingPipeline.inpaint(int idx,
Mat frame,
Mat mask) |
void |
ConsistentMosaicInpainter.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 |
ColorAverageInpainter.inpaint(int idx,
Mat frame,
Mat mask) |
void |
TranslationBasedLocalOutlierRejector.process(Size frameSize,
Mat points0,
Mat points1,
Mat mask) |
void |
IOutlierRejector.process(Size frameSize,
Mat points0,
Mat points1,
Mat mask) |
void |
NullOutlierRejector.process(Size frameSize,
Mat points0,
Mat points1,
Mat mask) |
void |
IDenseOptFlowEstimator.run(Mat frame0,
Mat frame1,
Mat flowX,
Mat flowY,
Mat errors) |
void |
ISparseOptFlowEstimator.run(Mat frame0,
Mat frame1,
Mat points0,
Mat points1,
Mat status,
Mat errors) |
void |
SparsePyrLkOptFlowEstimator.run(Mat frame0,
Mat frame1,
Mat points0,
Mat points1,
Mat status,
Mat errors) |
void |
KeypointBasedMotionEstimator.setFrameMask(Mat mask) |
void |
ToFileMotionWriter.setFrameMask(Mat mask) |
void |
ImageMotionEstimatorBase.setFrameMask(Mat mask) |
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 |
MotionStabilizationPipeline.stabilize(int size,
MatVector motions,
Range range,
Mat stabilizationMotions) |
void |
MotionFilterBase.stabilize(int size,
MatVector motions,
Range range,
Mat stabilizationMotions) |
void |
LpMotionStabilizer.stabilize(int size,
MatVector motions,
Range range,
Mat stabilizationMotions) |
void |
NullWobbleSuppressor.suppress(int idx,
Mat frame,
Mat result) |
void |
WobbleSuppressorBase.suppress(int idx,
Mat frame,
Mat result) |
void |
MoreAccurateMotionWobbleSuppressor.suppress(int idx,
Mat frame,
Mat result) |
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.
|
Modifier and Type | Method and Description |
---|---|
Mat |
DisparityWLSFilter.getConfidenceMap()
\brief Get the confidence map that was used in the last filter call.
|
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 |
StructuredEdgeDetection.detectEdges(Mat _src,
Mat _dst)
\brief The function detects edges in src and draw them to dst.
|
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 |
AdaptiveManifoldFilter.filter(Mat src,
Mat dst) |
void |
GuidedFilter.filter(Mat src,
Mat dst) |
void |
DTFilter.filter(Mat src,
Mat dst) |
void |
FastGlobalSmootherFilter.filter(Mat src,
Mat dst)
\brief Apply smoothing operation to the source image.
|
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 |
AdaptiveManifoldFilter.filter(Mat src,
Mat dst,
Mat joint)
\brief Apply high-dimensional filtering using adaptive manifolds.
|
void |
FastBilateralSolverFilter.filter(Mat src,
Mat confidence,
Mat dst)
\brief Apply smoothing operation to the source image.
|
void |
DisparityFilter.filter(Mat disparity_map_left,
Mat left_view,
Mat filtered_disparity_map) |
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 |
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 |
SuperpixelLSC.getLabelContourMask(Mat image) |
void |
SuperpixelSEEDS.getLabelContourMask(Mat image) |
void |
SuperpixelSLIC.getLabelContourMask(Mat image,
boolean thick_line)
\brief Returns the mask of the superpixel segmentation stored in SuperpixelSLIC object.
|
void |
SuperpixelLSC.getLabelContourMask(Mat image,
boolean thick_line)
\brief Returns the mask of the superpixel segmentation stored in SuperpixelLSC object.
|
void |
SuperpixelSEEDS.getLabelContourMask(Mat image,
boolean thick_line)
\brief Returns the mask of the superpixel segmentation stored in SuperpixelSEEDS object.
|
void |
SuperpixelSLIC.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 |
SuperpixelSEEDS.getLabels(Mat labels_out)
\brief Returns the segmentation labeling of the 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 |
RICInterpolator.setCostMap(Mat costMap)
\brief Interface to provide a more elaborated cost map, i.e.
|
void |
EdgeAwareInterpolator.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.
|
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.
|
Copyright © 2020. All rights reserved.