docs/pymnn/cv.md
module cv
cv模块提供了基础的图像处理函数，并在接口上兼容了opencv-python的API。
使用注意：
Var变量，其属性为：
data_format为NHWCshape是[h, w, c]dtype是uint8cv.COLOR_BGR2BGRA，不要用cv.ColorConversionCodes.COLOR_BGR2BGRA*[h, w, c]的图形转换为模型输入的[n, c, h, w]不要使用transpose；请使用expr.convert，示例如下：
import MNN.cv as cv
import MNN.numpy as np
import MNN.expr as expr
# data_format: NHWC, shape: [360, 480, 3], dtype: uint8
img = imread('cat.jpg')
# data_format: NHWC, shape: [360, 480, 3], dtype: float32
imgf = img.astype(np.float32)
# data_format: NHWC, shape: [1, 360, 480, 3], dtype: float32
imgf_batch = np.expand_dims(imgf, 0)
# data_format: NCHW, shape: [1, 360, 480, 3], dtype: float32
input_var = expr.convert(imgf_batch, expr.NCHW)
cv Typescv.COLOR_*描述图像颜色空间转换函数cvtColor的转换方式
intCOLOR_BGR2BGRACOLOR_RGB2RGBACOLOR_BGRA2BGRCOLOR_RGBA2RGBCOLOR_BGR2RGBACOLOR_RGB2BGRACOLOR_RGBA2BGRCOLOR_BGRA2RGBCOLOR_BGR2RGBCOLOR_RGB2BGRCOLOR_BGRA2RGBACOLOR_RGBA2BGRACOLOR_BGR2GRAYCOLOR_RGB2GRAYCOLOR_GRAY2BGRCOLOR_GRAY2RGBCOLOR_GRAY2BGRACOLOR_GRAY2RGBACOLOR_BGRA2GRAYCOLOR_RGBA2GRAYCOLOR_BGR2BGR565COLOR_RGB2BGR565COLOR_BGR5652BGRCOLOR_BGR5652RGBCOLOR_BGRA2BGR565COLOR_RGBA2BGR565COLOR_BGR5652BGRACOLOR_BGR5652RGBACOLOR_GRAY2BGR565COLOR_BGR5652GRAYCOLOR_BGR2BGR555COLOR_RGB2BGR555COLOR_BGR5552BGRCOLOR_BGR5552RGBCOLOR_BGRA2BGR555COLOR_RGBA2BGR555COLOR_BGR5552BGRACOLOR_BGR5552RGBACOLOR_GRAY2BGR555COLOR_BGR5552GRAYCOLOR_BGR2XYZCOLOR_RGB2XYZCOLOR_XYZ2BGRCOLOR_XYZ2RGBCOLOR_BGR2YCrCbCOLOR_RGB2YCrCbCOLOR_YCrCb2BGRCOLOR_YCrCb2RGBCOLOR_BGR2HSVCOLOR_RGB2HSVCOLOR_BGR2LabCOLOR_RGB2LabCOLOR_BGR2LuvCOLOR_RGB2LuvCOLOR_BGR2HLSCOLOR_RGB2HLSCOLOR_HSV2BGRCOLOR_HSV2RGBCOLOR_Lab2BGRCOLOR_Lab2RGBCOLOR_Luv2BGRCOLOR_Luv2RGBCOLOR_HLS2BGRCOLOR_HLS2RGBCOLOR_BGR2HSV_FULLCOLOR_RGB2HSV_FULLCOLOR_BGR2HLS_FULLCOLOR_RGB2HLS_FULLCOLOR_HSV2BGR_FULLCOLOR_HSV2RGB_FULLCOLOR_HLS2BGR_FULLCOLOR_HLS2RGB_FULLCOLOR_LBGR2LabCOLOR_LRGB2LabCOLOR_LBGR2LuvCOLOR_LRGB2LuvCOLOR_Lab2LBGRCOLOR_Lab2LRGBCOLOR_Luv2LBGRCOLOR_Luv2LRGBCOLOR_BGR2YUVCOLOR_RGB2YUVCOLOR_YUV2BGRCOLOR_YUV2RGBCOLOR_YUV2RGB_NV12COLOR_YUV2BGR_NV12COLOR_YUV2RGB_NV21COLOR_YUV2BGR_NV21COLOR_YUV420sp2RGBCOLOR_YUV420sp2BGRCOLOR_YUV2RGBA_NV12COLOR_YUV2BGRA_NV12COLOR_YUV2RGBA_NV21COLOR_YUV2BGRA_NV21COLOR_YUV420sp2RGBACOLOR_YUV420sp2BGRACOLOR_YUV2RGB_YV12COLOR_YUV2BGR_YV12COLOR_YUV2RGB_IYUVCOLOR_YUV2BGR_IYUVCOLOR_YUV2RGB_I420COLOR_YUV2BGR_I420COLOR_YUV420p2RGBCOLOR_YUV420p2BGRCOLOR_YUV2RGBA_YV12COLOR_YUV2BGRA_YV12COLOR_YUV2RGBA_IYUVCOLOR_YUV2BGRA_IYUVCOLOR_YUV2RGBA_I420COLOR_YUV2BGRA_I420COLOR_YUV420p2RGBACOLOR_YUV420p2BGRACOLOR_YUV2GRAY_420COLOR_YUV2GRAY_NV21COLOR_YUV2GRAY_NV12COLOR_YUV2GRAY_YV12COLOR_YUV2GRAY_IYUVCOLOR_YUV2GRAY_I420COLOR_YUV420sp2GRAYCOLOR_YUV420p2GRAYCOLOR_YUV2RGB_UYVYCOLOR_YUV2BGR_UYVYCOLOR_YUV2RGB_Y422COLOR_YUV2BGR_Y422COLOR_YUV2RGB_UYNVCOLOR_YUV2BGR_UYNVCOLOR_YUV2RGBA_UYVYCOLOR_YUV2BGRA_UYVYCOLOR_YUV2RGBA_Y422COLOR_YUV2BGRA_Y422COLOR_YUV2RGBA_UYNVCOLOR_YUV2BGRA_UYNVCOLOR_YUV2RGB_YUY2COLOR_YUV2BGR_YUY2COLOR_YUV2RGB_YVYUCOLOR_YUV2BGR_YVYUCOLOR_YUV2RGB_YUYVCOLOR_YUV2BGR_YUYVCOLOR_YUV2RGB_YUNVCOLOR_YUV2BGR_YUNVCOLOR_YUV2RGBA_YUY2COLOR_YUV2BGRA_YUY2COLOR_YUV2RGBA_YVYUCOLOR_YUV2BGRA_YVYUCOLOR_YUV2RGBA_YUYVCOLOR_YUV2BGRA_YUYVCOLOR_YUV2RGBA_YUNVCOLOR_YUV2BGRA_YUNVCOLOR_YUV2GRAY_UYVYCOLOR_YUV2GRAY_YUY2COLOR_YUV2GRAY_Y422COLOR_YUV2GRAY_UYNVCOLOR_YUV2GRAY_YVYUCOLOR_YUV2GRAY_YUYVCOLOR_YUV2GRAY_YUNVCOLOR_RGBA2mRGBACOLOR_mRGBA2RGBACOLOR_RGB2YUV_I420COLOR_BGR2YUV_I420COLOR_RGB2YUV_IYUVCOLOR_BGR2YUV_IYUVCOLOR_RGBA2YUV_I420COLOR_BGRA2YUV_I420COLOR_RGBA2YUV_IYUVCOLOR_BGRA2YUV_IYUVCOLOR_RGB2YUV_YV12COLOR_BGR2YUV_YV12COLOR_RGBA2YUV_YV12COLOR_BGRA2YUV_YV12cv.INTER_*描述图像形变函数resize,warpAffine,warpPerspective的插值方式
intINTER_NEARESTINTER_LINEARINTER_CUBICINTER_AREAINTER_LANCZOS4INTER_LINEAR_EXACTINTER_NEAREST_EXACTWARP_FILL_OUTLIERSWARP_INVERSE_MAPcv.BORDER_*描述图像形变函数warpAffine,warpPerspective的边界填充方式
intBORDER_CONSTANTBORDER_REFLECT_101BORDER_REFLECTBORDER_REFLECT101BORDER_DEFAULTcv.THRESH_*描述阈值函数threshold的阈值方式
intTHRESH_BINARYTHRESH_BINARY_INVTHRESH_TRUNCTHRESH_TOZEROTHRESH_TOZERO_INVTHRESH_MASKTHRESH_OTSUTHRESH_TRIANGLEcv.RETR_*描述轮廓检测函数findContours的轮廓检索方式
intRETR_EXTERNALRETR_LISTRETR_CCOMPRETR_TREERETR_FLOODFILLcv.CHAIN_*描述轮廓检测函数findContours的轮廓逼近算法
intCHAIN_APPROX_NONECHAIN_APPROX_SIMPLECHAIN_APPROX_TC89_L1CHAIN_APPROX_TC89_KCOScv.LINE_*用在画图相关函数，如：line, fillPoly等，描述画线的类型
int
FILLEDLINE_4LINE_8LINE_AAcv.IMREAD_*用在图片读取函数imread的参数flag中，分别表示读取：uint8灰度图，uint8的bgr图，float32的bgr图
int
IMREAD_GRAYSCALEIMREAD_COLORIMREAD_ANYDEPTHcv.ROTATE_*描述图像旋转函数rotate的旋转方式
int
ROTATE_90_CLOCKWISEROTATE_180ROTATE_90_COUNTERCLOCKWISEcv.SOLVEPNP_*描述3d重建函数solvePnP的求解方法
int
SOLVEPNP_ITERATIVESOLVEPNP_SQPNPcv.DECOMP_*描述线性方程组求解函数solve的求解方法
int
DECOMP_LUDECOMP_SVDDECOMP_EIGDECOMP_CHOLESKYDECOMP_QRDECOMP_NORMALcv.NORM_*描述线归一化函数normalize的归一化方法
int
NORM_INFNORM_L1NORM_L2NORM_MINMAXcv.ADAPTIVE_THRESH_*描述自适应阈值函数adaptiveThreshold的自适应方法
int
ADAPTIVE_THRESH_MEAN_CADAPTIVE_THRESH_GAUSSIAN_CcopyTo(src, |mask, dst)将src复制并返回，如果mask不为空，则只拷贝mask为1的像素；如果dst不为空，则在mask为0时拷贝dst中对应的像素，参考：copyTo
注意：目前src仅支持int32类型数据，用户使用前后需要自行转换类型
参数：
src:Var 源图像mask:Var 掩码图像，可选dst:Var mask为0时选择的图像，可选返回：复制的图像
返回类型：Var
示例：
>>> img = cv.imread('cat.jpg')
>>> h, w, _ = img.shape
>>> zero = np.zeros((h//3, w), dtype=np.int32)
>>> one = np.ones((h//3, w), dtype=np.int32)
>>> mask = np.concatenate((one, zero, one), axis=0)
>>> img = img.astype(np.int32)
>>> copyTo = cv.copyTo(img, mask).astype(np.uint8)
>>> cv.imwrite('copyTo.jpg', copyTo)
True
bitwise_and(src1, src2, |dst, mask)对src1和src2执行按位与操作，并对结果按照执行copyTo返回，参考：bitwise_and
参数：
src1:Var 源图像src2:Var 源图像mask:Var 掩码图像，可选dst:Var mask为0时选择的图像，可选返回：按位与的图像
返回类型：Var
示例：
>>> img = cv.imread('cat.jpg')
>>> cv.bitwise_and(img, img)
array([[[ 49, 57, 26],
...
[158, 175, 184]]], dtype=uint8)
bitwise_or(src1, src2, |dst, mask)对src1和src2执行按位或操作，并对结果按照执行copyTo返回，参考：bitwise_or
参数：
src1:Var 源图像src2:Var 源图像mask:Var 掩码图像，可选dst:Var mask为0时选择的图像，可选返回：按位或的图像
返回类型：Var
示例：
>>> img = cv.imread('cat.jpg')
>>> cv.bitwise_or(img, img)
array([[[ 49, 57, 26],
...
[158, 175, 184]]], dtype=uint8)
bitwise_xor(src1, src2, |dst, mask)对src1和src2执行按位异或操作，并对结果按照执行copyTo返回，参考：bitwise_xor
参数：
src1:Var 源图像src2:Var 源图像mask:Var 掩码图像，可选dst:Var mask为0��选择的图像，可选返回：按位异或的图像
返回类型：Var
示例：
>>> img = cv.imread('cat.jpg')
>>> cv.bitwise_xor(img, img)
array([[[0, 0, 0],
...
[0, 0, 0]]], dtype=uint8)
hconcat(src)在水平方向上将src中的图像连接起来，并返回，相当于做axis=1的concat，参考：hconcat
参数：
src:Var 源图像返回：水平连接的图像
返回类型：Var
示例：
>>> img = cv.imread('cat.jpg')
>>> cv.hconcat(img)
>>> cv.hconcat(img)
array([[ 49, 57, 26, ..., 25, 62, 46],
...,
[ 45, 94, 56, ..., 158, 175, 184]], dtype=uint8)
vconcat(src)在垂直方向上将src中的图像连接起来，并返回，相当于做axis=0的concat，参考：vconcat
参数：
src:Var 源图像返回：垂直连接的图像
返回类型：Var
示例：
>>> img = cv.imread('cat.jpg')
>>> cv.vconcat(img)
array([[ 49, 57, 26],
...,
[158, 175, 184]], dtype=uint8)
mean(src, mask)逐channel计算src的元素均值，如果mask不为空，则只返回mask为1的结果，参考：mean
参数：
src:Var 源图像返回：每个channel的均值
返回类型：Var
示例：
>>> img = cv.imread('cat.jpg')
>>> cv.mean(img)
array([ 85.656685, 135.9716, 125.76543, 0.], dtype=float32)
flip(src, flipCode)对src进行水平，垂直，或水平+垂直翻转，并返回，参考：flip
| flipCode | 说明 |
|---|---|
| filpCode = 0 | 垂直翻转 |
| flipCode > 0 | 水平翻转 |
| flipCode < 0 | 水平+垂直翻转 |
参数：
src:Var 源图像返回：翻转的图像
返回类型：Var
示例：
>>> img = cv.imread('cat.jpg')
>>> flip = cv.flip(img, -1)
>>> cv.imwrite('flip.jpg', flip)
True
rotate(src, rotateMode)以90度的倍数旋转src，并返回，参考：rotate
| rotateCode | 说明 |
|---|---|
| ROTATE_90_CLOCKWISE | 顺时针旋转90度 |
| ROTATE_180 | 顺时针旋转180度 |
| ROTATE_90_COUNTERCLOCKWISE | 顺时针旋转270度 |
参数：
src:Var 源图像返回：翻转的图像
返回类型：Var
示例：
>>> img = cv.imread('cat.jpg')
>>> rotate = cv.rotate(img, cv.ROTATE_90_CLOCKWISE)
>>> cv.imwrite('rotate.jpg', rotate)
True
solve(src1, src2, |method)求解线性方程组，目前仅实现了LU方法；参考：solve
参数：
src1:Var 线性方程组左侧矩阵src2:Var 线性方程组右侧矩阵method:int 求解方法，可选；默认为cv.DECOMP_LU (目前仅实现了LU方法)返回：能否求解，求解获得的矩阵
返回类型：Tuple(bool, Var)
示例：
>>> a = np.array([2., 3., 4., 0., 1., 5., 0., 0., 3.]).reshape(3, 3)
>>> b = np.array([1., 2., 3.]).reshape(3, 1)
>>> cv.solve(a, b)
(True, array([[ 3.],
[-3.],
[ 1.]], dtype=float32))
normalize(src, dst, alpha, beta, norm_type, |dtype, mask)对输入进行归一化；参考：normalize
参数：
src:Var 输入矩阵dst:Var Python中不需要使用该参数，直接赋为None即可alpha:float 归一化的下限beta:float 归一化的上限norm_type:int 归一化类型，如：cv.NORM_MINMAXdtype:dtype 输入类型，不需要赋值mask 兼容性参数，目前还不支持mask返回：归一化结果
返回类型：Var
示例：
>>> x = np.arange(12).reshape(2, 2, 3).astype(np.uint8)
>>> cv.normalize(x, None, -50, 270, cv.NORM_MINMAX)
array([[[ 0, 0, 8],
[ 37, 66, 95]],
[[125, 154, 183],
[212, 241, 255]]], dtype=uint8)
merge(mv)将多张图片沿channel合并；参考：merge
参数：
mv:[Var] 输入矩阵数组返回：合并结果矩阵
返回类型：Var
示例：
>>> x = np.arange(9).reshape(3, 3)
>>> cv.merge([x, x])
array([[[0, 0],
[1, 1],
[2, 2]],
[[3, 3],
[4, 4],
[5, 5]],
[[6, 6],
[7, 7],
[8, 8]]], dtype=int32)
split(m)将图片沿channel方向拆分；参考：split
参数：
m:Var 待拆分图片返回：拆分出的图片
返回类型：[Var]
示例：
>>> x = np.arange(12).reshape(2, 2, 3)
>>> cv.split(x)
[array([[0, 3],[6, 9]], dtype=int32),
array([[1, 4],[7, 10]], dtype=int32),
array([[2, 5],[8, 11]], dtype=int32)]
addWeighted(src1, alpha, src2, beta, gamma)对输入的两个矩阵执行权重相加：dst = src1 * alpha + src2 * beta + gamma；参考：addWeighted
参数：
src1:Var 第一个输入矩阵alpha:float 第一个输入矩阵的权重src2:Var 第二个输入矩阵beta:float 第二个输入矩阵的权重gamma:float 额外增加的常量返回：加权得到的和
返回类型：Var
示例：
>>> x = np.arange(3.)
>>> cv.addWeighted(x, 0.2, x, 0.5, 1)
array([1. , 1.7, 2.4], dtype=float32)
haveImageReader(filename)用于判断是否支持特定图像格式的解码，目前支持的图像格式：jpg, jpeg, png, bmp，参考：haveImageReader
移动端默认不包含该函数
参数：
filename:str 图像文件路径返回：是否有读取图像的接口
返回类型：bool
示例：
>>> cv.haveImageReader('cat.jpg')
True
haveImageWriter(filename)用于判断是否支持特定图像格式的编码，目前支持的图像格式：jpg, jpeg, png, bmp，参考：haveImageWriter
移动端默认不包含该函数
参数：
filename:str 图像文件路径返回：是否有写图像的接口
返回类型：bool
示例：
>>> cv.haveImageWriter('cat.jpg')
True
imdecode(buf, |flag)将内存数据解码为图像，并返回，参考：imdecode
移动端默认不包含该函数
参数：
buf:ndarray|sequence 图像数据序列，可以是ndarray, list, tuple, bytes等flag:int 解码方式，可选，默认为cv2.IMREAD_COLOR返回：解码后的图像
返回类型：Var
示例：
>>> cv.imdecode(bytearray(open('cat.jpg', 'rb').read()), cv.IMREAD_COLOR)
array([[[ 49, 57, 26],
[ 50, 58, 27],
[ 47, 55, 25],
...,
[188, 205, 214],
[158, 175, 184],
[158, 175, 184]]], dtype=uint8)
imencode(ext, img, |params)将图像编码为图像数据，并返回，参考：imencode
移动端默认不包含该函数
参数：
ext:str 图像文件扩展名，如jpg, png等img:Var 图像params:[int] 编码参数，可选，默认为[cv2.IMWRITE_JPEG_QUALITY, 95]返回：编码后的图像数据序列，first是bool代表是否编码成功，second是listofuint8代表编码后的图像数据序列
返回类型：pair
示例：
>>> success, buf = cv.imencode('jpg', cv.imread('cat.jpg'))
>>> success
True
>>> buf[:10]
[255, 216, 255, 224, 0, 16, 74, 70, 73, 70]
imread(filename, |flag)读取图像，并返回，参考：imread
移动端默认不包含该函数
参数：
filename:str 图像文件路径flag:int 读取方式，可选，默认为cv2.IMREAD_COLOR返回：读取的图像
返回类型：Var
示例：
>>> cv.imread('cat.jpg')
array([[[ 49, 57, 26],
[ 50, 58, 27],
[ 47, 55, 25],
...,
[188, 205, 214],
[158, 175, 184],
[158, 175, 184]]], dtype=uint8)
imwrite(filename, img, |params)将图像写入文件，参考：imwrite
移动端默认不包含该函数
参数：
filename:str 图像文件写的路径img:Var 图像对象params:[int] 编码参数，可选，默认为[cv2.IMWRITE_JPEG_QUALITY, 95]返回：是否写入成功
返回类型：bool
示例：
>>> img = cv.imread('cat.jpg')
>>> cv.imwrite('write.jpg', img)
True
Rodrigues(src)将旋转矩阵转换为旋转向量，在solvePnP的返回值前会被使用，参考：Rodrigues
该函数只支持旋转矩阵到旋转向量，反之不支持
参数：
src:Var 旋转矩阵返回：旋转向量
返回类型：Var
示例：
>>> cv.Rodrigues(np.array([[1., 0., 0.], [0., 1., 0.], [0., 0., 1.]]))
array([[0.],
[0.],
[0.]], dtype=float32)
solvePnP(objectPoints, imagePoints, cameraMatrix, distCoeffs, |flags)根据输入的 3d坐标集合和2d坐标集合，相机内参和平移矩阵，计算3d坐标到2d坐标的映射关系，并返回旋转矩阵和平移矩阵，参考：solvePnP
目前仅支持SOLVEPNP_SQPNP
参数：
objectPoints:Var 3d坐标集合, shape为(n,3)，n为点的个数imagePoints:Var 2d坐标集合, shape为(n,2)，n为点的个数cameraMatrix:Var 相机内参矩阵, shape为(3,3)distCoeffs:Var 相机畸变系数, shape为(1,5)或(5,), 不使用可以传入[]flags:int 标志位，可选，做兼容性处理，目前仅支持SOLVEPNP_SQPNP返回：返回值tuple中有3个值，第一个值为bool是否找到变换关系，第二个值为Var是旋转向量，第三个值为Var是平移矩阵
返回类型：tuple
示例：
>>> model_points = np.array([0.0, 0.0, 0.0, 0.0, -330.0, -65.0, -225.0, 170.0, -135.0, 225.0, 170.0, -135.0, -150.0, -150.0, -125.0, 150.0, -150.0, -125.0]).reshape(6, 3)
>>> image_points = np.array([359., 391., 399., 561., 337., 297., 513., 301., 345., 465., 453., 469.]).reshape(6, 2)
>>> camera_matrix = np.array([1200., 0., 600., 0., 1200., 337.5, 0., 0., 1.]).reshape(3, 3)
>>> dist_coeffs = np.array([0.0, 0.0, 0.0, 0.0]).reshape(4, 1)
>>> cv.solvePnP(model_points, image_points, camera_matrix, dist_coeffs, flags=cv.SOLVEPNP_SQPNP)
(True, array([[ 3.000745 ],
[ 0.03165916],
[-0.9225616 ]], dtype=float32), array([[-435.97495],
[ 95.3929 ],
[2201.46 ]], dtype=float32))
cvtColor(src, code, |dstCn)将图像转换为另一种颜色空间，参考: cvtColor
如果src为YUV图像请使用cvtColorTwoPlane
参数：
src:Var 输入图像code:int 转换方式，使用cv.COLOR_*dstCn:int 转换后图像的通道数，可选，默认为原图像的通道数返回：转换后的图像
返回类型：Var
示例：
>>> img = cv.imread('cat.jpg') # bgr
>>> cv.cvtColor(img, cv.COLOR_BGR2GRAY) # gray
>>> gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
>>> cv.imwrite('cvtColor.jpg', gray)
True
cvtColorTwoPlane(src1, src2, code)将图像转换为另一种颜色空间，源图像存储在两个平面中，一般用于YUV_NV21和YUV_NV12到其他颜色空间的转换，参考: cvtColorTwoPlane
参数：
src1:Var 图像的第一个平面src2:Var 图像的第二个平面code:int 转换方式，使用cv.COLOR_*返回：转换后的图像
返回类型：Var
示例：
>>> h = w = 224
>>> y = np.random.randint(0, 255, h * w).reshape(h, w).astype(np.uint8)
>>> uv = np.random.randint(0, 255, h * w / 2).astype(np.uint8)
>>> rgb = cv.cvtColorTwoPlane(y, uv, cv.COLOR_YUV2RGB_NV21)
>>> cv.imwrite('cvtColorTwoPlane.jpg', rgb)
True
bilateralFilter(src, d, sigmaColor, sigmaSpace, |borderType)双边滤波，直接实现未优化，速度较慢；参考: bilateralFilter
参数：
src:Var 输入图像d:int 滤波时考虑周围像素的直径，如果为负数则通过sigmaSpace计算sigmaColor:float 颜色空间sigma值sigmaSpace:float 坐标空间sigma值borderType:int 边界模式，可选值；默认为REFLECT返回：滤波后的图像
返回类型：Var
示例：
>>> img = cv.imread('cat.jpg')
>>> img = cv.bilateralFilter(img, 20, 80.0, 35.0)
>>> cv.imwrite('bilateralFilter.jpg', img)
True
blur(src, ksize, |borderType)使用归一化框滤镜模糊图像，参考: blur
参数：
src:Var 输入图像ksize:[int] kernel大小borderType:int 边界类型，可选，默认为cv.BORDER_DEFAULT返回：模糊后的图像
返回类型：Var
示例：
>>> img = cv.imread('cat.jpg')
>>> img = cv.blur(img, [3, 3])
>>> cv.imwrite('blur.jpg', img)
True
boxFilter(src, ddepth, ksize, |normalize, borderType)使用方框滤镜模糊图像，参考: boxFilter
参数：
src:Var 输入图像ddepth:int 图像的深度ksize:[int] kernel大小borderType:int 边界类型，可选，默认为cv.BORDER_DEFAULT返回：模糊后的图像
返回类型：Var
示例：
>>> img = cv.imread('cat.jpg')
>>> img = cv.boxFilter(img, -1, [7, 7])
>>> cv.imwrite('boxFilter.jpg', img)
True
dilate(src, kernel, |iterations, borderType)通过使用特定的结构元素对图像进行扩张，参考: dilate
参数：
src:Var 输入图像kernel:Var 结构元素iterations:int 迭代次数，可选，默认为1borderType:int 边界类型，可选，默认为cv.BORDER_DEFAULT返回：扩张后的图像
返回类型：Var
示例：
>>> img = cv.imread('cat.jpg')
>>> img = cv.dilate(img, cv.getStructuringElement(0, (3, 3)))
>>> cv.imwrite('dilate.jpg', img)
True
erode(src, kernel, |iterations, borderType)通过使用特定的结构元素对图像进行腐蚀，参考: erode
参数：
src:Var 输入图像kernel:Var 结构元素iterations:int 迭代次数，可选，默认为1borderType:int 边界类型，可选，默认为cv.BORDER_DEFAULT返回：腐蚀后的图像
返回类型：Var
示例：
>>> img = cv.imread('cat.jpg')
>>> img = cv.erode(img, cv.getStructuringElement(0, (3, 3)))
>>> cv.imwrite('erode.jpg', img)
True
filter2D(src, ddepth, kernel, |delta, borderType)度图像执行二维卷积，参考: filter2D
参数：
src:Var 输入图像ddepth:int 图像的深度kernel:Var 卷积核delta:float 加到卷积结果的偏移量，可选，默认为0borderType:int 边界类型，可选，默认为cv.BORDER_DEFAULT返回：卷积结果
返回类型：Var
示例：
>>> img = cv.imread('cat.jpg')
>>> img = cv.filter2D(img, -1, cv.getStructuringElement(0, (3, 3)))
>>> cv.imwrite('filter2D.jpg', img)
True
GaussianBlur(src, ksize, sigmaX, |sigmaY, borderType)使用高斯滤镜模糊图像，参考: GaussianBlur
参数：
src:Var 输入图像ksize:[int] kernel大小sigmaX:float X 方向的高斯核标准差sigmaY:float Y方向的高斯核标准差；如果 sigmaY 为零，则设置为等于 sigmaX，可选，默认为0borderType:int 边界类型，可选，默认为cv.BORDER_DEFAULT返回：模糊后的图像
返回类型：Var
示例：
>>> img = cv.imread('cat.jpg')
>>> img = cv.GaussianBlur(img, [5, 5], 3)
>>> cv.imwrite('GaussianBlur.jpg', img)
True
getDerivKernels(dx, dy, ksize, |normalize)返回用于计算空间图像导数的滤波器系数，参考: getDerivKernels
参数：
dx:int 关于 x 的导数dy:int 关于 y 的导数ksize:int 返回的kernel大小，可以是1,3,5,7normalize:bool 是否将系数归一化，可选，默认为false返回：滤波器系数
返回类型：Var
示例：
>>> cv.getDerivKernels(1, 1, 3)
(array([[-1., 0., 1.]], dtype=float32), array([[-1., 0., 1.]], dtype=float32))
getGaborKernel(ksize, sigma, theta, lambd, gamma, |psi)返回Gabor滤波器系数，参考: getGaborKernel
参数：
ksize:[int] 返回的kernel大小sigma:float Gabor的标准差theta:float Gabor函数的平行条纹的法线方向lambd:float 正弦因子的波长gamma:float 空间纵横比psi:float 相位偏移，可选，默认为PI/2返回：滤波器系数
返回类型：Var
示例：
>>> cv.getGaborKernel([3, 3], 10, 5, 5, 5)
array([[ 6.1722213e-01, 9.2025989e-01, 9.3729156e-01],
[-3.1094351e-01, -4.3711388e-08, 3.1094342e-01],
[-9.3729156e-01, -9.2025995e-01, -6.1722219e-01]], dtype=float32)
getGaussianKernel(ksize, sigma)返回高斯滤波器系数，参考: getGaussianKernel
参数：
ksize:int 返回的kernel大小，必须是奇数sigma:float 高斯标准差sigma = 0.3*((ksize-1)*0.5 - 1) + 0.8返回：滤波器系数
返回类型：Var
示例：
>>> cv.getGaussianKernel(3, 5)
array([[0.33110374, 0.3377925 , 0.33110374]], dtype=float32)
getStructuringElement(shape, ksize)返回指定大小和形状的结构元素，用于形态学操作，参考: getStructuringElement
参数：
shape:int 元素形状
ksize:[int] 结构元素的大小返回：结构元素
返回类型：Var
示例：
>>> cv.getStructuringElement(0, (3, 3))
array([[1, 1, 1],
[1, 1, 1],
[1, 1, 1]], dtype=uint8)
Laplacian(src, ddepth, |ksize, scale, delta, borderType)计算图像的拉普拉斯算子，参考: Laplacian
参数：
src:Var 输入图像ddepth:int 图像的深度ksize:int 卷积核大小，可选，默认为1scale:float 缩放因子，可选，默认为1delta:float 加到结果的偏移量，可选，默认为0borderType:int 边界类型，可选，默认为cv.BORDER_DEFAULT返回：拉普拉斯算子计算结果
返回类型：Var
示例：
>>> img = cv.imread('cat.jpg')
>>> img = cv.Laplacian(img, -1, 3)
>>> cv.imwrite('Laplacian.jpg', img)
True
pyrDown(src, |dstsize, borderType)模糊图像并对其进行下采样，参考: pyrDown
参数：
src:Var 输入图像dstsize:[int] 输出图像的大小borderType:int 边界类型，可选，默认为cv.BORDER_DEFAULT返回：下采样后的图像
返回类型：Var
示例：
>>> img = cv.imread('cat.jpg')
>>> img = cv.pyrDown(img)
>>> cv.imwrite('pyrDown.jpg', img)
True
pyrUp(src, |dstsize, borderType)对图像进行上采样，然后对其进行模糊处理，参考: pyrUp
参数：
src:Var 输入图像dstsize:[int] 输出图像的大小borderType:int 边界类型，可选，默认为cv.BORDER_DEFAULT返回：下采样后的图像
返回类型：Var
示例：
>>> img = cv.imread('cat.jpg')
>>> img = cv.pyrUp(img)
>>> cv.imwrite('pyrUp.jpg', img)
True
Scharr(src, ddepth, dx, dy, |scale, delta, borderType)使用Scharr算子计算图像导数，参考: Scharr
参数：
src:Var 输入图像ddepth:int 图像的深度dx:int 导数x的阶数dy:int 导数y的阶数scale:float 缩放因子，可选，默认为1delta:float 加到结果的偏移量，可选，默认为0borderType:int 边界类型，可选，默认为cv.BORDER_DEFAULT返回：Scharr算子计算结果
返回类型：Var
示例：
>>> img = cv.imread('cat.jpg')
>>> cv.Scharr(img, -1, 1, 1)
array([[[0, 0, 0],
[0, 0, 0],
[0, 0, 0],
...,
[0, 0, 0],
[0, 0, 0],
[0, 0, 0]]], dtype=uint8)
sepFilter2D(src, ddepth, kx, ky, |delta, borderType)对图像应用可分离的线性过滤器，参考: sepFilter2D
参数：
src:Var 输入图像ddepth:int 图像的深度kx:int x方向的kernelky:int y方向的kerneldelta:float 加到结果的偏移量，可选，默认为0borderType:int 边界类型，可选，默认为cv.BORDER_DEFAULT返回：sepFilter2D计算结果
返回类型：Var
示例：
>>> img = cv.imread('cat.jpg')
>>> kernelX = np.array([[0., -1., 0.]])
>>> kernelY = np.array([[-1., 0., -1.]])
>>> cv.sepFilter2D(img, -1, kernelX, kernelY, 1)
array([[[1, 1, 1],
[1, 1, 1],
[1, 1, 1],
...,
[1, 1, 1],
[1, 1, 1],
[1, 1, 1]]], dtype=uint8)
Sobel(src, ddepth, dx, dy, |ksize, scale, delta, borderType)使用Sobel算子计算图像导数，参考: Sobel
参数：
src:Var 输入图像ddepth:int 图像的深度dx:int 导数x的阶数dy:int 导数y的阶数ksize:int kernel的大小，可选，默认为3scale:float 缩放因子，可选，默认为1delta:float 加到结果的偏移量，可选，默认为0borderType:int 边界类型，可选，默认为cv.BORDER_DEFAULT返回：Sobel算子计算结果
返回类型：Var
示例：
>>> img = cv.imread('cat.jpg')
>>> cv.Sobel(img, -1, 1, 0)
array([[[0, 0, 0],
[0, 0, 0],
[0, 0, 2],
...,
[0, 0, 0],
[0, 0, 0],
[0, 0, 0]]], dtype=uint8)
spatialGradient(src, |ksize, borderType)使用Sobel算子分别计算x和y方向的一阶图像导数，参考: spatialGradient
参数：
src:Var 输入图像ksize:int Sobel kernel的大小，可选，默认为3borderType:int 边界类型，可选，默认为cv.BORDER_DEFAULT返回：spatialGradient计算结果
返回类型：Var
sqrBoxFilter(src, ddepth, ksize, |normalize, borderType)计算与过滤器重叠的像素值的归一化平方和，参考: sqrBoxFilter
参数：
src:Var 输入图像ddepth:int 图像的深度ksize:[int] kernel的大小normalize:bool 是否归一化，可选，默认为trueborderType:int 边界类型，可选，默认为cv.BORDER_DEFAULT返回：sqrBoxFilter计算结果
返回类型：Var
示例：
>>> img = cv.imread('cat.jpg')
>>> img = cv.sqrBoxFilter(img, -1, (3,3))
>>> img = img.astype(np.uint8)
>>> cv.imwrite('sqrBoxFilter.jpg', img)
True
getAffineTransform(src, dst)计算两组三个顶点之间仿射变换矩阵，参考: getAffineTransform
参数：
src:[float] 输入的一组顶点，类型为list。里面为6个 float元素，分别代表三个顶点的 x, ydst:[float] 计算仿射变换的另一组顶点，类型为list。里面为6个float元素，分别代表三个顶点的 x, y返回：变换矩阵
返回类型：CVMatrix 参考：CVMatrix
示例：
>>> src = [50.0, 50.0, 200.0, 50.0, 50.0, 200.0]
>>> dst = [10.0, 100.0, 200.0, 20.0, 100.0, 250.0]
>>> cv.getAffineTransform(src, dst)
[[1.266667 0.600000 -83.333336]
[-0.533333 1.000000 76.666664]
[76.666664 0.000000 0.000000]]
getPerspectiveTransform(src, dst)计算两组三个顶点之间透视变换矩阵，参考: getPerspectiveTransform
参数：
src:[float] 输入的一组顶点，类型为list。里面为6个 float元素，分别代表三个顶点的 x, ydst:[float] 计算仿射变换的另一组顶点，类型为list。里面为6个float元素，分别代表三个顶点的 x, y返回：变换矩阵
返回类型：CVMatrix 参考：CVMatrix
示例：
>>> src = [100.0, 50.0, 100.0, 390.0, 600.0, 50.0, 600.0, 390.0]
>>> dst = [200.0, 100.0, 200.0, 330.0, 500.0, 50.0, 600.0, 390.0]
>>> cv2.getPerspectiveTransform(src, dst)
[[0.307692 -0.104072 174.434372]
[-0.129231 0.504751 87.685509]
[87.685509 -0.000585 -0.000520]]
getRectSubPix(image, patchSize, center)获取图像的矩形子块，参考: getRectSubPix
参数：
image:Var 输入的图像patchSize:[int] 裁剪的patch大小(width, height)center:[int] 被裁减出的矩形的中心点(x, y)返回：裁剪出的图像
返回类型：Var
示例：
>>> img = cv.imread('cat.jpg')
>>> h, w, c = img.shape
>>> center = (w / 2.0, h / 2.0)
>>> img = cv2.getRectSubPix(img, [90, 90], center)
>>> cv.imwrite('getRectSubPix.jpg', img)
True
getRotationMatrix2D(center, angle, scale)作用等同与 OpenCV 中 Geometric Image Transformations 模块的getRotationMatrix2D 函数，用于计算 2D 旋转的仿射变换矩阵。
参数：
center:[float] 图像中的旋转中心点(x, y)angle:float 旋转角度(degrees)scale:float 同向放缩因子返回：仿射变换矩阵
返回类型：类型为 CVMatrix
示例：
>>> cv.getRotationMatrix2D((500.0 / 2.0, 333.0 / 2.0), 90, 1.0)
[[-0.000000 1.000000 83.500015]
[-1.000000 -0.000000 416.500000]
[416.500000 0.000000 0.000000]]
invertAffineTransform(m)作用等同与 OpenCV 中 Geometric Image Transformations 模块的invertAffineTransform 函数，计算仿射变换矩阵的逆矩阵。
参数：
m:CVMatrix 输入的仿射矩阵返回：仿射变换矩阵的逆矩阵
返回类型：类型为 CVMatrix
示例：
>>> m = MNN.CVMatrix()
>>> m.setScale(5.0, 5.0)
>>> cv.invertAffineTransform(m)
[[0.200000 0.000000 -0.000000]
[0.000000 0.200000 -0.000000]
[-0.000000 0.000000 0.000000]]
convertMaps(map1, map2, dstmap1type, |interpolation)映射map转换，为了兼容OpenCV中的convertMaps 函数；但实际不进行任何操作，仍返回map1, map2
参数：
map1:Var 原始映射关系map2:Var 原始映射关系dstmap1type:int 兼容性参数，不支持interpolation:int 兼容性参数，不支持返回：(map1, map2)
返回类型：类型为 Tuple
remap(src, map1, map2, interpolation, |borderMode, borderValue)作用等同与 OpenCV 中 Geometric Image Transformations 模块的remap 函数，用于图像重映射。
不支持borderMode与borderValue
参数：
src:Var 输入的图像map1:Var x坐标映射map2:Var y坐标映射interpolation:int 插值方式，仅支持cv.INTER_NEAREST和cv.INTER_LINEARborderMode:int 兼容性参数，不支持borderValue:int 兼容性参数，不支持返回：重映射后的图像
返回类型：类型为 Var
示例：
>>> img = cv.imread('cat.jpg')
>>> row, col, ch = img.shape
>>> mapx = np.ones(img.shape[:2], np.float32)
>>> mapy = np.ones(img.shape[:2], np.float32)
>>> for i in range(row):
>>> for j in range(col):
>>> mapx[i, j] = float(j)
>>> mapy[i, j] = float(row-i)
>>> img = cv.remap(img, mapx, mapy, cv.INTER_LINEAR)
>>> cv.imwrite('remap.jpg', img)
True
resize(src, dsize, |fx, fy, interpolation, code, mean, norm)作用等同与 OpenCV 中 Geometric Image Transformations 模块的resize 函数，用于放缩图像。
该函数在兼容OpenCV函数的基础上，额外增加了3个参数可选参数：code, mean, norm可以额外完成cvtColor和typeas的功能
参数：
src:Var 输入的图像dsize:tuple 放缩后的大小fx:float 水平方向的放缩因子，如果为0，则自动计算，默认为0fy:float 竖直方便的放缩因子，如果为0，则自动计算，默认为0interpolation:int 放缩的插值方法，默认为cv.INTER_LINEARcode:int 可以在缩放时转换颜色空间，默认为-1不执行转换mean:[float] 转换为float的归一化的均值，默认为空不转换为floatnorm:[float] 转换为float的归一化的标准差，默认为空不转换为float返回：放缩后的图像
返回类型：类型为 Var
示例：
>>> img = cv.imread('cat.jpg')
>>> img = cv.resize(img, [100, 100])
>>> cv.imwrite('resize.jpg', img)
True
warpAffine(src, M, dsize, |flag, borderMode, borderValue, code, mean, norm)作用等同与 OpenCV 中 Geometric Image Transformations 模块的warpAffine 函数，对一个图像应用仿射变换。
该函数在兼容OpenCV函数的基础上，额外增加了3个参数可选参数：code, mean, norm可以额外完成cvtColor和typeas的功能
参数：
src:Var 输入的图像dsize:tuple 放缩后的大小interpolation:int 放缩的插值方法，默认为cv.INTER_LINEARborderMode:int 边界模式，默认为cv.BORDER_CONSTANTborderValue:int 当边界模式为 cv.BORDER_CONSTANT 时设定的值，默认为0code:int 可以在缩放时转换颜色空间，默认为-1不执行转换mean:[float] 转换为float的归一化的均值，默认为空不转换为floatnorm:[float] 转换为float的归一化的标准差，默认为空不转换为float返回：仿射变换的图像
返回类型：Var
示例：
>>> src = [50.0, 50.0, 200.0, 50.0, 50.0, 200.0, 125.0, 222.0]
>>> dst = [10.0, 100.0, 200.0, 20.0, 100.0, 250.0, 200.0, 300.0]
>>> transform = cv.getAffineTransform(src, dst)
>>> img = cv.imread('cat.jpg')
>>> img = cv.warpAffine(img, transform, [300, 330])
>>> cv.imwrite('warpAffine.jpg', img)
True
warpPerspective(src, M, dsize, flag, borderMode, borderValue)作用等同与 OpenCV 中 Geometric Image Transformations 模块的warpPerspective 函数，对一个图像应用透视变换。
参数：
src:Var 输入的图像dsize:tuple 放缩后的大小interpolation:int 放缩的插值方法，默认为cv.INTER_LINEARborderMode:int 边界模式，默认为cv.BORDER_CONSTANTborderValue:int 当边界模式为 cv.BORDER_CONSTANT 时设定的值，默认为0返回：透视变换的图像
返回类型：Var
示例：
>>> src = [50.0, 50.0, 200.0, 50.0, 50.0, 200.0, 125.0, 222.0]
>>> dst = [10.0, 100.0, 200.0, 20.0, 100.0, 250.0, 200.0, 300.0]
>>> transform = cv.getPerspectiveTransform(src, dst)
>>> img = cv.imread('cat.jpg')
>>> img = cv.warpPerspective(img, transform, [500, 333])
>>> cv.imwrite('warpPerspective.jpg', img)
True
adaptiveThreshold(src, maxValue, adaptiveMethod, thresholdType, blockSize, C)作用等同与 OpenCV 中 Miscellaneous Image Transformations 模块的adaptiveThreshold 函数，对图像逐像素进行自适应阈值变化，可以将使用此函数将图像变成二值图像。
参数：
src:Var 输入的图像maxValue:float 阈值的最大值adaptiveMethod:int 自适应方法，如：cv.ADAPTIVE_THRESH_MEAN_CthresholdType:int 阈值变化的类型，如：cv.THRESH_BINARYblockSize:int 计算阈值时取邻域的大小，如：3,5,7等C:float返回：阈值变化后的图像
返回类型：Var
示例：
>>> img = cv.imread('cat.jpg')
>>> img = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
>>> img = cv.adaptiveThreshold(img, 50, cv.ADAPTIVE_THRESH_MEAN_C, cv.THRESH_BINARY, 5, 2)
>>> cv.imwrite('adaptiveThreshold.jpg', img)
True
blendLinear(src1, src2, weight1, weight2)作用等同与 OpenCV 中 Miscellaneous Image Transformations 模块的blendLinear 函数，对两幅图像进行线性混合。
参数：
src1:Var 输入的图像src2:Var 输入的图像weight1:Var src1 计算的叠加权重weight2:Var src2 计算的叠加权重返回：混合后的图像。
返回类型：Var
示例：
>>> src1 = np.array([[2.0, 3.0], [1.0, 1.0]])
>>> src2 = np.array([[0.0, 1.0], [1.0, 1.0]])
>>> weight1 = np.array([[1.0, 2.0], [1.5, 1.5]])
>>> weight2 = np.array([[0.1, 0.5], [0.2, 0.3]])
>>> cv.blendLinear(src1, src2, weight1, weight2)
array([[1.8181652 , 2.5999894 ],
[0.9999941 , 0.99999446]], dtype=float32)
threshold(src, thresh, maxval, type)作用等同与 OpenCV 中 Miscellaneous Image Transformations 模块的threshold 函数，对图像逐像素进行阈值变化，可以将使用此函数将图像变成二值图像，比如在寻找轮廓时(findContours)可以使用该函数。
参数：
src:Var 输入的图像thresh:float 阈值maxval:float 阈值的最大值type:int 阈值变化的类型，默认为cv.THRESH_BINARY| 参数 | 说明 |
|---|---|
THRESH_BINARY | 小于阈值的像素置为0，大于阈值的像素置为maxval |
THRESH_BINARY_INV | 小于阈值的像素置为maxval，大于阈值的像素置为0 |
THRESH_TRUNC | 小于阈值的像素置为0，大于阈值的像素保持不变 |
THRESH_TOZERO | 小于阈值的像素置为0，大于阈值的像素不变 |
THRESH_TOZERO_INV | 小于阈值的像素不变，大于阈值的像素置为0 |
返回：阈值变化后的图像
返回类型：Var
示例：
>>> img = cv.imread('cat.jpg')
>>> img = img.astype(np.float32)
>>> img = cv.threshold(img, 127, 255, cv.THRESH_BINARY)
>>> img = img.astype(np.uint8)
>>> cv.imwrite('threshold.jpg', img)
True
findContours(image, mode, method, offset)作用等同与 OpenCV 中 Structural Analysis and Shape Descriptors模块的findContours 函数，对二值图像进行轮廓查找，查找得到的结果可以用作contourArea，fillPoly和drawContours的参数使用。
注意：该实现未计算hierarchy信息
参数：
image:Var 输入的图像mode:int 轮廓查找的模式，默认为cv.RETR_EXTERNALmethod:int 轮廓查找的方法，默认为cv.CHAIN_APPROX_SIMPLEoffset:tuple 轮廓查找的偏移量，默认为(0, 0)返回：tuple的第一个元素为找到的轮廓像素，类型为list of Var，第二个值为兼容opencv的值，本函数未实现。
返回类型：tuple
示例：
>>> img = cv.imread('cat.jpg')
>>> gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
>>> binary = cv.threshold(gray, 127, 255, cv.THRESH_BINARY)
>>> cv.findContours(binary, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE)
([array([[[143, 294]],
...,
[[144, 295]]], dtype=int32),
...
array([[[304, 1]],
...,
[[309, 1]]], dtype=int32)], 'no hierarchy')
contourArea(points, oriented)作用等同与 OpenCV 中 Structural Analysis and Shape Descriptors模块的contourArea 函数，计算轮廓的面积。
参数：
points:Var 轮廓像素oriented:bool 是否计算有向面积，默认为False返回：轮廓的面积
返回类型：float
示例：
>>> img = cv.imread('cat.jpg')
>>> gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
>>> binary = cv.threshold(gray, 127, 255, cv.THRESH_BINARY)
>>> contours, _ = cv.findContours(binary, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE)
>>> cv.contourArea(contours[0], False)
15.5
convexHull(points, clockwise, returnPoints)作用等同与 OpenCV 中 Structural Analysis and Shape Descriptors模块的convexHull 函数，计算点集的凸包。
参数：
points:Var 轮廓像素clockwise:bool 是否按顺时针方向计算凸包，默认为FalsereturnPoints:bool 是否返回凸包的点集，默认为True返回：凸包的点集
返回类型：Var
示例：
>>> img = cv.imread('cat.jpg')
>>> gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
>>> binary = cv.threshold(gray, 127, 255, cv.THRESH_BINARY)
>>> contours, _ = cv.findContours(binary, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE)
>>> cv.convexHull(contours[0])
array([[[147, 295]],
[[147, 298]],
[[146, 299]],
[[143, 298]],
[[142, 297]],
[[142, 296]],
[[143, 294]]], dtype=int32)
minAreaRect(points)作用等同与 OpenCV 中 Structural Analysis and Shape Descriptors模块的minAreaRect 函数，计算点集的最小外接矩形。
参数：
points:Var 轮廓像素返回：最小外接矩形的中心点坐标，长宽，旋转角度
返回类型：tuple
示例：
>>> img = cv.imread('cat.jpg')
>>> gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
>>> binary = cv.threshold(gray, 127, 255, cv.THRESH_BINARY)
>>> contours, _ = cv.findContours(binary, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE)
>>> cv.minAreaRect(contours[0])
((144.61766052246094, 296.5294494628906), (5.3357834815979, 4.123105525970459), 14.03624439239502)
boundingRect(points)作用等同与 OpenCV 中 Structural Analysis and Shape Descriptors模块的boundingRect 函数，计算点集的最小外接矩形。
参数：
points:Var 轮廓像素返回：最小外接矩形的中心点坐标，长宽
返回类型：tuple
示例：
>>> img = cv.imread('cat.jpg')
>>> gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
>>> binary = cv.threshold(gray, 127, 255, cv.THRESH_BINARY)
>>> contours, _ = cv.findContours(binary, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE)
>>> cv.boundingRect(contours[0])
[142, 294, 6, 6]
connectedComponentsWithStats(image, connectivity)作用等同与 OpenCV 中 Connected Components模块的connectedComponentsWithStats 函数，计算图像的连通域。
参数：
image:Var 图像connectivity:int 连通域的连通性，默认为8返回：连通域的数量，连通域的标签，每个标签的统计输出，每个标签的质心输出
返回类型：tuple
示例：
>>> img = cv.imread('cat.jpg')
>>> cv.connectedComponentsWithStats(img)
(2, array([[[[1], ..., [1]], ..., [[1], ..., [1]]]], dtype=int32),
array([[213, 60, 262, 52, 3], [0, 0, 480, 360, 172797]], dtype=int32),
array([[386., 77.333336], [239.49745, 179.50177]], dtype=float32))
boxPoints(box)作用等同与 OpenCV 中 Structural Analysis and Shape Descriptors模块的boxPoints 函数，计算矩形的四个顶点坐标。
参数：
box:tuple 矩形的中心点坐标，长宽，旋转角度，参考 minAreaRect 函数的返回值返回：四个顶点坐标
返回类型：Var
示例：
>>> img = cv.imread('cat.jpg')
>>> gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
>>> binary = cv.threshold(gray, 127, 255, cv.THRESH_BINARY)
>>> contours, _ = cv.findContours(binary, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE)
>>> cv.boxPoints(cv.minAreaRect(contours[0]))
array([[141.52942, 297.8824 ],
[142.52942, 293.8824 ],
[147.7059 , 295.1765 ],
[146.7059 , 299.1765 ]], dtype=float32)
line(img, pt1, pt2, color, thickness, lineType, shift)作用等同与 OpenCV 中 Drawing Functions 模块的line 函数，绘制从第一个点指向第二个点的直线。
该函数为 in-replace，直接作用于原图
参数：
img:Var 代表需要绘制线条的图像pt1:tuple 线条绘制的起点(x, y)pt2:tuple 线条绘制的终点(x, y)color:tuple 线条绘制的颜色(b, g, r, a)thickness:int 线的粗细，默认为1lineType:int 线条绘制的方式，默认为cv.LINE_8shift:int 坐标小数点向前移动的位数（缩小10倍数），默认为0返回：None
返回类型：None
示例：
>>> img = cv.imread('cat.jpg')
>>> cv.line(img, (10, 10), (100, 100), (255, 0, 0, 0), 5)
>>> cv.imwrite('line.jpg', img)
True
arrowedLine(img, pt1, pt2, color, thickness, lineType, shift, tipLength)作用等同与 OpenCV 中 Drawing Functions 模块的arrowedLine 函数，绘制从第一个点指向第二个点的箭头段。
该函数为 in-replace，直接作用于原图
参数：
img:Var 代表需要绘制箭头的图像pt1:tuple 箭头绘制的起点(x, y)pt2:tuple 箭头绘制的终点(x, y)color:tuple 箭头绘制的颜色(b, g, r, a)thickness:int 箭头的粗细，默认为1lineType:int 箭头绘制的方式，默认为cv.LINE_8shift:int 坐标小数点向前移动的位数（缩小10倍数），默认为0tipLength:float 箭头部分与直线长度的百分比，默认为0.1返回：None
返回类型：None
示例：
>>> img = cv.imread('cat.jpg')
>>> cv.arrowedLine(img, (10, 10), (100, 100), (255, 0, 0, 0), 5)
>>> cv.imwrite('arrowedLine.jpg', img)
True
circle(img, center, radius, color, thickness, lineType, shift)作用等同与 OpenCV 中 Drawing Functions 模块的circle 函数，绘制一个圆。
该函数为 in-replace，直接作用于原图
参数：
img:Var 代表需要绘制圆的图像center:tuple 圆的中心点(x, y)radius:int 圆的半径大小color:tuple 圆绘制的颜色(b, g, r, a)thickness:int 圆的粗细，默认为1lineType:int 圆绘制的方式，默认为cv.LINE_8shift:int 坐标小数点向前移动的位数（缩小10倍数），默认为0返回：None
返回类型：None
示例：
>>> img = cv.imread('cat.jpg')
>>> cv.circle(img, (100, 100), 5, (255, 0, 0, 0), 5)
>>> cv.circle(img, (100, 100), 50, (0, 0, 255, 0), 5)
>>> cv.imwrite('circle.jpg', img)
True
rectangle(src, pt1, pt2, color, thickness, lineType, shift)作用等同与 OpenCV 中 Drawing Functions 模块的rectangle 函数，绘制一个矩形。
该函数为 in-replace，直接作用于原图
参数：
img:Var 代表需要绘制圆的图像pt1:tuple 矩形的一个顶(x, y)pt2:tuple 矩形的另一个顶(x, y)color:tuple 矩形绘制的颜色(b, g, r, a)thickness:int 矩形的粗细，默认为1lineType:int 矩形绘制的方式，默认为cv.LINE_8shift:int 坐标小数点向前移动的位数（缩小10倍数），默认为0返回：None
返回类型：None
示例：
>>> img = cv.imread('cat.jpg')
>>> cv.rectangle(img, (50, 50), (150, 150), (255, 0, 0, 0), 5)
>>> cv.rectangle(img, (100, 100), (200, 200), (0, 0, 255, 0), 5)
>>> cv.imwrite('rectangle.jpg', img)
True
drawContours(img, contours, contourIdx, color, thickness, lineType)作用等同与 OpenCV 中 Drawing Functions 模块的drawContours 函数，绘制轮廓边缘或对其填充。
该函数为 in-replace，直接作用于原图
参数：
img:Var 代表需要绘制圆的图像contours:[[int]] 其中每一个元素都是一个list，代表一组轮廓点。一组轮廓点中的元素分别代表一个点的 x 或者 y，必须配对contourIdx:int 代表要绘制第几个轮廓组。如果传入负数，绘制所有轮廓组color:tuple 矩形绘制的颜色(b, g, r, a)thickness:int 矩形的粗细，默认为1lineType:int 矩形绘制的方式，默认为cv.LINE_8返回：None
返回类型：None
示例：
>>> img = cv.imread('cat.jpg')
>>> gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
>>> gray = gray.astype(np.float32)
>>> binary = cv.threshold(gray, 127, 255, cv.THRESH_BINARY)
>>> binary = binary.astype(np.uint8)
>>> contours, _ = cv.findContours(binary, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE)
>>> cv.drawContours(img, contours, -1, [0, 0, 255])
>>> cv.imwrite('drawContours.jpg', img)
True
fillPoly(img, contours, color, lineType, shift, offset)作用等同与 OpenCV 中 Drawing Functions 模块的fillPoly 函数，绘制填充多边形。
该函数为 in-replace，直接作用于原图
参数：
img:Var 代表需要绘制圆的图像contours:[[int]] 其中每一个元素都是一个list，代表一组轮廓点。一组轮廓点中的元素分别代表一个点的 x 或者 y，必须配对color:tuple 矩形绘制的颜色(b, g, r, a)lineType:int 矩形绘制的方式，默认为cv.LINE_8shift:int 坐标小数点向前移动的位数（缩小10倍数），默认为0offset:tuple 所有点相对轮廓的偏移量，默认为(0, 0)返回：None
返回类型：None
示例：
>>> img = cv.imread('cat.jpg')
>>> gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
>>> gray = gray.astype(np.float32)
>>> binary = cv.threshold(gray, 127, 255, cv.THRESH_BINARY)
>>> binary = binary.astype(np.uint8)
>>> contours, _ = cv.findContours(binary, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE)
>>> cv.fillPoly(img, contours, [0, 0, 255])
>>> cv.imwrite('fillPoly.jpg', img)
True
calcHist(imgs, channels, mask, histSize, ranges, accumulate)作用等同与 OpenCV 中 Histograms 模块的calcHist 函数，计算图像的直方图。
参数：
imgs:[Var] 需要计算的图像channels:[int] 需要计算的通道mask:Var 需要计算的图像的掩码，本函数实现不支持maskhistSize:[int] 直方图的大小，如：[256]ranges:[float] 直方图的范围，如：[0., 256.]accumulate:bool 是否累加，默认为False 本函数实现不支持累加返回：计算得到的直方图
返回类型：Var
示例：
>>> img = cv.imread('cat.jpg')
>>> cv.calcHist([img], [0], None, [256], [0., 256.])
array([ 9., 5., 13., 25., ..., 41., 74., 41., 173.], dtype=float32)