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

目录

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、图像直方图详解——定义、计算、均衡、比较、反射投影

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的知识）

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、均值模糊、中值模糊，高斯模糊，双边模糊

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

模糊操作基本原理：

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---超大图像二值化和空白区域过滤

• 原型：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，写入的当前帧

 

参考博客：

• https://blog.csdn.net/weixin_40427089/article/details/81365076
• https://www.cnblogs.com/zlel/p/9267629.html