|
| 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) |
| | 使用归一化盒式滤波器模糊图像。
|
| |
| 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 hist, 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算法[49]在图像中查找边缘。
|
| |
| 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)值[82]。
|
| |
| 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) |
| | 将图像从一个颜色空间转换到另一个，其中源图像存储在两个平面中。
|
| |
| void | dct (InputArray src, OutputArray dst, int flags=0) |
| | 对一维或二维数组执行正向或逆向离散余弦变换。
|
| |
| void | decolor (InputArray src, OutputArray grayscale, OutputArray color_boost) |
| | 将彩色图像转换为灰度图像。它是数字印刷、风格化黑白照片渲染以及许多单通道图像处理应用程序中的基本工具[178]。
|
| |
| 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) |
| | 所有去马赛克过程的主函数
|
| |
| 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.4f) |
| | 此滤镜增强特定图像的细节。边缘保留平滑滤镜应用于许多不同的应用中[101]。
|
| |
| 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()) |
| | 计算两个加权点配置之间的“最小工作量”距离。
|
| |
| float | EMDL1 (InputArray signature1, InputArray signature2) |
| | 根据 Haibin Ling 和 Kazunori Okuda 的论文“EMD-L1: An efficient and Robust Algorithm for comparing histogram-based descriptors”以及 Elizaveta Levina 和 Peter Bickel 的论文“The Earth Mover's Distance is the Mallows Distance: Some Insights from Statistics”计算两个加权点配置之间的“最小工作量”距离。
|
| |
| 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) |
| | 计算两个二维点集之间的最优仿射变换。
|
| |
| 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) |
| | 计算两个三维点集之间的最优仿射变换。
|
| |
| int | estimateAffine3D (InputArray src, InputArray dst, OutputArray out, OutputArray inliers, double ransacThreshold=3, double confidence=0.99) |
| | 计算两个三维点集之间的最优仿射变换。
|
| |
| 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) |
| | 计算两个二维点集之间的最优仿射变换。
|
| |
| int | estimateTranslation3D (InputArray src, InputArray dst, OutputArray out, OutputArray inliers, double ransacThreshold=3, double confidence=0.99) |
| | 计算两个三维点集之间的最优平移。
|
| |
| 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 函数的修改版本。此函数版本适用于灰度图像或颜色空间的手动操作。更多详情请参见 [45]（开放访问 此处）。
|
| |
| void | fastNlMeansDenoisingMulti (InputArrayOfArrays srcImgs, OutputArray dst, int imgToDenoiseIndex, int temporalWindowSize, float h=3, int templateWindowSize=7, int searchWindowSize=21) |
| | 在短时间内连续捕获的图像序列（例如视频）的 fastNlMeansDenoising 函数的修改版本。此函数版本适用于灰度图像或颜色空间的手动操作。更多详情请参见 [45]（开放访问 此处）。
|
| |
| 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) |
| | 使用链接运行算法查找轮廓。
|
| |
| 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 准则 [82] 查找两幅图像之间的几何变换（扭曲）。
|
| |
| 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()) |
| |
| RotatedRect | fitEllipse (InputArray points) |
| | 围绕一组 2D 点拟合椭圆。
|
| |
| RotatedRect | fitEllipseAMS (InputArray points) |
| | 围绕一组 2D 点拟合椭圆。
|
| |
| RotatedRect | fitEllipseDirect (InputArray points) |
| | 围绕一组 2D 点拟合椭圆。
|
| |
| void | fitLine (InputArray points, OutputArray line, int distType, double param, double reps, double aeps) |
| | 将直线拟合到 2D 或 3D 点集。
|
| |
| void | flip (InputArray src, OutputArray dst, int flipCode) |
| | 沿垂直、水平或两个轴翻转 2D 数组。
|
| |
| 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) |
| | 计算每个 2D 点到给定椭圆上最近的 2D 点。
|
| |
| 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) |
| | 计算 2D 旋转的仿射矩阵。
|
| |
| 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) |
| | 从校正图像的有效 ROI（由 stereoRectify 返回）计算有效视差 ROI
|
| |
| int | getVersionMajor () |
| | 返回库主版本号。
|
| |
| int | getVersionMinor () |
| | 返回库次版本号。
|
| |
| int | getVersionRevision () |
| | 返回库版本的修订字段。
|
| |
| String | getVersionString () |
| | 返回库版本字符串。
|
| |
| Rect | getWindowImageRect (const String &winname) |
| | 提供窗口中图像的矩形区域。
|
| |
| double | getWindowProperty (const String &winname, int prop_id) |
| | 提供窗口参数。
|
| |
| 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) |
| | 检查是否存在至少一个非零数组元素。
|
| |
| CV_EXPORTS_W bool | haveImageReader (const String &filename) |
| | 检查 OpenCV 是否可以解码指定的图像文件。
|
| |
| CV_EXPORTS_W bool | haveImageWriter (const String &filename) |
| | 检查 OpenCV 是否可以编码指定的图像文件或指定的文件扩展名。
|
| |
| bool | haveOpenVX () |
| | 检查是否可以使用 OpenVX。
|
| |
| 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) |
| | 使用霍夫变换在灰度图像中查找圆形并获取累加器。
|
| |
| 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) |
| | 使用标准霍夫变换在二值图像中查找直线并获取累加器。
|
| |
| 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) |
| | 通过对选区内的梯度场进行适当的非线性变换，然后用泊松求解器积分回来，可以局部修改图像的表观光照。
|
| |
| CV_EXPORTS_W size_t | imcount (const String &filename, int flags=IMREAD_ANYCOLOR) |
| | 返回给定文件中的图像数量。
|
| |
| CV_EXPORTS_W Mat | imdecode (InputArray buf, int flags) |
| | 从内存缓冲区读取图像。
|
| |
| CV_EXPORTS Mat | imdecode (InputArray buf, int flags, Mat *dst) |
| |
| CV_EXPORTS_W bool | imdecodeanimation (InputArray buf, CV_OUT Animation &animation, int start=0, int count=INT16_MAX) |
| | 将动画图像缓冲区中的帧加载到 Animation 结构中。
|
| |
| CV_EXPORTS_W bool | imdecodemulti (InputArray buf, int flags, CV_OUT std::vector< Mat > &mats, const cv::Range &range=Range::all()) |
| | 从内存缓冲区读取多页图像。
|
| |
| CV_EXPORTS_W Mat | imdecodeWithMetadata (InputArray buf, CV_OUT std::vector< int > &metadataTypes, OutputArrayOfArrays metadata, int flags=IMREAD_ANYCOLOR) |
| | 从内存缓冲区读取图像以及关联的元数据。
|
| |
| CV_EXPORTS_W bool | imencode (const String &ext, InputArray img, CV_OUT std::vector< uchar > &buf, const std::vector< int > ¶ms=std::vector< int >()) |
| | 将图像编码到内存缓冲区。
|
| |
| CV_EXPORTS_W bool | imencodeanimation (const String &ext, const Animation &animation, CV_OUT std::vector< uchar > &buf, const std::vector< int > ¶ms=std::vector< int >()) |
| | 将 Animation 编码到内存缓冲区。
|
| |
| CV_EXPORTS_W bool | imencodemulti (const String &ext, InputArrayOfArrays imgs, CV_OUT std::vector< uchar > &buf, const std::vector< int > ¶ms=std::vector< int >()) |
| | 将图像数组编码到内存缓冲区。
|
| |
| CV_EXPORTS_W bool | imencodeWithMetadata (const String &ext, InputArray img, const std::vector< int > &metadataTypes, InputArrayOfArrays metadata, CV_OUT std::vector< uchar > &buf, const std::vector< int > ¶ms=std::vector< int >()) |
| | 将图像编码到内存缓冲区。
|
| |
| CV_EXPORTS_W Mat | imread (const String &filename, int flags=IMREAD_COLOR_BGR) |
| | 从文件加载图像。
|
| |
| CV_EXPORTS_W void | imread (const String &filename, OutputArray dst, int flags=IMREAD_COLOR_BGR) |
| | 从文件加载图像。
|
| |
| CV_EXPORTS_W bool | imreadanimation (const String &filename, CV_OUT Animation &animation, int start=0, int count=INT16_MAX) |
| | 从动画图像文件加载帧到 Animation 结构中。
|
| |
| CV_EXPORTS_W bool | imreadmulti (const String &filename, CV_OUT std::vector< Mat > &mats, int flags=IMREAD_ANYCOLOR) |
| | 从文件加载多页图像。
|
| |
| CV_EXPORTS_W bool | imreadmulti (const String &filename, CV_OUT std::vector< Mat > &mats, int start, int count, int flags=IMREAD_ANYCOLOR) |
| | 从文件加载多页图像的图像。
|
| |
| CV_EXPORTS_W Mat | imreadWithMetadata (const String &filename, CV_OUT std::vector< int > &metadataTypes, OutputArrayOfArrays metadata, int flags=IMREAD_ANYCOLOR) |
| | 从文件读取图像及相关元数据。
|
| |
| void | imshow (const String &winname, const ogl::Texture2D &tex) |
| | 在指定窗口中显示 OpenGL 2D 纹理。
|
| |
| void | imshow (const String &winname, InputArray mat) |
| | 在指定窗口中显示图像。
|
| |
| CV_EXPORTS_W bool | imwrite (const String &filename, InputArray img, const std::vector< int > ¶ms=std::vector< int >()) |
| | 将图像保存到指定文件。
|
| |
| CV_EXPORTS_W bool | imwriteanimation (const String &filename, const Animation &animation, const std::vector< int > ¶ms=std::vector< int >()) |
| | 将 Animation 保存到指定文件。
|
| |
| static CV_WRAP bool | imwritemulti (const String &filename, InputArrayOfArrays img, const std::vector< int > ¶ms=std::vector< int >()) |
| | 用于绑定的多图像重载
|
| |
| CV_EXPORTS_W 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) |
| | 计算投影和逆校正变换图。本质上，这是 initUndistortRectifyMap 的逆操作，以适应投影仪（“逆相机”）在投影仪-相机对中的立体校正。
|
| |
| 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) |
| | 加载指定窗口的参数。
|
| |
| 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) |
| | 最小值和最大值函数。
|
| |
| 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 | 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, OutputArray dst) |
| | 将指定通道从输入数组复制到输出数组的指定通道。
|
| |
| 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 是一个包含成员字段 x, y 和 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) |
| | 此运算符允许在运行时补充输入向量。
|
| |
| GRunArgsP & | operator+= (GRunArgsP &lhs, const GRunArgsP &rhs) |
| | 此运算符允许在运行时补充输出向量。
|
| |
| 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) |
| | 该函数用于检测两个图像之间发生的平移。
|
| |
| 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) |
| | 将三维点投影到图像平面。
|
| |
| 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()) |
| | 使用手性检查，从估计的基本矩阵和两幅图像中的对应点恢复相对相机旋转和平移。返回通过检查的内点数量。
|
| |
| int | recoverPose (InputArray E, InputArray points1, InputArray points2, 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()) |
| | 使用手性检查，从两台不同相机的两幅图像中的对应点恢复相对相机旋转和平移。返回通过检查的内点数量。
|
| |
| 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< schar > (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）的更改轻松无缝地应用。这些更改可以从轻微的扭曲到被新内容完全替换 [218]。
|
| |
| 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) |
| | 使用单纯形算法（Simplex Method）求解给定的（非整数）线性规划问题。
|
| |
| 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 | solvePnPRansac (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 | 启动窗口线程 () |
| |
| 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 | 停止循环 () |
| |
| void | stylization (InputArray src, OutputArray dst, float sigma_s=60, float sigma_r=0.45f) |
| | 风格化旨在产生具有多种非真实感效果的数字图像。边缘感知滤波器是风格化的理想选择，因为它们可以抽象低对比度区域，同时保留或增强高对比度特征。
|
| |
| void | subtract (InputArray src1, InputArray src2, OutputArray dst, 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) |
| | 通过仅保留边缘位置的梯度，然后在Poisson求解器中积分，可以消除选定区域的纹理，使其内容呈现平坦的方面。这里使用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) |
| | 此函数通过使用立体相机观察到的3D点（在齐次坐标系中）来重建它们。
|
| |
| 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+TermCriteria::EPS, 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) |
| | 强制窗口重绘其内容并调用绘图回调（参见 cv::setOpenGlDrawCallback）。
|
| |
| 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) |
| | 从内存加载寄存器内容并双重扩展。
|
| |
| 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) |
| | 从内存加载寄存器内容并四重扩展。
|
| |
| 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) |
| | 从内存加载寄存器内容并双重扩展。
|
| |
| 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) |
| | 从内存加载寄存器内容并四重扩展。
|
| |
| 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) |
| | 按位与。
|
| |
| 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) |
| | 将下半部分转换为浮点数。
|
| |
| template<int n> |
| v_reg< float, n *2 > | v_cvt_f32 (const v_reg< double, n > &a, const v_reg< double, n > &b) |
| | 转换为浮点数。
|
| |
| template<int n> |
| v_reg< float, n > | v_cvt_f32 (const v_reg< int, n > &a) |
| | 转换为浮点数。
|
| |
| template<int n> |
| v_reg< double,(n/2)> | v_cvt_f64 (const v_reg< float, n > &a) |
| | 将下半部分转换为双精度浮点数。
|
| |
| template<int n> |
| v_reg< double, n/2 > | v_cvt_f64 (const v_reg< int, n > &a) |
| | 将下半部分转换为双精度浮点数。
|
| |
| template<int n> |
| v_reg< double, n > | v_cvt_f64 (const v_reg< int64, n > &a) |
| | 转换为双精度浮点数。
|
| |
| template<int n> |
| v_reg< double,(n/2)> | v_cvt_f64_high (const v_reg< float, n > &a) |
| | 将向量高位部分转换为双精度浮点数。
|
| |
| template<int n> |
| v_reg< double,(n/2)> | v_cvt_f64_high (const v_reg< int, n > &a) |
| | 将向量高位部分转换为双精度浮点数。
|
| |
| 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) |
| | 误差函数。
|
| |
| 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) |
| | 乘加运算。
|
| |
| 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) |
| | 从内存加载寄存器内容并双重扩展。
|
| |
| 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) |
| | 从内存加载寄存器内容并四重扩展。
|
| |
| 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) |
| | 幅值。
|
| |
| 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) |
| | 按位非。
|
| |
| 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) |
| | 按位或。
|
| |
| 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) |
| | 值的绝对差之和。
|
| |
| 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) |
| | 逐元素选择（混合操作）
|
| |
| 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) |
| | 按位异或。
|
| |
| 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) |
| | 使用左右检查验证视差。立体对应算法应计算“成本”矩阵。
|
| |
| 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 生成