|
| softdouble | abs (softdouble a) |
| |
| softfloat | abs (softfloat a) |
| | 绝对值。
|
| |
| static uchar | abs (uchar a) |
| |
| static uint64 | abs (uint64 a) |
| |
| static unsigned | abs (unsigned a) |
| |
| static ushort | abs (ushort a) |
| |
| void | absdiff (InputArray src1, InputArray src2, OutputArray dst) |
| | 计算两个数组之间或数组与标量之间的逐元素绝对差值。
|
| |
| void | accumulate (InputArray src, InputOutputArray dst, InputArray mask=noArray()) |
| | 将图像添加到累加器图像中。
|
| |
| void | accumulateProduct (InputArray src1, InputArray src2, InputOutputArray dst, InputArray mask=noArray()) |
| | 将两个输入图像的逐元素乘积添加到累加器图像中。
|
| |
| void | accumulateSquare (InputArray src, InputOutputArray dst, InputArray mask=noArray()) |
| | 将源图像的平方添加到累加器图像中。
|
| |
| void | accumulateWeighted (InputArray src, InputOutputArray dst, double alpha, InputArray mask=noArray()) |
| | 更新运行平均值。
|
| |
| template<typename T > |
| Quat< T > | acos (const Quat< T > &q) |
| |
| template<typename T > |
| Quat< T > | acosh (const Quat< T > &q) |
| |
| void | adaptiveThreshold (InputArray src, OutputArray dst, double maxValue, int adaptiveMethod, int thresholdType, int blockSize, double C) |
| | 对数组应用自适应阈值。
|
| |
| void | add (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray(), int dtype=-1) |
| | 计算两个数组或数组与标量的逐元素之和。
|
| |
| void | addText (const Mat &img, const String &text, Point org, const QtFont &font) |
| | 在图像上绘制文本。
|
| |
| void | addText (const Mat &img, const String &text, Point org, const String &nameFont, int pointSize=-1, Scalar color=Scalar::all(0), int weight=QT_FONT_NORMAL, int style=QT_STYLE_NORMAL, int spacing=0) |
| | 在图像上绘制文本。
|
| |
| void | addWeighted (InputArray src1, double alpha, InputArray src2, double beta, double gamma, OutputArray dst, int dtype=-1) |
| | 计算两个数组的加权和。
|
| |
| void | AGAST (InputArray image, std::vector< KeyPoint > &keypoints, int threshold, bool nonmaxSuppression, AgastFeatureDetector::DetectorType type) |
| | 使用 AGAST 算法检测角点。
|
| |
| void | AGAST (InputArray image, std::vector< KeyPoint > &keypoints, int threshold, bool nonmaxSuppression=true) |
| |
| template<typename _Tp > |
| static _Tp * | alignPtr (_Tp *ptr, int n=(int) sizeof(_Tp)) |
| | 将指针按照指定的字节数对齐。
|
| |
| static size_t | alignSize (size_t sz, int n) |
| | 将缓冲区大小按照指定的字节数对齐。
|
| |
| void | applyColorMap (InputArray src, OutputArray dst, InputArray userColor) |
| | 在给定图像上应用用户自定义的颜色映射表。
|
| |
| void | applyColorMap (InputArray src, OutputArray dst, int colormap) |
| | 在给定图像上应用等同于 GNU Octave/MATLAB 的颜色映射表。
|
| |
| void | approxPolyDP (InputArray curve, OutputArray approxCurve, double epsilon, bool closed) |
| | 以指定的精度逼近多边形曲线。
|
| |
| void | approxPolyN (InputArray curve, OutputArray approxCurve, int nsides, float epsilon_percentage=-1.0, bool ensure_convex=true) |
| | 以指定的精度和边数逼近凸包多边形。
|
| |
| double | arcLength (InputArray curve, bool closed) |
| | 计算轮廓周长或曲线长度。
|
| |
| void | arrowedLine (InputOutputArray img, Point pt1, Point pt2, const Scalar &color, int thickness=1, int line_type=8, int shift=0, double tipLength=0.1) |
| | 绘制一个从第一个点指向第二个点的箭头线段。
|
| |
| template<typename T > |
| Quat< T > | asin (const Quat< T > &q) |
| |
| template<typename T > |
| Quat< T > | asinh (const Quat< T > &q) |
| |
| template<typename T > |
| Quat< T > | atan (const Quat< T > &q) |
| |
| template<typename T > |
| Quat< T > | atanh (const Quat< T > &q) |
| |
| void | batchDistance (InputArray src1, InputArray src2, OutputArray dist, int dtype, OutputArray nidx, int normType=NORM_L2, int K=0, InputArray mask=noArray(), int update=0, bool crosscheck=false) |
| | 朴素最近邻查找器
|
| |
| void | bilateralFilter (InputArray src, OutputArray dst, int d, double sigmaColor, double sigmaSpace, int borderType=BORDER_DEFAULT) |
| | 对图像应用双边滤波。
|
| |
| void | bitwise_and (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray()) |
| | 计算两个数组的逐位与运算 (dst = src1 & src2)。计算两个数组或数组与标量的逐位与。
|
| |
| void | bitwise_not (InputArray src, OutputArray dst, InputArray mask=noArray()) |
| | 对数组的每一位取反。
|
| |
| void | bitwise_or (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray()) |
| | 计算两个数组或数组与标量的逐位或运算。
|
| |
| void | bitwise_xor (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray()) |
| | 计算两个数组或数组与标量的逐位“异或”运算。
|
| |
| void | blendLinear (InputArray src1, InputArray src2, InputArray weights1, InputArray weights2, OutputArray dst) |
| |
| void | blur (InputArray src, OutputArray dst, Size ksize, Point anchor=Point(-1,-1), int borderType=BORDER_DEFAULT) |
| | 使用归一化框式滤波（normalized box filter）模糊图像。
|
| |
| int | borderInterpolate (int p, int len, int borderType) |
| | 计算外推像素的源位置。
|
| |
| Rect | boundingRect (InputArray array) |
| | 计算点集或灰度图像中非零像素的正外接矩形。
|
| |
| void | boxFilter (InputArray src, OutputArray dst, int ddepth, Size ksize, Point anchor=Point(-1,-1), bool normalize=true, int borderType=BORDER_DEFAULT) |
| | 使用框式滤波模糊图像。
|
| |
| void | boxPoints (RotatedRect box, OutputArray points) |
| | 查找旋转矩形的四个顶点。常用于绘制旋转矩形。
|
| |
| void | broadcast (InputArray src, InputArray shape, OutputArray dst) |
| | 将给定的 Mat 广播至指定形状。
|
| |
| int | buildOpticalFlowPyramid (InputArray img, OutputArrayOfArrays pyramid, Size winSize, int maxLevel, bool withDerivatives=true, int pyrBorder=BORDER_REFLECT_101, int derivBorder=BORDER_CONSTANT, bool tryReuseInputImage=true) |
| | 构建可以传递给 calcOpticalFlowPyrLK 的图像金字塔。
|
| |
| void | buildPyramid (InputArray src, OutputArrayOfArrays dst, int maxlevel, int borderType=BORDER_DEFAULT) |
| | 构建图像的高斯金字塔。
|
| |
| void | calcBackProject (const Mat *images, int nimages, const int *channels, const SparseMat &hist, OutputArray backProject, const float **ranges, double scale=1, bool uniform=true) |
| |
| void | calcBackProject (const Mat *images, int nimages, const int *channels, InputArray hist, OutputArray backProject, const float **ranges, double scale=1, bool uniform=true) |
| | 计算直方图的反向投影。
|
| |
| void | calcBackProject (InputArrayOfArrays images, const std::vector< int > &channels, InputArray hist, OutputArray dst, const std::vector< float > &ranges, double scale) |
| |
| void | calcCovarMatrix (const Mat *samples, int nsamples, Mat &covar, Mat &mean, int flags, int ctype=6) |
| | 计算一组向量的协方差矩阵。
|
| |
| void | calcCovarMatrix (InputArray samples, OutputArray covar, InputOutputArray mean, int flags, int ctype=6) |
| |
| void | calcHist (const Mat *images, int nimages, const int *channels, InputArray mask, OutputArray hist, int dims, const int *histSize, const float **ranges, bool uniform=true, bool accumulate=false) |
| | 计算一组数组的直方图。
|
| |
| void | calcHist (const Mat *images, int nimages, const int *channels, InputArray mask, SparseMat &hist, int dims, const int *histSize, const float **ranges, bool uniform=true, bool accumulate=false) |
| |
| void | calcHist (InputArrayOfArrays images, const std::vector< int > &channels, InputArray mask, OutputArray hist, const std::vector< int > &histSize, const std::vector< float > &ranges, bool accumulate=false) |
| |
| void | calcOpticalFlowFarneback (InputArray prev, InputArray next, InputOutputArray flow, double pyr_scale, int levels, int winsize, int iterations, int poly_n, double poly_sigma, int flags) |
| | 使用 Gunnar Farneback 算法计算稠密光流。
|
| |
| void | calcOpticalFlowPyrLK (InputArray prevImg, InputArray nextImg, InputArray prevPts, InputOutputArray nextPts, OutputArray status, OutputArray err, Size winSize=Size(21, 21), int maxLevel=3, TermCriteria criteria=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 0.01), int flags=0, double minEigThreshold=1e-4) |
| | 使用带金字塔的迭代 Lucas-Kanade 方法计算稀疏特征集的光流。
|
| |
| double | calibrateCamera (InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints, Size imageSize, InputOutputArray cameraMatrix, InputOutputArray distCoeffs, OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs, int flags=0, TermCriteria criteria=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, DBL_EPSILON)) |
| |
| double | calibrateCamera (InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints, Size imageSize, InputOutputArray cameraMatrix, InputOutputArray distCoeffs, OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs, OutputArray stdDeviationsIntrinsics, OutputArray stdDeviationsExtrinsics, OutputArray perViewErrors, int flags=0, TermCriteria criteria=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, DBL_EPSILON)) |
| | 从标定图案的多个视图中寻找相机内参和外参参数。
|
| |
| double | calibrateCameraRO (InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints, Size imageSize, int iFixedPoint, InputOutputArray cameraMatrix, InputOutputArray distCoeffs, OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs, OutputArray newObjPoints, int flags=0, TermCriteria criteria=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, DBL_EPSILON)) |
| |
| double | calibrateCameraRO (InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints, Size imageSize, int iFixedPoint, InputOutputArray cameraMatrix, InputOutputArray distCoeffs, OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs, OutputArray newObjPoints, OutputArray stdDeviationsIntrinsics, OutputArray stdDeviationsExtrinsics, OutputArray stdDeviationsObjPoints, OutputArray perViewErrors, int flags=0, TermCriteria criteria=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, DBL_EPSILON)) |
| | 从标定图案的多个视图中寻找相机内参和外参参数。
|
| |
| void | calibrateHandEye (InputArrayOfArrays R_gripper2base, InputArrayOfArrays t_gripper2base, InputArrayOfArrays R_target2cam, InputArrayOfArrays t_target2cam, OutputArray R_cam2gripper, OutputArray t_cam2gripper, HandEyeCalibrationMethod method=CALIB_HAND_EYE_TSAI) |
| | 计算手眼标定：\(_{}^{g}\textrm{T}_c\)。
|
| |
| void | calibrateRobotWorldHandEye (InputArrayOfArrays R_world2cam, InputArrayOfArrays t_world2cam, InputArrayOfArrays R_base2gripper, InputArrayOfArrays t_base2gripper, OutputArray R_base2world, OutputArray t_base2world, OutputArray R_gripper2cam, OutputArray t_gripper2cam, RobotWorldHandEyeCalibrationMethod method=CALIB_ROBOT_WORLD_HAND_EYE_SHAH) |
| | 计算机器人-世界/手眼标定：\(_{}^{w}\textrm{T}_b\) 和 \(_{}^{c}\textrm{T}_g\)。
|
| |
| void | calibrationMatrixValues (InputArray cameraMatrix, Size imageSize, double apertureWidth, double apertureHeight, double &fovx, double &fovy, double &focalLength, Point2d &principalPoint, double &aspectRatio) |
| | 从相机内参矩阵计算有用的相机特性。
|
| |
| RotatedRect | CamShift (InputArray probImage, Rect &window, TermCriteria criteria) |
| | 查找物体的中心、大小和方向。
|
| |
| bool | can_describe (const GMetaArg &meta, const GRunArg &arg) |
| |
| bool | can_describe (const GMetaArg &meta, const GRunArgP &argp) |
| |
| bool | can_describe (const GMetaArgs &metas, const GRunArgs &args) |
| |
| void | Canny (InputArray dx, InputArray dy, OutputArray edges, double threshold1, double threshold2, bool L2gradient=false) |
| |
| void | Canny (InputArray image, OutputArray edges, double threshold1, double threshold2, int apertureSize=3, bool L2gradient=false) |
| | 使用 Canny 算法查找图像中的边缘 [50]。
|
| |
| void | cartToPolar (InputArray x, InputArray y, OutputArray magnitude, OutputArray angle, bool angleInDegrees=false) |
| | 计算二维向量的幅值和角度。
|
| |
| softfloat | cbrt (const softfloat &a) |
| | 立方根。
|
| |
| bool | checkChessboard (InputArray img, Size size) |
| |
| bool | checkHardwareSupport (int feature) |
| | 如果主机硬件支持指定的功能，则返回 true。
|
| |
| bool | checkRange (InputArray a, bool quiet=true, Point *pos=0, double minVal=-DBL_MAX, double maxVal=DBL_MAX) |
| | 检查输入数组中的每个元素是否含有无效值。
|
| |
| bool | Cholesky (double *A, size_t astep, int m, double *b, size_t bstep, int n) |
| |
| bool | Cholesky (float *A, size_t astep, int m, float *b, size_t bstep, int n) |
| |
| void | circle (InputOutputArray img, Point center, int radius, const Scalar &color, int thickness=1, int lineType=LINE_8, int shift=0) |
| | 绘制一个圆。
|
| |
| bool | clipLine (Rect imgRect, Point &pt1, Point &pt2) |
| |
| bool | clipLine (Size imgSize, Point &pt1, Point &pt2) |
| | 根据图像矩形裁剪直线。
|
| |
| bool | clipLine (Size2l imgSize, Point2l &pt1, Point2l &pt2) |
| |
| void | colorChange (InputArray src, InputArray mask, OutputArray dst, float red_mul=1.0f, float green_mul=1.0f, float blue_mul=1.0f) |
| | 给定一张原始彩色图像，可以无缝混合该图像的两个不同颜色版本。
|
| |
| void | compare (InputArray src1, InputArray src2, OutputArray dst, int cmpop) |
| | 执行两个数组或数组与标量值的逐元素比较。
|
| |
| double | compareHist (const SparseMat &H1, const SparseMat &H2, int method) |
| |
| double | compareHist (InputArray H1, InputArray H2, int method) |
| | 比较两个直方图。
|
| |
| template<typename... Ts> |
| GCompileArgs | compile_args (Ts &&... args) |
| | 将参数列表（参数包）包装成编译参数向量（cv::GCompileArg）。
|
| |
| void | completeSymm (InputOutputArray m, bool lowerToUpper=false) |
| | 将方阵的下半部分或上半部分复制到另一半。
|
| |
| void | composeRT (InputArray rvec1, InputArray tvec1, InputArray rvec2, InputArray tvec2, OutputArray rvec3, OutputArray tvec3, OutputArray dr3dr1=noArray(), OutputArray dr3dt1=noArray(), OutputArray dr3dr2=noArray(), OutputArray dr3dt2=noArray(), OutputArray dt3dr1=noArray(), OutputArray dt3dt1=noArray(), OutputArray dt3dr2=noArray(), OutputArray dt3dt2=noArray()) |
| | 结合两个旋转和平移变换。
|
| |
| void | computeCorrespondEpilines (InputArray points, int whichImage, InputArray F, OutputArray lines) |
| | 对于立体像对中一幅图像上的点，计算另一幅图像中相应的极线。
|
| |
| double | computeECC (InputArray templateImage, InputArray inputImage, InputArray inputMask=noArray()) |
| | 计算两幅图像之间的增强相关系数（ECC）值。
|
| |
| void | computeRecallPrecisionCurve (const std::vector< std::vector< DMatch > > &matches1to2, const std::vector< std::vector< uchar > > &correctMatches1to2Mask, std::vector< Point2f > &recallPrecisionCurve) |
| |
| int | connectedComponents (InputArray image, OutputArray labels, int connectivity, int ltype, int ccltype) |
| | 计算二值图像的连通域标记图像
|
| |
| int | connectedComponents (InputArray image, OutputArray labels, int connectivity=8, int ltype=CV_32S) |
| |
| int | connectedComponentsWithStats (InputArray image, OutputArray labels, OutputArray stats, OutputArray centroids, int connectivity, int ltype, int ccltype) |
| | 计算二值图像的连通域标记图像，并输出每个标记的统计信息
|
| |
| int | connectedComponentsWithStats (InputArray image, OutputArray labels, OutputArray stats, OutputArray centroids, int connectivity=8, int ltype=CV_32S) |
| |
| double | contourArea (InputArray contour, bool oriented=false) |
| | 计算轮廓面积。
|
| |
| void | convertFp16 (InputArray src, OutputArray dst) |
| | 将数组转换为半精度浮点数。
|
| |
| void | convertMaps (InputArray map1, InputArray map2, OutputArray dstmap1, OutputArray dstmap2, int dstmap1type, bool nninterpolation=false) |
| | 将图像变换映射从一种表示形式转换为另一种。
|
| |
| void | convertPointsFromHomogeneous (InputArray src, OutputArray dst) |
| | 将点从齐次空间转换为欧几里得空间。
|
| |
| void | convertPointsHomogeneous (InputArray src, OutputArray dst) |
| | 在齐次坐标之间转换点。
|
| |
| void | convertPointsToHomogeneous (InputArray src, OutputArray dst) |
| | 将点从欧几里得空间转换为齐次空间。
|
| |
| void | convertScaleAbs (InputArray src, OutputArray dst, double alpha=1, double beta=0) |
| | 进行缩放，计算绝对值，并将结果转换为 8 位格式。
|
| |
| void | convexHull (InputArray points, OutputArray hull, bool clockwise=false, bool returnPoints=true) |
| | 查找点集的凸包。
|
| |
| void | convexityDefects (InputArray contour, InputArray convexhull, OutputArray convexityDefects) |
| | 查找轮廓的凸性缺陷。
|
| |
| void | copyMakeBorder (InputArray src, OutputArray dst, int top, int bottom, int left, int right, int borderType, const Scalar &value=Scalar()) |
| | 在图像周围形成边框。
|
| |
| void | copyTo (InputArray src, OutputArray dst, InputArray mask) |
| | 这是一个重载的成员函数，为了方便 (python) 提供。将矩阵复制到另一个矩阵。指定操作掩码时，如果上述 Mat::create 调用重新分配了矩阵，则新分配的矩阵在复制数据前会被初始化为全零。
|
| |
| void | cornerEigenValsAndVecs (InputArray src, OutputArray dst, int blockSize, int ksize, int borderType=BORDER_DEFAULT) |
| | 计算用于角点检测的图像块的特征值和特征向量。
|
| |
| void | cornerHarris (InputArray src, OutputArray dst, int blockSize, int ksize, double k, int borderType=BORDER_DEFAULT) |
| | Harris 角点检测器。
|
| |
| void | cornerMinEigenVal (InputArray src, OutputArray dst, int blockSize, int ksize=3, int borderType=BORDER_DEFAULT) |
| | 计算用于角点检测的梯度矩阵的最小特征值。
|
| |
| void | cornerSubPix (InputArray image, InputOutputArray corners, Size winSize, Size zeroZone, TermCriteria criteria) |
| | 优化角点位置（亚像素精度）。
|
| |
| void | correctMatches (InputArray F, InputArray points1, InputArray points2, OutputArray newPoints1, OutputArray newPoints2) |
| | 精细化对应点的坐标。
|
| |
| template<typename T > |
| Quat< T > | cos (const Quat< T > &q) |
| |
| softdouble | cos (const softdouble &a) |
| | 余弦。
|
| |
| template<typename T > |
| Quat< T > | cosh (const Quat< T > &q) |
| |
| int | countNonZero (InputArray src) |
| | 统计非零数组元素的数量。
|
| |
| Ptr< AffineTransformer > | createAffineTransformer (bool fullAffine) |
| |
| Ptr< AlignMTB > | createAlignMTB (int max_bits=6, int exclude_range=4, bool cut=true) |
| | 创建 AlignMTB 对象。
|
| |
| Ptr< BackgroundSubtractorKNN > | createBackgroundSubtractorKNN (int history=500, double dist2Threshold=400.0, bool detectShadows=true) |
| | 创建 KNN 背景减除器。
|
| |
| Ptr< BackgroundSubtractorMOG2 > | createBackgroundSubtractorMOG2 (int history=500, double varThreshold=16, bool detectShadows=true) |
| | 创建 MOG2 背景减除器。
|
| |
| int | createButton (const String &bar_name, ButtonCallback on_change, void *userdata=0, int type=QT_PUSH_BUTTON, bool initial_button_state=false) |
| | 将按钮附加到控制面板。
|
| |
| Ptr< CalibrateDebevec > | createCalibrateDebevec (int samples=70, float lambda=10.0f, bool random=false) |
| | 创建 CalibrateDebevec 对象。
|
| |
| Ptr< CalibrateRobertson > | createCalibrateRobertson (int max_iter=30, float threshold=0.01f) |
| | 创建 CalibrateRobertson 对象。
|
| |
| Ptr< HistogramCostExtractor > | createChiHistogramCostExtractor (int nDummies=25, float defaultCost=0.2f) |
| |
| Ptr< CLAHE > | createCLAHE (double clipLimit=40.0, Size tileGridSize=Size(8, 8)) |
| | 创建一个指向 cv::CLAHE 类的智能指针并初始化。
|
| |
| Ptr< HistogramCostExtractor > | createEMDHistogramCostExtractor (int flag=DIST_L2, int nDummies=25, float defaultCost=0.2f) |
| |
| Ptr< HistogramCostExtractor > | createEMDL1HistogramCostExtractor (int nDummies=25, float defaultCost=0.2f) |
| |
| Ptr< BaseCascadeClassifier::MaskGenerator > | createFaceDetectionMaskGenerator () |
| |
| Ptr< GeneralizedHoughBallard > | createGeneralizedHoughBallard () |
| | 创建一个指向 cv::GeneralizedHoughBallard 类的智能指针并初始化。
|
| |
| Ptr< GeneralizedHoughGuil > | createGeneralizedHoughGuil () |
| | 创建一个指向 cv::GeneralizedHoughGuil 类的智能指针并初始化。
|
| |
| void | createHanningWindow (OutputArray dst, Size winSize, int type) |
| | 该函数计算二维 Hanning 窗系数。
|
| |
| Ptr< HausdorffDistanceExtractor > | createHausdorffDistanceExtractor (int distanceFlag=cv::NORM_L2, float rankProp=0.6f) |
| |
| Ptr< LineSegmentDetector > | createLineSegmentDetector (int refine=LSD_REFINE_STD, double scale=0.8, double sigma_scale=0.6, double quant=2.0, double ang_th=22.5, double log_eps=0, double density_th=0.7, int n_bins=1024) |
| | 创建一个指向 LineSegmentDetector 对象的智能指针并初始化。
|
| |
| Ptr< MergeDebevec > | createMergeDebevec () |
| | 创建 MergeDebevec 对象。
|
| |
| Ptr< MergeMertens > | createMergeMertens (float contrast_weight=1.0f, float saturation_weight=1.0f, float exposure_weight=0.0f) |
| | 创建 MergeMertens 对象。
|
| |
| Ptr< MergeRobertson > | createMergeRobertson () |
| | 创建 MergeRobertson 对象。
|
| |
| Ptr< HistogramCostExtractor > | createNormHistogramCostExtractor (int flag=DIST_L2, int nDummies=25, float defaultCost=0.2f) |
| |
| Ptr< ShapeContextDistanceExtractor > | createShapeContextDistanceExtractor (int nAngularBins=12, int nRadialBins=4, float innerRadius=0.2f, float outerRadius=2, int iterations=3, const Ptr< HistogramCostExtractor > &comparer=createChiHistogramCostExtractor(), const Ptr< ShapeTransformer > &transformer=createThinPlateSplineShapeTransformer()) |
| |
| Ptr< Stitcher > | createStitcher (bool try_use_gpu=false) |
| |
| Ptr< Stitcher > | createStitcherScans (bool try_use_gpu=false) |
| |
| Ptr< ThinPlateSplineShapeTransformer > | createThinPlateSplineShapeTransformer (double regularizationParameter=0) |
| |
| Ptr< Tonemap > | createTonemap (float gamma=1.0f) |
| | 创建简单的线性映射器，带伽马校正。
|
| |
| Ptr< TonemapDrago > | createTonemapDrago (float gamma=1.0f, float saturation=1.0f, float bias=0.85f) |
| | 创建 TonemapDrago 对象。
|
| |
| Ptr< TonemapMantiuk > | createTonemapMantiuk (float gamma=1.0f, float scale=0.7f, float saturation=1.0f) |
| | 创建 TonemapMantiuk 对象。
|
| |
| Ptr< TonemapReinhard > | createTonemapReinhard (float gamma=1.0f, float intensity=0.0f, float light_adapt=1.0f, float color_adapt=0.0f) |
| | 创建 TonemapReinhard 对象。
|
| |
| int | createTrackbar (const String &trackbarname, const String &winname, int *value, int count, TrackbarCallback onChange=0, void *userdata=0) |
| | 创建一个轨迹条并将其附加到指定的窗口。
|
| |
| template<typename T > |
| Quat< T > | crossProduct (const Quat< T > &p, const Quat< T > &q) |
| |
| static double | cubeRoot (double val) |
| |
| float | cubeRoot (float val) |
| | 计算参数的立方根。
|
| |
| const std::string | currentUIFramework () |
| | 使用的 HighGUI 后端。
|
| |
| template<typename _Tp > |
| static void | cv2eigen (const Mat &src, Eigen::Matrix< _Tp, 1, Eigen::Dynamic > &dst) |
| |
| template<typename _Tp , int _rows, int _cols, int _options, int _maxRows, int _maxCols> |
| static void | cv2eigen (const Mat &src, Eigen::Matrix< _Tp, _rows, _cols, _options, _maxRows, _maxCols > &dst) |
| |
| template<typename _Tp > |
| static void | cv2eigen (const Mat &src, Eigen::Matrix< _Tp, Eigen::Dynamic, 1 > &dst) |
| |
| template<typename _Tp > |
| static void | cv2eigen (const Mat &src, Eigen::Matrix< _Tp, Eigen::Dynamic, Eigen::Dynamic > &dst) |
| |
| template<typename _Tp > |
| static void | cv2eigen (const Mat &src, Eigen::Matrix< _Tp, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor > &dst) |
| |
| template<typename _Tp , int _layout> |
| static void | cv2eigen (const Mat &src, Eigen::Tensor< _Tp, 3, _layout > &dst) |
| | 将 cv::Mat 转换为 Eigen::Tensor。
|
| |
| template<typename _Tp , int _cols> |
| static void | cv2eigen (const Matx< _Tp, 1, _cols > &src, Eigen::Matrix< _Tp, 1, Eigen::Dynamic > &dst) |
| |
| template<typename _Tp , int _rows> |
| static void | cv2eigen (const Matx< _Tp, _rows, 1 > &src, Eigen::Matrix< _Tp, Eigen::Dynamic, 1 > &dst) |
| |
| template<typename _Tp , int _rows, int _cols, int _options, int _maxRows, int _maxCols> |
| static void | cv2eigen (const Matx< _Tp, _rows, _cols > &src, Eigen::Matrix< _Tp, _rows, _cols, _options, _maxRows, _maxCols > &dst) |
| |
| template<typename _Tp , int _rows, int _cols> |
| static void | cv2eigen (const Matx< _Tp, _rows, _cols > &src, Eigen::Matrix< _Tp, Eigen::Dynamic, Eigen::Dynamic > &dst) |
| |
| template<typename _Tp , int _rows, int _cols> |
| static void | cv2eigen (const Matx< _Tp, _rows, _cols > &src, Eigen::Matrix< _Tp, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor > &dst) |
| |
| template<typename _Tp > |
| static Eigen::TensorMap< Eigen::Tensor< _Tp, 3, Eigen::RowMajor > > | cv2eigen_tensormap (InputArray src) |
| | 将 cv::Mat 数据映射到 Eigen::TensorMap。
|
| |
| template<typename _Tp > |
| _Tp | cv_abs (_Tp x) |
| |
| int | cv_abs (schar x) |
| |
| int | cv_abs (short x) |
| |
| int | cv_abs (uchar x) |
| |
| int | cv_abs (ushort x) |
| |
| void | cvtColor (InputArray src, OutputArray dst, int code, int dstCn=0, AlgorithmHint hint=cv::ALGO_HINT_DEFAULT) |
| | 将图像从一种颜色空间转换为另一种。
|
| |
| void | cvtColorTwoPlane (InputArray src1, InputArray src2, OutputArray dst, int code, AlgorithmHint hint=cv::ALGO_HINT_DEFAULT) |
| | 将图像从一种颜色空间转换为另一种，源图像存储在两个平面（planes）中。
|
| |
| void | dct (InputArray src, OutputArray dst, int flags=0) |
| | 对一维或二维数组执行正向或逆向离散余弦变换。
|
| |
| void | decolor (InputArray src, OutputArray grayscale, OutputArray color_boost) |
| | 将彩色图像转换为灰度图像。它是数字印刷、风格化黑白照片渲染以及许多单通道图像处理应用中的基本工具 [181] 。
|
| |
| void | decomposeEssentialMat (InputArray E, OutputArray R1, OutputArray R2, OutputArray t) |
| | 将本质矩阵分解为可能的旋转和平移。
|
| |
| int | decomposeHomographyMat (InputArray H, InputArray K, OutputArrayOfArrays rotations, OutputArrayOfArrays translations, OutputArrayOfArrays normals) |
| | 将单应性矩阵分解为旋转、平移和平面法线。
|
| |
| void | decomposeProjectionMatrix (InputArray projMatrix, OutputArray cameraMatrix, OutputArray rotMatrix, OutputArray transVect, OutputArray rotMatrixX=noArray(), OutputArray rotMatrixY=noArray(), OutputArray rotMatrixZ=noArray(), OutputArray eulerAngles=noArray()) |
| | 将投影矩阵分解为旋转矩阵和相机内参矩阵。
|
| |
| void | demosaicing (InputArray src, OutputArray dst, int code, int dstCn=0) |
| | 所有去马赛克（demosaicing）处理的主函数
|
| |
| void | denoise_TVL1 (const std::vector< Mat > &observations, Mat &result, double lambda=1.0, int niters=30) |
| | 原对偶算法是一种求解特殊变分问题（即找到一个函数使某个泛函最小化）的算法。由于图像去噪，特别是，可以被视为一个变分问题，因此原对偶算法可以用于执行去噪，这正是此处实现的。
|
| |
| const char * | depthToString (int depth) |
| |
| GMatDesc | descr_of (const cv::Mat &mat) |
| |
| GScalarDesc | descr_of (const cv::Scalar &scalar) |
| |
| GMatDesc | descr_of (const cv::UMat &mat) |
| |
| GMetaArg | descr_of (const GRunArg &arg) |
| |
| GMetaArg | descr_of (const GRunArgP &argp) |
| |
| GMetaArgs | descr_of (const GRunArgs &args) |
| |
| GFrameDesc | descr_of (const MediaFrame &frame) |
| |
| GMatDesc | descr_of (const RMat &mat) |
| |
| template<typename U > |
| GArrayDesc | descr_of (const std::vector< U > &) |
| |
| template<typename U > |
| GOpaqueDesc | descr_of (const U &) |
| |
| cv::GMetaArgs | descrs_of (const std::vector< cv::Mat > &vec) |
| |
| cv::GMetaArgs | descrs_of (const std::vector< cv::UMat > &vec) |
| |
| void | destroyAllWindows () |
| | 销毁所有 HighGUI 窗口。
|
| |
| void | destroyWindow (const String &winname) |
| | 销毁指定窗口。
|
| |
| void | detailEnhance (InputArray src, OutputArray dst, float sigma_s=10, float sigma_r=0.15f) |
| | 该滤波器增强特定图像的细节。
|
| |
| template<typename _Tp , int m> |
| static double | determinant (const Matx< _Tp, m, m > &a) |
| |
| double | determinant (InputArray mtx) |
| | 返回浮点方阵的行列式。
|
| |
| void | dft (InputArray src, OutputArray dst, int flags=0, int nonzeroRows=0) |
| | 对一维或二维浮点数组执行正向或逆向离散傅里叶变换。
|
| |
| void | dilate (InputArray src, OutputArray dst, InputArray kernel, Point anchor=Point(-1,-1), int iterations=1, int borderType=BORDER_CONSTANT, const Scalar &borderValue=morphologyDefaultBorderValue()) |
| | 使用特定的结构元素膨胀图像。
|
| |
| void | displayOverlay (const String &winname, const String &text, int delayms=0) |
| | 在窗口图像上显示文本，并持续指定的时间。
|
| |
| void | displayStatusBar (const String &winname, const String &text, int delayms=0) |
| | 在窗口状态栏上显示文本，并持续指定的时间。
|
| |
| void | distanceTransform (InputArray src, OutputArray dst, int distanceType, int maskSize, int dstType=CV_32F) |
| |
| void | distanceTransform (InputArray src, OutputArray dst, OutputArray labels, int distanceType, int maskSize, int labelType=DIST_LABEL_CCOMP) |
| | 计算源图像中每个像素到最近零像素的距离。
|
| |
| void | divide (double scale, InputArray src2, OutputArray dst, int dtype=-1) |
| |
| void | divide (InputArray src1, InputArray src2, OutputArray dst, double scale=1, int dtype=-1) |
| | 执行两个数组的逐元素除法，或标量除以数组。
|
| |
| void | divSpectrums (InputArray a, InputArray b, OutputArray c, int flags, bool conjB=false) |
| | 执行第一个傅里叶频谱与第二个傅里叶频谱的逐元素除法。
|
| |
| static int | divUp (int a, unsigned int b) |
| | 结果向上舍入的整数除法。
|
| |
| static size_t | divUp (size_t a, unsigned int b) |
| |
| void | drawChessboardCorners (InputOutputArray image, Size patternSize, InputArray corners, bool patternWasFound) |
| | 渲染检测到的棋盘格角点。
|
| |
| void | drawContours (InputOutputArray image, InputArrayOfArrays contours, int contourIdx, const Scalar &color, int thickness=1, int lineType=LINE_8, InputArray hierarchy=noArray(), int maxLevel=INT_MAX, Point offset=Point()) |
| | 绘制轮廓外框或填充轮廓。
|
| |
| void | drawFrameAxes (InputOutputArray image, InputArray cameraMatrix, InputArray distCoeffs, InputArray rvec, InputArray tvec, float length, int thickness=3) |
| | 根据姿态估计绘制世界/物体坐标系的轴。
|
| |
| void | drawKeypoints (InputArray image, const std::vector< KeyPoint > &keypoints, InputOutputArray outImage, const Scalar &color=Scalar::all(-1), DrawMatchesFlags flags=DrawMatchesFlags::DEFAULT) |
| | 绘制关键点。
|
| |
| void | drawMarker (InputOutputArray img, Point position, const Scalar &color, int markerType=MARKER_CROSS, int markerSize=20, int thickness=1, int line_type=8) |
| | 在图像预定义位置绘制标记。
|
| |
| void | drawMatches (InputArray img1, const std::vector< KeyPoint > &keypoints1, InputArray img2, const std::vector< KeyPoint > &keypoints2, const std::vector< DMatch > &matches1to2, InputOutputArray outImg, const int matchesThickness, const Scalar &matchColor=Scalar::all(-1), const Scalar &singlePointColor=Scalar::all(-1), const std::vector< char > &matchesMask=std::vector< char >(), DrawMatchesFlags flags=DrawMatchesFlags::DEFAULT) |
| |
| void | drawMatches (InputArray img1, const std::vector< KeyPoint > &keypoints1, InputArray img2, const std::vector< KeyPoint > &keypoints2, const std::vector< DMatch > &matches1to2, InputOutputArray outImg, const Scalar &matchColor=Scalar::all(-1), const Scalar &singlePointColor=Scalar::all(-1), const std::vector< char > &matchesMask=std::vector< char >(), DrawMatchesFlags flags=DrawMatchesFlags::DEFAULT) |
| | 绘制两张图像中找到的关键点匹配项。
|
| |
| void | drawMatches (InputArray img1, const std::vector< KeyPoint > &keypoints1, InputArray img2, const std::vector< KeyPoint > &keypoints2, const std::vector< std::vector< DMatch > > &matches1to2, InputOutputArray outImg, const Scalar &matchColor=Scalar::all(-1), const Scalar &singlePointColor=Scalar::all(-1), const std::vector< std::vector< char > > &matchesMask=std::vector< std::vector< char > >(), DrawMatchesFlags flags=DrawMatchesFlags::DEFAULT) |
| |
| static void | dumpOpenCLInformation () |
| |
| void | edgePreservingFilter (InputArray src, OutputArray dst, int flags=1, float sigma_s=60, float sigma_r=0.15f) |
| | 滤波是图像和视频处理中的基本操作。保边平滑滤波器用于许多不同的应用 [102] 。
|
| |
| bool | eigen (InputArray src, OutputArray eigenvalues, OutputArray eigenvectors=noArray()) |
| | 计算对称矩阵的特征值和特征向量。
|
| |
| template<typename _Tp , int _rows, int _cols, int _options, int _maxRows, int _maxCols> |
| static void | eigen2cv (const Eigen::Matrix< _Tp, _rows, _cols, _options, _maxRows, _maxCols > &src, Matx< _Tp, _rows, _cols > &dst) |
| |
| template<typename _Tp , int _rows, int _cols, int _options, int _maxRows, int _maxCols> |
| static void | eigen2cv (const Eigen::Matrix< _Tp, _rows, _cols, _options, _maxRows, _maxCols > &src, OutputArray dst) |
| |
| template<typename _Tp , int _layout> |
| static void | eigen2cv (const Eigen::Tensor< _Tp, 3, _layout > &src, OutputArray dst) |
| | 将 Eigen::Tensor 转换为 cv::Mat。
|
| |
| void | eigenNonSymmetric (InputArray src, OutputArray eigenvalues, OutputArray eigenvectors) |
| | 计算非对称矩阵的特征值和特征向量（仅限实特征值）。
|
| |
| void | ellipse (InputOutputArray img, const RotatedRect &box, const Scalar &color, int thickness=1, int lineType=LINE_8) |
| |
| void | ellipse (InputOutputArray img, Point center, Size axes, double angle, double startAngle, double endAngle, const Scalar &color, int thickness=1, int lineType=LINE_8, int shift=0) |
| | 绘制简单或加厚的椭圆弧，或填充椭圆扇区。
|
| |
| void | ellipse2Poly (Point center, Size axes, int angle, int arcStart, int arcEnd, int delta, std::vector< Point > &pts) |
| | 用折线逼近椭圆弧。
|
| |
| void | ellipse2Poly (Point2d center, Size2d axes, int angle, int arcStart, int arcEnd, int delta, std::vector< Point2d > &pts) |
| |
| float | EMD (InputArray signature1, InputArray signature2, int distType, InputArray cost=noArray(), float *lowerBound=0, OutputArray flow=noArray()) |
| | 计算两个加权点配置之间的“最小工作量”距离（Earth Mover's Distance）。
|
| |
| float | EMDL1 (InputArray signature1, InputArray signature2) |
| | 计算两个加权点配置之间的“最小工作”距离，基于论文“EMD-L1：一种高效鲁棒的直方图描述符比较算法”，作者：Haibin Ling 和 Kazunori Okuda；以及“Earth Mover's Distance是Mallows Distance：来自统计学的一些见解”，作者：Elizaveta Levina 和 Peter Bickel。
|
| |
| GArrayDesc | empty_array_desc () |
| |
| static GFrameDesc | empty_gframe_desc () |
| |
| static GMatDesc | empty_gmat_desc () |
| |
| GOpaqueDesc | empty_gopaque_desc () |
| |
| GScalarDesc | empty_scalar_desc () |
| |
| void | equalizeHist (InputArray src, OutputArray dst) |
| | 对灰度图像进行直方图均衡化。
|
| |
| void | erode (InputArray src, OutputArray dst, InputArray kernel, Point anchor=Point(-1,-1), int iterations=1, int borderType=BORDER_CONSTANT, const Scalar &borderValue=morphologyDefaultBorderValue()) |
| | 使用特定的结构元素腐蚀图像。
|
| |
| void | error (const Exception &exc) |
| | 发出错误信号并引发异常。
|
| |
| void | error (int code, const String &err, const char *func, const char *file, int line) |
| | 发出错误信号并引发异常。
|
| |
| cv::Mat | estimateAffine2D (InputArray from, InputArray to, OutputArray inliers=noArray(), int method=RANSAC, double ransacReprojThreshold=3, size_t maxIters=2000, double confidence=0.99, size_t refineIters=10) |
| | 计算两个 2D 点集之间的最佳仿射变换。
|
| |
| cv::Mat | estimateAffine2D (InputArray pts1, InputArray pts2, OutputArray inliers, const UsacParams ¶ms) |
| |
| cv::Mat | estimateAffine3D (InputArray src, InputArray dst, double *scale=nullptr, bool force_rotation=true) |
| | 计算两个 3D 点集之间的最佳仿射变换。
|
| |
| int | estimateAffine3D (InputArray src, InputArray dst, OutputArray out, OutputArray inliers, double ransacThreshold=3, double confidence=0.99) |
| | 计算两个 3D 点集之间的最佳仿射变换。
|
| |
| cv::Mat | estimateAffinePartial2D (InputArray from, InputArray to, OutputArray inliers=noArray(), int method=RANSAC, double ransacReprojThreshold=3, size_t maxIters=2000, double confidence=0.99, size_t refineIters=10) |
| | 计算两个 2D 点集之间的具有 4 个自由度的最佳受限仿射变换。
|
| |
| Scalar | estimateChessboardSharpness (InputArray image, Size patternSize, InputArray corners, float rise_distance=0.8F, bool vertical=false, OutputArray sharpness=noArray()) |
| | 估计检测到的棋盘格的清晰度。
|
| |
| Mat | estimateRigidTransform (InputArray src, InputArray dst, bool fullAffine) |
| | 计算两个 2D 点集之间的最佳仿射变换。
|
| |
| cv::Vec2d | estimateTranslation2D (InputArray from, InputArray to, OutputArray inliers=noArray(), int method=RANSAC, double ransacReprojThreshold=3, size_t maxIters=2000, double confidence=0.99, size_t refineIters=0) |
| | 计算两个 2D 点集之间的纯 2D 平移。
|
| |
| int | estimateTranslation3D (InputArray src, InputArray dst, OutputArray out, OutputArray inliers, double ransacThreshold=3, double confidence=0.99) |
| | 计算两个 3D 点集之间的最佳平移。
|
| |
| void | evaluateFeatureDetector (const Mat &img1, const Mat &img2, const Mat &H1to2, std::vector< KeyPoint > *keypoints1, std::vector< KeyPoint > *keypoints2, float &repeatability, int &correspCount, const Ptr< FeatureDetector > &fdetector=Ptr< FeatureDetector >()) |
| |
| template<typename T > |
| Quat< T > | exp (const Quat< T > &q) |
| |
| softdouble | exp (const softdouble &a) |
| |
| softfloat | exp (const softfloat &a) |
| | 指数。
|
| |
| void | exp (InputArray src, OutputArray dst) |
| | 计算每个数组元素的指数。
|
| |
| void | extractChannel (InputArray src, OutputArray dst, int coi) |
| | 从 src 中提取单个通道（coi 是从 0 开始的索引）
|
| |
| void | FAST (InputArray image, std::vector< KeyPoint > &keypoints, int threshold, bool nonmaxSuppression, FastFeatureDetector::DetectorType type) |
| | 使用 FAST 算法检测角点。
|
| |
| void | FAST (InputArray image, std::vector< KeyPoint > &keypoints, int threshold, bool nonmaxSuppression=true) |
| |
| float | fastAtan2 (float y, float x) |
| | 以度为单位计算 2D 向量的角度。
|
| |
| void | fastFree (void *ptr) |
| | 释放内存缓冲区。
|
| |
| void * | fastMalloc (size_t bufSize) |
| | 分配对齐的内存缓冲区。
|
| |
| void | fastNlMeansDenoising (InputArray src, OutputArray dst, const std::vector< float > &h, int templateWindowSize=7, int searchWindowSize=21, int normType=NORM_L2) |
| | 使用非局部均值去噪算法 http://www.ipol.im/pub/algo/bcm_non_local_means_denoising/ 并通过若干计算优化进行图像去噪。噪声预期为高斯白噪声。
|
| |
| void | fastNlMeansDenoising (InputArray src, OutputArray dst, float h=3, int templateWindowSize=7, int searchWindowSize=21) |
| | 使用非局部均值去噪算法 http://www.ipol.im/pub/algo/bcm_non_local_means_denoising/ 并通过若干计算优化进行图像去噪。噪声预期为高斯白噪声。
|
| |
| void | fastNlMeansDenoisingColored (InputArray src, OutputArray dst, float h=3, float hColor=3, int templateWindowSize=7, int searchWindowSize=21) |
| | 针对彩色图像修改的 fastNlMeansDenoising 函数。
|
| |
| void | fastNlMeansDenoisingColoredMulti (InputArrayOfArrays srcImgs, OutputArray dst, int imgToDenoiseIndex, int temporalWindowSize, float h=3, float hColor=3, int templateWindowSize=7, int searchWindowSize=21) |
| | 针对彩色图像序列的 fastNlMeansDenoisingMulti 函数的修改。
|
| |
| void | fastNlMeansDenoisingMulti (InputArrayOfArrays srcImgs, OutputArray dst, int imgToDenoiseIndex, int temporalWindowSize, const std::vector< float > &h, int templateWindowSize=7, int searchWindowSize=21, int normType=NORM_L2) |
| | 对 fastNlMeansDenoising 函数的修改，适用于连续图像在短时间内捕获的图像序列。例如视频。此版本的函数适用于灰度图像或颜色空间的手动操作。更多详情请参见[46]（可在此处开放获取）。
|
| |
| void | fastNlMeansDenoisingMulti (InputArrayOfArrays srcImgs, OutputArray dst, int imgToDenoiseIndex, int temporalWindowSize, float h=3, int templateWindowSize=7, int searchWindowSize=21) |
| | 对 fastNlMeansDenoising 函数的修改，适用于连续图像在短时间内捕获的图像序列。例如视频。此版本的函数适用于灰度图像或颜色空间的手动操作。更多详情请参见[46]（可在此处开放获取）。
|
| |
| void | fillConvexPoly (InputOutputArray img, const Point *pts, int npts, const Scalar &color, int lineType=LINE_8, int shift=0) |
| |
| void | fillConvexPoly (InputOutputArray img, InputArray points, const Scalar &color, int lineType=LINE_8, int shift=0) |
| | 填充凸多边形。
|
| |
| void | fillPoly (InputOutputArray img, const Point **pts, const int *npts, int ncontours, const Scalar &color, int lineType=LINE_8, int shift=0, Point offset=Point()) |
| |
| void | fillPoly (InputOutputArray img, InputArrayOfArrays pts, const Scalar &color, int lineType=LINE_8, int shift=0, Point offset=Point()) |
| | 填充一个或多个多边形包围的区域。
|
| |
| void | filter2D (InputArray src, OutputArray dst, int ddepth, InputArray kernel, Point anchor=Point(-1,-1), double delta=0, int borderType=BORDER_DEFAULT) |
| | 将图像与卷积核进行卷积。
|
| |
| void | filterHomographyDecompByVisibleRefpoints (InputArrayOfArrays rotations, InputArrayOfArrays normals, InputArray beforePoints, InputArray afterPoints, OutputArray possibleSolutions, InputArray pointsMask=noArray()) |
| | 基于附加信息过滤单应性分解结果。
|
| |
| void | filterSpeckles (InputOutputArray img, double newVal, int maxSpeckleSize, double maxDiff, InputOutputArray buf=noArray()) |
| | 过滤视差图中的细小噪声点（斑点）。
|
| |
| bool | find4QuadCornerSubpix (InputArray img, InputOutputArray corners, Size region_size) |
| | 寻找棋盘格角点的亚像素级精确位置
|
| |
| bool | findChessboardCorners (InputArray image, Size patternSize, OutputArray corners, int flags=CALIB_CB_ADAPTIVE_THRESH+CALIB_CB_NORMALIZE_IMAGE) |
| | 寻找棋盘格内角点的位置。
|
| |
| bool | findChessboardCornersSB (InputArray image, Size patternSize, OutputArray corners, int flags, OutputArray meta) |
| | 使用基于扇区的方法寻找棋盘格内角点的位置。
|
| |
| bool | findChessboardCornersSB (InputArray image, Size patternSize, OutputArray corners, int flags=0) |
| |
| bool | findCirclesGrid (InputArray image, Size patternSize, OutputArray centers, int flags, const Ptr< FeatureDetector > &blobDetector, const CirclesGridFinderParameters ¶meters) |
| | 寻找圆网格中的中心点。
|
| |
| bool | findCirclesGrid (InputArray image, Size patternSize, OutputArray centers, int flags=CALIB_CB_SYMMETRIC_GRID, const Ptr< FeatureDetector > &blobDetector=SimpleBlobDetector::create()) |
| |
| void | findContours (InputArray image, OutputArrayOfArrays contours, int mode, int method, Point offset=Point()) |
| |
| void | findContours (InputArray image, OutputArrayOfArrays contours, OutputArray hierarchy, int mode, int method, Point offset=Point()) |
| | 在二值图像中查找轮廓。
|
| |
| void | findContoursLinkRuns (InputArray image, OutputArrayOfArrays contours) |
| | 这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。
|
| |
| void | findContoursLinkRuns (InputArray image, OutputArrayOfArrays contours, OutputArray hierarchy) |
| | 使用 link runs 算法查找轮廓。
|
| |
| Mat | findEssentialMat (InputArray points1, InputArray points2, double focal, Point2d pp, int method, double prob, double threshold, OutputArray mask) |
| |
| Mat | findEssentialMat (InputArray points1, InputArray points2, double focal=1.0, Point2d pp=Point2d(0, 0), int method=RANSAC, double prob=0.999, double threshold=1.0, int maxIters=1000, OutputArray mask=noArray()) |
| |
| Mat | findEssentialMat (InputArray points1, InputArray points2, InputArray cameraMatrix, int method, double prob, double threshold, OutputArray mask) |
| |
| Mat | findEssentialMat (InputArray points1, InputArray points2, InputArray cameraMatrix, int method=RANSAC, double prob=0.999, double threshold=1.0, int maxIters=1000, OutputArray mask=noArray()) |
| | 根据两幅图像中的对应点计算本质矩阵。
|
| |
| Mat | findEssentialMat (InputArray points1, InputArray points2, InputArray cameraMatrix1, InputArray cameraMatrix2, InputArray dist_coeff1, InputArray dist_coeff2, OutputArray mask, const UsacParams ¶ms) |
| |
| Mat | findEssentialMat (InputArray points1, InputArray points2, InputArray cameraMatrix1, InputArray distCoeffs1, InputArray cameraMatrix2, InputArray distCoeffs2, int method=RANSAC, double prob=0.999, double threshold=1.0, OutputArray mask=noArray()) |
| | 根据两幅图像（可能来自两台不同的相机）中的对应点计算本质矩阵。
|
| |
| Mat | findFundamentalMat (InputArray points1, InputArray points2, int method, double ransacReprojThreshold, double confidence, int maxIters, OutputArray mask=noArray()) |
| | 根据两幅图像中的对应点计算基础矩阵。
|
| |
| Mat | findFundamentalMat (InputArray points1, InputArray points2, int method=FM_RANSAC, double ransacReprojThreshold=3., double confidence=0.99, OutputArray mask=noArray()) |
| |
| Mat | findFundamentalMat (InputArray points1, InputArray points2, OutputArray mask, const UsacParams ¶ms) |
| |
| Mat | findFundamentalMat (InputArray points1, InputArray points2, OutputArray mask, int method=FM_RANSAC, double ransacReprojThreshold=3., double confidence=0.99) |
| |
| Mat | findHomography (InputArray srcPoints, InputArray dstPoints, int method=0, double ransacReprojThreshold=3, OutputArray mask=noArray(), const int maxIters=2000, const double confidence=0.995) |
| | 寻找两个平面之间的透视变换。
|
| |
| Mat | findHomography (InputArray srcPoints, InputArray dstPoints, OutputArray mask, const UsacParams ¶ms) |
| |
| Mat | findHomography (InputArray srcPoints, InputArray dstPoints, OutputArray mask, int method=0, double ransacReprojThreshold=3) |
| |
| void | findNonZero (InputArray src, OutputArray idx) |
| | 返回非零像素的位置列表。
|
| |
| double | findTransformECC (InputArray templateImage, InputArray inputImage, InputOutputArray warpMatrix, int motionType, TermCriteria criteria, InputArray inputMask, int gaussFiltSize) |
| | 根据 ECC 标准 [84] 寻找两幅图像之间的几何变换（扭曲）。
|
| |
| double | findTransformECC (InputArray templateImage, InputArray inputImage, InputOutputArray warpMatrix, int motionType=MOTION_AFFINE, TermCriteria criteria=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 50, 0.001), InputArray inputMask=noArray()) |
| |
| double | findTransformECCWithMask (InputArray templateImage, InputArray inputImage, InputArray templateMask, InputArray inputMask, InputOutputArray warpMatrix, int motionType=MOTION_AFFINE, TermCriteria criteria=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 50, 1e-6), int gaussFiltSize=5) |
| | 使用模板图像和输入图像的有效掩码，根据 ECC 标准 [84] 寻找两幅图像之间的几何变换（扭曲）。
|
| |
| RotatedRect | fitEllipse (InputArray points) |
| | 围绕一组二维点拟合椭圆。
|
| |
| RotatedRect | fitEllipseAMS (InputArray points) |
| | 围绕一组二维点拟合椭圆。
|
| |
| RotatedRect | fitEllipseDirect (InputArray points) |
| | 围绕一组二维点拟合椭圆。
|
| |
| void | fitLine (InputArray points, OutputArray line, int distType, double param, double reps, double aeps) |
| | 对二维或三维点集进行直线拟合。
|
| |
| void | flip (InputArray src, OutputArray dst, int flipCode) |
| | 沿垂直轴、水平轴或双轴翻转二维数组。
|
| |
| void | flipND (InputArray src, OutputArray dst, int axis) |
| | 沿给定轴翻转 n 维数组。
|
| |
| int | floodFill (InputOutputArray image, InputOutputArray mask, Point seedPoint, Scalar newVal, Rect *rect=0, Scalar loDiff=Scalar(), Scalar upDiff=Scalar(), int flags=4) |
| | 使用给定颜色填充连通域。
|
| |
| int | floodFill (InputOutputArray image, Point seedPoint, Scalar newVal, Rect *rect=0, Scalar loDiff=Scalar(), Scalar upDiff=Scalar(), int flags=4) |
| |
| QtFont | fontQt (const String &nameFont, int pointSize=-1, Scalar color=Scalar::all(0), int weight=QT_FONT_NORMAL, int style=QT_STYLE_NORMAL, int spacing=0) |
| | 创建用于在图像上绘制文本的字体。
|
| |
| String | format (const char *fmt,...) |
| | 返回使用类似 printf 表达式格式化的文本字符串。
|
| |
| void | GaussianBlur (InputArray src, OutputArray dst, Size ksize, double sigmaX, double sigmaY=0, int borderType=BORDER_DEFAULT, AlgorithmHint hint=cv::ALGO_HINT_DEFAULT) |
| | 使用高斯滤波器模糊图像。
|
| |
| void | gemm (InputArray src1, InputArray src2, double alpha, InputArray src3, double beta, OutputArray dst, int flags=0) |
| | 执行广义矩阵乘法。
|
| |
| Mat | getAffineTransform (const Point2f src[], const Point2f dst[]) |
| | 通过三对对应点计算仿射变换矩阵。
|
| |
| Mat | getAffineTransform (InputArray src, InputArray dst) |
| |
| const String & | getBuildInformation () |
| | 返回配置时的完整 cmake 输出。
|
| |
| void | getClosestEllipsePoints (const RotatedRect &ellipse_params, InputArray points, OutputArray closest_pts) |
| | 为每个二维点计算其在给定椭圆上最近的二维点。
|
| |
| std::string | getCPUFeaturesLine () |
| | 返回编译期间启用的 CPU 功能列表。
|
| |
| int64 | getCPUTickCount () |
| | 返回 CPU 滴答数。
|
| |
| AlgorithmHint | getDefaultAlgorithmHint () |
| | 返回 OpenCV 编译期间定义的 AlgorithmHint。定义了 ALGO_HINT_DEFAULT 的行为。
|
| |
| Mat | getDefaultNewCameraMatrix (InputArray cameraMatrix, Size imgsize=Size(), bool centerPrincipalPoint=false) |
| | 返回默认的新相机矩阵。
|
| |
| void | getDerivKernels (OutputArray kx, OutputArray ky, int dx, int dy, int ksize, bool normalize=false, int ktype=CV_32F) |
| | 返回用于计算图像空间导数的滤波器系数。
|
| |
| static size_t | getElemSize (int type) |
| |
| double | getFontScaleFromHeight (const int fontFace, const int pixelHeight, const int thickness=1) |
| | 计算为达到给定像素高度所需的特定字体缩放比例。
|
| |
| Mat | getGaborKernel (Size ksize, double sigma, double theta, double lambd, double gamma, double psi=CV_PI *0.5, int ktype=CV_64F) |
| | 返回 Gabor 滤波器系数。
|
| |
| Mat | getGaussianKernel (int ksize, double sigma, int ktype=CV_64F) |
| | 返回高斯滤波器系数。
|
| |
| String | getHardwareFeatureName (int feature) |
| | 根据 ID 返回特性名称。
|
| |
| int | getMouseWheelDelta (int flags) |
| | 获取鼠标滚轮事件（cv::EVENT_MOUSEWHEEL 和 cv::EVENT_MOUSEHWHEEL）的鼠标滚轮运动增量。
|
| |
| int | getNearestPoint (const std::vector< Point2f > &recallPrecisionCurve, float l_precision) |
| |
| int | getNumberOfCPUs () |
| | 返回进程可用的逻辑 CPU 数量。
|
| |
| int | getNumThreads () |
| | 返回 OpenCV 在并行区域使用的线程数。
|
| |
| int | getOptimalDFTSize (int vecsize) |
| | 返回给定向量大小的最佳 DFT 大小。
|
| |
| Mat | getOptimalNewCameraMatrix (InputArray cameraMatrix, InputArray distCoeffs, Size imageSize, double alpha, Size newImgSize=Size(), Rect *validPixROI=0, bool centerPrincipalPoint=false) |
| | 基于自由缩放参数返回新的相机内参矩阵。
|
| |
| Mat | getPerspectiveTransform (const Point2f src[], const Point2f dst[], int solveMethod=DECOMP_LU) |
| |
| Mat | getPerspectiveTransform (InputArray src, InputArray dst, int solveMethod=DECOMP_LU) |
| | 通过四对对应点计算透视变换矩阵。
|
| |
| float | getRecall (const std::vector< Point2f > &recallPrecisionCurve, float l_precision) |
| |
| void | getRectSubPix (InputArray image, Size patchSize, Point2f center, OutputArray patch, int patchType=-1) |
| | 以亚像素精度从图像中提取像素矩形。
|
| |
| Mat | getRotationMatrix2D (Point2f center, double angle, double scale) |
| | 计算二维旋转的仿射矩阵。
|
| |
| Matx23d | getRotationMatrix2D_ (Point2f center, double angle, double scale) |
| |
| Mat | getStructuringElement (int shape, Size ksize, Point anchor=Point(-1,-1)) |
| | 返回用于形态学操作的指定大小和形状的结构元素。
|
| |
| Size | getTextSize (const String &text, int fontFace, double fontScale, int thickness, int *baseLine) |
| | 计算文本字符串的宽度和高度。
|
| |
| int | getThreadNum () |
| | 返回当前并行区域内当前执行线程的索引。如果在并行区域外调用，则始终返回 0。
|
| |
| int64 | getTickCount () |
| | 返回滴答数。
|
| |
| double | getTickFrequency () |
| | 返回每秒的滴答数。
|
| |
| int | getTrackbarPos (const String &trackbarname, const String &winname) |
| | 返回跟踪条位置。
|
| |
| Rect | getValidDisparityROI (Rect roi1, Rect roi2, int minDisparity, int numberOfDisparities, int blockSize) |
| | computes valid disparity ROI from the valid ROIs of the rectified images (that are returned by stereoRectify)
|
| |
| int | getVersionMajor () |
| | 返回库的主版本号。
|
| |
| int | getVersionMinor () |
| | 返回库的次版本号。
|
| |
| int | getVersionRevision () |
| | 返回库版本的修订字段。
|
| |
| String | getVersionString () |
| | 返回库版本字符串。
|
| |
| Rect | getWindowImageRect (const String &winname) |
| | Provides rectangle of image in the window.
|
| |
| double | getWindowProperty (const String &winname, int prop_id) |
| | Provides parameters of a window.
|
| |
| template<typename... Ts> |
| GProtoInputArgs | GIn (Ts &&... ts) |
| |
| template<typename... Ts> |
| GRunArgs | gin (const Ts &... args) |
| |
| void | glob (String pattern, std::vector< String > &result, bool recursive=false) |
| | 在目录中搜索匹配指定模式的文件。
|
| |
| void | goodFeaturesToTrack (InputArray image, OutputArray corners, int maxCorners, double qualityLevel, double minDistance, InputArray mask, int blockSize, int gradientSize, bool useHarrisDetector=false, double k=0.04) |
| |
| void | goodFeaturesToTrack (InputArray image, OutputArray corners, int maxCorners, double qualityLevel, double minDistance, InputArray mask, OutputArray cornersQuality, int blockSize=3, int gradientSize=3, bool useHarrisDetector=false, double k=0.04) |
| | 与上述相同，但同时返回检测到的角点的质量度量。
|
| |
| void | goodFeaturesToTrack (InputArray image, OutputArray corners, int maxCorners, double qualityLevel, double minDistance, InputArray mask=noArray(), int blockSize=3, bool useHarrisDetector=false, double k=0.04) |
| | 在图像上确定强角点。
|
| |
| template<typename... Ts> |
| GProtoOutputArgs | GOut (const std::tuple< Ts... > &ts) |
| |
| template<typename... Ts> |
| GProtoOutputArgs | GOut (std::tuple< Ts... > &&ts) |
| |
| template<typename... Ts> |
| GProtoOutputArgs | GOut (Ts &&... ts) |
| |
| template<typename T , typename... Ts> |
| GOptRunArgsP | gout (optional< T > &arg, optional< Ts > &... args) |
| |
| template<typename... Ts> |
| GRunArgsP | gout (Ts &... args) |
| |
| void | grabCut (InputArray img, InputOutputArray mask, Rect rect, InputOutputArray bgdModel, InputOutputArray fgdModel, int iterCount, int mode=GC_EVAL) |
| | 运行 GrabCut 算法。
|
| |
| void | groupRectangles (std::vector< Rect > &rectList, int groupThreshold, double eps, std::vector< int > *weights, std::vector< double > *levelWeights) |
| |
| void | groupRectangles (std::vector< Rect > &rectList, int groupThreshold, double eps=0.2) |
| | 对对象候选矩形进行分组。
|
| |
| void | groupRectangles (std::vector< Rect > &rectList, std::vector< int > &rejectLevels, std::vector< double > &levelWeights, int groupThreshold, double eps=0.2) |
| |
| void | groupRectangles (std::vector< Rect > &rectList, std::vector< int > &weights, int groupThreshold, double eps=0.2) |
| |
| void | groupRectangles_meanshift (std::vector< Rect > &rectList, std::vector< double > &foundWeights, std::vector< double > &foundScales, double detectThreshold=0.0, Size winDetSize=Size(64, 128)) |
| |
| bool | hasNonZero (InputArray src) |
| | 检查数组中是否至少存在一个非零元素。
|
| |
| bool | haveImageReader (const String &filename) |
| | 检查指定的图像文件是否可以被 OpenCV 解码。
|
| |
| bool | haveImageWriter (const String &filename) |
| | 检查指定的图像文件或指定的文件扩展名是否可以被 OpenCV 编码。
|
| |
| bool | haveOpenVX () |
| | Check if use of OpenVX is possible.
|
| |
| void | hconcat (const Mat *src, size_t nsrc, OutputArray dst) |
| | 对给定的矩阵进行水平拼接。
|
| |
| void | hconcat (InputArray src1, InputArray src2, OutputArray dst) |
| |
| void | hconcat (InputArrayOfArrays src, OutputArray dst) |
| |
| hfloat | hfloatFromBits (ushort w) |
| |
| void | HoughCircles (InputArray image, OutputArray circles, int method, double dp, double minDist, double param1=100, double param2=100, int minRadius=0, int maxRadius=0) |
| | 使用霍夫变换在灰度图像中查找圆。
|
| |
| static void | HoughCirclesWithAccumulator (InputArray image, OutputArray circles, int method, double dp, double minDist, double param1=100, double param2=100, int minRadius=0, int maxRadius=0) |
| | Finds circles in a grayscale image using the Hough transform and get accumulator.
|
| |
| void | HoughLines (InputArray image, OutputArray lines, double rho, double theta, int threshold, double srn=0, double stn=0, double min_theta=0, double max_theta=CV_PI, bool use_edgeval=false) |
| | 使用标准霍夫变换在二值图像中查找直线。
|
| |
| void | HoughLinesP (InputArray image, OutputArray lines, double rho, double theta, int threshold, double minLineLength=0, double maxLineGap=0) |
| | 使用概率霍夫变换在二值图像中查找线段。
|
| |
| void | HoughLinesPointSet (InputArray point, OutputArray lines, int lines_max, int threshold, double min_rho, double max_rho, double rho_step, double min_theta, double max_theta, double theta_step) |
| | 使用标准霍夫变换在点集中查找直线。
|
| |
| static void | HoughLinesWithAccumulator (InputArray image, OutputArray lines, double rho, double theta, int threshold, double srn=0, double stn=0, double min_theta=0, double max_theta=CV_PI, bool use_edgeval=false) |
| | Finds lines in a binary image using the standard Hough transform and get accumulator.
|
| |
| void | HuMoments (const Moments &m, OutputArray hu) |
| |
| void | HuMoments (const Moments &moments, double hu[7]) |
| | 计算七个 Hu 不变量。
|
| |
| std::string | icvExtractPattern (const std::string &filename, unsigned *offset) |
| |
| void | idct (InputArray src, OutputArray dst, int flags=0) |
| | 计算一维或二维数组的逆离散余弦变换。
|
| |
| void | idft (InputArray src, OutputArray dst, int flags=0, int nonzeroRows=0) |
| | 计算一维或二维数组的逆离散傅里叶变换。
|
| |
| void | illuminationChange (InputArray src, InputArray mask, OutputArray dst, float alpha=0.2f, float beta=0.4f) |
| | 通过对所选区域内的梯度场应用适当的非线性变换，然后使用泊松求解器重新积分，局部修改图像的视照明。
|
| |
| size_t | imcount (const String &filename, int flags=IMREAD_ANYCOLOR) |
| | 返回给定文件中的图像数量。
|
| |
| Mat | imdecode (InputArray buf, int flags) |
| | 从内存缓冲区读取图像。
|
| |
| Mat | imdecode (InputArray buf, int flags, Mat *dst) |
| |
| bool | imdecodeanimation (InputArray buf, Animation &animation, int start=0, int count=INT16_MAX) |
| | 将动画图像缓冲区中的帧加载到 Animation 结构中。
|
| |
| bool | imdecodemulti (InputArray buf, int flags, std::vector< Mat > &mats, const cv::Range &range=Range::all()) |
| | 从内存缓冲区读取多页图像。
|
| |
| Mat | imdecodeWithMetadata (InputArray buf, std::vector< int > &metadataTypes, OutputArrayOfArrays metadata, int flags=IMREAD_ANYCOLOR) |
| | 从内存缓冲区读取图像并提取相关的元数据。
|
| |
| bool | imencode (const String &ext, InputArray img, std::vector< uchar > &buf, const std::vector< int > ¶ms=std::vector< int >()) |
| | 将图像编码到内存缓冲区中。
|
| |
| bool | imencodeanimation (const String &ext, const Animation &animation, std::vector< uchar > &buf, const std::vector< int > ¶ms=std::vector< int >()) |
| | 将 Animation 编码到内存缓冲区。
|
| |
| bool | imencodemulti (const String &ext, InputArrayOfArrays imgs, std::vector< uchar > &buf, const std::vector< int > ¶ms=std::vector< int >()) |
| | 将图像数组编码到内存缓冲区中。
|
| |
| bool | encodeWithMetadata (const String &ext, InputArray img, const std::vector< int > &metadataTypes, InputArrayOfArrays metadata, std::vector< uchar > &buf, const std::vector< int > ¶ms=std::vector< int >()) |
| | 将图像编码到内存缓冲区中。
|
| |
| Mat | imread (const String &filename, int flags=IMREAD_COLOR_BGR) |
| | 从文件加载图像。
|
| |
| void | imread (const String &filename, OutputArray dst, int flags=IMREAD_COLOR_BGR) |
| | 从文件加载图像。
|
| |
| bool | imreadanimation (const String &filename, Animation &animation, int start=0, int count=INT16_MAX) |
| | 将动画图像文件中的帧加载到 Animation 结构中。
|
| |
| bool | imreadmulti (const String &filename, std::vector< Mat > &mats, int flags=IMREAD_ANYCOLOR) |
| | 从文件中加载多页图像。
|
| |
| bool | imreadmulti (const String &filename, std::vector< Mat > &mats, int start, int count, int flags=IMREAD_ANYCOLOR) |
| | 从文件中加载多页图像的特定图像。
|
| |
| Mat | imreadWithMetadata (const String &filename, std::vector< int > &metadataTypes, OutputArrayOfArrays metadata, int flags=IMREAD_ANYCOLOR) |
| | 从文件读取图像及其相关的元数据。
|
| |
| void | imshow (const String &winname, const ogl::Texture2D &tex) |
| | Displays OpenGL 2D texture in the specified window.
|
| |
| void | imshow (const String &winname, InputArray mat) |
| | 在指定窗口中显示图像。
|
| |
| bool | imwrite (const String &filename, InputArray img, const std::vector< int > ¶ms=std::vector< int >()) |
| | 将图像保存到指定文件。
|
| |
| bool | imwriteanimation (const String &filename, const Animation &animation, const std::vector< int > ¶ms=std::vector< int >()) |
| | 将 Animation 保存到指定文件。
|
| |
| static bool | imwritemulti (const String &filename, InputArrayOfArrays img, const std::vector< int > ¶ms=std::vector< int >()) |
| | 多图像重载用于绑定
|
| |
| bool | imwriteWithMetadata (const String &filename, InputArray img, const std::vector< int > &metadataTypes, InputArrayOfArrays &metadata, const std::vector< int > ¶ms=std::vector< int >()) |
| | 将图像和元数据保存到指定文件。
|
| |
| Mat | initCameraMatrix2D (InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints, Size imageSize, double aspectRatio=1.0) |
| | 从 3D-2D 点对应关系寻找初始相机内参矩阵。
|
| |
| void | initInverseRectificationMap (InputArray cameraMatrix, InputArray distCoeffs, InputArray R, InputArray newCameraMatrix, const Size &size, int m1type, OutputArray map1, OutputArray map2) |
| | Computes the projection and inverse-rectification transformation map. In essense, this is the inverse of initUndistortRectifyMap to accomodate stereo-rectification of projectors ('inverse-cameras') in projector-camera pairs.
|
| |
| void | initUndistortRectifyMap (InputArray cameraMatrix, InputArray distCoeffs, InputArray R, InputArray newCameraMatrix, Size size, int m1type, OutputArray map1, OutputArray map2) |
| | 计算去畸变和校正变换映射。
|
| |
| float | initWideAngleProjMap (InputArray cameraMatrix, InputArray distCoeffs, Size imageSize, int destImageWidth, int m1type, OutputArray map1, OutputArray map2, enum UndistortTypes projType=PROJ_SPHERICAL_EQRECT, double alpha=0) |
| | 初始化用于广角图像 remap 的映射。
|
| |
| static float | initWideAngleProjMap (InputArray cameraMatrix, InputArray distCoeffs, Size imageSize, int destImageWidth, int m1type, OutputArray map1, OutputArray map2, int projType, double alpha=0) |
| |
| void | inpaint (InputArray src, InputArray inpaintMask, OutputArray dst, double inpaintRadius, int flags) |
| | 使用区域邻域修复图像中的选定区域。
|
| |
| void | inRange (InputArray src, InputArray lowerb, InputArray upperb, OutputArray dst) |
| | 检查数组元素是否落在另外两个数组的对应元素之间。
|
| |
| void | insertChannel (InputArray src, InputOutputArray dst, int coi) |
| | 将单个通道插入 dst（coi 是从 0 开始的索引）
|
| |
| void | integral (InputArray src, OutputArray sum, int sdepth=-1) |
| |
| void | integral (InputArray src, OutputArray sum, OutputArray sqsum, int sdepth=-1, int sqdepth=-1) |
| |
| void | integral (InputArray src, OutputArray sum, OutputArray sqsum, OutputArray tilted, int sdepth=-1, int sqdepth=-1) |
| | 计算图像的积分图。
|
| |
| float | intersectConvexConvex (InputArray p1, InputArray p2, OutputArray p12, bool handleNested=true) |
| | 查找两个凸多边形的交集。
|
| |
| template<typename T > |
| Quat< T > | inv (const Quat< T > &q, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) |
| |
| double | invert (InputArray src, OutputArray dst, int flags=DECOMP_LU) |
| | 计算矩阵的逆或伪逆。
|
| |
| void | invertAffineTransform (InputArray M, OutputArray iM) |
| | 计算仿射变换的逆变换。
|
| |
| template<int N, typename T > |
| static bool | isAligned (const T &data) |
| | 对传递的值进行对齐检查。
|
| |
| template<int N> |
| static bool | isAligned (const void *p1) |
| |
| template<int N> |
| static bool | isAligned (const void *p1, const void *p2) |
| |
| template<int N> |
| static bool | isAligned (const void *p1, const void *p2, const void *p3) |
| |
| template<int N> |
| static bool | isAligned (const void *p1, const void *p2, const void *p3, const void *p4) |
| |
| bool | isContourConvex (InputArray contour) |
| | 测试轮廓的凸性。
|
| |
| double | kmeans (InputArray data, int K, InputOutputArray bestLabels, TermCriteria criteria, int attempts, int flags, OutputArray centers=noArray()) |
| | 查找聚类中心并将输入样本围绕聚类进行分组。
|
| |
| void | Laplacian (InputArray src, OutputArray dst, int ddepth, int ksize=1, double scale=1, double delta=0, int borderType=BORDER_DEFAULT) |
| | 计算图像的拉普拉斯算子。
|
| |
| void | line (InputOutputArray img, Point pt1, Point pt2, const Scalar &color, int thickness=1, int lineType=LINE_8, int shift=0) |
| | 绘制连接两个点的线段。
|
| |
| void | linearPolar (InputArray src, OutputArray dst, Point2f center, double maxRadius, int flags) |
| | 将图像重映射到极坐标空间。
|
| |
| void | loadWindowParameters (const String &windowName) |
| | Loads parameters of the specified window.
|
| |
| template<typename T > |
| Quat< T > | log (const Quat< T > &q, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) |
| |
| softdouble | log (const softdouble &a) |
| |
| softfloat | log (const softfloat &a) |
| | 自然对数。
|
| |
| void | log (InputArray src, OutputArray dst) |
| | 计算每个数组元素的自然对数。
|
| |
| void | logPolar (InputArray src, OutputArray dst, Point2f center, double M, int flags) |
| | 将图像重映射到对数极坐标空间。
|
| |
| int | LU (double *A, size_t astep, int m, double *b, size_t bstep, int n) |
| |
| int | LU (float *A, size_t astep, int m, float *b, size_t bstep, int n) |
| |
| void | LUT (InputArray src, InputArray lut, OutputArray dst) |
| | 对数组执行查找表变换。
|
| |
| void | magnitude (InputArray x, InputArray y, OutputArray magnitude) |
| | 计算二维向量的幅值。
|
| |
| double | Mahalanobis (InputArray v1, InputArray v2, InputArray icovar) |
| | 计算两个向量之间的马氏距离。
|
| |
| template<typename T , typename... Ts> |
| RMat | make_rmat (Ts &&... args) |
| |
| template<typename _Tp , typename ... A1> |
| static Ptr< _Tp > | makePtr (const A1 &... a1) |
| |
| double | matchShapes (InputArray contour1, InputArray contour2, int method, double parameter) |
| | 比较两个形状。
|
| |
| void | matchTemplate (InputArray image, InputArray templ, OutputArray result, int method, InputArray mask=noArray()) |
| | 在重叠的图像区域中匹配模板。
|
| |
| void | matMulDeriv (InputArray A, InputArray B, OutputArray dABdA, OutputArray dABdB) |
| | 针对相乘的每个矩阵计算矩阵乘积的偏导数。
|
| |
| void | max (const Mat &src1, const Mat &src2, Mat &dst) |
| |
| softdouble | max (const softdouble &a, const softdouble &b) |
| |
| softfloat | max (const softfloat &a, const softfloat &b) |
| |
| void | max (const UMat &src1, const UMat &src2, UMat &dst) |
| |
| void | max (InputArray src1, InputArray src2, OutputArray dst) |
| | 计算两个数组或数组与标量的逐元素最大值。
|
| |
| Scalar | mean (InputArray src, InputArray mask=noArray()) |
| | 计算数组元素的平均值（均值）。
|
| |
| int | meanShift (InputArray probImage, Rect &window, TermCriteria criteria) |
| | 在反向投影图像上寻找物体。
|
| |
| void | meanStdDev (InputArray src, OutputArray mean, OutputArray stddev, InputArray mask=noArray()) |
| |
| void | medianBlur (InputArray src, OutputArray dst, int ksize) |
| | 使用中值滤波器模糊图像。
|
| |
| void | merge (const Mat *mv, size_t count, OutputArray dst) |
| | 将多个单通道数组合并为一个多通道数组。
|
| |
| void | merge (InputArrayOfArrays mv, OutputArray dst) |
| |
| void | min (const Mat &src1, const Mat &src2, Mat &dst) |
| |
| softdouble | min (const softdouble &a, const softdouble &b) |
| |
| softfloat | min (const softfloat &a, const softfloat &b) |
| | Min和Max函数。
|
| |
| void | min (const UMat &src1, const UMat &src2, UMat &dst) |
| |
| void | min (InputArray src1, InputArray src2, OutputArray dst) |
| | 计算两个数组或数组与标量的逐元素最小值。
|
| |
| RotatedRect | minAreaRect (InputArray points) |
| | 查找包围输入二维点集的最小面积旋转矩形。
|
| |
| void | minEnclosingCircle (InputArray points, Point2f ¢er, float &radius) |
| | 查找包围二维点集的最小面积圆。
|
| |
| double | minEnclosingConvexPolygon (InputArray points, OutputArray polygon, int k) |
| | 查找包围二维点集的最小面积凸多边形并返回其面积。
|
| |
| double | minEnclosingTriangle (InputArray points, OutputArray triangle) |
| | 查找包围二维点集的最小面积三角形并返回其面积。
|
| |
| void | minMaxIdx (InputArray src, double *minVal, double *maxVal=0, int *minIdx=0, int *maxIdx=0, InputArray mask=noArray()) |
| | 查找数组中的全局最小值和最大值。
|
| |
| void | minMaxLoc (const SparseMat &a, double *minVal, double *maxVal, int *minIdx=0, int *maxIdx=0) |
| |
| void | minMaxLoc (InputArray src, double *minVal, double *maxVal=0, Point *minLoc=0, Point *maxLoc=0, InputArray mask=noArray()) |
| | 查找数组中的全局最小值和最大值。
|
| |
| void | mixChannels (const Mat *src, size_t nsrcs, Mat *dst, size_t ndsts, const int *fromTo, size_t npairs) |
| | 将输入数组中的指定通道复制到输出数组的指定通道。
|
| |
| void | mixChannels (InputArrayOfArrays src, InputOutputArrayOfArrays dst, const int *fromTo, size_t npairs) |
| |
| void | mixChannels (InputArrayOfArrays src, InputOutputArrayOfArrays dst, const std::vector< int > &fromTo) |
| |
| Moments | moments (InputArray array, bool binaryImage=false) |
| | 计算多边形或光栅化形状的所有三阶以内矩。
|
| |
| static Scalar | morphologyDefaultBorderValue () |
| | 返回腐蚀和膨胀的“魔术”边界值。在膨胀操作中，它会自动转换为 Scalar::all(-DBL_MAX)。
|
| |
| void | morphologyEx (InputArray src, OutputArray dst, int op, InputArray kernel, Point anchor=Point(-1,-1), int iterations=1, int borderType=BORDER_CONSTANT, const Scalar &borderValue=morphologyDefaultBorderValue()) |
| | 执行高级形态学变换。
|
| |
| void | moveWindow (const String &winname, int x, int y) |
| | 将窗口移动到指定位置。
|
| |
| softdouble | mulAdd (const softdouble &a, const softdouble &b, const softdouble &c) |
| |
| softfloat | mulAdd (const softfloat &a, const softfloat &b, const softfloat &c) |
| | 融合乘加。
|
| |
| void | mulSpectrums (InputArray a, InputArray b, OutputArray c, int flags, bool conjB=false) |
| | 执行两个傅里叶频谱的逐元素乘法。
|
| |
| void | multiply (InputArray src1, InputArray src2, OutputArray dst, double scale=1, int dtype=-1) |
| | 计算两个数组的逐元素缩放乘积。
|
| |
| void | mulTransposed (InputArray src, OutputArray dst, bool aTa, InputArray delta=noArray(), double scale=1, int dtype=-1) |
| | 计算矩阵与其转置的乘积。
|
| |
| void | namedWindow (const String &winname, int flags=WINDOW_AUTOSIZE) |
| | 创建窗口。
|
| |
| InputOutputArray | noArray () |
| | 返回一个空的 InputArray 或 OutputArray。
|
| |
| template<typename _Tp , int m, int n> |
| static double | norm (const Matx< _Tp, m, n > &M) |
| |
| template<typename _Tp , int m, int n> |
| static double | norm (const Matx< _Tp, m, n > &M, int normType) |
| |
| double | norm (const SparseMat &src, int normType) |
| |
| double | norm (InputArray src1, InputArray src2, int normType=NORM_L2, InputArray mask=noArray()) |
| | 计算绝对差范数或相对差范数。
|
| |
| double | norm (InputArray src1, int normType=NORM_L2, InputArray mask=noArray()) |
| | 计算数组的绝对范数。
|
| |
| void | normalize (const SparseMat &src, SparseMat &dst, double alpha, int normType) |
| |
| template<typename _Tp , int cn> |
| Vec< _Tp, cn > | normalize (const Vec< _Tp, cn > &v) |
| |
| void | normalize (InputArray src, InputOutputArray dst, double alpha=1, double beta=0, int norm_type=NORM_L2, int dtype=-1, InputArray mask=noArray()) |
| | 归一化数组的范数或数值范围。
|
| |
| template<typename _Tp , typename _AccTp > |
| static _AccTp | normInf (const _Tp *a, const _Tp *b, int n) |
| |
| template<typename _Tp , typename _AccTp > |
| static _AccTp | normInf (const _Tp *a, int n) |
| |
| template<typename _Tp , typename _AccTp > |
| static _AccTp | normL1 (const _Tp *a, const _Tp *b, int n) |
| |
| template<typename _Tp , typename _AccTp > |
| static _AccTp | normL1 (const _Tp *a, int n) |
| |
| float | normL1 (const float *a, const float *b, int n) |
| |
| int | normL1 (const uchar *a, const uchar *b, int n) |
| |
| template<typename _Tp , typename _AccTp > |
| static _AccTp | normL2Sqr (const _Tp *a, const _Tp *b, int n) |
| |
| template<typename _Tp , typename _AccTp > |
| static _AccTp | normL2Sqr (const _Tp *a, int n) |
| |
| static float | normL2Sqr (const float *a, const float *b, int n) |
| |
| cv::GMat | operator!= (const cv::GMat &lhs, const cv::GMat &rhs) |
| |
| cv::GMat | operator!= (const cv::GMat &lhs, const cv::GScalar &rhs) |
| |
| cv::GMat | operator!= (const cv::GScalar &lhs, const cv::GMat &rhs) |
| |
| bool | operator!= (const FileNodeIterator &it1, const FileNodeIterator &it2) |
| |
| template<typename _Tp , int m, int n> |
| static bool | operator!= (const Matx< _Tp, m, n > &a, const Matx< _Tp, m, n > &b) |
| |
| cv::GMat | operator& (const cv::GMat &lhs, const cv::GMat &rhs) |
| |
| cv::GMat | operator& (const cv::GMat &lhs, const cv::GScalar &rhs) |
| |
| cv::GMat | operator& (const cv::GScalar &lhs, const cv::GMat &rhs) |
| |
| template<typename T , typename V > |
| static V | operator* (const Affine3< T > &affine, const V &vector) |
| | V is a 3-element vector with member fields x, y and z.
|
| |
| template<typename T > |
| static Affine3< T > | operator* (const Affine3< T > &affine1, const Affine3< T > &affine2) |
| |
| static Vec3d | operator* (const Affine3d &affine, const Vec3d &vector) |
| |
| static Vec3f | operator* (const Affine3f &affine, const Vec3f &vector) |
| |
| cv::GMat | operator* (const cv::GMat &lhs, const cv::GScalar &rhs) |
| |
| cv::GMat | operator* (const cv::GMat &lhs, float rhs) |
| |
| cv::GMat | operator* (const cv::GScalar &lhs, const cv::GMat &rhs) |
| |
| template<typename _Tp , int m, int n, int l> |
| static Matx< _Tp, m, n > | operator* (const Matx< _Tp, m, l > &a, const Matx< _Tp, l, n > &b) |
| |
| template<typename _Tp , int m, int n> |
| static Vec< _Tp, m > | operator* (const Matx< _Tp, m, n > &a, const Vec< _Tp, n > &b) |
| |
| template<typename _Tp , int m, int n> |
| static Matx< _Tp, m, n > | operator* (const Matx< _Tp, m, n > &a, double alpha) |
| |
| template<typename _Tp , int m, int n> |
| static Matx< _Tp, m, n > | operator* (const Matx< _Tp, m, n > &a, float alpha) |
| |
| template<typename _Tp , int m, int n> |
| static Matx< _Tp, m, n > | operator* (const Matx< _Tp, m, n > &a, int alpha) |
| |
| template<typename T > |
| Quat< T > | operator* (const Quat< T > &, const T) |
| |
| template<typename T > |
| Quat< T > | operator* (const T, const Quat< T > &) |
| |
| template<typename _Tp > |
| Vec< _Tp, 4 > | operator* (const Vec< _Tp, 4 > &v1, const Vec< _Tp, 4 > &v2) |
| |
| template<typename _Tp , int cn> |
| static Vec< _Tp, cn > | operator* (const Vec< _Tp, cn > &a, double alpha) |
| |
| template<typename _Tp , int cn> |
| static Vec< _Tp, cn > | operator* (const Vec< _Tp, cn > &a, float alpha) |
| |
| template<typename _Tp , int cn> |
| static Vec< _Tp, cn > | operator* (const Vec< _Tp, cn > &a, int alpha) |
| |
| template<typename _Tp , int m, int n> |
| static Matx< _Tp, m, n > | operator* (double alpha, const Matx< _Tp, m, n > &a) |
| |
| template<typename _Tp , int cn> |
| static Vec< _Tp, cn > | operator* (double alpha, const Vec< _Tp, cn > &a) |
| |
| template<typename _Tp , int m, int n> |
| static Matx< _Tp, m, n > | operator* (float alpha, const Matx< _Tp, m, n > &a) |
| |
| template<typename _Tp , int cn> |
| static Vec< _Tp, cn > | operator* (float alpha, const Vec< _Tp, cn > &a) |
| |
| cv::GMat | operator* (float lhs, const cv::GMat &rhs) |
| |
| template<typename _Tp , int m, int n> |
| static Matx< _Tp, m, n > | operator* (int alpha, const Matx< _Tp, m, n > &a) |
| |
| template<typename _Tp , int cn> |
| static Vec< _Tp, cn > | operator* (int alpha, const Vec< _Tp, cn > &a) |
| |
| template<typename _Tp , int m, int n> |
| static Matx< _Tp, m, n > & | operator*= (Matx< _Tp, m, n > &a, double alpha) |
| |
| template<typename _Tp , int m, int n> |
| static Matx< _Tp, m, n > & | operator*= (Matx< _Tp, m, n > &a, float alpha) |
| |
| template<typename _Tp , int m, int n> |
| static Matx< _Tp, m, n > & | operator*= (Matx< _Tp, m, n > &a, int alpha) |
| |
| template<typename _Tp > |
| Vec< _Tp, 4 > & | operator*= (Vec< _Tp, 4 > &v1, const Vec< _Tp, 4 > &v2) |
| |
| template<typename _Tp , int cn> |
| static Vec< _Tp, cn > & | operator*= (Vec< _Tp, cn > &a, double alpha) |
| |
| template<typename _Tp , int cn> |
| static Vec< _Tp, cn > & | operator*= (Vec< _Tp, cn > &a, float alpha) |
| |
| template<typename _Tp , int cn> |
| static Vec< _Tp, cn > & | operator*= (Vec< _Tp, cn > &a, int alpha) |
| |
| cv::GMat | operator+ (const cv::GMat &lhs, const cv::GMat &rhs) |
| |
| cv::GMat | operator+ (const cv::GMat &lhs, const cv::GScalar &rhs) |
| |
| cv::GMat | operator+ (const cv::GScalar &lhs, const cv::GMat &rhs) |
| |
| template<typename _Tp , int m, int n> |
| static Matx< _Tp, m, n > | operator+ (const Matx< _Tp, m, n > &a, const Matx< _Tp, m, n > &b) |
| |
| template<typename _Tp , int cn> |
| static Vec< _Tp, cn > | operator+ (const Vec< _Tp, cn > &a, const Vec< _Tp, cn > &b) |
| |
| cv::GCompileArgs & | operator+= (cv::GCompileArgs &lhs, const cv::GCompileArgs &rhs) |
| |
| template<typename Tg > |
| cv::GIOProtoArgs< Tg > & | operator+= (cv::GIOProtoArgs< Tg > &lhs, const cv::GIOProtoArgs< Tg > &rhs) |
| |
| GRunArgs & | operator+= (GRunArgs &lhs, const GRunArgs &rhs) |
| | This operator allows to complement the input vector at runtime.
|
| |
| GRunArgsP & | operator+= (GRunArgsP &lhs, const GRunArgsP &rhs) |
| | This operator allows to complement the output vector at runtime.
|
| |
| template<typename _Tp1 , typename _Tp2 , int m, int n> |
| static Matx< _Tp1, m, n > & | operator+= (Matx< _Tp1, m, n > &a, const Matx< _Tp2, m, n > &b) |
| |
| template<typename _Tp1 , typename _Tp2 , int cn> |
| static Vec< _Tp1, cn > & | operator+= (Vec< _Tp1, cn > &a, const Vec< _Tp2, cn > &b) |
| |
| cv::GMat | operator- (const cv::GMat &lhs, const cv::GMat &rhs) |
| |
| cv::GMat | operator- (const cv::GMat &lhs, const cv::GScalar &rhs) |
| |
| cv::GMat | operator- (const cv::GScalar &lhs, const cv::GMat &rhs) |
| |
| static ptrdiff_t | operator- (const FileNodeIterator &it1, const FileNodeIterator &it2) |
| |
| template<typename _Tp , int m, int n> |
| static Matx< _Tp, m, n > | operator- (const Matx< _Tp, m, n > &a) |
| |
| template<typename _Tp , int m, int n> |
| static Matx< _Tp, m, n > | operator- (const Matx< _Tp, m, n > &a, const Matx< _Tp, m, n > &b) |
| |
| template<typename _Tp , int cn> |
| static Vec< _Tp, cn > | operator- (const Vec< _Tp, cn > &a) |
| |
| template<typename _Tp , int cn> |
| static Vec< _Tp, cn > | operator- (const Vec< _Tp, cn > &a, const Vec< _Tp, cn > &b) |
| |
| template<typename _Tp1 , typename _Tp2 , int m, int n> |
| static Matx< _Tp1, m, n > & | operator-= (Matx< _Tp1, m, n > &a, const Matx< _Tp2, m, n > &b) |
| |
| template<typename _Tp1 , typename _Tp2 , int cn> |
| static Vec< _Tp1, cn > & | operator-= (Vec< _Tp1, cn > &a, const Vec< _Tp2, cn > &b) |
| |
| cv::GMat | operator/ (const cv::GMat &lhs, const cv::GMat &rhs) |
| |
| cv::GMat | operator/ (const cv::GMat &lhs, const cv::GScalar &rhs) |
| |
| cv::GMat | operator/ (const cv::GScalar &lhs, const cv::GMat &rhs) |
| |
| template<typename _Tp , int m, int n> |
| static Matx< _Tp, m, n > | operator/ (const Matx< _Tp, m, n > &a, double alpha) |
| |
| template<typename _Tp , int m, int n> |
| static Matx< _Tp, m, n > | operator/ (const Matx< _Tp, m, n > &a, float alpha) |
| |
| template<typename _Tp , int cn> |
| static Vec< _Tp, cn > | operator/ (const Vec< _Tp, cn > &a, double alpha) |
| |
| template<typename _Tp , int cn> |
| static Vec< _Tp, cn > | operator/ (const Vec< _Tp, cn > &a, float alpha) |
| |
| template<typename _Tp , int cn> |
| static Vec< _Tp, cn > | operator/ (const Vec< _Tp, cn > &a, int alpha) |
| |
| template<typename _Tp , int m, int n> |
| static Matx< _Tp, m, n > & | operator/= (Matx< _Tp, m, n > &a, double alpha) |
| |
| template<typename _Tp , int m, int n> |
| static Matx< _Tp, m, n > & | operator/= (Matx< _Tp, m, n > &a, float alpha) |
| |
| template<typename _Tp , int cn> |
| static Vec< _Tp, cn > & | operator/= (Vec< _Tp, cn > &a, double alpha) |
| |
| template<typename _Tp , int cn> |
| static Vec< _Tp, cn > & | operator/= (Vec< _Tp, cn > &a, float alpha) |
| |
| template<typename _Tp , int cn> |
| static Vec< _Tp, cn > & | operator/= (Vec< _Tp, cn > &a, int alpha) |
| |
| cv::GMat | operator< (const cv::GMat &lhs, const cv::GMat &rhs) |
| |
| cv::GMat | operator< (const cv::GMat &lhs, const cv::GScalar &rhs) |
| |
| cv::GMat | operator< (const cv::GScalar &lhs, const cv::GMat &rhs) |
| |
| static bool | operator< (const FileNodeIterator &it1, const FileNodeIterator &it2) |
| |
| static FileStorage & | operator<< (FileStorage &fs, char *value) |
| | 将数据写入文件存储。
|
| |
| template<typename _Tp > |
| static FileStorage & | operator<< (FileStorage &fs, const _Tp &value) |
| | 将数据写入文件存储。
|
| |
| static FileStorage & | operator<< (FileStorage &fs, const char *str) |
| | 将数据写入文件存储。
|
| |
| FileStorage & | operator<< (FileStorage &fs, const String &str) |
| | 将字符串写入文件存储。
|
| |
| template<typename _Tp > |
| std::ostream & | operator<< (std::ostream &, const DualQuat< _Tp > &) |
| |
| template<typename _Tp > |
| std::ostream & | operator<< (std::ostream &, const Quat< _Tp > &) |
| |
| template<typename S > |
| std::ostream & | operator<< (std::ostream &, const Quat< S > &) |
| |
| std::ostream & | operator<< (std::ostream &os, const cv::GArrayDesc &desc) |
| |
| std::ostream & | operator<< (std::ostream &os, const cv::GFrameDesc &desc) |
| |
| std::ostream & | operator<< (std::ostream &os, const cv::GMatDesc &desc) |
| |
| std::ostream & | operator<< (std::ostream &os, const cv::GOpaqueDesc &desc) |
| |
| std::ostream & | operator<< (std::ostream &os, const cv::GScalarDesc &desc) |
| |
| std::ostream & | operator<< (std::ostream &os, const GMetaArg &) |
| |
| static std::ostream & | operator<< (std::ostream &out, const TickMeter &tm) |
| | 输出运算符
|
| |
| static String & | operator<< (String &out, const Mat &mtx) |
| |
| static String & | operator<< (String &out, Ptr< Formatted > fmtd) |
| |
| cv::GMat | operator<= (const cv::GMat &lhs, const cv::GMat &rhs) |
| |
| cv::GMat | operator<= (const cv::GMat &lhs, const cv::GScalar &rhs) |
| |
| cv::GMat | operator<= (const cv::GScalar &lhs, const cv::GMat &rhs) |
| |
| cv::GMat | operator== (const cv::GMat &lhs, const cv::GMat &rhs) |
| |
| cv::GMat | operator== (const cv::GMat &lhs, const cv::GScalar &rhs) |
| |
| cv::GMat | operator== (const cv::GScalar &lhs, const cv::GMat &rhs) |
| |
| bool | operator== (const FileNodeIterator &it1, const FileNodeIterator &it2) |
| |
| template<typename _Tp , int m, int n> |
| static bool | operator== (const Matx< _Tp, m, n > &a, const Matx< _Tp, m, n > &b) |
| |
| cv::GMat | operator> (const cv::GMat &lhs, const cv::GMat &rhs) |
| |
| cv::GMat | operator> (const cv::GMat &lhs, const cv::GScalar &rhs) |
| |
| cv::GMat | operator> (const cv::GScalar &lhs, const cv::GMat &rhs) |
| |
| cv::GMat | operator>= (const cv::GMat &lhs, const cv::GMat &rhs) |
| |
| cv::GMat | operator>= (const cv::GMat &lhs, const cv::GScalar &rhs) |
| |
| cv::GMat | operator>= (const cv::GScalar &lhs, const cv::GMat &rhs) |
| |
| template<typename _Tp > |
| static void | operator>> (const FileNode &n, _Tp &value) |
| | 从文件存储读取数据。
|
| |
| static void | operator>> (const FileNode &n, DMatch &m) |
| | 从文件存储读取DMatch。
|
| |
| static void | operator>> (const FileNode &n, KeyPoint &kpt) |
| | 从文件存储读取KeyPoint。
|
| |
| template<typename _Tp > |
| static void | operator>> (const FileNode &n, std::vector< _Tp > &vec) |
| | 从文件存储读取数据。
|
| |
| template<typename _Tp > |
| static FileNodeIterator & | operator>> (FileNodeIterator &it, _Tp &value) |
| | 从文件存储读取数据。
|
| |
| template<typename _Tp > |
| static FileNodeIterator & | operator>> (FileNodeIterator &it, std::vector< _Tp > &vec) |
| | 从文件存储读取数据。
|
| |
| cv::GMat | operator^ (const cv::GMat &lhs, const cv::GMat &rhs) |
| |
| cv::GMat | operator^ (const cv::GMat &lhs, const cv::GScalar &rhs) |
| |
| cv::GMat | operator^ (const cv::GScalar &lhs, const cv::GMat &rhs) |
| |
| cv::GMat | operator| (const cv::GMat &lhs, const cv::GMat &rhs) |
| |
| cv::GMat | operator| (const cv::GMat &lhs, const cv::GScalar &rhs) |
| |
| cv::GMat | operator| (const cv::GScalar &lhs, const cv::GMat &rhs) |
| |
| cv::GMat | operator~ (const cv::GMat &lhs) |
| |
| void | parallel_for_ (const Range &range, const ParallelLoopBody &body, double nstripes=-1.) |
| | 并行数据处理器。
|
| |
| static void | parallel_for_ (const Range &range, std::function< void(const Range &)> functor, double nstripes=-1.) |
| |
| template<typename _Tp , class _EqPredicate > |
| int | partition (const std::vector< _Tp > &vec, std::vector< int > &labels, _EqPredicate predicate=_EqPredicate()) |
| | 将元素集分割成等价类。
|
| |
| void | patchNaNs (InputOutputArray a, double val=0) |
| | 将矩阵中的 NaN（非数字值）替换为指定值。
|
| |
| void | PCABackProject (InputArray data, InputArray mean, InputArray eigenvectors, OutputArray result) |
| |
| void | PCACompute (InputArray data, InputOutputArray mean, OutputArray eigenvectors, double retainedVariance) |
| |
| void | PCACompute (InputArray data, InputOutputArray mean, OutputArray eigenvectors, int maxComponents=0) |
| |
| void | PCACompute (InputArray data, InputOutputArray mean, OutputArray eigenvectors, OutputArray eigenvalues, double retainedVariance) |
| |
| void | PCACompute (InputArray data, InputOutputArray mean, OutputArray eigenvectors, OutputArray eigenvalues, int maxComponents=0) |
| |
| void | PCAProject (InputArray data, InputArray mean, InputArray eigenvectors, OutputArray result) |
| |
| void | pencilSketch (InputArray src, OutputArray dst1, OutputArray dst2, float sigma_s=60, float sigma_r=0.07f, float shade_factor=0.02f) |
| | 铅笔画风格的非写实线条画。
|
| |
| void | perspectiveTransform (InputArray src, OutputArray dst, InputArray m) |
| | 执行向量的透视矩阵变换。
|
| |
| void | phase (InputArray x, InputArray y, OutputArray angle, bool angleInDegrees=false) |
| | 计算二维向量的旋转角度。
|
| |
| Point2d | phaseCorrelate (InputArray src1, InputArray src2, InputArray window=noArray(), double *response=0) |
| | 该函数用于检测两幅图像之间发生的平移偏差。
|
| |
| Point2d | phaseCorrelateIterative (InputArray src1, InputArray src2, int L2size=7, int maxIters=10) |
| | 迭代地检测两幅图像之间的平移偏差。
|
| |
| double | pointPolygonTest (InputArray contour, Point2f pt, bool measureDist) |
| | 执行点与轮廓的位置关系测试。
|
| |
| void | polarToCart (InputArray magnitude, InputArray angle, OutputArray x, OutputArray y, bool angleInDegrees=false) |
| | 根据二维向量的幅值和角度计算其 x 和 y 坐标。
|
| |
| int | pollKey () |
| | 轮询按下的键。
|
| |
| void | polylines (InputOutputArray img, const Point *const *pts, const int *npts, int ncontours, bool isClosed, const Scalar &color, int thickness=1, int lineType=LINE_8, int shift=0) |
| |
| void | polylines (InputOutputArray img, InputArrayOfArrays pts, bool isClosed, const Scalar &color, int thickness=1, int lineType=LINE_8, int shift=0) |
| | 绘制多条多边形曲线。
|
| |
| softdouble | pow (const softdouble &a, const softdouble &b) |
| |
| softfloat | pow (const softfloat &a, const softfloat &b) |
| | 幂运算。
|
| |
| void | pow (InputArray src, double power, OutputArray dst) |
| | 计算每个数组元素的幂。
|
| |
| template<typename T > |
| Quat< T > | power (const Quat< T > &q, const Quat< T > &p, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) |
| |
| template<typename T > |
| Quat< T > | power (const Quat< T > &q, const T x, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) |
| |
| void | preCornerDetect (InputArray src, OutputArray dst, int ksize, int borderType=BORDER_DEFAULT) |
| | 计算用于角点检测的特征图。
|
| |
| void | projectPoints (InputArray objectPoints, InputArray rvec, InputArray tvec, InputArray cameraMatrix, InputArray distCoeffs, OutputArray imagePoints, OutputArray jacobian=noArray(), double aspectRatio=0) |
| | 将 3D 点投影到图像平面。
|
| |
| double | PSNR (InputArray src1, InputArray src2, double R=255.) |
| | 计算峰值信噪比 (PSNR) 图像质量指标。
|
| |
| void | putText (InputOutputArray img, const String &text, Point org, int fontFace, double fontScale, Scalar color, int thickness=1, int lineType=LINE_8, bool bottomLeftOrigin=false) |
| | 绘制文本字符串。
|
| |
| void | pyrDown (InputArray src, OutputArray dst, const Size &dstsize=Size(), int borderType=BORDER_DEFAULT) |
| | 模糊并下采样图像。
|
| |
| void | pyrMeanShiftFiltering (InputArray src, OutputArray dst, double sp, double sr, int maxLevel=1, TermCriteria termcrit=TermCriteria(TermCriteria::MAX_ITER+TermCriteria::EPS, 5, 1)) |
| | 执行图像均值漂移分割的初始步骤。
|
| |
| void | pyrUp (InputArray src, OutputArray dst, const Size &dstsize=Size(), int borderType=BORDER_DEFAULT) |
| | 上采样并模糊图像。
|
| |
| void | randn (InputOutputArray dst, InputArray mean, InputArray stddev) |
| | 用正态分布的随机数填充数组。
|
| |
| void | randShuffle (InputOutputArray dst, double iterFactor=1., RNG *rng=0) |
| | 随机打乱数组元素。
|
| |
| void | randu (InputOutputArray dst, InputArray low, InputArray high) |
| | 生成单个均匀分布的随机数或随机数数组。
|
| |
| template<typename _Tp > |
| static _InputArray | rawIn (_Tp &v) |
| |
| template<typename _Tp > |
| static _InputOutputArray | rawInOut (_Tp &v) |
| |
| template<typename _Tp > |
| static _OutputArray | rawOut (_Tp &v) |
| |
| void | read (const FileNode &fn, optflow::GPCTree::Node &node, optflow::GPCTree::Node) |
| |
| template<typename _Tp , typename std::enable_if< std::is_enum< _Tp >::value >::type * = nullptr> |
| static void | read (const FileNode &node, _Tp &value, const _Tp &default_value=static_cast< _Tp >(0)) |
| |
| static void | read (const FileNode &node, bool &value, bool default_value) |
| |
| template<typename _Tp > |
| static void | read (const FileNode &node, Complex< _Tp > &value, const Complex< _Tp > &default_value) |
| |
| void | read (const FileNode &node, DMatch &value, const DMatch &default_value) |
| |
| void | read (const FileNode &node, double &value, double default_value) |
| |
| void | read (const FileNode &node, float &value, float default_value) |
| |
| void | read (const FileNode &node, int &value, int default_value) |
| |
| void | read (const FileNode &node, int64_t &value, int64_t default_value) |
| |
| void | read (const FileNode &node, KeyPoint &value, const KeyPoint &default_value) |
| |
| void | read (const FileNode &node, Mat &mat, const Mat &default_mat=Mat()) |
| |
| template<typename _Tp , int m, int n> |
| static void | read (const FileNode &node, Matx< _Tp, m, n > &value, const Matx< _Tp, m, n > &default_matx=Matx< _Tp, m, n >()) |
| |
| template<typename _Tp > |
| static void | read (const FileNode &node, Point3_< _Tp > &value, const Point3_< _Tp > &default_value) |
| |
| template<typename _Tp > |
| static void | read (const FileNode &node, Point_< _Tp > &value, const Point_< _Tp > &default_value) |
| |
| static void | read (const FileNode &node, Range &value, const Range &default_value) |
| |
| template<typename _Tp > |
| static void | read (const FileNode &node, Rect_< _Tp > &value, const Rect_< _Tp > &default_value) |
| |
| template<typename _Tp > |
| static void | read (const FileNode &node, Scalar_< _Tp > &value, const Scalar_< _Tp > &default_value) |
| |
| static void | read (const FileNode &node, schar &value, schar default_value) |
| |
| static void | read (const FileNode &node, short &value, short default_value) |
| |
| template<typename _Tp > |
| static void | read (const FileNode &node, Size_< _Tp > &value, const Size_< _Tp > &default_value) |
| |
| void | read (const FileNode &node, SparseMat &mat, const SparseMat &default_mat=SparseMat()) |
| |
| void | read (const FileNode &node, std::string &value, const std::string &default_value) |
| |
| template<typename _Tp > |
| static void | read (const FileNode &node, std::vector< _Tp > &vec, const std::vector< _Tp > &default_value=std::vector< _Tp >()) |
| |
| static void | read (const FileNode &node, std::vector< DMatch > &vec, const std::vector< DMatch > &default_value) |
| |
| static void | read (const FileNode &node, std::vector< KeyPoint > &vec, const std::vector< KeyPoint > &default_value) |
| |
| static void | read (const FileNode &node, uchar &value, uchar default_value) |
| |
| static void | read (const FileNode &node, ushort &value, ushort default_value) |
| |
| template<typename _Tp , int cn> |
| static void | read (const FileNode &node, Vec< _Tp, cn > &value, const Vec< _Tp, cn > &default_value) |
| |
| template<typename _Tp > |
| static void | read (FileNodeIterator &it, std::vector< _Tp > &vec, size_t maxCount=(size_t) INT_MAX) |
| |
| Mat | readOpticalFlow (const String &path) |
| | 读取 .flo 文件。
|
| |
| int | recoverPose (InputArray E, InputArray points1, InputArray points2, InputArray cameraMatrix, OutputArray R, OutputArray t, double distanceThresh, InputOutputArray mask=noArray(), OutputArray triangulatedPoints=noArray()) |
| |
| int | recoverPose (InputArray E, InputArray points1, InputArray points2, InputArray cameraMatrix, OutputArray R, OutputArray t, InputOutputArray mask=noArray()) |
| | 根据估算的本质矩阵和两幅图像中的对应点，通过手性检查（chirality check）恢复相机的相对旋转和平移。返回通过检查的内点数量。
|
| |
| int | recoverPose (InputArray E, InputArray points1, InputArray points2, InputArray cameraMatrix, OutputArray R, OutputArray t, double focal=1.0, Point2d pp=Point2d(0, 0), InputOutputArray mask=noArray()) |
| |
| int | recoverPose (InputArray points1, InputArray points2, InputArray cameraMatrix1, InputArray distCoeffs1, InputArray cameraMatrix2, InputArray distCoeffs2, OutputArray E, OutputArray R, OutputArray t, int method=cv::RANSAC, double prob=0.999, double threshold=1.0, InputOutputArray mask=noArray()) |
| | 利用手性检查（cheirality check），从两台不同相机的两幅图像中的对应点恢复相机的相对旋转和平移。返回通过检查的内点（inliers）数量。
|
| |
| void | rectangle (InputOutputArray img, Point pt1, Point pt2, const Scalar &color, int thickness=1, int lineType=LINE_8, int shift=0) |
| | 绘制一个简单的、粗线条的或填充的正矩形。
|
| |
| void | rectangle (InputOutputArray img, Rect rec, const Scalar &color, int thickness=1, int lineType=LINE_8, int shift=0) |
| |
| float | rectify3Collinear (InputArray cameraMatrix1, InputArray distCoeffs1, InputArray cameraMatrix2, InputArray distCoeffs2, InputArray cameraMatrix3, InputArray distCoeffs3, InputArrayOfArrays imgpt1, InputArrayOfArrays imgpt3, Size imageSize, InputArray R12, InputArray T12, InputArray R13, InputArray T13, OutputArray R1, OutputArray R2, OutputArray R3, OutputArray P1, OutputArray P2, OutputArray P3, OutputArray Q, double alpha, Size newImgSize, Rect *roi1, Rect *roi2, int flags) |
| | 计算三头相机的校正变换，其中所有相机头都在同一直线上。
|
| |
| ErrorCallback | redirectError (ErrorCallback errCallback, void *userdata=0, void **prevUserdata=0) |
| | 设置新的错误处理程序和可选的用户数据。
|
| |
| void | reduce (InputArray src, OutputArray dst, int dim, int rtype, int dtype=-1) |
| | 将矩阵降维为向量。
|
| |
| void | reduceArgMax (InputArray src, OutputArray dst, int axis, bool lastIndex=false) |
| | 查找沿指定轴的最大元素索引。
|
| |
| void | reduceArgMin (InputArray src, OutputArray dst, int axis, bool lastIndex=false) |
| | 查找沿指定轴的最小元素索引。
|
| |
| void | remap (InputArray src, OutputArray dst, InputArray map1, InputArray map2, int interpolation, int borderMode=BORDER_CONSTANT, const Scalar &borderValue=Scalar()) |
| | 对图像应用通用的几何变换。
|
| |
| Mat | repeat (const Mat &src, int ny, int nx) |
| |
| void | repeat (InputArray src, int ny, int nx, OutputArray dst) |
| | 用输入数组的重复副本填充输出数组。
|
| |
| void | reprojectImageTo3D (InputArray disparity, OutputArray _3dImage, InputArray Q, bool handleMissingValues=false, int ddepth=-1) |
| | 将视差图像重新投影到 3D 空间。
|
| |
| void | resize (InputArray src, OutputArray dst, Size dsize, double fx=0, double fy=0, int interpolation=INTER_LINEAR) |
| | 调整图像大小。
|
| |
| void | resizeWindow (const String &winname, const cv::Size &size) |
| |
| void | resizeWindow (const String &winname, int width, int height) |
| | 将窗口大小调整为指定的大小。
|
| |
| void | Rodrigues (InputArray src, OutputArray dst, OutputArray jacobian=noArray()) |
| | 在旋转矩阵与旋转向量之间进行转换。
|
| |
| void | rotate (InputArray src, OutputArray dst, int rotateCode) |
| | 以 90 度的倍数旋转 2D 数组。函数 cv::rotate 以三种不同方式之一旋转数组：顺时针旋转 90 度 (rotateCode = ROTATE_90_CLOCKWISE)。顺时针旋转 180 度 (rotateCode = ROTATE_180)。顺时针旋转 270 度 (rotateCode = ROTATE_90_COUNTERCLOCKWISE)。
|
| |
| int | rotatedRectangleIntersection (const RotatedRect &rect1, const RotatedRect &rect2, OutputArray intersectingRegion) |
| | 查找两个旋转矩形之间是否存在交集。
|
| |
| static int | roundUp (int a, unsigned int b) |
| | 将第一个值向上舍入为第二个值的最近倍数。
|
| |
| static size_t | roundUp (size_t a, unsigned int b) |
| |
| Vec3d | RQDecomp3x3 (InputArray src, OutputArray mtxR, OutputArray mtxQ, OutputArray Qx=noArray(), OutputArray Qy=noArray(), OutputArray Qz=noArray()) |
| | 计算 3x3 矩阵的 RQ 分解。
|
| |
| double | sampsonDistance (InputArray pt1, InputArray pt2, InputArray F) |
| | 计算两点之间的 Sampson 距离。
|
| |
| template<typename _Tp > |
| static _Tp | saturate_cast (double v) |
| |
| template<typename _Tp > |
| static _Tp | saturate_cast (float v) |
| |
| template<typename _Tp > |
| static _Tp | saturate_cast (hfloat v) |
| |
| template<typename _Tp > |
| static _Tp | saturate_cast (int v) |
| |
| template<typename _Tp > |
| static _Tp | saturate_cast (int64 v) |
| |
| template<typename _Tp > |
| static _Tp | saturate_cast (schar v) |
| |
| template<typename _Tp > |
| static _Tp | saturate_cast (short v) |
| |
| template<typename _Tp > |
| static _Tp | saturate_cast (softdouble a) |
| |
| template<typename _Tp > |
| static _Tp | saturate_cast (softfloat a) |
| | 饱和转换。
|
| |
| template<typename _Tp > |
| static _Tp | saturate_cast (uchar v) |
| | 用于从一种原始类型准确转换为另一种原始类型的模板函数。
|
| |
| template<typename _Tp > |
| static _Tp | saturate_cast (uint64 v) |
| |
| template<typename _Tp > |
| static _Tp | saturate_cast (unsigned v) |
| |
| template<typename _Tp > |
| static _Tp | saturate_cast (ushort v) |
| |
| template<> |
| hfloat | saturate_cast< hfloat > (double v) |
| |
| template<> |
| hfloat | saturate_cast< hfloat > (float v) |
| |
| template<> |
| hfloat | saturate_cast< hfloat > (int v) |
| |
| template<> |
| hfloat | saturate_cast< hfloat > (int64 v) |
| |
| template<> |
| hfloat | saturate_cast< hfloat > (schar v) |
| |
| template<> |
| hfloat | saturate_cast< hfloat > (short v) |
| |
| template<> |
| hfloat | saturate_cast< hfloat > (uchar v) |
| |
| template<> |
| hfloat | saturate_cast< hfloat > (uint64 v) |
| |
| template<> |
| hfloat | saturate_cast< hfloat > (unsigned v) |
| |
| template<> |
| hfloat | saturate_cast< hfloat > (ushort v) |
| |
| template<> |
| int64 | saturate_cast< int64 > (uint64 v) |
| |
| template<> |
| int64_t | saturate_cast< int64_t > (softdouble a) |
| |
| template<> |
| int64_t | saturate_cast< int64_t > (softfloat a) |
| |
| template<> |
| schar | saturate_cast< schar > (double v) |
| |
| template<> |
| schar | saturate_cast< schar > (float v) |
| |
| template<> |
| schar | saturate_cast< schar > (int v) |
| |
| template<> |
| schar | saturate_cast< schar > (int64 v) |
| |
| template<> |
| schar | saturate_cast< schar > (short v) |
| |
| template<> |
| schar | saturate_cast< schar > (softdouble a) |
| |
| template<> |
| schar | saturate_cast< schar > (softfloat a) |
| |
| template<> |
| schar | saturate_cast< schar > (uchar v) |
| |
| template<> |
| schar | saturate_cast< schar > (uint64 v) |
| |
| template<> |
| schar | saturate_cast< schar > (unsigned v) |
| |
| template<> |
| schar | saturate_cast< schar > (ushort v) |
| |
| template<> |
| short | saturate_cast< short > (double v) |
| |
| template<> |
| short | saturate_cast< short > (float v) |
| |
| template<> |
| short | saturate_cast< short > (int v) |
| |
| template<> |
| short | saturate_cast< short > (int64 v) |
| |
| template<> |
| short | saturate_cast< short > (softdouble a) |
| |
| template<> |
| short | saturate_cast< short > (softfloat a) |
| |
| template<> |
| short | saturate_cast< short > (uint64 v) |
| |
| template<> |
| short | saturate_cast< short > (unsigned v) |
| |
| template<> |
| short | saturate_cast< short > (ushort v) |
| |
| template<> |
| uchar | saturate_cast< uchar > (double v) |
| |
| template<> |
| uchar | saturate_cast< uchar > (float v) |
| |
| template<> |
| uchar | saturate_cast< uchar > (int v) |
| |
| template<> |
| uchar | saturate_cast< uchar > (int64 v) |
| |
| template<> |
| uchar | saturate_cast< uchar > (schar v) |
| |
| template<> |
| uchar | saturate_cast< uchar > (short v) |
| |
| template<> |
| uchar | saturate_cast< uchar > (softdouble a) |
| |
| template<> |
| uchar | saturate_cast< uchar > (softfloat a) |
| |
| template<> |
| uchar | saturate_cast< uchar > (uint64 v) |
| |
| template<> |
| uchar | saturate_cast< uchar > (unsigned v) |
| |
| template<> |
| uchar | saturate_cast< uchar > (ushort v) |
| |
| template<> |
| uint64 | saturate_cast< uint64 > (int v) |
| |
| template<> |
| uint64 | saturate_cast< uint64 > (int64 v) |
| |
| template<> |
| uint64 | saturate_cast< uint64 > (schar v) |
| |
| template<> |
| uint64 | saturate_cast< uint64 > (short v) |
| |
| template<> |
| uint64_t | saturate_cast< uint64_t > (softdouble a) |
| |
| template<> |
| uint64_t | saturate_cast< uint64_t > (softfloat a) |
| |
| template<> |
| unsigned | saturate_cast< unsigned > (double v) |
| |
| template<> |
| unsigned | saturate_cast< unsigned > (float v) |
| |
| template<> |
| unsigned | saturate_cast< unsigned > (int v) |
| |
| template<> |
| unsigned | saturate_cast< unsigned > (int64 v) |
| |
| template<> |
| unsigned | saturate_cast< unsigned > (schar v) |
| |
| template<> |
| unsigned | saturate_cast< unsigned > (short v) |
| |
| template<> |
| unsigned | saturate_cast< unsigned > (softdouble a) |
| |
| template<> |
| unsigned | saturate_cast< unsigned > (softfloat a) |
| | 饱和转换为无符号整数和无符号长长整数。我们故意不剪裁负数，以使 -1 变为 0xffffffff 等。
|
| |
| template<> |
| unsigned | saturate_cast< unsigned > (uint64 v) |
| |
| template<> |
| ushort | saturate_cast< ushort > (double v) |
| |
| template<> |
| ushort | saturate_cast< ushort > (float v) |
| |
| template<> |
| ushort | saturate_cast< ushort > (int v) |
| |
| template<> |
| ushort | saturate_cast< ushort > (int64 v) |
| |
| template<> |
| ushort | saturate_cast< ushort > (schar v) |
| |
| template<> |
| ushort | saturate_cast< ushort > (short v) |
| |
| template<> |
| ushort | saturate_cast< ushort > (softdouble a) |
| |
| template<> |
| ushort | saturate_cast< ushort > (softfloat a) |
| |
| template<> |
| ushort | saturate_cast< ushort > (uint64 v) |
| |
| template<> |
| ushort | saturate_cast< ushort > (unsigned v) |
| |
| void | saveWindowParameters (const String &windowName) |
| | 保存指定窗口的参数。
|
| |
| void | scaleAdd (InputArray src1, double alpha, InputArray src2, OutputArray dst) |
| | 计算缩放后的数组与另一个数组之和。
|
| |
| void | Scharr (InputArray src, OutputArray dst, int ddepth, int dx, int dy, double scale=1, double delta=0, int borderType=BORDER_DEFAULT) |
| | 使用 Scharr 算子计算图像的一阶 x 或 y 导数。
|
| |
| void | seamlessClone (InputArray src, InputArray dst, InputArray mask, Point p, OutputArray blend, int flags) |
| | 执行无缝克隆，将源图像的区域融合到目标图像中。该函数旨在进行局部图像编辑，允许将更改限制在特定区域（手动选择为ROI），以便轻松无缝地应用。这些更改可以是从轻微扭曲到完全替换为新内容 [221]。
|
| |
| Rect | selectROI (const String &windowName, InputArray img, bool showCrosshair=true, bool fromCenter=false, bool printNotice=true) |
| | 允许用户在给定图像上选择一个ROI。
|
| |
| Rect | selectROI (InputArray img, bool showCrosshair=true, bool fromCenter=false, bool printNotice=true) |
| |
| void | selectROIs (const String &windowName, InputArray img, std::vector< Rect > &boundingBoxes, bool showCrosshair=true, bool fromCenter=false, bool printNotice=true) |
| | 允许用户选择图像上的多个ROI。
|
| |
| void | sepFilter2D (InputArray src, OutputArray dst, int ddepth, InputArray kernelX, InputArray kernelY, Point anchor=Point(-1,-1), double delta=0, int borderType=BORDER_DEFAULT) |
| | 对图像应用可分离线性滤波器。
|
| |
| bool | setBreakOnError (bool flag) |
| | 设置/重置出错时中断模式。
|
| |
| void | setIdentity (InputOutputArray mtx, const Scalar &s=Scalar(1)) |
| | 初始化一个缩放后的单位矩阵。
|
| |
| void | setMouseCallback (const String &winname, MouseCallback onMouse, void *userdata=0) |
| | 为指定窗口设置鼠标处理程序。
|
| |
| void | setNumThreads (int nthreads) |
| | OpenCV 将尝试为随后的并行区域设置线程数。
|
| |
| void | setOpenGlContext (const String &winname) |
| | 将指定窗口设置为当前 OpenGL 上下文。
|
| |
| void | setOpenGlDrawCallback (const String &winname, OpenGlDrawCallback onOpenGlDraw, void *userdata=0) |
| | 设置一个回调函数，用于在显示的图像上方进行绘制。
|
| |
| void | setRNGSeed (int seed) |
| | 设置默认随机数生成器的状态。
|
| |
| void | setTrackbarMax (const String &trackbarname, const String &winname, int maxval) |
| | 设置滑块的最大位置。
|
| |
| void | setTrackbarMin (const String &trackbarname, const String &winname, int minval) |
| | 设置滑块的最小位置。
|
| |
| void | setTrackbarPos (const String &trackbarname, const String &winname, int pos) |
| | 设置轨迹条位置。
|
| |
| void | setUseOpenVX (bool flag) |
| | 启用/禁用 OpenVX 的使用。
|
| |
| void | setUseOptimized (bool onoff) |
| | 启用或禁用优化代码。
|
| |
| void | setWindowProperty (const String &winname, int prop_id, double prop_value) |
| | 动态更改窗口的参数。
|
| |
| void | setWindowTitle (const String &winname, const String &title) |
| | 更新窗口标题。
|
| |
| template<typename T > |
| Quat< T > | sin (const Quat< T > &q) |
| |
| softdouble | sin (const softdouble &a) |
| | 正弦。
|
| |
| template<typename T > |
| Quat< T > | sinh (const Quat< T > &q) |
| |
| void | Sobel (InputArray src, OutputArray dst, int ddepth, int dx, int dy, int ksize=3, double scale=1, double delta=0, int borderType=BORDER_DEFAULT) |
| | 使用扩展 Sobel 算子计算图像的一阶、二阶、三阶或混合导数。
|
| |
| bool | solve (InputArray src1, InputArray src2, OutputArray dst, int flags=DECOMP_LU) |
| | 求解一个或多个线性系统或最小二乘问题。
|
| |
| int | solveCubic (InputArray coeffs, OutputArray roots) |
| | 求三次方程的实根。
|
| |
| int | solveLP (InputArray Func, InputArray Constr, OutputArray z) |
| |
| int | solveLP (InputArray Func, InputArray Constr, OutputArray z, double constr_eps) |
| | 使用单纯形算法（单纯形法）求解给定的（非整数）线性规划问题。
|
| |
| int | solveP3P (InputArray objectPoints, InputArray imagePoints, InputArray cameraMatrix, InputArray distCoeffs, OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs, int flags) |
| | 从 3 组 3D-2D 点对应关系中寻找物体姿态 \( {}^{c}\mathbf{T}_o \)。
|
| |
| bool | solvePnP (InputArray objectPoints, InputArray imagePoints, InputArray cameraMatrix, InputArray distCoeffs, OutputArray rvec, OutputArray tvec, bool useExtrinsicGuess=false, int flags=SOLVEPNP_ITERATIVE) |
| | 从 3D-2D 点对应关系中寻找物体姿态 \( {}^{c}\mathbf{T}_o \)
|
| |
| int | solvePnPGeneric (InputArray objectPoints, InputArray imagePoints, InputArray cameraMatrix, InputArray distCoeffs, OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs, bool useExtrinsicGuess=false, SolvePnPMethod flags=SOLVEPNP_ITERATIVE, InputArray rvec=noArray(), InputArray tvec=noArray(), OutputArray reprojectionError=noArray()) |
| | 从 3D-2D 点对应关系中寻找物体姿态 \( {}^{c}\mathbf{T}_o \)。
|
| |
| bool | solvePnPRansac (InputArray objectPoints, InputArray imagePoints, InputArray cameraMatrix, InputArray distCoeffs, OutputArray rvec, OutputArray tvec, bool useExtrinsicGuess=false, int iterationsCount=100, float reprojectionError=8.0, double confidence=0.99, OutputArray inliers=noArray(), int flags=SOLVEPNP_ITERATIVE) |
| | 利用 RANSAC 方案从 3D-2D 点对应关系中寻找物体姿态 \( {}^{c}\mathbf{T}_o \)，以处理错误匹配。
|
| |
| bool | solvePnP Ransac (InputArray objectPoints, InputArray imagePoints, InputOutputArray cameraMatrix, InputArray distCoeffs, OutputArray rvec, OutputArray tvec, OutputArray inliers, const UsacParams ¶ms=UsacParams()) |
| |
| void | solvePnPRefineLM (InputArray objectPoints, InputArray imagePoints, InputArray cameraMatrix, InputArray distCoeffs, InputOutputArray rvec, InputOutputArray tvec, TermCriteria criteria=TermCriteria(TermCriteria::EPS+TermCriteria::COUNT, 20, FLT_EPSILON)) |
| | 基于 3D-2D 点对应关系，从初始解开始精细化姿态（将物体坐标系中的 3D 点变换到相机坐标系的平移和旋转向量）。
|
| |
| void | solvePnPRefineVVS (InputArray objectPoints, InputArray imagePoints, InputArray cameraMatrix, InputArray distCoeffs, InputOutputArray rvec, InputOutputArray tvec, TermCriteria criteria=TermCriteria(TermCriteria::EPS+TermCriteria::COUNT, 20, FLT_EPSILON), double VVSlambda=1) |
| | 基于 3D-2D 点对应关系，从初始解开始精细化姿态（将物体坐标系中的 3D 点变换到相机坐标系的平移和旋转向量）。
|
| |
| double | solvePoly (InputArray coeffs, OutputArray roots, int maxIters=300) |
| | 求多项式方程的实根或复根。
|
| |
| void | sort (InputArray src, OutputArray dst, int flags) |
| | 对矩阵的每一行或每一列进行排序。
|
| |
| void | sortIdx (InputArray src, OutputArray dst, int flags) |
| | 对矩阵的每一行或每一列进行排序。
|
| |
| void | spatialGradient (InputArray src, OutputArray dx, OutputArray dy, int ksize=3, int borderType=BORDER_DEFAULT) |
| | 使用 Sobel 算子同时计算 x 和 y 方向的一阶图像导数。
|
| |
| void | split (const Mat &src, Mat *mvbegin) |
| | 将多通道数组拆分为多个单通道数组。
|
| |
| void | split (InputArray m, OutputArrayOfArrays mv) |
| |
| void | sqrBoxFilter (InputArray src, OutputArray dst, int ddepth, Size ksize, Point anchor=Point(-1, -1), bool normalize=true, int borderType=BORDER_DEFAULT) |
| | 计算与滤波器重叠的像素值的归一化平方和。
|
| |
| template<typename S > |
| Quat< S > | sqrt (const Quat< S > &q, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) |
| |
| softdouble | sqrt (const softdouble &a) |
| |
| softfloat | sqrt (const softfloat &a) |
| | 平方根。
|
| |
| void | sqrt (InputArray src, OutputArray dst) |
| | 计算数组元素的平方根。
|
| |
| void | stackBlur (InputArray src, OutputArray dst, Size ksize) |
| | 使用 stackBlur 模糊图像。
|
| |
| int | startLoop (int(*pt2Func)(int argc, char *argv[]), int argc, char *argv[]) |
| |
| int | startWindowThread () |
| |
| double | stereoCalibrate (InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints1, InputArrayOfArrays imagePoints2, InputOutputArray cameraMatrix1, InputOutputArray distCoeffs1, InputOutputArray cameraMatrix2, InputOutputArray distCoeffs2, Size imageSize, InputOutputArray R, InputOutputArray T, OutputArray E, OutputArray F, OutputArray perViewErrors, int flags=CALIB_FIX_INTRINSIC, TermCriteria criteria=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 1e-6)) |
| | 这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。
|
| |
| double | stereoCalibrate (InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints1, InputArrayOfArrays imagePoints2, InputOutputArray cameraMatrix1, InputOutputArray distCoeffs1, InputOutputArray cameraMatrix2, InputOutputArray distCoeffs2, Size imageSize, InputOutputArray R, InputOutputArray T, OutputArray E, OutputArray F, OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs, OutputArray perViewErrors, int flags=CALIB_FIX_INTRINSIC, TermCriteria criteria=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 1e-6)) |
| | 标定双目相机设置。此函数计算两个相机各自的内参数，以及两个相机之间的外参数。
|
| |
| double | stereoCalibrate (InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints1, InputArrayOfArrays imagePoints2, InputOutputArray cameraMatrix1, InputOutputArray distCoeffs1, InputOutputArray cameraMatrix2, InputOutputArray distCoeffs2, Size imageSize, OutputArray R, OutputArray T, OutputArray E, OutputArray F, int flags=CALIB_FIX_INTRINSIC, TermCriteria criteria=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 1e-6)) |
| | 这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。
|
| |
| void | stereoRectify (InputArray cameraMatrix1, InputArray distCoeffs1, InputArray cameraMatrix2, InputArray distCoeffs2, Size imageSize, InputArray R, InputArray T, OutputArray R1, OutputArray R2, OutputArray P1, OutputArray P2, OutputArray Q, int flags=CALIB_ZERO_DISPARITY, double alpha=-1, Size newImageSize=Size(), Rect *validPixROI1=0, Rect *validPixROI2=0) |
| | 为已标定的立体相机的每个镜头计算校正变换。
|
| |
| bool | stereoRectifyUncalibrated (InputArray points1, InputArray points2, InputArray F, Size imgSize, OutputArray H1, OutputArray H2, double threshold=5) |
| | 为未标定的立体相机计算校正变换。
|
| |
| void | stopLoop () |
| |
| void | stylization (InputArray src, OutputArray dst, float sigma_s=60, float sigma_r=0.45f) |
| | 风格化旨在产生具有多种效果的数字图像，重点不在于写实主义。边缘感知滤波器是风格化的理想选择，因为它们可以抽象化低对比度区域，同时保留或增强高对比度特征。
|
| |
| void | subtract (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray(), int dtype=-1) |
| | 计算两个数组或数组与标量之间的逐元素差值。
|
| |
| Scalar | sum (InputArray src) |
| | 计算数组元素的总和。
|
| |
| void | SVBackSubst (InputArray w, InputArray u, InputArray vt, InputArray rhs, OutputArray dst) |
| |
| void | SVDecomp (InputArray src, OutputArray w, OutputArray u, OutputArray vt, int flags=0) |
| |
| void | swap (Mat &a, Mat &b) |
| | 交换两个矩阵。
|
| |
| void | swap (UMat &a, UMat &b) |
| |
| template<typename T > |
| Quat< T > | tan (const Quat< T > &q) |
| |
| template<typename T > |
| Quat< T > | tanh (const Quat< T > &q) |
| |
| String | tempfile (const char *suffix=0) |
| | 生成唯一的临时文件名。
|
| |
| void | terminate (int code, const String &err, const char *func, const char *file, int line) CV_NOEXCEPT |
| | 发出错误信号并终止应用程序。
|
| |
| void | textureFlattening (InputArray src, InputArray mask, OutputArray dst, float low_threshold=30, float high_threshold=45, int kernel_size=3) |
| | 通过仅保留边缘位置的梯度，在用泊松求解器积分之前，可以消除选定区域的纹理，使其内容呈现平坦的外观。此处使用Canny边缘检测器。
|
| |
| RNG (随机数生成器) & | theRNG () |
| | 返回默认随机数生成器。
|
| |
| double | threshold (InputArray src, OutputArray dst, double thresh, double maxval, int type) |
| | 对数组的每个元素应用固定阈值操作。
|
| |
| double | thresholdWithMask (InputArray src, InputOutputArray dst, InputArray mask, double thresh, double maxval, int type) |
| | 与threshold相同，但带有一个可选的掩码。
|
| |
| template<typename T > |
| std::vector< T > | to_own (const cv::MatSize &sz) |
| |
| cv::gapi::own::Mat | to_own (Mat &&)=delete |
| |
| cv::gapi::own::Mat | to_own (Mat const &m) |
| |
| static std::string | toLowerCase (const std::string &str) |
| |
| static std::string | toUpperCase (const std::string &str) |
| |
| template<typename _Tp , int m, int n> |
| static double | trace (const Matx< _Tp, m, n > &a) |
| |
| Scalar | trace (InputArray mtx) |
| | 返回矩阵的迹。
|
| |
| void | transform (InputArray src, OutputArray dst, InputArray m) |
| | 对数组的每个元素执行矩阵变换。
|
| |
| void | transpose (InputArray src, OutputArray dst) |
| | 矩阵转置。
|
| |
| void | transposeND (InputArray src, const std::vector< int > &order, OutputArray dst) |
| | n 维矩阵的转置。
|
| |
| void | triangulatePoints (InputArray projMatr1, InputArray projMatr2, InputArray projPoints1, InputArray projPoints2, OutputArray points4D) |
| | 此函数利用立体相机的观测结果重建三维点（齐次坐标）。
|
| |
| String | typeToString (int type) |
| |
| void | undistort (InputArray src, OutputArray dst, InputArray cameraMatrix, InputArray distCoeffs, InputArray newCameraMatrix=noArray()) |
| | 对图像进行变换以补偿镜头畸变。
|
| |
| void | undistortImagePoints (InputArray src, OutputArray dst, InputArray cameraMatrix, InputArray distCoeffs, TermCriteria=TermCriteria(TermCriteria::MAX_ITER, 5, 0.01)) |
| | 计算去畸变后的图像点位置。
|
| |
| void | undistortPoints (InputArray src, OutputArray dst, InputArray cameraMatrix, InputArray distCoeffs, InputArray R, InputArray P, TermCriteria criteria) |
| |
| void | undistortPoints (InputArray src, OutputArray dst, InputArray cameraMatrix, InputArray distCoeffs, InputArray R=noArray(), InputArray P=noArray()) |
| | 根据观测到的点坐标计算理想点坐标。
|
| |
| void | updateWindow (const String &winname) |
| | 通过保留边缘位置的梯度，在用泊松求解器积分之前，可以消除选定区域的纹理，使其内容呈现平坦的外观。此处使用Canny边缘检测器。
|
| |
| bool | useOpenVX () |
| | 检查是否启用了OpenVX。
|
| |
| bool | useOptimized () |
| | 返回优化代码的使用状态。
|
| |
| void | v256_cleanup () |
| |
| template<typename _Tp > |
| v_reg< _Tp, simd256_width/sizeof(_Tp)> | v256_load (const _Tp *ptr) |
| | 从内存加载 256 位长度的寄存器内容。
|
| |
| template<typename _Tp > |
| v_reg< _Tp, simd256_width/sizeof(_Tp)> | v256_load_aligned (const _Tp *ptr) |
| | 从内存加载寄存器内容 (对齐加载)
|
| |
| template<typename _Tp > |
| v_reg< typename V_TypeTraits< _Tp >::w_type, simd256_width/sizeof(typename V_TypeTraits< _Tp >::w_type)> | v256_load_expand (const _Tp *ptr) |
| | 从内存加载寄存器内容并进行双倍扩展 (double expand)。
|
| |
| v_reg< float, simd256_width/sizeof(float)> | v256_load_expand (const hfloat *ptr) |
| |
| template<typename _Tp > |
| v_reg< typename V_TypeTraits< _Tp >::q_type, simd256_width/sizeof(typename V_TypeTraits< _Tp >::q_type)> | v256_load_expand_q (const _Tp *ptr) |
| | 从内存加载寄存器内容并进行四倍扩展 (quad expand)。
|
| |
| template<typename _Tp > |
| v_reg< _Tp, simd256_width/sizeof(_Tp)> | v256_load_halves (const _Tp *loptr, const _Tp *hiptr) |
| | 从两个内存块加载寄存器内容。
|
| |
| template<typename _Tp > |
| v_reg< _Tp, simd256_width/sizeof(_Tp)> | v256_load_low (const _Tp *ptr) |
| | 加载 128 位数据到低位部分 (高位部分未定义)。
|
| |
| void | v512_cleanup () |
| |
| template<typename _Tp > |
| v_reg< _Tp, simd512_width/sizeof(_Tp)> | v512_load (const _Tp *ptr) |
| | 从内存加载 512 位长度的寄存器内容。
|
| |
| template<typename _Tp > |
| v_reg< _Tp, simd512_width/sizeof(_Tp)> | v512_load_aligned (const _Tp *ptr) |
| | 从内存加载寄存器内容 (对齐加载)
|
| |
| template<typename _Tp > |
| v_reg< typename V_TypeTraits< _Tp >::w_type, simd512_width/sizeof(typename V_TypeTraits< _Tp >::w_type)> | v512_load_expand (const _Tp *ptr) |
| | 从内存加载寄存器内容并进行双倍扩展 (double expand)。
|
| |
| v_reg< float, simd512_width/sizeof(float)> | v512_load_expand (const hfloat *ptr) |
| |
| template<typename _Tp > |
| v_reg< typename V_TypeTraits< _Tp >::q_type, simd512_width/sizeof(typename V_TypeTraits< _Tp >::q_type)> | v512_load_expand_q (const _Tp *ptr) |
| | 从内存加载寄存器内容并进行四倍扩展 (quad expand)。
|
| |
| template<typename _Tp > |
| v_reg< _Tp, simd512_width/sizeof(_Tp)> | v512_load_halves (const _Tp *loptr, const _Tp *hiptr) |
| | 从两个内存块加载寄存器内容。
|
| |
| template<typename _Tp > |
| v_reg< _Tp, simd512_width/sizeof(_Tp)> | v512_load_low (const _Tp *ptr) |
| | 加载 256 位数据到低位部分 (高位部分未定义)。
|
| |
| template<typename _Tp , int n> |
| v_reg< typename V_TypeTraits< _Tp >::abs_type, n > | v_abs (const v_reg< _Tp, n > &a) |
| | 元素的绝对值。
|
| |
| template<typename _Tp , int n> |
| v_reg< typename V_TypeTraits< _Tp >::abs_type, n > | v_absdiff (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b) |
| | 绝对差值。
|
| |
| template<int n> |
| v_reg< double, n > | v_absdiff (const v_reg< double, n > &a, const v_reg< double, n > &b) |
| |
| template<int n> |
| v_reg< float, n > | v_absdiff (const v_reg< float, n > &a, const v_reg< float, n > &b) |
| |
| template<typename _Tp , int n> |
| v_reg< _Tp, n > | v_absdiffs (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b) |
| | 饱和绝对差值。
|
| |
| template<typename _Tp , int n> |
| v_reg< _Tp, n > | v_add (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b) |
| | 数值相加。
|
| |
| template<typename _Tp , int n> |
| v_reg< _Tp, n > | v_add_wrap (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b) |
| | 数值相加 (不进行饱和处理)。
|
| |
| template<typename _Tp , int n> |
| v_reg< _Tp, n > | v_and (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b) |
| | 按位与 (Bitwise AND)。
|
| |
| template<int i, typename _Tp , int n> |
| v_reg< _Tp, n > | v_broadcast_element (const v_reg< _Tp, n > &a) |
| | 广播向量的第 i 个元素。
|
| |
| template<int n> |
| v_reg< int, n *2 > | v_ceil (const v_reg< double, n > &a) |
| |
| template<int n> |
| v_reg< int, n > | v_ceil (const v_reg< float, n > &a) |
| | 向上取整。
|
| |
| template<typename _Tp , int n> |
| bool | v_check_all (const v_reg< _Tp, n > &a) |
| | 检查是否所有打包值都小于零。
|
| |
| template<typename _Tp , int n> |
| bool | v_check_any (const v_reg< _Tp, n > &a) |
| | 检查是否有任何打包值小于零。
|
| |
| void | v_cleanup () |
| |
| template<typename _Tp , int n> |
| v_reg< _Tp, n > | v_combine_high (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b) |
| | 从两个向量的后半部分元素组合成新向量。
|
| |
| template<typename _Tp , int n> |
| v_reg< _Tp, n > | v_combine_low (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b) |
| | 从两个向量的前半部分元素组合成新向量。
|
| |
| template<typename _Tp , int n> |
| v_reg< _Tp, n > | v_cos (const v_reg< _Tp, n > &a) |
| | 元素的余弦值 \( cos(x) \)。
|
| |
| template<int n> |
| v_reg< float, n *2 > | v_cvt_f32 (const v_reg< double, n > &a) |
| | 将低半部分转换为 float。
|
| |
| template<int n> |
| v_reg< float, n *2 > | v_cvt_f32 (const v_reg< double, n > &a, const v_reg< double, n > &b) |
| | 转换为 float。
|
| |
| template<int n> |
| v_reg< float, n > | v_cvt_f32 (const v_reg< int, n > &a) |
| | 转换为 float。
|
| |
| template<int n> |
| v_reg< double,(n/2)> | v_cvt_f64 (const v_reg< float, n > &a) |
| | 将低半部分转换为 double。
|
| |
| template<int n> |
| v_reg< double, n/2 > | v_cvt_f64 (const v_reg< int, n > &a) |
| | 将低半部分转换为 double。
|
| |
| template<int n> |
| v_reg< double, n > | v_cvt_f64 (const v_reg< int64, n > &a) |
| | 转换为 double。
|
| |
| template<int n> |
| v_reg< double,(n/2)> | v_cvt_f64_high (const v_reg< float, n > &a) |
| | 将向量的高半部分转换为 double。
|
| |
| template<int n> |
| v_reg< double,(n/2)> | v_cvt_f64_high (const v_reg< int, n > &a) |
| | 将向量的高半部分转换为 double。
|
| |
| template<typename _Tp , int n> |
| v_reg< _Tp, n > | v_div (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b) |
| | 数值相除。
|
| |
| template<typename _Tp , int n> |
| v_reg< typename V_TypeTraits< _Tp >::w_type, n/2 > | v_dotprod (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b) |
| | 元素的点积。
|
| |
| template<typename _Tp , int n> |
| v_reg< typename V_TypeTraits< _Tp >::w_type, n/2 > | v_dotprod (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b, const v_reg< typename V_TypeTraits< _Tp >::w_type, n/2 > &c) |
| | 元素的点积。
|
| |
| template<typename _Tp , int n> |
| v_reg< typename V_TypeTraits< _Tp >::q_type, n/4 > | v_dotprod_expand (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b) |
| | 点积并扩展。
|
| |
| template<typename _Tp , int n> |
| v_reg< typename V_TypeTraits< _Tp >::q_type, n/4 > | v_dotprod_expand (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b, const v_reg< typename V_TypeTraits< _Tp >::q_type, n/4 > &c) |
| | 元素的点积。
|
| |
| template<int n> |
| v_reg< double, n/2 > | v_dotprod_expand (const v_reg< int, n > &a, const v_reg< int, n > &b) |
| |
| template<int n> |
| v_reg< double, n/2 > | v_dotprod_expand (const v_reg< int, n > &a, const v_reg< int, n > &b, const v_reg< double, n/2 > &c) |
| |
| template<typename _Tp , int n> |
| v_reg< typename V_TypeTraits< _Tp >::q_type, n/4 > | v_dotprod_expand_fast (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b) |
| | 快速点积并扩展。
|
| |
| template<typename _Tp , int n> |
| v_reg< typename V_TypeTraits< _Tp >::q_type, n/4 > | v_dotprod_expand_fast (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b, const v_reg< typename V_TypeTraits< _Tp >::q_type, n/4 > &c) |
| | 快速点积。
|
| |
| template<int n> |
| v_reg< double, n/2 > | v_dotprod_expand_fast (const v_reg< int, n > &a, const v_reg< int, n > &b) |
| |
| template<int n> |
| v_reg< double, n/2 > | v_dotprod_expand_fast (const v_reg< int, n > &a, const v_reg< int, n > &b, const v_reg< double, n/2 > &c) |
| |
| template<typename _Tp , int n> |
| v_reg< typename V_TypeTraits< _Tp >::w_type, n/2 > | v_dotprod_fast (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b) |
| | 快速点积。
|
| |
| template<typename _Tp , int n> |
| v_reg< typename V_TypeTraits< _Tp >::w_type, n/2 > | v_dotprod_fast (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b, const v_reg< typename V_TypeTraits< _Tp >::w_type, n/2 > &c) |
| | 快速点积。
|
| |
| template<typename _Tp , int n> |
| v_reg< _Tp, n > | v_eq (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b) |
| | 等于比较。
|
| |
| template<typename _Tp , int n> |
| v_reg< _Tp, n > | v_erf (const v_reg< _Tp, n > &a) |
| | 误差 (Error) 函数。
|
| |
| template<typename _Tp , int n> |
| v_reg< _Tp, n > | v_exp (const v_reg< _Tp, n > &a) |
| | 元素的指数值 \( e^x \)。
|
| |
| template<typename _Tp , int n> |
| void | v_expand (const v_reg< _Tp, n > &a, v_reg< typename V_TypeTraits< _Tp >::w_type, n/2 > &b0, v_reg< typename V_TypeTraits< _Tp >::w_type, n/2 > &b1) |
| | 将数值扩展到更宽的打包类型。
|
| |
| template<typename _Tp , int n> |
| v_reg< typename V_TypeTraits< _Tp >::w_type, n/2 > | v_expand_high (const v_reg< _Tp, n > &a) |
| | 将高位数值扩展到更宽的打包类型。
|
| |
| template<typename _Tp , int n> |
| v_reg< typename V_TypeTraits< _Tp >::w_type, n/2 > | v_expand_low (const v_reg< _Tp, n > &a) |
| | 将低位数值扩展到更宽的打包类型。
|
| |
| template<int s, typename _Tp , int n> |
| v_reg< _Tp, n > | v_extract (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b) |
| | 向量提取。
|
| |
| template<int s, typename _Tp , int n> |
| _Tp | v_extract_n (const v_reg< _Tp, n > &v) |
| | 向量提取。
|
| |
| template<int n> |
| v_reg< int, n *2 > | v_floor (const v_reg< double, n > &a) |
| |
| template<int n> |
| v_reg< int, n > | v_floor (const v_reg< float, n > &a) |
| | 向下取整。
|
| |
| template<typename _Tp , int n> |
| v_reg< _Tp, n > | v_fma (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b, const v_reg< _Tp, n > &c) |
| | 乘加运算 (FMA)。
|
| |
| template<typename _Tp , int n> |
| v_reg< _Tp, n > | v_ge (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b) |
| | 大于或等于比较。
|
| |
| template<typename _Tp , int n> |
| v_reg< _Tp, n > | v_gt (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b) |
| | 大于比较。
|
| |
| template<typename _Tp , int n> |
| v_reg< _Tp, n > | v_interleave_pairs (const v_reg< _Tp, n > &vec) |
| |
| template<typename _Tp , int n> |
| v_reg< _Tp, n > | v_interleave_quads (const v_reg< _Tp, n > &vec) |
| |
| template<typename _Tp , int n> |
| v_reg< _Tp, n > | v_invsqrt (const v_reg< _Tp, n > &a) |
| | 平方根倒数。
|
| |
| template<typename _Tp , int n> |
| v_reg< _Tp, n > | v_le (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b) |
| | 小于或等于比较。
|
| |
| template<typename _Tp > |
| v_reg< _Tp, simd128_width/sizeof(_Tp)> | v_load (const _Tp *ptr) |
| | 从内存加载寄存器内容。
|
| |
| template<typename _Tp > |
| v_reg< _Tp, simd128_width/sizeof(_Tp)> | v_load_aligned (const _Tp *ptr) |
| | 从内存加载寄存器内容 (对齐加载)
|
| |
| template<typename _Tp , int n> |
| void | v_load_deinterleave (const _Tp *ptr, v_reg< _Tp, n > &a, v_reg< _Tp, n > &b) |
| | 加载并去交错 (2 通道)
|
| |
| template<typename _Tp , int n> |
| void | v_load_deinterleave (const _Tp *ptr, v_reg< _Tp, n > &a, v_reg< _Tp, n > &b, v_reg< _Tp, n > &c) |
| | 加载并去交错 (3 通道)
|
| |
| template<typename _Tp , int n> |
| void | v_load_deinterleave (const _Tp *ptr, v_reg< _Tp, n > &a, v_reg< _Tp, n > &b, v_reg< _Tp, n > &c, v_reg< _Tp, n > &d) |
| | 加载并去交错 (4 通道)
|
| |
| template<typename _Tp > |
| v_reg< typename V_TypeTraits< _Tp >::w_type, simd128_width/sizeof(typename V_TypeTraits< _Tp >::w_type)> | v_load_expand (const _Tp *ptr) |
| | 从内存加载寄存器内容并进行双倍扩展 (double expand)。
|
| |
| v_reg< float, simd128_width/sizeof(float)> | v_load_expand (const hfloat *ptr) |
| |
| template<typename _Tp > |
| v_reg< typename V_TypeTraits< _Tp >::q_type, simd128_width/sizeof(typename V_TypeTraits< _Tp >::q_type)> | v_load_expand_q (const _Tp *ptr) |
| | 从内存加载寄存器内容并进行四倍扩展 (quad expand)。
|
| |
| template<typename _Tp > |
| v_reg< _Tp, simd128_width/sizeof(_Tp)> | v_load_halves (const _Tp *loptr, const _Tp *hiptr) |
| | 从两个内存块加载寄存器内容。
|
| |
| template<typename _Tp > |
| v_reg< _Tp, simd128_width/sizeof(_Tp)> | v_load_low (const _Tp *ptr) |
| | 加载 64 位数据到低位部分 (高位部分未定义)。
|
| |
| template<typename _Tp , int n> |
| v_reg< _Tp, n > | v_log (const v_reg< _Tp, n > &a) |
| | 元素的自然对数 \( \log(x) \)。
|
| |
| template<typename _Tp , int n> |
| v_reg< _Tp, n > | v_lt (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b) |
| | 小于比较。
|
| |
| template<typename _Tp > |
| v_reg< _Tp, simd128_width/sizeof(_Tp)> | v_lut (const _Tp *tab, const int *idx) |
| |
| template<int n> |
| v_reg< double, n/2 > | v_lut (const double *tab, const v_reg< int, n > &idx) |
| |
| template<int n> |
| v_reg< float, n > | v_lut (const float *tab, const v_reg< int, n > &idx) |
| |
| template<int n> |
| v_reg< int, n > | v_lut (const int *tab, const v_reg< int, n > &idx) |
| |
| template<int n> |
| v_reg< unsigned, n > | v_lut (const unsigned *tab, const v_reg< int, n > &idx) |
| |
| template<int n> |
| void | v_lut_deinterleave (const double *tab, const v_reg< int, n *2 > &idx, v_reg< double, n > &x, v_reg< double, n > &y) |
| |
| template<int n> |
| void | v_lut_deinterleave (const float *tab, const v_reg< int, n > &idx, v_reg< float, n > &x, v_reg< float, n > &y) |
| |
| template<typename _Tp > |
| v_reg< _Tp, simd128_width/sizeof(_Tp)> | v_lut_pairs (const _Tp *tab, const int *idx) |
| |
| template<typename _Tp > |
| v_reg< _Tp, simd128_width/sizeof(_Tp)> | v_lut_quads (const _Tp *tab, const int *idx) |
| |
| template<typename _Tp , int n> |
| v_reg< _Tp, n > | v_magnitude (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b) |
| | 模长 (Magnitude)。
|
| |
| template<int n> |
| v_reg< float, n > | v_matmul (const v_reg< float, n > &v, const v_reg< float, n > &a, const v_reg< float, n > &b, const v_reg< float, n > &c, const v_reg< float, n > &d) |
| | 矩阵乘法。
|
| |
| template<int n> |
| v_reg< float, n > | v_matmuladd (const v_reg< float, n > &v, const v_reg< float, n > &a, const v_reg< float, n > &b, const v_reg< float, n > &c, const v_reg< float, n > &d) |
| | 矩阵乘加运算。
|
| |
| template<typename _Tp , int n> |
| v_reg< _Tp, n > | v_max (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b) |
| | 为每对元素选择最大值。
|
| |
| template<typename _Tp , int n> |
| v_reg< _Tp, n > | v_min (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b) |
| | 为每对元素选择最小值。
|
| |
| template<typename _Tp , int n> |
| v_reg< _Tp, n > | v_mul (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b) |
| | 数值相乘。
|
| |
| template<typename _Tp , int n> |
| void | v_mul_expand (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b, v_reg< typename V_TypeTraits< _Tp >::w_type, n/2 > &c, v_reg< typename V_TypeTraits< _Tp >::w_type, n/2 > &d) |
| | 相乘并扩展。
|
| |
| template<typename _Tp , int n> |
| v_reg< _Tp, n > | v_mul_hi (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b) |
| | 相乘并提取高位部分。
|
| |
| template<typename _Tp , int n> |
| v_reg< _Tp, n > | v_mul_wrap (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b) |
| | 数值相乘 (不进行饱和处理)。
|
| |
| template<typename _Tp , int n> |
| v_reg< _Tp, n > | v_muladd (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b, const v_reg< _Tp, n > &c) |
| | v_fma 的同义词。
|
| |
| template<typename _Tp , int n> |
| v_reg< _Tp, n > | v_ne (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b) |
| | 不等于比较。
|
| |
| template<typename _Tp , int n> |
| v_reg< _Tp, n > | v_not (const v_reg< _Tp, n > &a) |
| | 按位非 (Bitwise NOT)。
|
| |
| template<int n> |
| v_reg< double, n > | v_not_nan (const v_reg< double, n > &a) |
| |
| template<int n> |
| v_reg< float, n > | v_not_nan (const v_reg< float, n > &a) |
| |
| template<typename _Tp , int n> |
| v_reg< _Tp, n > | v_or (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b) |
| | 按位或 (Bitwise OR)。
|
| |
| template<int n> |
| void | v_pack_store (hfloat *ptr, const v_reg< float, n > &v) |
| |
| template<typename _Tp , int n> |
| v_reg< _Tp, n > | v_pack_triplets (const v_reg< _Tp, n > &vec) |
| |
| template<typename _Tp , int n> |
| v_reg< typename V_TypeTraits< _Tp >::abs_type, n > | v_popcount (const v_reg< _Tp, n > &a) |
| | 统计向量通道中 1 位的数量，并以相应的无符号类型返回结果。
|
| |
| template<typename _Tp , int n> |
| void | v_recombine (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b, v_reg< _Tp, n > &low, v_reg< _Tp, n > &high) |
| | 从另外两个向量的低位和高位部分组合出两个新向量。
|
| |
| template<typename _Tp , int n> |
| _Tp | v_reduce_max (const v_reg< _Tp, n > &a) |
| | 寻找一个最大值。
|
| |
| template<typename _Tp , int n> |
| _Tp | v_reduce_min (const v_reg< _Tp, n > &a) |
| | 寻找一个最小值。
|
| |
| template<typename _Tp , int n> |
| V_TypeTraits< typenameV_TypeTraits< _Tp >::abs_type >::sum_type | v_reduce_sad (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b) |
| | 计算数值的绝对差之和 (SAD)。
|
| |
| template<typename _Tp , int n> |
| V_TypeTraits< _Tp >::sum_type | v_reduce_sum (const v_reg< _Tp, n > &a) |
| | 对打包值求和。
|
| |
| template<int n> |
| v_reg< float, n > | v_reduce_sum4 (const v_reg< float, n > &a, const v_reg< float, n > &b, const v_reg< float, n > &c, const v_reg< float, n > &d) |
| | 对每个输入向量的所有元素求和，并返回由这些和组成的向量。
|
| |
| template<typename _Tp , int n> |
| v_reg< _Tp, n > | v_reverse (const v_reg< _Tp, n > &a) |
| | 向量元素次序反转。
|
| |
| template<int imm, typename _Tp , int n> |
| v_reg< _Tp, n > | v_rotate_left (const v_reg< _Tp, n > &a) |
| | 向量内元素向左平移。
|
| |
| template<int imm, typename _Tp , int n> |
| v_reg< _Tp, n > | v_rotate_left (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b) |
| |
| template<int imm, typename _Tp , int n> |
| v_reg< _Tp, n > | v_rotate_right (const v_reg< _Tp, n > &a) |
| | 向量内元素向右平移。
|
| |
| template<int imm, typename _Tp , int n> |
| v_reg< _Tp, n > | v_rotate_right (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b) |
| |
| template<int n> |
| v_reg< int, n *2 > | v_round (const v_reg< double, n > &a) |
| |
| template<int n> |
| v_reg< int, n *2 > | v_round (const v_reg< double, n > &a, const v_reg< double, n > &b) |
| |
| template<int n> |
| v_reg< int, n > | v_round (const v_reg< float, n > &a) |
| | 元素舍入。
|
| |
| template<typename _Tp , int n> |
| int | v_scan_forward (const v_reg< _Tp, n > &a) |
| | 获取第一个负值通道的索引。
|
| |
| template<typename _Tp , int n> |
| v_reg< _Tp, n > | v_select (const v_reg< _Tp, n > &mask, const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b) |
| | 逐元素选择 (混合操作/blend operation)
|
| |
| template<typename _Tp , int n> |
| v_reg< _Tp, n > | v_shl (const v_reg< _Tp, n > &a, int imm) |
| | 按位左移。
|
| |
| template<typename _Tp , int n> |
| v_reg< _Tp, n > | v_shr (const v_reg< _Tp, n > &a, int imm) |
| | 按位右移。
|
| |
| template<typename _Tp , int n> |
| int | v_signmask (const v_reg< _Tp, n > &a) |
| | 获取负值掩码。
|
| |
| template<typename _Tp , int n> |
| v_reg< _Tp, n > | v_sin (const v_reg< _Tp, n > &a) |
| | 元素的正弦值 \( sin(x) \)。
|
| |
| template<typename _Tp , int n> |
| void | v_sincos (const v_reg< _Tp, n > &x, v_reg< _Tp, n > &s, v_reg< _Tp, n > &c) |
| | 同时计算元素的正弦 \( sin(x) \) 和余弦 \( cos(x) \)。
|
| |
| template<typename _Tp , int n> |
| v_reg< _Tp, n > | v_sqr_magnitude (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b) |
| | 模长的平方。
|
| |
| template<typename _Tp , int n> |
| v_reg< _Tp, n > | v_sqrt (const v_reg< _Tp, n > &a) |
| | 元素的平方根。
|
| |
| template<typename _Tp , int n> |
| void | v_store (_Tp *ptr, const v_reg< _Tp, n > &a) |
| | 将数据存储到内存。
|
| |
| template<typename _Tp , int n> |
| void | v_store (_Tp *ptr, const v_reg< _Tp, n > &a, hal::StoreMode) |
| |
| template<typename _Tp , int n> |
| void | v_store_aligned (_Tp *ptr, const v_reg< _Tp, n > &a) |
| | 将数据存储到内存 (对齐存储)
|
| |
| template<typename _Tp , int n> |
| void | v_store_aligned (_Tp *ptr, const v_reg< _Tp, n > &a, hal::StoreMode) |
| |
| template<typename _Tp , int n> |
| void | v_store_aligned_nocache (_Tp *ptr, const v_reg< _Tp, n > &a) |
| |
| template<typename _Tp , int n> |
| void | v_store_high (_Tp *ptr, const v_reg< _Tp, n > &a) |
| | 将数据存储到内存 (高半部分)
|
| |
| template<typename _Tp , int n> |
| void | v_store_interleave (_Tp *ptr, const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b, const v_reg< _Tp, n > &c, const v_reg< _Tp, n > &d, hal::StoreMode=hal::STORE_UNALIGNED) |
| | 交错并存储 (4 通道)
|
| |
| template<typename _Tp , int n> |
| void | v_store_interleave (_Tp *ptr, const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b, const v_reg< _Tp, n > &c, hal::StoreMode=hal::STORE_UNALIGNED) |
| | 交错并存储 (3 通道)
|
| |
| template<typename _Tp , int n> |
| void | v_store_interleave (_Tp *ptr, const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b, hal::StoreMode=hal::STORE_UNALIGNED) |
| | 交错并存储 (2 通道)
|
| |
| template<typename _Tp , int n> |
| void | v_store_low (_Tp *ptr, const v_reg< _Tp, n > &a) |
| | 将数据存储到内存 (低半部分)
|
| |
| template<typename _Tp , int n> |
| v_reg< _Tp, n > | v_sub (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b) |
| | 数值相减。
|
| |
| template<typename _Tp , int n> |
| v_reg< _Tp, n > | v_sub_wrap (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b) |
| | 数值相减 (不进行饱和处理)。
|
| |
| template<typename _Tp , int n> |
| void | v_transpose4x4 (v_reg< _Tp, n > &a0, const v_reg< _Tp, n > &a1, const v_reg< _Tp, n > &a2, const v_reg< _Tp, n > &a3, v_reg< _Tp, n > &b0, v_reg< _Tp, n > &b1, v_reg< _Tp, n > &b2, v_reg< _Tp, n > &b3) |
| | 4x4 矩阵转置。
|
| |
| template<int n> |
| v_reg< int, n *2 > | v_trunc (const v_reg< double, n > &a) |
| |
| template<int n> |
| v_reg< int, n > | v_trunc (const v_reg< float, n > &a) |
| | 元素截断 (取整)。
|
| |
| template<typename _Tp , int n> |
| v_reg< _Tp, n > | v_xor (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b) |
| | 按位异或 (Bitwise XOR)。
|
| |
| template<typename _Tp , int n> |
| void | v_zip (const v_reg< _Tp, n > &a0, const v_reg< _Tp, n > &a1, v_reg< _Tp, n > &b0, v_reg< _Tp, n > &b1) |
| | 交织两个向量。
|
| |
| void | validate_input_arg (const GRunArg &arg) |
| |
| void | validate_input_args (const GRunArgs &args) |
| |
| void | validateDisparity (InputOutputArray disparity, InputArray cost, int minDisparity, int numberOfDisparities, int disp12MaxDisp=1) |
| | 使用左右检查（left-right check）验证视差。矩阵“cost”应由双目匹配算法计算得出。
|
| |
| GRunArg | value_of (const GOrigin &origin) |
| |
| void | vconcat (const Mat *src, size_t nsrc, OutputArray dst) |
| | 对给定的矩阵进行垂直拼接。
|
| |
| void | vconcat (InputArray src1, InputArray src2, OutputArray dst) |
| |
| void | vconcat (InputArrayOfArrays src, OutputArray dst) |
| |
| int | waitKey (int delay=0) |
| | 等待按键操作。
|
| |
| int | waitKeyEx (int delay=0) |
| | 类似于waitKey，但返回完整的按键代码。
|
| |
| void | warpAffine (InputArray src, OutputArray dst, InputArray M, Size dsize, int flags=INTER_LINEAR, int borderMode=BORDER_CONSTANT, const Scalar &borderValue=Scalar()) |
| | 对图像应用仿射变换。
|
| |
| void | warpPerspective (InputArray src, OutputArray dst, InputArray M, Size dsize, int flags=INTER_LINEAR, int borderMode=BORDER_CONSTANT, const Scalar &borderValue=Scalar()) |
| | 对图像应用透视变换。
|
| |
| void | warpPolar (InputArray src, OutputArray dst, Size dsize, Point2f center, double maxRadius, int flags) |
| | 将图像重映射到极坐标或对数极坐标空间。
|
| |
| void | watershed (InputArray image, InputOutputArray markers) |
| | 使用分水岭算法执行基于标记的图像分割。
|
| |
| void | winrt_imshow () |
| |
| void | winrt_initContainer (::Windows::UI::Xaml::Controls::Panel^ container) |
| | 初始化将用于容纳生成的窗口内容的容器组件。
|
| |
| void | winrt_onVisibilityChanged (bool visible) |
| |
| void | winrt_setFrameContainer (::Windows::UI::Xaml::Controls::Image^ image) |
| |
| template<typename ... Args> |
| void | winrt_startMessageLoop (std::function< void(Args...)> &&callback, Args... args) |
| |
| template<typename ... Args> |
| void | winrt_startMessageLoop (void callback(Args...), Args... args) |
| |
| template void | winrt_startMessageLoop (void callback(void)) |
| |
| float | wrapperEMD (InputArray signature1, InputArray signature2, int distType, InputArray cost=noArray(), Ptr< float > lowerBound=Ptr< float >(), OutputArray flow=noArray()) |
| |
| template<typename _Tp > |
| static void | write (FileStorage &fs, const _Tp &value) |
| |
| template<typename _Tp > |
| static void | write (FileStorage &fs, const Complex< _Tp > &c) |
| |
| template<> |
| void | write (FileStorage &fs, const double &value) |
| |
| template<> |
| void | write (FileStorage &fs, const float &value) |
| |
| template<> |
| void | write (FileStorage &fs, const int &value) |
| |
| template<typename _Tp , int m, int n> |
| static void | write (FileStorage &fs, const Matx< _Tp, m, n > &x) |
| |
| template<typename _Tp > |
| static void | write (FileStorage &fs, const Point3_< _Tp > &pt) |
| |
| template<typename _Tp > |
| static void | write (FileStorage &fs, const Point_< _Tp > &pt) |
| |
| static void | write (FileStorage &fs, const Range &r) |
| |
| template<typename _Tp > |
| static void | write (FileStorage &fs, const Rect_< _Tp > &r) |
| |
| template<typename _Tp > |
| static void | write (FileStorage &fs, const Scalar_< _Tp > &s) |
| |
| template<typename _Tp > |
| static void | write (FileStorage &fs, const Size_< _Tp > &sz) |
| |
| template<typename _Tp > |
| static void | write (FileStorage &fs, const std::vector< _Tp > &vec) |
| |
| template<typename _Tp , typename std::enable_if< std::is_enum< _Tp >::value >::type * = nullptr> |
| static void | write (FileStorage &fs, const String &name, const _Tp &val) |
| |
| template<typename _Tp > |
| static void | write (FileStorage &fs, const String &name, const Complex< _Tp > &c) |
| |
| static void | write (FileStorage &fs, const String &name, const DMatch &m) |
| |
| static void | write (FileStorage &fs, const String &name, const KeyPoint &kpt) |
| |
| void | write (FileStorage &fs, const String &name, const Mat &value) |
| |
| template<typename _Tp , int m, int n> |
| static void | write (FileStorage &fs, const String &name, const Matx< _Tp, m, n > &x) |
| |
| void | write (FileStorage &fs, const String &name, const optflow::GPCTree::Node &node) |
| |
| template<typename _Tp > |
| static void | write (FileStorage &fs, const String &name, const Point3_< _Tp > &pt) |
| |
| template<typename _Tp > |
| static void | write (FileStorage &fs, const String &name, const Point_< _Tp > &pt) |
| |
| static void | write (FileStorage &fs, const String &name, const Range &r) |
| |
| template<typename _Tp > |
| static void | write (FileStorage &fs, const String &name, const Rect_< _Tp > &r) |
| |
| template<typename _Tp > |
| static void | write (FileStorage &fs, const String &name, const Scalar_< _Tp > &s) |
| |
| template<typename _Tp > |
| static void | write (FileStorage &fs, const String &name, const Size_< _Tp > &sz) |
| |
| void | write (FileStorage &fs, const String &name, const SparseMat &value) |
| |
| template<typename _Tp > |
| static void | write (FileStorage &fs, const String &name, const std::vector< _Tp > &vec) |
| |
| template<typename _Tp > |
| static void | write (FileStorage &fs, const String &name, const std::vector< std::vector< _Tp > > &vec) |
| |
| void | write (FileStorage &fs, const String &name, const String &value) |
| |
| template<typename _Tp , int cn> |
| static void | write (FileStorage &fs, const String &name, const Vec< _Tp, cn > &v) |
| |
| void | write (FileStorage &fs, const String &name, double value) |
| |
| void | write (FileStorage &fs, const String &name, float value) |
| |
| void | write (FileStorage &fs, const String &name, int value) |
| |
| void | write (FileStorage &fs, const String &name, int64_t value) |
| |
| template<> |
| void | write (FileStorage &fs, const String &value) |
| |
| template<typename _Tp , int cn> |
| static void | write (FileStorage &fs, const Vec< _Tp, cn > &v) |
| |
| bool | writeOpticalFlow (const String &path, InputArray flow) |
| | 将 .flo 文件写入磁盘。
|
| |
| void | writeScalar (FileStorage &fs, const String &value) |
| |
| void | writeScalar (FileStorage &fs, double value) |
| |
| void | writeScalar (FileStorage &fs, float value) |
| |
| void | writeScalar (FileStorage &fs, int value) |
| |
| void | writeScalar (FileStorage &fs, int64_t value) |
| |
|
|
| v_uint8x16 | v_setzero_u8 () |
| |
| template<> |
| v_uint8x16 | v_setzero_ () |
| |
| v_int8x16 | v_setzero_s8 () |
| |
| template<> |
| v_int8x16 | v_setzero_ () |
| |
| v_uint16x8 | v_setzero_u16 () |
| |
| template<> |
| v_uint16x8 | v_setzero_ () |
| |
| v_int16x8 | v_setzero_s16 () |
| |
| template<> |
| v_int16x8 | v_setzero_ () |
| |
| v_uint32x4 | v_setzero_u32 () |
| |
| template<> |
| v_uint32x4 | v_setzero_ () |
| |
| v_int32x4 | v_setzero_s32 () |
| |
| template<> |
| v_int32x4 | v_setzero_ () |
| |
| v_float32x4 | v_setzero_f32 () |
| |
| template<> |
| v_float32x4 | v_setzero_ () |
| |
| v_float64x2 | v_setzero_f64 () |
| |
| template<> |
| v_float64x2 | v_setzero_ () |
| |
| v_uint64x2 | v_setzero_u64 () |
| |
| template<> |
| v_uint64x2 | v_setzero_ () |
| |
| v_int64x2 | v_setzero_s64 () |
| |
| template<> |
| v_int64x2 | v_setzero_ () |
| |
| v_uint8x32 | v256_setzero_u8 () |
| |
| template<> |
| v_uint8x32 | v_setzero_ () |
| |
| v_int8x32 | v256_setzero_s8 () |
| |
| template<> |
| v_int8x32 | v_setzero_ () |
| |
| v_uint16x16 | v256_setzero_u16 () |
| |
| template<> |
| v_uint16x16 | v_setzero_ () |
| |
| v_int16x16 | v256_setzero_s16 () |
| |
| template<> |
| v_int16x16 | v_setzero_ () |
| |
| v_uint32x8 | v256_setzero_u32 () |
| |
| template<> |
| v_uint32x8 | v_setzero_ () |
| |
| v_int32x8 | v256_setzero_s32 () |
| |
| template<> |
| v_int32x8 | v_setzero_ () |
| |
| v_float32x8 | v256_setzero_f32 () |
| |
| template<> |
| v_float32x8 | v_setzero_ () |
| |
| v_float64x4 | v256_setzero_f64 () |
| |
| template<> |
| v_float64x4 | v_setzero_ () |
| |
| v_uint64x4 | v256_setzero_u64 () |
| |
| template<> |
| v_uint64x4 | v_setzero_ () |
| |
| v_int64x4 | v256_setzero_s64 () |
| |
| template<> |
| v_int64x4 | v_setzero_ () |
| |
| v_uint8x64 | v512_setzero_u8 () |
| |
| template<> |
| v_uint8x64 | v_setzero_ () |
| |
| v_int8x64 | v512_setzero_s8 () |
| |
| template<> |
| v_int8x64 | v_setzero_ () |
| |
| v_uint16x32 | v512_setzero_u16 () |
| |
| template<> |
| v_uint16x32 | v_setzero_ () |
| |
| v_int16x32 | v512_setzero_s16 () |
| |
| template<> |
| v_int16x32 | v_setzero_ () |
| |
| v_uint32x16 | v512_setzero_u32 () |
| |
| template<> |
| v_uint32x16 | v_setzero_ () |
| |
| v_int32x16 | v512_setzero_s32 () |
| |
| template<> |
| v_int32x16 | v_setzero_ () |
| |
| v_float32x16 | v512_setzero_f32 () |
| |
| template<> |
| v_float32x16 | v_setzero_ () |
| |
| v_float64x8 | v512_setzero_f64 () |
| |
| template<> |
| v_float64x8 | v_setzero_ () |
| |
| v_uint64x8 | v512_setzero_u64 () |
| |
| template<> |
| v_uint64x8 | v_setzero_ () |
| |
| v_int64x8 | v512_setzero_s64 () |
| |
| template<> |
| v_int64x8 | v_setzero_ () |
| |
|
|
| v_uint8x16 | v_setall_u8 (uchar val) |
| |
| template<> |
| v_uint8x16 | v_setall_ (uchar val) |
| |
| v_int8x16 | v_setall_s8 (schar val) |
| |
| template<> |
| v_int8x16 | v_setall_ (schar val) |
| |
| v_uint16x8 | v_setall_u16 (ushort val) |
| |
| template<> |
| v_uint16x8 | v_setall_ (ushort val) |
| |
| v_int16x8 | v_setall_s16 (short val) |
| |
| template<> |
| v_int16x8 | v_setall_ (short val) |
| |
| v_uint32x4 | v_setall_u32 (unsigned val) |
| |
| template<> |
| v_uint32x4 | v_setall_ (unsigned val) |
| |
| v_int32x4 | v_setall_s32 (int val) |
| |
| template<> |
| v_int32x4 | v_setall_ (int val) |
| |
| v_float32x4 | v_setall_f32 (float val) |
| |
| template<> |
| v_float32x4 | v_setall_ (float val) |
| |
| v_float64x2 | v_setall_f64 (double val) |
| |
| template<> |
| v_float64x2 | v_setall_ (double val) |
| |
| v_uint64x2 | v_setall_u64 (uint64 val) |
| |
| template<> |
| v_uint64x2 | v_setall_ (uint64 val) |
| |
| v_int64x2 | v_setall_s64 (int64 val) |
| |
| template<> |
| v_int64x2 | v_setall_ (int64 val) |
| |
| v_uint8x32 | v256_setall_u8 (uchar val) |
| |
| template<> |
| v_uint8x32 | v_setall_ (uchar val) |
| |
| v_int8x32 | v256_setall_s8 (schar val) |
| |
| template<> |
| v_int8x32 | v_setall_ (schar val) |
| |
| v_uint16x16 | v256_setall_u16 (ushort val) |
| |
| template<> |
| v_uint16x16 | v_setall_ (ushort val) |
| |
| v_int16x16 | v256_setall_s16 (short val) |
| |
| template<> |
| v_int16x16 | v_setall_ (short val) |
| |
| v_uint32x8 | v256_setall_u32 (unsigned val) |
| |
| template<> |
| v_uint32x8 | v_setall_ (unsigned val) |
| |
| v_int32x8 | v256_setall_s32 (int val) |
| |
| template<> |
| v_int32x8 | v_setall_ (int val) |
| |
| v_float32x8 | v256_setall_f32 (float val) |
| |
| template<> |
| v_float32x8 | v_setall_ (float val) |
| |
| v_float64x4 | v256_setall_f64 (double val) |
| |
| template<> |
| v_float64x4 | v_setall_ (double val) |
| |
| v_uint64x4 | v256_setall_u64 (uint64 val) |
| |
| template<> |
| v_uint64x4 | v_setall_ (uint64 val) |
| |
| v_int64x4 | v256_setall_s64 (int64 val) |
| |
| template<> |
| v_int64x4 | v_setall_ (int64 val) |
| |
| v_uint8x64 | v512_setall_u8 (uchar val) |
| |
| template<> |
| v_uint8x64 | v_setall_ (uchar val) |
| |
| v_int8x64 | v512_setall_s8 (schar val) |
| |
| template<> |
| v_int8x64 | v_setall_ (schar val) |
| |
| v_uint16x32 | v512_setall_u16 (ushort val) |
| |
| template<> |
| v_uint16x32 | v_setall_ (ushort val) |
| |
| v_int16x32 | v512_setall_s16 (short val) |
| |
| template<> |
| v_int16x32 | v_setall_ (short val) |
| |
| v_uint32x16 | v512_setall_u32 (unsigned val) |
| |
| template<> |
| v_uint32x16 | v_setall_ (unsigned val) |
| |
| v_int32x16 | v512_setall_s32 (int val) |
| |
| template<> |
| v_int32x16 | v_setall_ (int val) |
| |
| v_float32x16 | v512_setall_f32 (float val) |
| |
| template<> |
| v_float32x16 | v_setall_ (float val) |
| |
| v_float64x8 | v512_setall_f64 (double val) |
| |
| template<> |
| v_float64x8 | v_setall_ (double val) |
| |
| v_uint64x8 | v512_setall_u64 (uint64 val) |
| |
| template<> |
| v_uint64x8 | v_setall_ (uint64 val) |
| |
| v_int64x8 | v512_setall_s64 (int64 val) |
| |
| template<> |
| v_int64x8 | v_setall_ (int64 val) |
| |
|
在不修改底层数据的情况下，将向量转换为不同的类型。
|
| template<typename _Tp0 , int n0> |
| v_reg< uchar, n0 *sizeof(_Tp0)/sizeof(uchar)> | v_reinterpret_as_u8 (const v_reg< _Tp0, n0 > &a) |
| |
| template<typename _Tp0 , int n0> |
| v_reg< schar, n0 *sizeof(_Tp0)/sizeof(schar)> | v_reinterpret_as_s8 (const v_reg< _Tp0, n0 > &a) |
| |
| template<typename _Tp0 , int n0> |
| v_reg< ushort, n0 *sizeof(_Tp0)/sizeof(ushort)> | v_reinterpret_as_u16 (const v_reg< _Tp0, n0 > &a) |
| |
| template<typename _Tp0 , int n0> |
| v_reg< short, n0 *sizeof(_Tp0)/sizeof(short)> | v_reinterpret_as_s16 (const v_reg< _Tp0, n0 > &a) |
| |
| template<typename _Tp0 , int n0> |
| v_reg< unsigned, n0 *sizeof(_Tp0)/sizeof(unsigned)> | v_reinterpret_as_u32 (const v_reg< _Tp0, n0 > &a) |
| |
| template<typename _Tp0 , int n0> |
| v_reg< int, n0 *sizeof(_Tp0)/sizeof(int)> | v_reinterpret_as_s32 (const v_reg< _Tp0, n0 > &a) |
| |
| template<typename _Tp0 , int n0> |
| v_reg< float, n0 *sizeof(_Tp0)/sizeof(float)> | v_reinterpret_as_f32 (const v_reg< _Tp0, n0 > &a) |
| |
| template<typename _Tp0 , int n0> |
| v_reg< double, n0 *sizeof(_Tp0)/sizeof(double)> | v_reinterpret_as_f64 (const v_reg< _Tp0, n0 > &a) |
| |
| template<typename _Tp0 , int n0> |
| v_reg< uint64, n0 *sizeof(_Tp0)/sizeof(uint64)> | v_reinterpret_as_u64 (const v_reg< _Tp0, n0 > &a) |
| |
| template<typename _Tp0 , int n0> |
| v_reg< int64, n0 *sizeof(_Tp0)/sizeof(int64)> | v_reinterpret_as_s64 (const v_reg< _Tp0, n0 > &a) |
| |
|
|
| template<int shift, int n> |
| v_reg< ushort, n > | v_shl (const v_reg< ushort, n > &a) |
| |
| template<int shift, int n> |
| v_reg< short, n > | v_shl (const v_reg< short, n > &a) |
| |
| template<int shift, int n> |
| v_reg< unsigned, n > | v_shl (const v_reg< unsigned, n > &a) |
| |
| template<int shift, int n> |
| v_reg< int, n > | v_shl (const v_reg< int, n > &a) |
| |
| template<int shift, int n> |
| v_reg< uint64, n > | v_shl (const v_reg< uint64, n > &a) |
| |
| template<int shift, int n> |
| v_reg< int64, n > | v_shl (const v_reg< int64, n > &a) |
| |
|
|
| template<int shift, int n> |
| v_reg< ushort, n > | v_shr (const v_reg< ushort, n > &a) |
| |
| template<int shift, int n> |
| v_reg< short, n > | v_shr (const v_reg< short, n > &a) |
| |
| template<int shift, int n> |
| v_reg< unsigned, n > | v_shr (const v_reg< unsigned, n > &a) |
| |
| template<int shift, int n> |
| v_reg< int, n > | v_shr (const v_reg< int, n > &a) |
| |
| template<int shift, int n> |
| v_reg< uint64, n > | v_shr (const v_reg< uint64, n > &a) |
| |
| template<int shift, int n> |
| v_reg< int64, n > | v_shr (const v_reg< int64, n > &a) |
| |
|
|
| template<int shift, int n> |
| v_reg< ushort, n > | v_rshr (const v_reg< ushort, n > &a) |
| |
| template<int shift, int n> |
| v_reg< short, n > | v_rshr (const v_reg< short, n > &a) |
| |
| template<int shift, int n> |
| v_reg< unsigned, n > | v_rshr (const v_reg< unsigned, n > &a) |
| |
| template<int shift, int n> |
| v_reg< int, n > | v_rshr (const v_reg< int, n > &a) |
| |
| template<int shift, int n> |
| v_reg< uint64, n > | v_rshr (const v_reg< uint64, n > &a) |
| |
| template<int shift, int n> |
| v_reg< int64, n > | v_rshr (const v_reg< int64, n > &a) |
| |
|
将两个向量的值压缩为一个
返回的向量类型拥有的元素数量是输入向量类型的两倍。带有 u 后缀的变体还会转换为对应的无符号类型。
- pack：用于 16 位、32 位和 64 位整数输入类型
- pack_u：用于 16 位和 32 位有符号整数输入类型
- 注意
- 除 64 位外的所有变体都使用饱和处理。
|
| template<int n> |
| v_reg< uchar, 2 *n > | v_pack (const v_reg< ushort, n > &a, const v_reg< ushort, n > &b) |
| |
| template<int n> |
| v_reg< schar, 2 *n > | v_pack (const v_reg< short, n > &a, const v_reg< short, n > &b) |
| |
| template<int n> |
| v_reg< ushort, 2 *n > | v_pack (const v_reg< unsigned, n > &a, const v_reg< unsigned, n > &b) |
| |
| template<int n> |
| v_reg< short, 2 *n > | v_pack (const v_reg< int, n > &a, const v_reg< int, n > &b) |
| |
| template<int n> |
| v_reg< unsigned, 2 *n > | v_pack (const v_reg< uint64, n > &a, const v_reg< uint64, n > &b) |
| |
| template<int n> |
| v_reg< int, 2 *n > | v_pack (const v_reg< int64, n > &a, const v_reg< int64, n > &b) |
| |
| template<int n> |
| v_reg< uchar, 2 *n > | v_pack_u (const v_reg< short, n > &a, const v_reg< short, n > &b) |
| |
| template<int n> |
| v_reg< ushort, 2 *n > | v_pack_u (const v_reg< int, n > &a, const v_reg< int, n > &b) |
| |
|
将两个向量的值通过舍入移位压缩为一个
输入向量的值将向右舍入移位 n 位，转换为更窄的类型并返回到结果向量中。带有 u 后缀的变体转换为无符号类型。
- pack：用于 16 位、32 位和 64 位整数输入类型
- pack_u：用于 16 位和 32 位有符号整数输入类型
- 注意
- 除 64 位外的所有变体都使用饱和处理。
|
| template<int shift, int n> |
| v_reg< uchar, 2 *n > | v_rshr_pack (const v_reg< ushort, n > &a, const v_reg< ushort, n > &b) |
| |
| template<int shift, int n> |
| v_reg< schar, 2 *n > | v_rshr_pack (const v_reg< short, n > &a, const v_reg< short, n > &b) |
| |
| template<int shift, int n> |
| v_reg< ushort, 2 *n > | v_rshr_pack (const v_reg< unsigned, n > &a, const v_reg< unsigned, n > &b) |
| |
| template<int shift, int n> |
| v_reg< short, 2 *n > | v_rshr_pack (const v_reg< int, n > &a, const v_reg< int, n > &b) |
| |
| template<int shift, int n> |
| v_reg< unsigned, 2 *n > | v_rshr_pack (const v_reg< uint64, n > &a, const v_reg< uint64, n > &b) |
| |
| template<int shift, int n> |
| v_reg< int, 2 *n > | v_rshr_pack (const v_reg< int64, n > &a, const v_reg< int64, n > &b) |
| |
| template<int shift, int n> |
| v_reg< uchar, 2 *n > | v_rshr_pack_u (const v_reg< short, n > &a, const v_reg< short, n > &b) |
| |
| template<int shift, int n> |
| v_reg< ushort, 2 *n > | v_rshr_pack_u (const v_reg< int, n > &a, const v_reg< int, n > &b) |
| |
|
通过压缩将输入向量的值存储到内存中
值将被转换为更窄的类型并存储到内存中。带有 u 后缀的变体转换为对应的无符号类型。
- pack：用于 16 位、32 位和 64 位整数输入类型
- pack_u：用于 16 位和 32 位有符号整数输入类型
- 注意
- 除 64 位外的所有变体都使用饱和处理。
|
| template<int n> |
| void | v_pack_store (uchar *ptr, const v_reg< ushort, n > &a) |
| |
| template<int n> |
| void | v_pack_store (schar *ptr, const v_reg< short, n > &a) |
| |
| template<int n> |
| void | v_pack_store (ushort *ptr, const v_reg< unsigned, n > &a) |
| |
| template<int n> |
| void | v_pack_store (short *ptr, const v_reg< int, n > &a) |
| |
| template<int n> |
| void | v_pack_store (unsigned *ptr, const v_reg< uint64, n > &a) |
| |
| template<int n> |
| void | v_pack_store (int *ptr, const v_reg< int64, n > &a) |
| |
| template<int n> |
| void | v_pack_u_store (uchar *ptr, const v_reg< short, n > &a) |
| |
| template<int n> |
| void | v_pack_u_store (ushort *ptr, const v_reg< int, n > &a) |
| |
|
通过压缩将输入向量的值存储到内存中
值将通过舍入向右移位 n 位，转换为更窄的类型并存储到内存中。带有 u 后缀的变体转换为无符号类型。
- pack：用于 16 位、32 位和 64 位整数输入类型
- pack_u：用于 16 位和 32 位有符号整数输入类型
- 注意
- 除 64 位外的所有变体都使用饱和处理。
|
| template<int shift, int n> |
| void | v_rshr_pack_store (uchar *ptr, const v_reg< ushort, n > &a) |
| |
| template<int shift, int n> |
| void | v_rshr_pack_store (schar *ptr, const v_reg< short, n > &a) |
| |
| template<int shift, int n> |
| void | v_rshr_pack_store (ushort *ptr, const v_reg< unsigned, n > &a) |
| |
| template<int shift, int n> |
| void | v_rshr_pack_store (short *ptr, const v_reg< int, n > &a) |
| |
| template<int shift, int n> |
| void | v_rshr_pack_store (unsigned *ptr, const v_reg< uint64, n > &a) |
| |
| template<int shift, int n> |
| void | v_rshr_pack_store (int *ptr, const v_reg< int64, n > &a) |
| |
| template<int shift, int n> |
| void | v_rshr_pack_u_store (uchar *ptr, const v_reg< short, n > &a) |
| |
| template<int shift, int n> |
| void | v_rshr_pack_u_store (ushort *ptr, const v_reg< int, n > &a) |
| |
|
将多个向量的布尔值压缩为一个无符号 8 位整数向量
- 注意
- 必须提供有效的布尔值，以保证在所有架构上获得相同的结果。
|
| template<int n> |
| v_reg< uchar, 2 *n > | v_pack_b (const v_reg< ushort, n > &a, const v_reg< ushort, n > &b) |
| | ! 用于 16 位布尔值
|
| |
| template<int n> |
| v_reg< uchar, 4 *n > | v_pack_b (const v_reg< unsigned, n > &a, const v_reg< unsigned, n > &b, const v_reg< unsigned, n > &c, const v_reg< unsigned, n > &d) |
| |
| template<int n> |
| v_reg< uchar, 8 *n > | v_pack_b (const v_reg< uint64, n > &a, const v_reg< uint64, n > &b, const v_reg< uint64, n > &c, const v_reg< uint64, n > &d, const v_reg< uint64, n > &e, const v_reg< uint64, n > &f, const v_reg< uint64, n > &g, const v_reg< uint64, n > &h) |
| |
1.12.0