【Python】OpenCV常用操作函数大全！

左手的ㄟ右手 2024-04-18 19:17 88阅读 0赞

**目录**

cv2常用类：

1、图片加载、显示和保存

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

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

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

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

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

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

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

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

10、计算执行时间

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

12、彩色空间转换

13、cv2.inRange(hsv, lower\_hsv, upper\_hsv)

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

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

cv2.blur

cv2.medianBlur

cv2.GaussianBlur

cv2.bilateralFilter

15、二值化（cv2.threshold）

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

17、模板匹配

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

19、图像梯度

cv2.Sobel

cv2.scharr

cv2.Laplacian

VideoCapture 类

cv2.VideoCapture

VideoCapture.get

VideoCapture.isOpened

VideoCapture.release

VideoCapture.read

VideoWriter类

cv2.VideoWriter

VideoWriter.write

**整理不易，点个赞加个关注吧！**

--------------------

# cv2常用类： #

## 1、图片加载、显示和保存 ##

*  **cv2.imread(filename, flags) ：读取加载图片**
 *  **cv2.imshow(winname, mat) ： 显示图片**
 *  **cv2.waitKey() ： 等待图片的关闭**
 *  **cv2.imwrite(filename, img) ： 保存图片**

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**） ##

> 1.  一个图片img，它的某个像素点可以用 img\[x, y, c\] 表示（x，y为坐标，c为通道数）
> 2.  同理，这个图片的某个矩形区域可以表示为：img\[x1:x2, y1:y2, c\]（相当于截下一块矩形，左上角坐标为（x1, y1），右下角坐标为（x2, y2））
> 3.  其中 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的知识） ##

> ![vici][]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)

## ![70][] ##

## 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**的取值。**![2019100922403577.png][]**

# 颜色追踪
    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、均值模糊、中值模糊，高斯模糊，双边模糊 ##

> ### 附一篇博客：[真正搞懂均值模糊、中值模糊、高斯模糊、双边模糊][Link 2] ###
> 
> **模糊操作基本原理：**
> 
> 1.  基于离散卷积
> 2.  定义好每个卷积核
> 3.  不同卷积核得到不同的卷积效果
> 4.  模糊是卷积的一种表象

### 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---]
>  *  [OpenCV---超大图像二值化和空白区域过滤][OpenCV--- 1]

*  原型：**threshold(src,thresh,maxval,type,dst=None)**
 *  作用：将图像的每个像素点进行**二值化**
 *  参数：thresh，阈值（最小值）。maxval，二值化的最大取值。  
    type，二值化类型，一般设为0，也可以取以下的值：  
      
    ![70 1][]
    
      
    ![70 2][]
 *  返回值：计算过后的阈值值和二值化后的图像（如果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、图像直方图 ##

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

## 17、模板匹配 ##

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

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

> 函数：**matchTemplate(image, templ, method, result=None, mask=None)**
> 
> 参数：
> 
>  *  **image：**源图像S；
>  *  **templ：**模板图像T，一般是源图像S中的一小块；
>  *  **method：**模板匹配算法（cv.TM\_SQDIFF\_NORMED最小时最相似，其他最大时最相似）  
>     ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1ZpY2lfXw_size_16_color_FFFFFF_t_70][]

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()

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1ZpY2lfXw_size_16_color_FFFFFF_t_70 1][]

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

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

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

> 推荐博客：[OpenCV---图像金字塔原理][OpenCV--- 2]

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方向。

卷积因子：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1ZpY2lfXw_size_16_color_FFFFFF_t_70 2][]

>  *  原型： 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就行。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1ZpY2lfXw_size_16_color_FFFFFF_t_70 3][]

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邻域。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1ZpY2lfXw_size_16_color_FFFFFF_t_70 4][]

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

## 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，为该视频的宽、高。
 
 <table style="width:500px;"> 
 <tbody> 
 <tr> 
 <td> 参数名称 </td> 
 <td> 解释 </td> 
 </tr> 
 <tr> 
 <td> CV_FOURCC(‘P’, ‘I’, ‘M’, ‘1’)&nbsp; </td> 
 <td> MPEG-1 codec </td> 
 </tr> 
 <tr> 
 <td> CV_FOURCC(‘M’, ‘J’, ‘P’, ‘G’)&nbsp; </td> 
 <td> motion-jpeg codec </td> 
 </tr> 
 <tr> 
 <td> CV_FOURCC(‘M’, ‘P’, ‘4’, ‘2’)&nbsp; </td> 
 <td> MPEG-4.2 codec </td> 
 </tr> 
 <tr> 
 <td> CV_FOURCC(‘D’, ‘I’, ‘V’, ‘3’) </td> 
 <td> MPEG-4.3 codec </td> 
 </tr> 
 <tr> 
 <td> CV_FOURCC(‘D’, ‘I’, ‘V’, ‘X’) </td> 
 <td> MPEG-4 codec </td> 
 </tr> 
 <tr> 
 <td> CV_FOURCC(‘U’, ‘2’, ‘6’, ‘3’) </td> 
 <td> H263 codec </td> 
 </tr> 
 <tr> 
 <td> CV_FOURCC(‘I’, ‘2’, ‘6’, ‘3’) </td> 
 <td> H263I codec </td> 
 </tr> 
 <tr> 
 <td> CV_FOURCC(‘F’, ‘L’, ‘V’, ‘1’) </td> 
 <td> FLV1 codec </td> 
 </tr> 
 <tr> 
 <td> CV_FOURCC(‘X’, ‘V’, ‘I’, ‘D’)&nbsp; </td> 
 <td> MPEG-4 decode </td> 
 </tr> 
 </tbody> 
 </table>

## VideoWriter.write ##

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

**参考博客：**

*  [https://blog.csdn.net/weixin\_40427089/article/details/81365076][https_blog.csdn.net_weixin_40427089_article_details_81365076]
 *  [https://www.cnblogs.com/zlel/p/9267629.html][https_www.cnblogs.com_zlel_p_9267629.html]

[Link 1]: https://blog.csdn.net/Vici__/article/details/102525679
[vici]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/ef81c5dcff684545ac531be8caec56cb.png
[70]: https://img-blog.csdn.net/20180806141606407?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDQyNzA4OQ==/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70
[2019100922403577.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/204163cae1cf421aaddfb5be801976e4.png
[Link 2]: https://blog.csdn.net/Vici__/article/details/102476784
[OpenCV---]: https://www.cnblogs.com/ssyfj/p/9272615.html
[OpenCV--- 1]: https://www.cnblogs.com/ssyfj/p/9273116.html
[70 1]: https://img-blog.csdn.net/20180806142251571?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDQyNzA4OQ==/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70
[70 2]: https://img-blog.csdn.net/20180806142309297?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDQyNzA4OQ==/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1ZpY2lfXw_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/6d25d7d4e2234eb494793c218dbb30d9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1ZpY2lfXw_size_16_color_FFFFFF_t_70 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/dbda8e3728a94e95a9406d6c161867e5.png
[OpenCV--- 2]: https://www.cnblogs.com/ssyfj/p/9273643.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1ZpY2lfXw_size_16_color_FFFFFF_t_70 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/f7467da2a86d4d90893e1c726a70a829.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1ZpY2lfXw_size_16_color_FFFFFF_t_70 3]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/3c9adb493a93446a831e04325ad49564.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1ZpY2lfXw_size_16_color_FFFFFF_t_70 4]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/493421a5f0b04b10b1297bf4bad93ed6.png
[https_blog.csdn.net_weixin_40427089_article_details_81365076]: https://blog.csdn.net/weixin_40427089/article/details/81365076
[https_www.cnblogs.com_zlel_p_9267629.html]: https://www.cnblogs.com/zlel/p/9267629.html