
import cv2
 
 
# 读取图片，第二个参数为False时，显示为灰度图像，True为原图
img = cv2.imread(filename="cat.jpg", flags=False)
 
# 显示图片，第一个参数为图片的标题
cv2.imshow(winname="image title", mat=img)
 
# 等待图片的关闭，不写这句图片会一闪而过
cv2.waitKey()
 
# 保存图片
cv2.imwrite("Grey_img.jpg", img)

cv2.waitKey() ：等待图片的关闭

可设置参数，为多少毫秒后自动关闭


import cv2
 
for file in filelist:
    image = cv2.imread(file, flags=False)
    cv2.imshow(winname="11",mat=image)
    # 每隔1000ms显示一张图片
    cv2.waitKey(1000)

2、图像显示窗口创建与销毁

cv2.namedWindow(winname, 属性)：创建一个窗口
cv2.destroyWindow(winname)：销毁某个窗口
cv2.destroyAllWindows()：销毁所有窗口

winname作为窗口的唯一标识，如果想使用指定窗口显示目标图像，需要让cv2.imshow(winname)中的winname与窗口的winname需要保持一致。

窗口创建时可以添加的属性：

cv2.WINDOW_NORMAL：窗口大小可以改变（同cv2.WINDOW_GUI_NORMAL）
cv2.WINDOW_AUTOSIZE：窗口大小不能改变
cv2.WINDOW_FREERATIO：窗口大小自适应比例
cv2.WINDOW_KEEPRATIO：窗口大小保持比例
cv2.WINDOW_GUI_EXPANDED：显示色彩变成暗色

cv2.WINDOW_FULLSCREEN：全屏显示

cv2.WINDOW_OPENGL：支持OpenGL的窗口


img = cv2.imread("cat.jpg")
 
# 第二个参数为窗口属性
cv2.namedWindow(winname="title", cv2.WINDOW_NORMAL)
 
# 如果图片显示想使用上面的窗口，必须保证winname一致
cv2.imshow(winname="title", img)
 
cv2.waitKey()
 
# 销毁
cv2.destroyWindow("title")
# 销毁所有窗口：cv2.destroyAllWindows()

3、图片的常用属性的获取

img.shape：打印图片的高、宽和通道数（当图片为灰度图像时，颜色通道数为1，不显示）
img.size：打印图片的像素数目
img.dtype：打印图片的格式

注意：这几个是图片的属性，并不是调用的函数，所以后面没有‘ () ’。


import cv2
 
img = cv2.imread("cat.jpg")
imgGrey = cv2.imread("cat.jpg", False)
 
print(img.shape)
print(imgGrey.shape)
 
#输出：
#(280, 300, 3)
#(280, 300)
 
print(img.size)
print(img.dtype)
 
#输出：
# 252000
# uint8

4、生成指定大小的矩形区域（ROI）

一个图片img，它的某个像素点可以用 img[x, y, c] 表示（x，y为坐标，c为通道数）
同理，这个图片的某个矩形区域可以表示为：img[x1:x2, y1:y2, c]（相当于截下一块矩形，左上角坐标为（x1, y1），右下角坐标为（x2, y2））
其中 c 一般取值为0，1，2（BGR）代表第几个颜色通道，可以省略不写 img[x, y] 代表所有通道。

实例一：生成一个大小为（300，400）颜色通道为3的红色图片


import cv2
import numpy as np
 
imgzero = np.zeros(shape=(300, 400, 3), dtype=np.uint8)
 
imgzero[:, :] = (0, 0, 255) # (B, G, R)
cv2.imshow("imgzero",imgzero)
cv2.waitKey()

实例二：从一张图片上截取一个矩形区域


import cv2
import numpy as np
 
img = cv2.imread("cat.jpg")
# 输出（50，100）上的像素值
num = img[50, 100]
print(num)
 
# 截取部分区域并显示
region = img[50:100, 50:100]
cv2.imshow("img", region)
cv2.waitKey()

5、图片颜色通道的分离与合并

cv2.split(m)：将图片m分离为三个颜色通道
cv2.merge(mv)：将三个颜色通道合并为一张图片


import cv2
 
img = cv2.imread("cat.jpg")
 
b, g, r = cv2.split(img)
 
merge = cv2.merge([b, g, r])

6、两张图片相加，改变对比度和亮度

cv2.add(src1, src2)：普通相加
cv2.addWeighted(src1, alpha, src2, w2，beta)：带权相加
src1：第一张图片
alpha：第一张图片权重
src2：第二张图片
beta：第二张图片权重
gamma：图1与图2作和后添加的数值。
dst：输出图片


import cv2
 
img1 = cv2.imread("cat.jpg")
img2 = cv2.imread("dog.jpg")
 
add1 = cv2.add(img1,img2)
 
add2 = cv2.addWeighted(img1, 0.5, img2, 0.5, 3)
 
cv2.imshow("add1", add1)
cv2.imshow("add2", add2)
cv2.waitKey()

cv2.addWeighted(src1, alpha, src2, w2，beta)可以改变图像的对比度和亮度。

通过改变alpha的值改变对比度，beta控制亮度。
# 改变对比度和亮度
def contrast_brightness_demo(img, c, b):
    h, w, ch = img.shape
    blank = np.zeros([h, w, ch], img.dtype)
    dst = cv2.addWeighted(img, c, blank, 1-c , b)
    cv2.imshow("contrast_brightness_demo", dst)

7、像素运算（1）加减乘除

对两张相同大小的图像进行加减乘除，cv2.imread()读取的图像，其实相当于获取了一个多维数组，每一个像素值就是数组坐标下的值。那么像素的基本运算就相当于是数组之间的运算。


def add_demo(m1, m2):
    dst = cv2.add(m1, m2)
    cv2.imshow("add", dst)
 
def subtract_demo(m1, m2):
    dst = cv2.subtract(m1, m2)
    cv2.imshow("subtract", dst)
 
def multiply_demo(m1, m2):
    dst = cv2.multiply(m1, m2)
    cv2.imshow("multiply", dst)
 
def divide_demo(m1, m2):
    dst = cv2.divide(m1, m2)
    cv2.imshow("divide", dst)

8、像素运算（2）均值&方差


def demo(img):
    # 均值
    M1 = cv2.mean(img)
    print(M1)
    # 均值和方差
    M1, dev1 = cv2.meanStdDev(img)
    print(M1)
    print(dev1)

9、像素运算（3）逻辑运算——与、或、非、异或

其中非运算就是对图像进行颜色反转


def logic_demo(m1, m2):
    dst = cv2.bitwise_and(m1, m2)
    cv2.imshow("bitwise_and", dst)
    dst = cv2.bitwise_or(m1, m2) 
    cv2.imshow("bitwise_or", dst)
    dst = cv2.bitwise_not(m1, m2)
    cv2.imshow("bitwise_not", dst)
    dst = cv2.bitwise_xor(m1, m2)
    cv2.imshow("bitwise_xor", dst)

10、计算执行时间

cv2.getTickCount() ：用于返回从操作系统启动到当前所经的计时周期数；
cv2.getTickFrequency()：用于返回CPU的频率，也就是一秒内重复的次数。

时间(s) = 总次数 / 一秒内重复的次数
时间(ms) = 1000 *总次数 / 一秒内重复的次数


t1 = cv2.getTickCount()
function()   # 待测试的函数
t2 = cv2.getTickCount()
time = (t2 - t1) / cv2.getTickFrequency()
print("time : %s ms" % (time * 1000))

11、泛洪填充（需要4、ROI的知识）

Windows自带的画图中有一个工具（油桶形状的），看下右图中，白色的背景，你用黑色画一个菱形，然后用这个油桶工具点一下菱形内部，就可以把菱形内部染成红色。

你在菱形内部用鼠标点击的那一下，点在了一个像素点上，我们知道这个像素点是白色的，那么油桶在染色的时候，就在这个原像素点的周围寻找相同的像素（白色像素），然后把和原像素点相同的像素都染成红色。（就像是从原像素点360度无死角发散寻找）

那么它什么时候结束染色呢？当它遇到和原像素点的像素不同的点时，就会中止这个方向的寻找。（也就是遇到了我们画的那个黑色边框）

同理在OpenCV里，提供了这样的函数

def floodFill( image, 原图像
                    mask, 掩码，单通道8位图像，比image的高度多2个像素，宽度多2个像素。
                    seedPoint, 起始点（原像素点，相当于鼠标点击的那个像素点）
                    newVal, 在重绘区域像素的新值（RBG值，相当于上图指定的红色）
                    loDiff=None, 像素值的下限差值（最多比原像素点低多少）
                    upDiff=None, 像素值的上限差值（最多比原像素点高多少）
                    flags=None)

FLOODFILL_FIXED_RANGE – 改变图像，泛洪填充
FLOODFILL_MASK_ONLY – 不改变图像，只填充遮罩层本身，忽略新的颜色值参数
def fill_color_demo():
    copyImg = img.copy()
    h, w = img.shape[:2]
    mask = np.zeros([h+2, w+2], np.uint8)
    cv2.floodFill(copyImg, mask, (100, 200), (0, 255, 0), (100, 100, 100), (50, 50, 50), cv2.FLOODFILL_FIXED_RANGE)
    cv2.imshow("fill_color_demo", copyImg)
 
def fill_binary_demo():
    img2 = np.zeros([400, 400, 3], np.uint8)
    img2[100:300, 100:300, :] = 255
    mask = np.ones([402, 402], np.uint8)
    mask[101:301, 101:301] = 0
 
    cv2.floodFill(img2, mask, (200, 200), (0, 0, 255), cv2.FLOODFILL_MASK_ONLY)
    cv2.imshow("fill_binary_demo", img2)

12、彩色空间转换

cv2.cvtColor

原型：cvtColor(src,code,dst=None,dstCn=None)
作用：将一幅图像从一个色彩空间转换到另一个色彩空间
参数：code，转换的色彩空间


# 色彩空间转换
def color_space_demo(img):
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    cv2.imshow("gray", gray)
    hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
    cv2.imshow("hsv", hsv)
    yuv = cv2.cvtColor(img, cv2.COLOR_BGR2YUV)
    cv2.imshow("yuv", yuv)
    ycrcb = cv2.cvtColor(img, cv2.COLOR_BGR2YCrCb)
    cv2.imshow("ycrcb", ycrcb)

13、cv2.inRange(hsv, lower_hsv, upper_hsv)

利用cv2.inRange函数设阈值，这里注意用的颜色空间是hsv。

HSV：HSV颜色空间是孟塞尔彩色空间的简化形式，是一种基于感知的颜色模型。它将彩色信号分为3种属性：色调（Hue,H），饱和度（Saturation,S），亮度（Value,V）。色调表示从一个物体反射过来的或透过物体的光波长，也就是说，色调是由颜色的名称来辨别的，如红、黄、蓝；亮度是颜色的明暗程度；饱和度是颜色的深浅，如深红、浅红。
HSV颜色空间反映了人观察色彩的方式，具有两个显著的特点：

亮度分量与图像的彩色信息无关
“色调”和“饱和度”分量与人感受颜色的方式是紧密相连的

可以根据右表来确定lower_hsv, upper_hsv的取值。


# 颜色追踪
def extrace_object_demo():
    capture = cv2.VideoCapture("testvideo.mp4")
    while(True):
        ret, frame = capture.read()
        if ret == False:
            break
        hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
        lower_hsv = np.array([0, 0, 0])
        upper_hsv = np.array([180, 255, 46])
        mask = cv2.inRange(hsv, lower_hsv, upper_hsv)
        dst = cv2.bitwise_and(frame, frame, mask=mask)
        cv2.imshow("video", frame)
        cv2.imshow("video", dst)
        c = cv2.waitKey(40)
        if c == 27:
            break

14、均值模糊、中值模糊，高斯模糊，双边模糊

附一篇博客：真正搞懂均值模糊、中值模糊、高斯模糊、双边模糊

模糊操作基本原理：

基于离散卷积
定义好每个卷积核
不同卷积核得到不同的卷积效果
模糊是卷积的一种表象

cv2.blur

原型：blur(src,ksize,dst=None,anchor=None,borderType=None)
作用：对图像进行算术平均值模糊
参数：ksize，卷积核的大小。dst，若填入dst，则将图像写入到dst矩阵。

cv2.medianBlur

原型：mediaBlur(src,ksize,dst=None)
作用：对图像进行中值模糊


def blur_demo(img):
    # 均值模糊
    dst = cv2.blur(img, (5, 5)) # 5*5的卷积核
    cv2.imshow("dst", dst)
 
    # 中值模糊，可以去噪音
    dst = cv2.medianBlur(img, 5)
 
    # 自定义
    kernel = np.ones([5, 5], np.float32) / 25
    dst = cv2.filter2D(img, -1, kernel)
 
    # 锐化（特定的卷积核）
    kernel = np.array([[0, -1, 0], [-1, 5, -1], [0, -1, 0]], np.float32)
    dst = cv2.filter2D(img, -1, kernel)

cv2.GaussianBlur

原型：GaussianBlur(src, ksize, sigmaX, dst=None, sigmaY=None, borderType=None)
作用：对图像进行高斯模糊
参数：sigmaX，X方向上的方差，一般设为0让系统自动计算。


def Gauss_blur():
    img = np.array([[14, 15, 16], [24, 25, 26], [34, 35, 36]], dtype=np.float32)
    blur = cv2.GaussianBlur(img, (3, 3), 1.5)
    print(blur)
 
 
Gauss_blur()
 
# output:
[[20.771631 21.156027 21.540426]
 [24.615604 25.       25.3844  ]
 [28.45958  28.843975 29.228374]]

cv2.bilateralFilter

原型：bilateralFilter(src, d, sigmaColor, sigmaSpace, dst=None, borderType=None)
作用：对图像进行双边模糊
参数：int d: 表示在过滤过程中每个像素邻域的直径范围。如果这个值是非正数，则函数会从第五个参数sigmaSpace计算该值。
double sigmaColor: 颜色空间过滤器的sigma值，这个参数的值月大，表明该像素邻域内有越宽广的颜色会被混合到一起，产生较大的半相等颜色区域。（这个参数可以理解为值域核的）
double sigmaSpace: 坐标空间中滤波器的sigma值，如果该值较大，则意味着越远的像素将相互影响，从而使更大的区域中足够相似的颜色获取相同的颜色。当d>0时，d指定了邻域大小且与sigmaSpace无关，否则d正比于sigmaSpace. （这个参数可以理解为空间域核的）


def bilateralFilter_demo(img):
    dst = cv2.bilateralFilter(img, 0, 100, 150)
    cv2.imshow("bilateralFilter", dst)
 
bi_demo(img)

15、二值化（cv2.threshold）

二值化就是把图像的像素转变为0或者255，只有这两个像素值。

推荐博客：

OpenCV---图像二值化
OpenCV---超大图像二值化和空白区域过滤

原型：threshold(src,thresh,maxval,type,dst=None)
作用：将图像的每个像素点进行二值化
参数：thresh，阈值（最小值）。maxval，二值化的最大取值。
type，二值化类型，一般设为0，也可以取以下的值：
返回值：计算过后的阈值值和二值化后的图像（如果dst是None）


# 全局二值化
def threshold_demo():
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    ret, binary = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)
    cv2.ADAPTIVE
    print("threshold value : %s\n" % ret)
    cv2.imshow("binary_global", binary)
 
threshold_demo()

函数：adaptiveThreshold(src, maxValue, adaptiveMethod, thresholdType, blockSize, C, dst=None)

参数：

maxValue：阈值的最大值；
adaptiveMethod：指定自适应阈值算法。可选择ADAPTIVE_THRESH_MEAN_C 或 ADAPTIVE_THRESH_GAUSSIAN_C两种。（自适应阈值化计算大概过程是为每一个象素点单独计算的阈值，即每个像素点的阈值都是不同的，就是将该像素点周围blockSize*blockSize区域内的像素加权平均，然后减去一个常数C，从而得到该点的阈值。）。

ADAPTIVE_THRESH_MEAN_C：为局部邻域块的平均值。该算法是先求出块中的均值，再减去常数C。
ADAPTIVE_THRESH_GAUSSIAN_C：为局部邻域块的高斯加权和。该算法是在区域中（x，y）周围的像素根据高斯函数按照他们离中心点的距离进行加权计算，再减去常数C。

thresholdType：指定阈值类型。可选择THRESH_BINARY或者THRESH_BINARY_INV两种。（即二进制阈值或反二进制阈值）。
blockSize：表示邻域块大小，用来计算区域阈值，奇数，一般选择为3、5、7......等。
C：表示与算法有关的参数，它是一个从均值或加权均值提取的常数，可以是负数。（具体见下面的解释）。


# 局部二值化
def local_threshold_demo():
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    binary = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY, 25, 10)
    #print("threshold value : %s\n" % ret)
    cv2.imshow("binary_local", binary)

16、图像直方图

图像直方图详解——定义、计算、均衡、比较、反射投影

17、模板匹配

模板匹配，就是在整个图像区域发现与给定子图像匹配的小块区域，需要模板图像T和待检测图像-源图像S；

工作方法：在待检测的图像上，从左到右，从上倒下计算模板图像与重叠子图像匹配度，匹配度越大，两者相同的可能性越大。

函数：matchTemplate(image, templ, method, result=None, mask=None)

参数：

image：源图像S；
templ：模板图像T，一般是源图像S中的一小块；
method：模板匹配算法（cv.TM_SQDIFF_NORMED最小时最相似，其他最大时最相似）


import cv2
import numpy as np
from matplotlib import pyplot as plt
 
 
def template_demo():
    tpl = cv2.imread("sample.jpg")
    target = cv2.imread("target.jpg")
    cv2.imshow("tpl", tpl)
    cv2.imshow("target", target)
    methods = [cv2.TM_SQDIFF_NORMED, cv2.TM_CCORR_NORMED, cv2.TM_CCOEFF_NORMED]  # 三种模板匹配方法
    th, tw = tpl.shape[:2]
    
    for md in methods:
        print(md)
        result = cv2.matchTemplate(target, tpl, md)  # 得到匹配结果
        min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(result)
        if md == cv2.TM_SQDIFF_NORMED:  # cv.TM_SQDIFF_NORMED最小时最相似，其他最大时最相似
            tl = min_loc
        else:
            tl = max_loc
 
        br = (tl[0] + tw, tl[1] + th)
        cv2.rectangle(target, tl, br, (0, 0, 255), 2)  # tl为左上角坐标，br为右下角坐标，从而画出矩形
        cv2.imshow("match-"+np.str(md), target)
 
template_demo()
cv2.waitKey(0)
cv2.destroyAllWindows()

18、图像金字塔（上采样和下采样）

图像缩小（先高斯模糊，再降采样，需要一次次重复，不能一次到底）

图像扩大（先扩大，再卷积或者使用拉普拉斯金字塔）

推荐博客：OpenCV---图像金字塔原理


import cv2
import numpy as np
 
 
# 图像金字塔和拉普拉斯金字塔(L1 = g1 - expand(g2))：reduce：高斯模糊+降采样，expand：扩大+卷积
# PyrDown降采样，PyrUp还原
def pyramid_demo(image):
    level = 4
    temp = image.copy()
    pyramid_images = []
 
    for i in range(level):
        dst = cv2.pyrDown(temp)
        pyramid_images.append(dst)
        cv2.imshow("pyramid_down_"+str(i+1), dst)
        temp = dst.copy()
    return pyramid_images
 
 
def laplace_demo(image):  # 注意：图片必须是满足2^n这种分辨率
    pyramid_images = pyramid_demo(image)
    level = len(pyramid_images)
 
    for i in range(level-1, -1, -1):
        if i-1 < 0:
            expand  = cv2.pyrUp(pyramid_images[i], dstsize=image.shape[:2])
            lpls = cv2.subtract(image, expand)
            cv2.imshow("laplace_demo"+str(i), lpls)
        else:
            expand = cv2.pyrUp(pyramid_images[i], dstsize=pyramid_images[i-1].shape[:2])
            lpls = cv2.subtract(pyramid_images[i-1], expand)
            cv2.imshow("laplace_demo"+str(i), lpls)
 
 
src = cv2.imread("img1.jpg") # 图像必须是2^n * 2^m的
cv2.imshow("demo", src)
#pyramid_demo(src)
laplace_demo(src)
cv2.waitKey(0)
cv2.destroyAllWindows()

19、图像梯度

图像梯度其实就是对图像进行求导，图像也是一个函数（离散的），这里其实就是用特定的滤波器来进行卷积操作。

cv2.Sobel

Sobel算子是高斯平滑和微分操作的结合体，所以他的抗噪声能力很好。他计算的是一阶导数，可以自己定义x方向或者y方向。

卷积因子：

原型： Sobel(src,ddepth,dx,dy,dst=None,ksize=None,scale=None,delta=None,borderType=None)

作用：对图像进行Sobel算子计算。检测出其边缘。

参数：dx，x方向上的导数阶数；dy，y方向上的导数阶数。


import cv2 as cv
import numpy as np
 
 
def sobel_demo(image):
    grad_x = cv2.Sobel(image, cv2.CV_32F, 1, 0)  # 采用Scharr边缘更突出
    grad_y = cv2.Sobel(image, cv2.CV_32F, 0, 1)
 
    gradx = cv2.convertScaleAbs(grad_x)  # 由于算完的图像有正有负，所以对其取绝对值
    grady = cv2.convertScaleAbs(grad_y)
 
    # 计算两个图像的权值和，dst = src1*alpha + src2*beta + gamma
    gradxy = cv2.addWeighted(gradx, 0.5, grady, 0.5, 0)
 
    cv2.imshow("gradx", gradx)
    cv2.imshow("grady", grady)
    cv2.imshow("gradient", gradxy)
 
 
src = cv.imread("../images/lena.jpg")
cv.imshow("lena",src)
sobel_demo(src)
cv.waitKey(0)
cv.destroyAllWindows()

cv2.scharr

原型：Scharr(src, ddepth, dx, dy, dst=None, scale=None, delta=None, borderType=None, /)

是Sobel的优化版，在使用3*3卷积核时这个优于Sobel，其它尺寸的卷积核用Sobel就行。


import cv2 as cv
import numpy as np
 
 
def scharr_demo(image):
    grad_x = cv2.Scharr(image, cv2.CV_32F, 1, 0)  # 采用Scharr边缘更突出
    grad_y = cv2.Scharr(image, cv2.CV_32F, 0, 1)
 
    gradx = cv2.convertScaleAbs(grad_x)  # 由于算完的图像有正有负，所以对其取绝对值
    grady = cv2.convertScaleAbs(grad_y)
 
    # 计算两个图像的权值和，dst = src1*alpha + src2*beta + gamma
    gradxy = cv2.addWeighted(gradx, 0.5, grady, 0.5, 0)
 
    cv2.imshow("gradx", gradx)
    cv2.imshow("grady", grady)
    cv2.imshow("gradient", gradxy)
 
 
src = cv.imread("../images/lena.jpg")
cv.imshow("lena",src)
scharr_demo(src)
cv.waitKey(0)
cv.destroyAllWindows()

cv2.Laplacian

Laplacian算子是个二阶微分。下面两个卷积核，靠上的是4邻域的，靠下的是8邻域的。函数默认为8邻域。

原型:Laplacian(src,ddepth,dst=None,ksize=None,scale=None,delta=None,borderType=None)

作用：检测图像边缘。

参数：ddepth，图像位深度，对于灰度图来说，其值为：cv2.CV_8U。ksize，希望使用的卷积核的大小。scale，是缩放导数的比例常数。


import cv2 as cv
import numpy as np
 
 
def laplace_demo(image):  # 二阶导数，边缘更细
    dst = cv2.Laplacian(image,cv2.CV_32F)
    lpls = cv2.convertScaleAbs(dst)
    cv2.imshow("laplace_demo", lpls)
 
 
src = cv.imread("../images/lena.jpg")
cv.imshow("lena",src)
laplace_demo(src)
cv.waitKey(0)
cv.destroyAllWindows()

VideoCapture 类

cv2.VideoCapture

原型：VideoCapture(*args,**kwargs)
作用：初始化VideoCapture类并利用构造函数读入该视频的当前帧。
参数：一般仅填入一个，即文件名。如果填入整数，则打开对应的捕获设备ID。若为0，则打开默认摄像头。

VideoCapture.get

原型：VideoCapture.get(self,propld)
作用：返回该视频的propld所指定的属性

参数：propld，为需要读取的视频属性参数位，一般以cv2.CAP_PROP_ 开头

参数名称	作用
CV_CAP_PROP_POS_MSEC	当前视频文件的时间位置（返回毫秒）或视频捕获时间戳
CV_CAP_PROP_POS_FRAMES	从0开始的解码/捕获时间帧
CV_CAP_PROP_POS_AVI_RATIO	返回视频文件的相关位置：0，视频开始。1，视频结束
CV_CAP_PROP_FRAME_WIDTH	视频流中的帧宽
CV_CAP_PROP_FRAME_HEIGHT	视频流中的帧高
CV_CAP_PROP_FPS	帧率
CV_CAP_PROP_FOURCC	返回解码方式中的四字符
CV_CAP_PROP_FRAME_COUNT	视频文件的总帧数
CV_CAP_PROP_FORMAT	由retrieve()函数返回的矩阵对象的格式
CV_CAP_PROP_MODE	用于预测当前捕获模式的后端专用值
CV_CAP_PROP_BRIGHTNESS	图像的亮度（仅用于摄像头）
CV_CAP_PROP_CONTRAST	图像的对比度（仅用于摄像头）
CV_CAP_PROP_SATURATION	图像的饱和度（仅用于摄像头）
CV_CAP_PROP_HUE	图像的色调（仅用于摄像头）
CV_CAP_PROP_GAIN	图像增益（仅用于摄像头）
CV_CAP_PROP_EXPOSURE	曝光度（仅用于摄像头）
CV_CAP_PROP_CONVERT_RGB	用于预测图像是否应该被转换为RGB的布尔位
CV_CAP_PROP_WHITE_BALANCE	白平衡（当前不支持）
CV_CAP_PROP_RECTIFICATION	立体相机的纠正位

VideoCapture.isOpened

参数：无
作用：判断设备/文件是否读取成功，若成功，返回True

VideoCapture.release

参数：无
作用：关闭文件/摄像头

VideoCapture.read

参数：无
返回值：bool，numpy.array
作用：读取该文件/摄像头的下一帧，成功与否由bool返回值决定，返回的帧矩阵为第二个参数

VideoWriter类

cv2.VideoWriter

原型：cv2.VideoWriter(*args,**kwargs)

参数：第一个，写入的视频文件名。第二个，由cv2.VideoWriter_fourcc返回的视频制式特定代码，通常有XVID，MPEG等。第三个，该视频的fps。第四个，一个tuple，为该视频的宽、高。

参数名称	解释
CV_FOURCC(‘P’, ‘I’, ‘M’, ‘1’)	MPEG-1 codec
CV_FOURCC(‘M’, ‘J’, ‘P’, ‘G’)	motion-jpeg codec
CV_FOURCC(‘M’, ‘P’, ‘4’, ‘2’)	MPEG-4.2 codec
CV_FOURCC(‘D’, ‘I’, ‘V’, ‘3’)	MPEG-4.3 codec
CV_FOURCC(‘D’, ‘I’, ‘V’, ‘X’)	MPEG-4 codec
CV_FOURCC(‘U’, ‘2’, ‘6’, ‘3’)	H263 codec
CV_FOURCC(‘I’, ‘2’, ‘6’, ‘3’)	H263I codec
CV_FOURCC(‘F’, ‘L’, ‘V’, ‘1’)	FLV1 codec
CV_FOURCC(‘X’, ‘V’, ‘I’, ‘D’)	MPEG-4 decode

VideoWriter.write

原型：VideoCapture.write(image)
作用：将当前帧内容写入视频文件
参数：image，写入的当前帧

参考博客：

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】