【Python】OpenCV库中常用函数详解和示例

在Python中，OpenCV（Open Source Computer Vision Library）是一个广泛使用的图像和视频处理库。它包含许多用于图像处理和计算机视觉任务的函数。本文对一些常用的OpenCV函数及其详细解释和示例，以帮助大家理解和使用。

cv2.imread（）

函数解析

cv2.imread() 是OpenCV库中的一个函数，用于读取图像文件。这个函数将图像读入为NumPy数组，适合处理.jpg，.png，.bmp，.tiff等常见格式的图像。

函数原型为：cv2.imread(filename, flags=1)

其中，filename 是要读取的图像文件的名称（包括路径，如果图像不在当前工作目录下）。
flags 参数用于指定读图的方式，它是一个可选参数，默认值为1。它可以接受的正整数值有以下几种可能：

1. cv2.IMREAD_COLOR：这是默认值，用于读取一张彩色图像。这种模式下，图像的三个通道分别是BGR（蓝，绿，红）。这种模式是直接从文件中读取RGB值。
2. cv2.IMREAD_GRAYSCALE：以灰度模式读取图像。
3. cv2.IMREAD_UNCHANGED：读取图像包括alpha通道。
4. 0：不进行任何操作，只读取文件信息。
5. -1：读取图像并检查其大小（如果需要的话）为8位、16位、32位或浮点型。


函数返回值是一个NumPy数组，它表示读取的图像。如果读取失败（例如文件不存在或无法打开），函数将返回None。
1
2
3
4
5
6
7
8
9
10
11
12
13

运行示例

import cv2
img1 = cv2.imread('image.jpg') 
img2 = cv2.imread('image.jpg', cv2.IMREAD_GRAYSCALE)  # 读取灰度图像
cv2.imshow('image1', img1)
cv2.imshow('image2', img2)
cv2.waitKey(0)

1
2
3
4
5
6
7

运行展示结果：

可以看到，改变flags 参数的值，尽管读取的是同一幅图像中但一个显示的是彩色图一个是灰度图。

**注意：**由于cv2.imread()函数会根据指定的模式（flags）读取图像，因此其返回的图像数据类型可能不同。例如，如果以cv2.IMREAD_GRAYSCALE模式读取图像，则返回的图像将是灰度图，数据类型为uint8；如果以cv2.IMREAD_COLOR模式读取图像，则返回的图像将是彩色图，数据类型通常为uint8，但也可能为float32或double，具体取决于读取的图像数据是否能被准确地表示为uint8。

cv2.imshow（）、cv2.waitKey()、cv2.destroyAllWindows()

这三个函数都是OpenCV库中的函数，用于显示和关闭图像窗口。

cv2.imshow()

cv2.imshow('image', img)：

参数：第一个参数是窗口名称，第二个参数是要显示的图像。

解释：这个函数用于在窗口中显示图像。如果你已经有了一个名为'image'的窗口，调用这个函数会覆盖该窗口中的图像。如果你没有名为'image'的窗口，这个函数会创建一个新窗口。
1
2
3
4
5

cv2.waitKey()

cv2.waitKey(0)

参数：该函数只有一个参数，通常是0或者是一个大于0的整数。
解释：这个函数会等待用户按下键盘上的任意键。参数0表示无限等待。如果参数大于0，函数会等待指定的毫秒数。例如，cv2.waitKey(5000)将等待5秒。如果在这段时间内用户按下了任意键，程序将继续执行；否则，程序将继续等待。
1
2
3
4
5
6

cv2.destroyAllWindows()

cv2.destroyAllWindows()

参数：该函数没有参数。
解释：这个函数会关闭所有由OpenCV创建的窗口。如果你在调用cv2.imshow()后想要确保窗口被关闭，通常会在显示完图像后调用这个函数。注意，这个函数不会影响由其他库（如matplotlib）创建的窗口。
1
2
3
4

示例

import cv2
img = cv2.imread('115.jpg')
cv2.imshow('image', img)
cv2.waitKey(0)
cv2.destroyAllWindows()
1
2
3
4
5

读取图像，然后显示在“image”的窗口中，手动按任意键程序继续，最后关闭窗口。

cv2.cvtColor()

函数解析

cv2.cvtColor() 是 OpenCV 库中的一个函数，用于将图像从一种颜色空间转换到另一种颜色空间。这个函数非常有用，因为不同的颜色空间可以提供不同的图像处理和分析视角。

函数原型为：

cv2.cvtColor(src, code)

参数详解：

src: 源图像，这应该是一个 NumPy 数组。
code: 转换的标识符，这是一个整数，用于指定目标颜色空间。可能的值包括：
cv2.COLOR_BGR2BGRA：从 BGR 到 BGRA。
cv2.COLOR_RGB2RGBA：从 RGB 到 RGBA。
cv2.COLOR_BGRA2BGR：从 BGRA 到 BGR。
cv2.COLOR_RGBA2RGB：从 RGBA 到 RGB。
cv2.COLOR_BGR2GRAY：从 BGR 到灰度。
cv2.COLOR_RGB2GRAY：从 RGB 到灰度。
cv2.COLOR_GRAY2BGR：从灰度到 BGR。
cv2.COLOR_GRAY2RGB：从灰度到 RGB。
cv2.COLOR_BGR2RGB：从 BGR 到 RGB。
cv2.COLOR_RGB2BGR：从 RGB 到 BGR。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

运行示例

import cv2
img = cv2.imread('image.jpg')
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
1
2
3

可以看到，用该函数转为灰度图的效果和cv2.imread（）函数读取时设置为灰度图类似。

cv2.blur（）

cv2.blur() 是 OpenCV 库中的一个函数，也被称为盒形滤波。它是一种简单平滑（滤波）技术，用于减小图像噪声和细节。该操作对于大多数图像是向下采样（分辨率降低）的。

函数原理

函数原型为：
cv2.blur(src, ksize[, dst[, anchor[, borderType]]])

参数详解：

src: 输入图像。
ksize: 滤波器的大小，这必须是奇数，如 (5,5)。
dst: 输出图像。
anchor: 锚点，定义了滤波器的参考点。默认值为 (-1,-1)。
borderType: 定义在滤波过程中使用的像素边界类型。默认值为 cv2.BORDER_DEFAULT。
1
2
3
4
5
6
7
8
9
10

运行示例

import cv2

# 读取图像
img = cv2.imread('115.jpg')

# 应用模糊操作
blurred = cv2.blur(img, (5,5))  # 使用5x5的滤波器

# 显示原始和模糊图像
cv2.imshow('Original Image', img)
cv2.imshow('Blurred Image', blurred)

cv2.waitKey(0)
cv2.destroyAllWindows()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

运行输出效果：

可以看到，处理后的图像变得模糊，尤其是在数字细节处。

cv2.threshold（）

cv2.threshold 是 OpenCV 库中的一个函数，主要用于对灰度图像进行阈值化处理，也就是将图像的像素值进行分类。这个函数的基本原理是将图像的每个像素值与设定的阈值进行比较，然后根据比较结果将像素值设置为0或255。

函数解析

函数原型：
cv2.threshold(src, thresh, maxval, type)

参数：
src: 输入图像，必须是8位或32位的单通道图像。
thresh: 阈值，是一个0到255之间的整数。
maxval: 当源图像的像素值大于（或小于）阈值时要赋予的值。如果最大值大于最大允许值（32767），则最大值被设置为最大允许值。
type: 阈值类型，有以下几种选择：cv2.THRESH_BINARY, cv2.THRESH_BINARY_INV, cv2.THRESH_TRUNC, cv2.THRESH_TOZERO, cv2.THRESH_TOZERO_INV。

阈值类型的解释：
cv2.THRESH_BINARY: 超过阈值的像素被赋予最大值，低于阈值的像素被赋予0。
cv2.THRESH_BINARY_INV: 低于阈值的像素被赋予最大值，超过阈值的像素被赋予0。
cv2.THRESH_TRUNC: 超过阈值的像素被赋予阈值。
cv2.THRESH_TOZERO: 低于阈值的像素被赋予0，超过阈值的像素被赋予最大值。
cv2.THRESH_TOZERO_INV: 超过阈值的像素被赋予0，低于阈值的像素被赋予最大值。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

运行示例

import cv2

# 读取图像并转换为灰度图像
image = cv2.imread('115.jpg')
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# 使用cv2.threshold进行阈值化处理
ret, thresh = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)

# 显示原始图像和阈值化后的图像
cv2.imshow('Original Image', image)
cv2.imshow('Thresholded Image', thresh)
cv2.imwrite('thread.jpg',thresh)
cv2.waitKey(0)
cv2.destroyAllWindows()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

上面的代码读取一个名为 ‘115.jpg’ 的图像文件，将其转换为灰度图像，并使用 cv2.threshold 函数进行阈值化处理。然后，它在窗口中显示原始图像和阈值化后的图像。运行输出效果如下图：

cv2.drawContours（）

cv2.drawContours 是 OpenCV 库中的一个函数，用于在图像上绘制轮廓。它可以在二维或三维图像上绘制连续的轮廓。

函数解析

函数原型：

函数原型：
cv2.drawContours(image, contours, contourIndex, color[, thickness[, font[, fontScale[, label[, offset ]]]])

参数：
image: 要绘制轮廓的图像，可以是彩色图像或灰度图像。
contours: 轮廓的集合，可以是嵌套的列表或者单独的列表。每个轮廓是一个点数组，表示对象的边界。
contourIndex: 要绘制的轮廓的索引。如果为负数，则绘制所有轮廓。
color: 轮廓的颜色。可以是 RGB 三元组或十六进制颜色代码。
thickness: 轮廓的线宽。如果是负数（例如 -CV_FILLED），则填充轮廓内部。
font: 用于绘制标签的字体。
fontScale: 字体缩放因子。
label: 轮廓的标签。
offset: 绘制的偏移量。
1
2
3
4
5
6
7
8
9
10
11
12
13

运行示例

下面是一个简单的示例，展示如何使用 cv2.drawContours 函数在图像上绘制轮廓：

import cv2
import numpy as np

# 创建一个黑色背景图像
image = np.zeros((500, 500), dtype=np.uint8)

# 创建三个不同大小的圆形轮廓
contours = [np.array([[200, 200], [300, 200], [300, 300], [200, 300]]),
             np.array([[100, 100], [300, 100], [300, 300], [100, 300]]),
             np.array([[100, 200], [200, 250], [300, 250], [350, 200]]),
             ]

# 使用cv2.drawContours绘制所有轮廓，颜色为红色，线宽为2
cv2.drawContours(image, contours, -1, (255, 0, 0), 2)

# 显示绘制后的图像
cv2.imshow('Contours', image)
cv2.imwrite('Contours.jpg',image)
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

输出的效果图：

cv2.findContours（）

cv2.findContours 是 OpenCV 库中的一个函数，用于找到图像中的轮廓。这对于在图像处理中识别和标记对象非常有用。该函数可以处理二值图像，并在其中找到轮廓。

函数解析

函数原型：
cv2.findContours(image, mode, method[, contours[, hierarchy[, offset ]]])

函数详解：
image：源图像必须是灰度图像，可以是 8 位无符号整数或者 32 位浮点数。如果是彩色图像或者多通道图像，那么它会被自动转换为灰度图像。
mode：这是一个枚举（Enumeration）类型，用来选择轮廓检索模式。可以选择四种模式中的一种，比如 cv2.RETR_EXTERNAL（只检索最外层的轮廓），cv2.RETR_LIST（检索所有轮廓并将其保存为列表），cv2.RETR_CCOMP（检索所有轮廓并将其保存为两个层的树状结构），和 cv2.RETR_TREE（检索所有轮廓并将其保存为多层的树状结构）。
method：这也是一个枚举（Enumeration）类型，用来选择轮廓近似方法。可以选择三种方法中的一种，比如 cv2.CHAIN_APPROX_SIMPLE（压缩水平的、垂直的和斜的部分，也就是，函数通过压缩零水平、垂直和斜线交叉得到轮廓），cv2.CHAIN_APPROX_TC89_L1（使用 Ramer-Douglas-Peucker 算法，设置参数 epsilon 为 0.5）和 cv2.CHAIN_APPROX_TC89_KCOS（使用 Ramer-Douglas-Peucker 算法，设置参数 epsilon 为 0.1）。
contours: 这是一个列表，用来存储检测到的轮廓。轮廓是点的集合，每个轮廓都有一个“父”轮廓（如果有的话）。这个参数是返回的结果。
hierarchy: 这是一个可选的输出参数。它是一个包含多个轮廓层次信息的对象。如果指定了这个参数，那么函数会在这个对象中存储最外层轮廓和它的嵌套层次。
offset: 可选的参数，指定点相对于当前位置的偏移量。如果指定了这个参数，那么在计算轮廓时，会从图像的边界像素开始偏移。
1
2
3
4
5
6
7
8
9
10

运行示例

import cv2
import numpy as np

# 加载图像并转换为灰度图像
image = cv2.imread('image.jpg')
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# 二值化图像
_, binary = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)

# 查找轮廓
contours, _ = cv2.findContours(binary, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

# 创建一个和原图大小一样的全黑图像，作为绘制轮廓的基础图像
drawn = np.zeros_like(image)

# 在新图像上绘制找到的轮廓
cv2.drawContours(drawn, contours, -1, (0, 255, 0), 3)

# 在窗口中显示原图和带有轮廓标记的图像
cv2.imshow('Original Image', image)
cv2.imshow('Drawn Image', drawn)
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

上面的代码读取一个名为 ‘115.jpg’ 的图像文件，将其转换为灰度图像，并查找其中的轮廓。最后在窗口中显示原图和带有轮廓标记的图像。

cv2.bitwise_and（）

cv2.bitwise_and() 是 OpenCV 库中的一个函数，用于对输入图像进行按位与操作。它将每个像素与对应的掩码像素进行按位与运算，生成结果图像。

函数解析

cv2.bitwise_and(src1, src2, mask[, dst[, dtype]])
参数详解：

src1 和 src2：源图像，必须是相同大小和类型。
mask：掩码图像，必须是与源图像相同大小和类型的单通道图像。
dst：输出图像，必须是相同大小和类型，并且与源图像和掩码图像的通道数相同。
dtype：可选参数，指定输出图像的数据类型。默认为 -1，表示使用与输入图像相同的数据类型。
1
2
3
4
5
6
7

运行示例

import cv2
import numpy as np

# 加载图像和掩码
image1 = cv2.imread('115.jpg')
image2 = cv2.imread('115.jpg')
mask = cv2.imread('115.jpg')

# 将图像转换为灰度图像
image1_gray = cv2.cvtColor(image1, cv2.COLOR_BGR2GRAY)
image2_gray = cv2.cvtColor(image2, cv2.COLOR_BGR2GRAY)
mask_gray = cv2.cvtColor(mask, cv2.COLOR_BGR2GRAY)

# 对图像进行按位与操作（使用掩码）
result = cv2.bitwise_and(image1_gray, image2_gray, mask=mask_gray)

# 显示结果图像
cv2.imshow('Result', result)
cv2.imwrite('Result.jpg', result)
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

这里为了省事，用的是同一幅图像，大家可以进行替换，使用不同图像进行。

cv2.inRange（）

cv2.inRange是OpenCV库中的一个函数，用于从指定的颜色范围中过滤图像的像素。它通常用于颜色过滤或对象识别。

函数解析

函数原型：
cv2.inRange(src, lowerbord, upperbord, mask)

参数：
src: 输入的源图像，必须是8位或32位的单通道图像。
lowerbord: 颜色范围的下界，表示为包含三个元素的元组，分别对应红色、绿色和蓝色的范围（0-255）。
upperbord: 颜色范围的上界，同样表示为包含三个元素的元组，分别对应红色、绿色和蓝色的范围（0-255）。
mask: 输出图像的位深度，例如对于8位图像，值为CV_8U。
函数原型：
1
2
3
4
5
6
7
8
9

运行示例

以下是一个使用cv2.inRange函数的示例，该示例读取一张图像，然后仅显示图像中蓝色和绿色像素位于特定范围内的部分：

import cv2
import numpy as np

# 加载图像并转换为灰度图像
image = cv2.imread('115.jpg')
#gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# 定义颜色范围的下界和上界
lower_range = np.array([110, 50, 50]) # 对于蓝绿色像素，下界为(110,50,50)，上界为(130,255,255)
upper_range = np.array([130, 255, 255])

# 使用cv2.inRange过滤图像中的像素
mask = cv2.inRange(image, lower_range, upper_range)

# 将原图和过滤后的图像进行按位与操作，得到最终的输出图像
res = cv2.bitwise_and(image, image, mask=mask)

# 显示原图和输出图像
cv2.imshow('Original Image', image)
cv2.imshow('Filtered Image', res)
cv2.imwrite('Filtered Image.jpg', res)
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

在这个示例中，我们首先加载一张图像。然后我们定义了一个颜色范围的下界和上界。接着我们使用cv2.inRange函数过滤图像中的像素，将过滤后的像素保存在一个掩码中。最后我们将原图和过滤后的图像进行按位与操作，得到最终的输出图像。