【基础知识】4、python-opencv 超详细介绍_opencv-python

一、概述

和Python一样，当前的OpenCV也有两个大版本，OpenCV2和OpenCV3。相比OpenCV2，OpenCV3提供了更强的功能和更多方便的特性。不过考虑到和深度学习框架的兼容性，以及上手安装的难度，这部分先以2为主进行介绍。

根据功能和需求的不同，OpenCV中的函数接口大体可以分为如下部分：

• core：核心模块，包含OpenCV最基本的结构（矩阵，点线和形状等），和相关的基础运算/操作。
• imgproc：图像处理模块，包含图像基础功能（滤波，梯度，改变大小等），以及衍生的高级功能（图像分割，直方图，形态分析和边缘/直线提取等）。
• highgui：提供了用户界面、文件读取的基本函数，比如图像显示窗口的生成和控制，图像/视频文件的IO等。

如果不考虑视频应用，以上三个就是最核心和常用的模块了。针对视频和一些特别的视觉应用，OpenCV也提供了强劲的支持：

• video：用于视频分析的常用功能，比如光流法（Optical Flow）和目标跟踪等。
• calib3d：三维重建，立体视觉和相机标定等的相关功能。
• features2d：二维特征相关的功能，主要是一些不受专利保护的，商业友好的特征点检测和匹配等功能，比如ORB特征。
• object：目标检测模块，包含级联分类和Latent SVM
• ml：机器学习算法模块，包含一些视觉中最常用的传统机器学习算法。
• flann：最近邻算法库，Fast Library for Approximate Nearest Neighbors，用于在多维空间进行聚类和检索，经常和关键点匹配搭配使用。
• gpu：包含了一些gpu加速的接口，底层的加速是CUDA实现。
• photo：计算摄像学（Computational Photography）相关的接口，当然这只是个名字，其实只有图像修复和降噪而已。
• stitching：图像拼接模块，有了它可以自己生成全景照片。
• nonfree：受到专利保护的一些算法，其实就是SIFT和SURF。
• contrib：一些实验性质的算法，考虑在未来版本中加入的。
• legacy：字面是遗产，意思就是废弃的一些接口，保留是考虑到向下兼容。
• ocl：利用OpenCL并行加速的一些接口。
• superres：超分辨率模块，其实就是BTV-L1（Biliteral Total Variation – L1
  regularization）算法
• viz：基础的3D渲染模块，其实底层就是著名的3D工具包VTK（Visualization Toolkit）。

从使用的角度来看，和 OpenCV2 相比，OpenCV3的主要变化是更多的功能和更细化的模块划分。

1.1 安装

在 mac 的 pycharm，可在 settings 里安装 opencv-python 库，而且这样可在 IDE 跳转到 opencv 源码，代码也有补全提示：

1.2 图像的表示

已知单通道的灰度图像在计算机中的表示是一个8位无符号整形的矩阵，在opencv的C++代码中，表示图像有专门的结构cv::Mat，但python中有numpy这种强大的基础工具，所以该矩阵就用numpy的array表示，多通道就是红绿蓝（RGB）三通道。

常见测试图片

urls = [
    "https://pyimagesearch.com/wp-content/uploads/2015/01/opencv_logo.png",
    "https://pyimagesearch.com/wp-content/uploads/2015/01/google_logo.png",
    "https://www.cosy.sbg.ac.at/~pmeerw/Watermarking/lena_color.gif",
    "https://www.cosy.sbg.ac.at/~pmeerw/Watermarking/lena_gray.gif"
]
1
2
3
4
5
6

二、图像

2.1 读、存、显示、下载

2.1.1 读存显示：imread()、imwrite()

可按不同模式读取，一般最常用到的是读单通道灰度图，或者直接默认读多通道

# 读取多通道图
import cv2
color_img=cv2.imread('4.jpg')
print(color_img.shape) # 输出 (720, 1280, 3)

# 读取单通道图
gray_img=cv2.imread('4.jpg',cv2.IMREAD_GRAYSCALE)
print(gray_img.shape) # 输出 (720, 1280)

# 把单通道图保存后，再读取，仍然是3通道，相当于将单通道复制到3个通道保存
cv2.imwrite('grayscale_4.jpg',gray_img)
reload_grayscale=cv2.imread('grayscale_4.jpg')
print(reload_grayscale.shape) # 输出 (720, 1280, 3)

# 指定jpg质量，范围从1~100，默认95，值越高画质越好，文件越大
cv2.imwrite('anglababy.jpg',color_img,(cv2.IMWRITE_JPEG_QUALITY,20))
# -rw-r--r--@ 1 y  staff   255K Aug  4 10:37 原图.jpg # 原图为 255K
# -rw-r--r--@ 1 y  staff    21K Aug 11 11:15 x.jpg # 质量为1时, 文件为21K
# -rw-r--r--@ 1 y  staff    62K Aug 11 11:15 x.jpg # 质量为20时, 文件为62K
# -rw-r--r--@ 1 y  staff   545K Aug 11 11:16 d.jpg # 质量为100时, 文件为545K

cv2.imshow('my_img_name', color_img) # 显示图片
cv2.waitKey(0) # 阻塞等键盘输入, 使图片展示而不被关闭
cv2.destroyAllWindows()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

2.1.2 下载

2.1.2.1 urllib

import numpy as np
import urllib.request
import cv2

def url_to_image(url):
    resp = urllib.request.urlopen(url)  # 下载图片
    image = np.asarray(bytearray(resp.read()), dtype="uint8")  # numpy 格式, 即一维array
    image = cv2.imdecode(image, cv2.IMREAD_COLOR)  # 转换为opencv 的格式, 即每个点分别含r/g/b
    return image

if __name__ == '__main__':
    urls = ["https://www.cosy.sbg.ac.at/~pmeerw/Watermarking/lena_color.gif",]
    for url in urls:
        print("downloading %s", url)
        image = url_to_image(url)
        cv2.imshow("a", image)
        cv2.waitKey(0)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

2.1.2.2 scikit-image

if __name__ == '__main__':
    urls = ["https://www.cosy.sbg.ac.at/~pmeerw/Watermarking/lena_color.gif"]
    for url in urls:
        print("downloading %s", url)
        image = io.imread(url)
        # cv2.imshow("错误方式, 因为 opencv 用 BGR 格式，而 scikit-image 用 RGB，所以必须要转换的", image)
        cv2.imshow("正确方式", cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
        cv2.waitKey(0)
1
2
3
4
5
6
7
8

注意要转换 BGR，左图是错的，右图是对的。

2.2 变换

2.2.1 缩放、裁剪、补边

• 缩放：cv2.resize()
• 裁剪：利用array下标截取实现

import cv2
img=cv2.imread('a.jpg')
img_200x200=cv2.resize(img,(200,200)) # 缩小为200x200的正方形
img_half=cv2.resize(img,(0,0),fx=0.5,fy=0.5,interpolation=cv2.INTER_NEAREST)# 通过fx和fy可指定长宽缩放比例(值域0~1), 插值方法默认为cv2.INTER_LINEAR线性插值, INTER_NEAREST为最近邻插值
img_add=cv2.copyMakeBorder(img,50,50,0,0,cv2.BORDER_CONSTANT,value=(0,0,0)) # 上下各贴50像素的黑边, 左右各贴0像素的黑边
patch_img=img[20:150, -180:-50] # 裁剪, 用来提取图像中感兴趣区域。表示选取img数组的行索引从20到149（不包括150）的部分，以及列索引从倒数第180到倒数第51（不包括倒数第50）的部分。换句话说，它选择了img矩阵的第21到第150行和倒数第180到倒数第51列之间的区域。
1
2
3
4
5
6

2.2.2 HSV(色调、饱和度、明暗）、直方图、Gamma曲线

比如可以通过HSV空间对色调和明暗进行调节。HSV空间是一种颜色空间，即色调（Hue），饱和度（Saturation）和明暗度（Value）。在HSV空间中进行调节就避免了直接在RGB空间中调节时还需要考虑三个通道的相关性。OpenCV中H的取值是[0, 180)，其他两个通道的取值都是[0, 256)，下面例子接着上面例子代码，通过HSV空间对图像进行调整：

import cv2
img=cv2.imread('a.jpg')
img_hsv=cv2.cvtColor(img,cv2.COLOR_BGR2HSV) # 通过cv2.cvtcolor把图像从RGB转到HSV

# 色调H，因为绿色比黄色值高，所以给每个像素+15，黄色的就会变绿
turn_green_hsv=img_hsv.copy()
turn_green_hsv[:,:,0]=(turn_green_hsv[:,:,0]+15)
turn_green_img=cv2.cvtColor(turn_green_hsv,cv2.COLOR_HSV2BGR)
cv2.imshow("turn_green_img",turn_green_img)
cv2.waitKey(0)

# 饱和度S, 减小饱和度会让图像损失鲜艳，变得更灰
colorless_hsv=img_hsv.copy()
colorless_hsv[:,:,1]=colorless_hsv[:,:,1] * 0.5
colorless_img=cv2.cvtColor(colorless_hsv,cv2.COLOR_HSV2BGR)
cv2.imshow("colorless_img",colorless_img)
cv2.waitKey(0)

# 明暗度V, 减小为原来的一半
darker_hsv=img_hsv.copy()
darker_hsv[:,:,2]=darker_hsv[:,:,2] * 0.5
darker_img=cv2.cvtColor(darker_hsv,cv2.COLOR_HSV2BGR)
cv2.imshow("darker_img",darker_img)
cv2.waitKey(0)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

直方图：方便对图像的像素值分布了解更清晰，低的像素值表示暗的部分，高的值表示亮度大的部分，但是显示的时候可能就出现了暗部细节不足或者亮部细节丢失的情况。

Gamma变换：是矫正「相机直接成像」和「人眼感受图像」差别的一种常用手段，其通过非线性变换让图像从「对曝光强度的线性响应」变得「更接近人眼感受到的响应」，提升暗度细节。

import numpy as np
import cv2
import matplotlib.pylab as plt
from mpl_toolkits.mplot3d import Axes3D

img=cv2.imread('a.jpg')

# 分通道计算每个通道的直方图
hist_b=cv2.calcHist([img],[0],None,[256],[0,256])
hist_g=cv2.calcHist([img],[1],None,[256],[0,256])
hist_r=cv2.calcHist([img],[2],None,[256],[0,256])

# Gamma变换的函数
def gamma_trans(img,gamma):
    # 先归一化到1，之后利用gamma作为指数求出新值，再还原
    gamma_table=[np.power(x/255.0,gamma)*255.0 for x in range(256)]
    gamma_table=np.round(np.array(gamma_table)).astype(np.uint8)
    return cv2.LUT(img,gamma_table) # 用opencv的查表函数实现该映射

# 执行Gamma变换，小于1的值让暗细节大量提升，同时亮部细节少量提升
img_corrected=gamma_trans(img,0.5)
cv2.imshow("img",img)
cv2.imshow("img_corrected",img_corrected)
# cv2.waitKey(0)

# 分通道计算Gamma矫正后的直方图
hist_b_corrected=cv2.calcHist([img_corrected],[0],None,[256],[0,256])
hist_g_corrected=cv2.calcHist([img_corrected],[1],None,[256],[0,256])
hist_r_corrected=cv2.calcHist([img_corrected],[2],None,[256],[0,256])

# 直方图可视化
fig=plt.figure()
pix_hists=[
    [hist_b,hist_g,hist_r],
    [hist_b_corrected,hist_g_corrected,hist_r_corrected]
]
pix_vals=range(256)

for sub_plt, pix_hist in zip([121,122], pix_hists):
    ax = fig.add_subplot(sub_plt, projection='3d')
    for c, z, channel_hist in zip(['b','g','r'],[20,10,0],pix_hist):
        channel_hist = channel_hist.reshape(256)
        cs = [c]*256
        ax.bar(pix_vals, channel_hist, zs=z, zdir='y', color=cs, alpha=0.618, edgecolor='none',lw=0)
    ax.set_xlabel('Pixel Values')
    ax.set_xlim([0,256])
    ax.set_ylabel('Channels')
    ax.set_zlabel('Counts')

plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

2.2.3 仿射变换

仿射变换常用于图像预处理，主要是对图像的缩放，旋转，剪切，翻转和平移的组合。在OpenCV中，仿射变换矩阵是一个2×3的矩阵，其中左边的2×2子矩阵是线性变换矩阵，右边的2×1的两项是平移项：

对于图像上的任一位置(x,y)，仿射变换执行的是如下的操作：

需注意，对于图像而言，宽度方向是x，高度方向是y，坐标的顺序和图像像素对应下标一致。所以原点的位置不是左下角而是右上角，y的方向也不是向上，而是向下。在OpenCV中通过仿射变换矩阵和 cv2.warpAffine() 函数实现仿射变换：

import numpy as np
import cv2

img = cv2.imread('a.jpg')

# 沿着横纵轴放大1.6倍，之后平移（-150，-240），最后沿原图大小截取，等效于剪裁并放大
M_crop = np.array([
    [1.6, 0, -150],
    [0, 1.6, -240]
], dtype=np.float32)

img_a = cv2.warpAffine(img, M_crop, (400, 400))  # cv2.warpAffine(原始图像, 变换矩阵,变换后的图像大小)
cv2.imshow("img_a", img_a)

# x轴的剪切变换，逆时针旋转角度15°
theta = 15 * np.pi / 180
M_shear = np.array([
    [1, np.tan(theta), 0],
    [0, 1, 0]
], dtype=np.float32)

img_sheared = cv2.warpAffine(img, M_shear, (400, 600))
cv2.imshow("img_sheared", img_sheared)

# 顺时针旋转，角度15°
M_rotate = np.array([
    [np.cos(theta), -np.sin(theta), 0],
    [np.sin(theta), np.cos(theta), 0]
], dtype=np.float32)

im_rotate = cv2.warpAffine(img, M_rotate, (400, 600))
cv2.imshow("im_rotate", im_rotate)

# 旋转+缩放+旋转组合，可以通过SVD分解理解
M = np.array([
    [1, 1.5, -400],
    [0.5, 2, -100]
], dtype=np.float32)

img_transformed = cv2.warpAffine(img, M, (400, 600))
cv2.imshow("img_transformed", img_transformed)
cv2.waitKey(0)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

2.2.4 渲染文字、图形

def hex_to_rgb(s):
    hex = s[1:]
    r = int(hex[0:2], 16)
    g = int(hex[2:4], 16)
    b = int(hex[4:6], 16)
    return tuple([r, g, b])  # 将 list 转为 tuple
colors = {8001: hex_to_rgb('#0C78B7'),8002: hex_to_rgb('#F54257')}
cns = {8001: '类别1',8002: '类别2'}


def cvPutTextChinese(img, text, position, textColor, textSize=20):  # 渲染中文字
    draw = ImageDraw.Draw(img)  # 创建一个可以在给定图像上绘图的对象
    fontStyle = ImageFont.truetype("simsun.ttc", textSize, encoding="utf-8")  # 此字体支持中文
    draw.text(position, text, fill=textColor, font=fontStyle, encoding="unic", stroke_width=2, stroke_fill=(255, 255, 255))  # 绘制文本, 其中stroke_fill是描边填充颜色
    return np.asarray(img)


def draw(url, objs): # 在图上渲染中文和矩形
    img = downloadImg(url)
    for obj in objs:
        uid, confidence = int(obj['UID']), round(obj['Confidence'], 3)
        x, y, w, h = obj['Box']['X'], obj['Box']['Y'], obj['Box']['Width'], obj['Box']['Height']
        if uid not in colors:  # invalid uid
            continue
        # cv2.putText(img, cns[uid], (x, y), fontFace=cv2.FONT_HERSHEY_SIMPLEX, fontScale=1.5, color=colors[uid], thickness=3) # 若只显示非中文, 用此原生函数即可
        img = Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2RGB)) # 因 opencv 的 img 是 BGR, 而 传入的 fontColor 是 RGB, 故需先将 img 转为 RGB
        img = cvPutTextChinese(img, cns[uid], (x, y), textColor=colors[uid])
        cv2.rectangle(img, (x, y), (x + w, y + h), color=colors[uid], thickness=2)
        img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR) # 运算后, 再从 RGB 转为 opencv 的 BGR
    cv2.imwrite(str(uid) + ".jpg", img)
    cv2.imshow('', img)
    cv2.waitKey(0)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

三、视频

3.1 录制

import os
import cv2
from utils import load_coefficients

if __name__ == "__main__":
    vidcap = cv2.VideoCapture(0)
    vidcap.set(cv2.CAP_PROP_FRAME_WIDTH, 1920)
    vidcap.set(cv2.CAP_PROP_FRAME_HEIGHT, 1080)
    vidcap.set(cv2.CAP_PROP_FPS, 30)
    vidcap.set(cv2.CAP_PROP_FOURCC, cv2.VideoWriter_fourcc('M', 'J', 'P', 'G'))

    # 参数文档
    # https://blog.csdn.net/m0_37605642/article/details/121045914
    # https://docs.opencv.org/4.6.0/d4/d15/group__videoio__flags__base.html#ggaeb8dd9c89c10a5c63c139bf7c4f5704da95753013fd8f0c0af3f743dc0293844b

    # 以下参数设置参考软件，AMCap.exe，对该设备的默认设置读取
    vidcap.set(cv2.CAP_PROP_BRIGHTNESS, 0)  # 亮度
    vidcap.set(cv2.CAP_PROP_CONTRAST, 32)  # 对比度
    vidcap.set(cv2.CAP_PROP_SATURATION, 64)  # 饱和度
    vidcap.set(cv2.CAP_PROP_HUE, -4)  # 色调
    vidcap.set(cv2.CAP_PROP_GAIN, 0)  # 图像增益
    vidcap.set(cv2.CAP_PROP_GAMMA, 100)  # 伽马
    vidcap.set(cv2.CAP_PROP_BACKLIGHT, 0)  # 逆光对比
    # vidcap.set(cv2.CAP_PROP_AUTO_EXPOSURE, 3)# 自动曝光开启
    vidcap.set(cv2.CAP_PROP_AUTO_WB, 3)  # 自动白平衡开启
    # vidcap.set(cv2.CAP_PROP_AUTOFOCUS, 3)# 自动聚焦开启

    frame_count = int(3000000000)
    frame_height = int(vidcap.get(cv2.CAP_PROP_FRAME_HEIGHT))
    frame_width = int(vidcap.get(cv2.CAP_PROP_FRAME_WIDTH))
    fps = vidcap.get(cv2.CAP_PROP_FPS)  # 视频平均帧率
    print(fps)

    save_path = os.path.join("./output_vis_3")
    os.makedirs(save_path, exist_ok=True)

    outcap = cv2.VideoWriter(os.path.join(save_path, "output.mp4"),
                             cv2.VideoWriter_fourcc('M', 'P', '4', 'V'), fps, (frame_width, frame_height))
    # Load coefficients
    mtx, dist = load_coefficients('calibration_chessboard.yml')
    count = 0
    while vidcap.isOpened():
        ret, image_bgr = vidcap.read()
        # image_bgr = cv2.undistort(image_bgr, mtx, dist, None, None)
        count += 1
        if count > frame_count:
            break
        if not ret:
            continue
        cv2.imshow("img", image_bgr)
        if cv2.waitKey(1) == ord('q'):  # 录屏可视化逻辑
            break
        # 标定保存图片逻辑
        # if cv2.waitKey(1) == ord('c'):
        #     img_file = os.path.join(save_path, 'pose_{:08d}.jpg'.format(count))
        #     cv2.imwrite(img_file, image_bgr)
        outcap.write(image_bgr)

    vidcap.release()
    outcap.release()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60