OpenCV 基础

18486 字约 62 分钟

2026-05-20

1，图像基本操作

1-1-1 安装相关库

pip install opencv-python
pip install opencv-contrib-python
## 尽量保持两个库安装的版本，比如我都是4.9.0.80opencv-contrib-python         4.9.0.80opencv-python                 4.9.0.80

1-1-2 导入使用

import cv2
import matplotlib.pyplot  as plt
import numpy as np

1-3-1 cv2.imshow() 显示图片

参数：

显示图像的窗口名称，以字符串类型表示
要加载的图像

注意：在调用显示图像的API后，要调用cv.waitKey()给图像绘制留下时间，否则窗口会出现无响应情况，并且图像无法显示出来。

img = cv2.imread('./img/01.jpg')
print(img)
## 图像的显示cv2.imshow('image',img)
## 等待时间，毫秒级。0表示任意键终止cv2.waitKey(0)
cv2.destroyAllWindows()

cv.IMREAD*COLOR：以彩色模式加载图像，任何图像的透明度都将被忽略。这是默认参数。
cv.IMREAD*GRAYSCALE：以灰度模式加载图像
cv.IMREAD_UNCHANGED：包括alpha通道的加载图像模式。

## 第二个参数，设置彩色还是灰度img = cv2.imread('./img/01.jpg',cv2.IMREAD_GRAYSCALE )
# 以灰度图的形式读取图像img = cv.imread('messi5.jpg',0)

1-3-2 matplotlib 显示图片

彩色图

import matplotlib.pyplot  as plt
img = cv2.imread('./img/01.jpg')
plt.imshow(img[:,:,::-1])
plt.show()

灰度图

import matplotlib.pyplot  as plt
img = cv2.imread('./img/01.jpg'，0)
plt.imshow(img,cmap=plt.cm.gray)
plt.show()

1-1-4 图片保存

参数：

文件名，要保存在哪里
要保存的图像

# 路径和保存的图片cv2.imwrite('nwe_img.png',img)

import numpy as np
import cv2 as cv
import matplotlib.pyplot as plt
# 1 读取图像img = cv.imread('messi5.jpg',0)
# 2 显示图像# 2.1 利用opencv展示图像cv.imshow('image',img)
# 2.2 在matplotplotlib中展示图像plt.imshow(img[:,:,::-1])
plt.title('匹配结果'), plt.xticks([]), plt.yticks([])
plt.show()
k = cv.waitKey(0)
# 3 保存图像cv.imwrite('messigray.png',img)

1-1-5 视频的读取

# 不指定文件可以捕获摄像头vc = cv2.VideoCapture()
## 指定文件路径，可以读取视频vc = cv2.VideoCapture('test.mp4')
## 判断视频能否打得开if vc.isOpened():
    open,frame = vc.read()
else:
    open = False

while open:
    ret,frame = vc.read()
    if frame is None:
        break    if ret == True:
        ## 转换成黑白图        gray = cv2.cvtColor(frame,cv2.COLOR_BGR2GRAY)
        cv2.imshow('result',gray)
        ## 100 是指处理完一帧等待的时间，单位是ms        if cv2.waitKey(10) & 0xFF == 27:
            breakvc.release()
cv2.destroyAllWindows()

1-1-6 截取部分图像数据

img =cv2.imread('./img/01.jpg')
cat = img[0:200,0:200]
cv2.imshow('cat',cat)

1-1-7 颜色通道提取

b,g,r = cv2.split(img)
print(r.shape)

1-1-8 通道的合并

img = cv2.merge(b,g,r)
img.shape

1-9-1 只保留R

img =cv2.imread('./img/01.jpg')
cur_img = img.copy()
cur_img[:,:,0] = 0cur_img[:,:,1] = 0cv2.imshow('R',cur_img)
cv2.waitKey(0)
cv2.destroyAllWindows()

1-9-2 只保留G

img =cv2.imread('./img/01.jpg')
cur_img = img.copy()
cur_img[:,:,0] = 0cur_img[:,:,2] = 0cv2.imshow('G',cur_img)
cv2.waitKey(0)
cv2.destroyAllWindows()

1-9-3 只保留B

img =cv2.imread('./img/01.jpg')
cur_img = img.copy()
cur_img[:,:,1] = 0cur_img[:,:,2] = 0cv2.imshow('B',cur_img)
cv2.waitKey(0)
cv2.destroyAllWindows()

1-1-10 边界填充

cv2.BORDER_REPLICATE ：复制法，也就是复制最边缘像素

cv2.BORDER_REFLECT ：反射法，对感兴趣的图像中的像素在两边进行复制

cv2.BORDER_REFLECT_101：反射法，也就是以最边缘像素为轴，对称

cv2.BORDER_WRAP：外包装法

cv2.BORDER_CONSTANT：常量法：常数值填充

top_size,bottom_size,left_size,right_size = (50,50,50,50)
img = cv2.imread('./img/01.jpg')
replicate = cv2.copyMakeBorder(img,top_size,bottom_size,left_size,right_size,borderType=cv2.BORDER_REPLICATE)
reflect = cv2.copyMakeBorder(img,top_size,bottom_size,left_size,right_size,borderType=cv2.BORDER_REFLECT)
reflect101 = cv2.copyMakeBorder(img,top_size,bottom_size,left_size,right_size,borderType=cv2.BORDER_REFLECT_101)
wrap = cv2.copyMakeBorder(img,top_size,bottom_size,left_size,right_size,borderType=cv2.BORDER_WRAP)
constant = cv2.copyMakeBorder(img, top_size, bottom_size, left_size, right_size, borderType=cv2.BORDER_CONSTANT, value=0)
cv2.imshow('B',img)
cv2.waitKey(0)
cv2.destroyAllWindows()

1-11-1 绘制直线

cv.line(img,start,end,color,thickness)

cv.line(img,(0,0),(511,511),(255,0,0),5)

参数：

img:要绘制直线的图像
Start,end: 直线的起点和终点
color: 线条的颜色
Thickness: 线条宽度

1-11-2 绘制圆形

cv.circle(img,centerpoint, r, color, thickness)
cv.circle(img,(447,63), 63, (0,0,255), -1)

参数：

img:要绘制圆形的图像
Centerpoint, r: 圆心和半径
color: 线条的颜色
Thickness: 线条宽度，为-1时生成闭合图案并填充颜色

1-11-3 绘制矩形

cv.rectangle(img,leftupper,rightdown,color,thickness)
cv.rectangle(img,(384,0),(510,128),(0,255,0),3)

参数：

img:要绘制矩形的图像
Leftupper, rightdown: 矩形的左上角和右下角坐标
color: 线条的颜色
Thickness: 线条宽度

1-11-4 向图像中添加文字

cv.putText(img,text,station, font, fontsize,color,thickness,cv.LINE_AA)
cv.putText(img,'OpenCV',(10,500), font, 4,(255,255,255),2,cv.LINE_AA)

参数：

img: 图像
text：要写入的文本数据
station：文本的放置位置
font：字体
Fontsize :字体大小

1-11-5 效果展示

我们生成一个全黑的图像，然后在里面绘制图像并添加文字

import numpy as np
import cv2 as cv
import matplotlib.pyplot as plt
# 1 创建一个空白的图像img = np.zeros((512,512,3), np.uint8)
# 2 绘制图形cv.line(img,(0,0),(511,511),(255,0,0),5)
cv.rectangle(img,(384,0),(510,128),(0,255,0),3)
cv.circle(img,(447,63), 63, (0,0,255), -1)
font = cv.FONT_HERSHEY_SIMPLEX
cv.putText(img,'OpenCV',(10,500), font, 4,(255,255,255),2,cv.LINE_AA)
# 3 图像展示plt.imshow(img[:,:,::-1])
plt.title('匹配结果'), plt.xticks([]), plt.yticks([])
plt.show()

1-1-13 ，获取图像的属性

图像属性包括行数，列数和通道数，图像数据类型，像素数等。

image-20240126173746529

img.shape   ## （256,256,3） 256*256 的三个通道的

img.dtype   ## dtype('uint8')

img.size   ## 196608

1-1-14，图像通道的拆分与合并

有时需要在B，G，R通道图像上单独工作。在这种情况下，需要将BGR图像分割为单个通道。或者在其他情况下，可能需要将这些单独的通道合并到BGR图像。你可以通过以下方式完成。

# 通道拆分b,g,r = cv.split(img)
# 通道合并img = cv.merge((b,g,r))

dili = cv.imread("./image/dili.jpg")
plt.imshow(dili[:,:,::-1])
b,g,r = cv.split(dili)
## b通道灰色显示plt.imshow(b,cmap=plt.cm.gray)
# 通道合并img2 = cv.merge((b,g,r))
plt.imshow(img2[:,:,::-1])

1-1-16 总结

图像IO操作的API：

cv.imread(): ## 读取图像cv.imshow()：## 显示图像cv.imwrite(): ## 保存图像

在图像上绘制几何图像

cv.line(): ## 绘制直线cv.circle(): ## 绘制圆形cv.rectangle(): ## 绘制矩形cv.putText(): ## 在图像上添加文字

直接使用行列索引获取图像中的像素并进行修改
图像的属性
image-20240127104906057
拆分通道：cv.split()
通道合并：cv.merge()
色彩空间的改变
cv.cvtColor(input_image，flag)

1-2-3 总结

图像加法：将两幅图像加载一起
cv.add()
图像的混合：将两幅图像按照不同的比例进行混合
cv.addweight()

注意：这里都要求两幅图像是相同大小的。

2，图像处理

2-1-7 总结

总结

图像缩放：对图像进行放大或缩小
cv.resize()
图像平移：
指定平移矩阵后，调用cv.warpAffine()平移图像
图像旋转：
调用cv.getRotationMatrix2D获取旋转矩阵，然后调用cv.warpAffine()进行旋转
仿射变换：
调用cv.getAffineTransform将创建变换矩阵，最后该矩阵将传递给cv.warpAffine()进行变换
透射变换：
通过函数cv.getPerspectiveTransform()找到变换矩阵，将cv.warpPerspective()进行投射变换
金字塔
图像金字塔是图像多尺度表达的一种，使用的API：
cv.pyrUp(): 向上采样
cv.pyrDown(): 向下采样1

2-2-1 连通性

image-20240127132209861

连通性是描述区域和边界的重要概念，两个像素连通的两个必要条件是：

两个像素的位置是否相邻
两个像素的灰度值是否满足特定的相似性准则（或者是否相等

根据连通性的定义，有4联通、8联通和m联通三种。

image-20240127132246597

image-20240127132304157

2-1 腐蚀和膨胀

腐蚀和膨胀是最基本的形态学操作，腐蚀和膨胀都是针对白色部分（高亮部分）而言的。

膨胀就是使图像中高亮部分扩张，效果图拥有比原图更大的高亮区域；腐蚀是原图中的高亮区域被蚕食，效果图拥有比原图更小的高亮区域。膨胀是求局部最大值的操作，腐蚀是求局部最小值的操作。

1，腐蚀

具体操作是：用一个结构元素扫描图像中的每一个像素，用结构元素中的每一个像素与其覆盖的像素做“与”操作，如果都为1，则该像素为1，否则为0。如下图所示，结构A被结构B腐蚀后：

image-20240127132747631

腐蚀的作用是消除物体边界点，使目标缩小，可以消除小于结构元素的噪声点。

API：

   cv.erode(img,kernel,iterations)

参数：

img: 要处理的图像
kernel: 核结构
iterations: 腐蚀的次数，默认是1

3-1-1 椒盐噪声

椒盐噪声也称为脉冲噪声，是图像中经常见到的一种噪声，它是一种随机出现的白点或者黑点，可能是亮的区域有黑色像素或是在暗的区域有白色像素（或是两者皆有）。椒盐噪声的成因可能是影像讯号受到突如其来的强烈干扰而产生、类比数位转换器或位元传输错误等。例如失效的感应器导致像素值为最小值，饱和的感应器导致像素值为最大值。

image-20240127143525121

3-1-2 高斯噪声

高斯噪声是指噪声密度函数服从高斯分布的一类噪声。由于高斯噪声在空间和频域中数学上的易处理性，这种噪声(也称为正态噪声)模型经常被用于实践中

image-20240127143636101

4-1-1 原理

直方图是对数据进行统计的一种方法，并且将统计值组织到一系列实现定义好的 bin 当中。其中， bin 为直方图中经常用到的一个概念，可以译为 “直条” 或 “组距”，其数值是从数据中计算出的特征统计量，这些数据可以是诸如梯度、方向、色彩或任何其他特征。

图像直方图（Image Histogram）是用以表示数字图像中亮度分布的直方图，标绘了图像中每个亮度值的像素个数。这种直方图中，横坐标的左侧为较暗的区域，而右侧为较亮的区域。因此一张较暗图片的直方图中的数据多集中于左侧和中间部分，而整体明亮、只有少量阴影的图像则相反。

image-20240127145908136

注意：直方图是根据灰度图进行绘制的，而不是彩色图像。假设有一张图像的信息（灰度值 0 - 255，已知数字的范围包含 256 个值，于是可以按一定规律将这个范围分割成子区域（也就是 bins）。如：

image-20240127145934618

直方图的一些术语和细节：

dims：需要统计的特征数目。在上例中，dims = 1 ，因为仅仅统计了灰度值。
bins：每个特征空间子区段的数目，可译为 “直条” 或 “组距”，在上例中， bins = 16。
range：要统计特征的取值范围。在上例中，range = [0, 255]。

直方图的意义：

直方图是图像中像素强度分布的图形表达方式。
它统计了每一个强度值所具有的像素个数。
不同的图像的直方图可能是相同的

2-2 自适应的直方图均衡化

上述的直方图均衡，我们考虑的是图像的全局对比度。的确在进行完直方图均衡化之后，图片背景的对比度被改变了，在猫腿这里太暗，我们丢失了很多信息，所以在许多情况下，这样做的效果并不好。如下图所示，对比下两幅图像中雕像的画面，由于太亮我们丢失了很多信息

image-20240127151718116

为了解决这个问题，需要使用自适应的直方图均衡化。此时，整幅图像会被分成很多小块，这些小块被称为“tiles”（在 OpenCV 中 tiles 的大小默认是 8x8），然后再对每一个小块分别进行直方图均衡化。所以在每一个的区域中，直方图会集中在某一个小的区域中）。如果有噪声的话，噪声会被放大。为了避免这种情况的出现要使用对比度限制。对于每个小块来说，如果直方图中的 bin 超过对比度的上限的话，就把其中的像素点均匀分散到其他 bins 中，然后在进行直方图均衡化。

image-20240127151733433

最后，为了去除每一个小块之间的边界，再使用双线性差值，对每一小块进行拼接。

API：

cv.createCLAHE(clipLimit, tileGridSize)

参数：

clipLimit: 对比度限制，默认是40
tileGridSize: 分块的大小，默认为8∗88∗8

示例：

import numpy as np
import cv2 as cv
# 1. 以灰度图形式读取图像img = cv.imread('./image/cat.jpeg',0)
# 2. 创建一个自适应均衡化的对象，并应用于图像clahe = cv.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
cl1 = clahe.apply(img)
# 3. 图像展示fig,axes=plt.subplots(nrows=1,ncols=2,figsize=(10,8),dpi=100)
axes[0].imshow(img,cmap=plt.cm.gray)
axes[0].set_title("原图")
axes[1].imshow(cl1,cmap=plt.cm.gray)
axes[1].set_title("自适应均衡化后的结果")
plt.show()

image-20240127151749093

2-5 边缘检测

2 -5-1 Sobel检测算子

利用OpenCV进行sobel边缘检测的API是：

Sobel_x_or_y = cv2.Sobel(src, ddepth, dx, dy, dst, ksize, scale, delta, borderType)

参数：

src：传入的图像
ddepth: 图像的深度
dx和dy: 指求导的阶数，0表示这个方向上没有求导，取值为0、1。
ksize: 是Sobel算子的大小，即卷积核的大小，必须为奇数1、3、5、7，默认为3。
注意：如果ksize=-1，就演变成为3x3的Scharr算子。
scale：缩放导数的比例常数，默认情况为没有伸缩系数。
borderType：图像边界的模式，默认值为cv2.BORDER_DEFAULT。

Sobel函数求完导数后会有负值，还有会大于255的值。而原图像是uint8，即8位无符号数，所以Sobel建立的图像位数不够，会有截断。因此要使用16位有符号的数据类型，即cv2.CV_16S。处理完图像后，再使用cv2.convertScaleAbs()函数将其转回原来的uint8格式，否则图像无法显示。

Sobel算子是在两个方向计算的，最后还需要用cv2.addWeighted( )函数将其组合起来

Scale_abs = cv2.convertScaleAbs(x)  # 格式转换函数
result = cv2.addWeighted(src1, alpha, src2, beta) # 图像混合

示例：

import cv2 as cv
import numpy as np
from matplotlib import pyplot as plt
# 1 读取图像img = cv.imread('./image/horse.jpg',0)
# 2 计算Sobel卷积结果x = cv.Sobel(img, cv.CV_16S, 1, 0)
y = cv.Sobel(img, cv.CV_16S, 0, 1)
# 3 将数据进行转换Scale_absX = cv.convertScaleAbs(x)  # convert 转换  scale 缩放Scale_absY = cv.convertScaleAbs(y)
# 4 结果合成result = cv.addWeighted(Scale_absX, 0.5, Scale_absY, 0.5, 0)
# 5 图像显示plt.figure(figsize=(10,8),dpi=100)
plt.subplot(121),plt.imshow(img,cmap=plt.cm.gray),plt.title('原图')
plt.xticks([]), plt.yticks([])
plt.subplot(122),plt.imshow(result,cmap = plt.cm.gray),plt.title('Sobel滤波后结果')
plt.xticks([]), plt.yticks([])
plt.show()

image-20240127154743664

2-5-2 Laplacian算子

image-20240127155228569

API：

laplacian = cv2.Laplacian(src, ddepth[, dst[, ksize[, scale[, delta[, borderType]]]]])

参数：

Src: 需要处理的图像，
Ddepth: 图像的深度，-1表示采用的是原图像相同的深度，目标图像的深度必须大于等于原图像的深度；
ksize：算子的大小，即卷积核的大小，必须为1,3,5,7。

示例：

import cv2 as cv
import numpy as np
from matplotlib import pyplot as plt
# 1 读取图像img = cv.imread('./image/horse.jpg',0)
# 2 laplacian转换result = cv.Laplacian(img,cv.CV_16S)
Scale_abs = cv.convertScaleAbs(result)
# 3 图像展示plt.figure(figsize=(10,8),dpi=100)
plt.subplot(121),plt.imshow(img,cmap=plt.cm.gray),plt.title('原图')
plt.xticks([]), plt.yticks([])
plt.subplot(122),plt.imshow(Scale_abs,cmap = plt.cm.gray),plt.title('Laplacian检测后结果')
plt.xticks([]), plt.yticks([])
plt.show()

image-20240127155243971

2-5-3 Canny边缘检测

在OpenCV中要实现Canny检测使用的API:

canny = cv2.Canny(image, threshold1, threshold2)

参数：

image:灰度图，
threshold1: minval，较小的阈值将间断的边缘连接起来
threshold2: maxval，较大的阈值检测图像中明显的边缘

示例：

import cv2 as cv
import numpy as np
from matplotlib import pyplot as plt
# 1 图像读取img = cv.imread('./image/horse.jpg',0)
# 2 Canny边缘检测lowThreshold = 0max_lowThreshold = 100canny = cv.Canny(img, lowThreshold, max_lowThreshold)
# 3 图像展示plt.figure(figsize=(10,8),dpi=100)
plt.subplot(121),plt.imshow(img,cmap=plt.cm.gray),plt.title('原图')
plt.xticks([]), plt.yticks([])
plt.subplot(122),plt.imshow(canny,cmap = plt.cm.gray),plt.title('Canny检测后结果')
plt.xticks([]), plt.yticks([])
plt.show()

image-20240127155437719

2-5-4 算发比较

image-20240127155527490

2-6 模板匹配霍夫变换

6-1 模板匹配

6-1.1 原理

所谓的模板匹配，就是在给定的图片中查找和模板最相似的区域，该算法的输入包括模板和图片，整个任务的思路就是按照滑窗的思路不断的移动模板图片，计算其与图像中对应区域的匹配度，最终将匹配度最高的区域选择为最终的结果。

实现流程：

准备两幅图像：
1.原图像(I)：在这幅图中，找到与模板相匹配的区域
2.模板(T)：与原图像进行比对的图像块

image-20240127160442547

滑动模板图像和原图像进行比对：

image-20240127160503427

image-20240127160512215

image-20240127160525277

获得上述图像后，查找最大值所在的位置，那么该位置对应的区域就被认为是最匹配的。对应的区域就是以该点为顶点，长宽和模板图像一样大小的矩阵。

6-1-2 实现

我们使用OpenCV中的方法实现模板匹配。

API：

res = cv.matchTemplate(img,template,method)

参数：

img: 要进行模板匹配的图像
Template ：模板
method：实现模板匹配的算法，主要有：
1. 平方差匹配(CV_TM_SQDIFF)：利用模板与图像之间的平方差进行匹配，最好的匹配是0，匹配越差，匹配的值越大。
2. 相关匹配(CV_TM_CCORR)：利用模板与图像间的乘法进行匹配，数值越大表示匹配程度较高，越小表示匹配效果差。
3. 利用相关系数匹配(CV_TM_CCOEFF)：利用模板与图像间的相关系数匹配，1表示完美的匹配，-1表示最差的匹配。

完成匹配后，使用cv.minMaxLoc()方法查找最大值所在的位置即可。如果使用平方差作为比较方法，则最小值位置是最佳匹配位置。

示例：

在该案例中，载入要搜索的图像和模板，图像如下所示：

image-20240127160611838

通过matchTemplate实现模板匹配，使用minMaxLoc定位最匹配的区域，并用矩形标注最匹配的区域。

import cv2 as cv
import numpy as np
from matplotlib import pyplot as plt
# 1 图像和模板读取img = cv.imread('./image/wulin2.jpeg')
template = cv.imread('./image/wulin.jpeg')
h,w,l = template.shape
# 2 模板匹配# 2.1 模板匹配res = cv.matchTemplate(img, template, cv.TM_CCORR)
# 2.2 返回图像中最匹配的位置，确定左上角的坐标，并将匹配位置绘制在图像上min_val, max_val, min_loc, max_loc = cv.minMaxLoc(res)
# 使用平方差时最小值为最佳匹配位置# top_left = min_loctop_left = max_loc
bottom_right = (top_left[0] + w, top_left[1] + h)
cv.rectangle(img, top_left, bottom_right, (0,255,0), 2)
# 3 图像显示plt.imshow(img[:,:,::-1])
plt.title('匹配结果'), plt.xticks([]), plt.yticks([])
plt.show()

拓展：模板匹配不适用于尺度变换，视角变换后的图像，这时我们就要使用关键点匹配算法，比较经典的关键点检测算法包括SIFT和SURF等，主要的思路是首先通过关键点检测算法获取模板和测试图片中的关键点；然后使用关键点匹配算法处理即可，这些关键点可以很好的处理尺度变化、视角变换、旋转变化、光照变化等，具有很好的不变性。

6-2 霍夫变换

霍夫变换常用来提取图像中的直线和圆等几何形状，如下图所示：

image-20240127172734941

在OpenCV中做霍夫线检测是使用的API是：

cv.HoughLines(img, rho, theta, threshold)

参数：

img: 检测的图像，要求是二值化的图像，所以在调用霍夫变换之前首先要进行二值化，或者进行Canny边缘检测
rho、theta: �ρ 和�θ的精确度
threshold: 阈值，只有累加器中的值高于该阈值时才被认为是直线。
霍夫线检测的整个流程如下图所示，这是在stackflow上一个关于霍夫线变换的解释：

示例：

检测下述图像中的直线：

image-20240127173252913

import numpy as np
import random
import cv2 as cv
import matplotlib.pyplot as plt
# 1.加载图片，转为二值图img = cv.imread('./image/rili.jpg')
gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
edges = cv.Canny(gray, 50, 150)
# 2.霍夫直线变换lines = cv.HoughLines(edges, 0.8, np.pi / 180, 150)
# 3.将检测的线绘制在图像上（注意是极坐标噢）for line in lines:
    rho, theta = line[0]
    a = np.cos(theta)
    b = np.sin(theta)
    x0 = a * rho
    y0 = b * rho
    x1 = int(x0 + 1000 * (-b))
    y1 = int(y0 + 1000 * (a))
    x2 = int(x0 - 1000 * (-b))
    y2 = int(y0 - 1000 * (a))
    cv.line(img, (x1, y1), (x2, y2), (0, 255, 0))
# 4. 图像显示plt.figure(figsize=(10,8),dpi=100)
plt.imshow(img[:,:,::-1]),plt.title('霍夫变换线检测')
plt.xticks([]), plt.yticks([])
plt.show()

image-20240127173311818

6-3 霍夫圆检测

原理
圆的表示式是：(�−�)2+(�−�)2=�(x−a)2+(y−b)2=r其中�a和�b表示圆心坐标，�r表示圆半径，因此标准的霍夫圆检测就是在这三个参数组成的三维空间累加器上进行圆形检测，此时效率就会很低，所以OpenCV中使用霍夫梯度法进行圆形的检测。
霍夫梯度法将霍夫圆检测范围两个阶段，第一阶段检测圆心，第二阶段利用圆心推导出圆半径。
- 圆心检测的原理：圆心是圆周法线的交汇处，设置一个阈值，在某点的相交的直线的条数大于这个阈值就认为该交汇点为圆心。
- 圆半径确定原理：圆心到圆周上的距离（半径）是相同的，确定一个阈值，只要相同距离的数量大于该阈值，就认为该距离是该圆心的半径。
原则上霍夫变换可以检测任何形状，但复杂的形状需要的参数就多，霍夫空间的维数就多，因此在程序实现上所需的内存空间以及运行效率上都不利于把标准霍夫变换应用于实际复杂图形的检测中。霍夫梯度法是霍夫变换的改进，它的目的是减小霍夫空间的维度，提高效率。
API
在OpenCV中检测图像中的圆环使用的是API是：
```
circles = cv.HoughCircles(image, method, dp, minDist, param1=100, param2=100, minRadius=0,maxRadius=0 )
```
参数：
- image：输入图像，应输入灰度图像
- method：使用霍夫变换圆检测的算法，它的参数是CV_HOUGH_GRADIENT
- dp：霍夫空间的分辨率，dp=1时表示霍夫空间与输入图像空间的大小一致，dp=2时霍夫空间是输入图像空间的一半，以此类推
- minDist为圆心之间的最小距离，如果检测到的两个圆心之间距离小于该值，则认为它们是同一个圆心
- param1：边缘检测时使用Canny算子的高阈值，低阈值是高阈值的一半。
- param2：检测圆心和确定半径时所共有的阈值
- minRadius和maxRadius为所检测到的圆半径的最小值和最大值
返回：
- circles：输出圆向量，包括三个浮点型的元素——圆心横坐标，圆心纵坐标和圆半径

实现

由于霍夫圆检测对噪声比较敏感，所以首先对图像进行中值滤波。

import cv2 as cv
import numpy as np
import matplotlib.pyplot as plt
# 1 读取图像，并转换为灰度图planets = cv.imread("./image/star.jpeg")
gay_img = cv.cvtColor(planets, cv.COLOR_BGRA2GRAY)
# 2 进行中值模糊，去噪点img = cv.medianBlur(gay_img, 7)
# 3 霍夫圆检测circles = cv.HoughCircles(img, cv.HOUGH_GRADIENT, 1, 200, param1=100, param2=30, minRadius=0, maxRadius=100)
# 4 将检测结果绘制在图像上for i in circles[0, :]:  # 遍历矩阵每一行的数据    # 绘制圆形    cv.circle(planets, (i[0], i[1]), i[2], (0, 255, 0), 2)
    # 绘制圆心    cv.circle(planets, (i[0], i[1]), 2, (0, 0, 255), 3)
# 5 图像显示plt.figure(figsize=(10,8),dpi=100)
plt.imshow(planets[:,:,::-1]),plt.title('霍夫变换圆检测')
plt.xticks([]), plt.yticks([])
plt.show()

image-20240127183316314

3，图像的特征提取和描述

3-1 Harris角点检测

在OpenCV中实现Hariis检测使用的API是：

dst=cv.cornerHarris(src, blockSize, ksize, k)

参数：

img：数据类型为 ﬂoat32 的输入图像。
blockSize：角点检测中要考虑的邻域大小。
ksize：sobel求导使用的核大小
k ：角点检测方程中的自由参数，取值参数为 [0.04，0.06].

示例：

import cv2 as cv
import numpy as np
import matplotlib.pyplot as plt
# 1 读取图像，并转换成灰度图像img = cv.imread('./image/chessboard.jpg')
gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
# 2 角点检测# 2.1 输入图像必须是 float32gray = np.float32(gray)
# 2.2 最后一个参数在 0.04 到 0.05 之间dst = cv.cornerHarris(gray,2,3,0.04)
# 3 设置阈值，将角点绘制出来，阈值根据图像进行选择img[dst>0.001*dst.max()] = [0,0,255]
# 4 图像显示plt.figure(figsize=(10,8),dpi=100)
plt.imshow(img[:,:,::-1]),plt.title('Harris角点检测')
plt.xticks([]), plt.yticks([])
plt.show()

image-20240127190622525

Harris角点检测的优缺点：

优点：

旋转不变性，椭圆转过一定角度但是其形状保持不变（特征值保持不变）
对于图像灰度的仿射变化具有部分的不变性，由于仅仅使用了图像的一介导数，对于图像灰度平移变化不变；对于图像灰度尺度变化不变

缺点：

对尺度很敏感，不具备几何尺度不变性。
提取的角点是像素级的

3-2 Shi-Tomasi角点检测

在OpenCV中实现Shi-Tomasi角点检测使用API:

corners = cv2.goodFeaturesToTrack ( image, maxcorners, qualityLevel, minDistance )

参数：

Image: 输入灰度图像
maxCorners : 获取角点数的数目。
qualityLevel：该参数指出最低可接受的角点质量水平，在0-1之间。
minDistance：角点之间最小的欧式距离，避免得到相邻特征点。

Corners: 搜索到的角点，在这里所有低于质量水平的角点被排除掉，然后把合格的角点按质量排序，然后将质量较好的角点附近（小于最小欧式距离）的角点删掉，最后找到maxCorners个角点返回。

示例：

import numpy as np
import cv2 as cv
import matplotlib.pyplot as plt
# 1 读取图像img = cv.imread('./img/tv.jpg')
gray = cv.cvtColor(img,cv.COLOR_BGR2GRAY)
# 2 角点检测corners = cv.goodFeaturesToTrack(gray,1000,0.01,10)
# 3 绘制角点for i in corners:
    x,y = i.ravel()
    cv.circle(img,(int(x),int(y)),2,(0,0,255),-1)
# 4 图像展示plt.figure(figsize=(10,8),dpi=100)
plt.imshow(img[:,:,::-1]),plt.title('shi-tomasi角点检测')
plt.xticks([]), plt.yticks([])
plt.show()

结果如下：

image-20240127193051968

总结

Harris算法
思想：通过图像的局部的小窗口观察图像，角点的特征是窗口沿任意方向移动都会导致图像灰度的明显变化。
API: cv.cornerHarris()
Shi-Tomasi算法
对Harris算法的改进，能够更好地检测角点
API: cv2.goodFeatureToTrack()

3-3 SIFT/SURF算法

在OpenCV中利用SIFT检测关键点的流程如下所示：

3-1 实例化sift

sift = cv.xfeatures2d.SIFT_create()

3-2 利用sift.detectAndCompute()检测关键点并计算

kp,des = sift.detectAndCompute(gray,None)

参数：

gray: 进行关键点检测的图像，注意是灰度图像

kp: 关键点信息，包括位置，尺度，方向信息
des: 关键点描述符，每个关键点对应128个梯度信息的特征向量

3- 3.将关键点检测结果绘制在图像上

cv.drawKeypoints(image, keypoints, outputimage, color, flags)

参数：

image: 原始图像
keypoints：关键点信息，将其绘制在图像上
outputimage：输出图片，可以是原始图像
color：颜色设置，通过修改（b,g,r）的值,更改画笔的颜色，b=蓝色，g=绿色，r=红色。
flags：绘图功能的标识设置
1. cv2.DRAW_MATCHES_FLAGS_DEFAULT：创建输出图像矩阵，使用现存的输出图像绘制匹配对和特征点，对每一个关键点只绘制中间点
2. cv2.DRAW_MATCHES_FLAGS_DRAW_OVER_OUTIMG：不创建输出图像矩阵，而是在输出图像上绘制匹配对
3. cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS：对每一个特征点绘制带大小和方向的关键点图形
4. cv2.DRAW_MATCHES_FLAGS_NOT_DRAW_SINGLE_POINTS：单点的特征点不被绘制

SURF算法的应用与上述流程是一致，这里就不在赘述。

示例：

利用SIFT算法在中央电视台的图片上检测关键点，并将其绘制出来：

import cv2 as cv
import numpy as np
import matplotlib.pyplot as plt
# 1 读取图像img = cv.imread('./image/tv.jpg')
gray= cv.cvtColor(img,cv.COLOR_BGR2GRAY)
# 2 sift关键点检测# 2.1 实例化sift对象sift = cv.xfeatures2d.SIFT_create()
# 2.2 关键点检测：kp关键点信息包括方向，尺度，位置信息，des是关键点的描述符kp,des=sift.detectAndCompute(gray,None)
# 2.3 在图像上绘制关键点的检测结果cv.drawKeypoints(img,kp,img,flags=cv.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)
# 3 图像显示plt.figure(figsize=(8,6),dpi=100)
plt.imshow(img[:,:,::-1]),plt.title('sift检测')
plt.xticks([]), plt.yticks([])
plt.show()

image-20240127194522892

3-4 Fast算法

1-1 原理

我们前面已经介绍过几个特征检测器，它们的效果都很好，特别是SIFT和SURF算法，但是从实时处理的角度来看，效率还是太低了。为了解决这个问题，Edward Rosten和Tom Drummond在2006年提出了FAST算法，并在2010年对其进行了修正。

FAST (全称Features from accelerated segment test)是一种用于角点检测的算法，该算法的原理是取图像中检测点，以该点为圆心的周围邻域内像素点判断检测点是否为角点，通俗的讲就是若一个像素周围有一定数量的像素与该点像素值不同，则认为其为角点。

1.1.1 FAST算法的基本流程

在图像中选取一个像素点 p，来判断它是不是关键点。Ip等于像素点 p的灰度值。
以r为半径画圆，覆盖p点周围的M个像素，通常情狂下，设置 r=3，则 M=16，如下图所示：
image17
设置一个阈值t，如果在这 16 个像素点中存在 n 个连续像素点的灰度值都高于Ip + t，或者低于Ip − t，那么像素点 p 就被认为是一个角点。如上图中的虚线所示，n 一般取值为 12。
由于在检测特征点时是需要对图像中所有的像素点进行检测，然而图像中的绝大多数点都不是特征点，如果对每个像素点都进行上述的检测过程，那显然会浪费许多时间，因此采用一种进行非特征点判别的方法：首先对候选点的周围每个 90 度的点：1，9，5，13 进行测试（先测试 1 和 19, 如果它们符合阈值要求再测试 5 和 13）。如果 p 是角点，那么这四个点中至少有 3 个要符合阈值要求，否则直接剔除。对保留下来的点再继续进行测试（是否有 12 的点符合阈值要求）。

虽然这个检测器的效率很高，但它有以下几条缺点：

获得的候选点比较多
特征点的选取不是最优的，因为它的效果取决与要解决的问题和角点的分布情况。
进行非特征点判别时大量的点被丢弃
检测到的很多特征点都是相邻的

前 3 个问题可以通过机器学习的方法解决，最后一个问题可以使用非最大值抑制的方法解决。

1.1.2 机器学习的角点检测器

选择一组训练图片（最好是跟最后应用相关的图片）
使用 FAST 算法找出每幅图像的特征点，对图像中的每一个特征点，将其周围的 16 个像素存储构成一个向量P。
image-20191010114459269
每一个特征点的 16 像素点都属于下列三类中的一种
image18
根据这些像素点的分类，特征向量 P 也被分为 3 个子集：Pd ，Ps ，Pb，
定义一个新的布尔变量Kp，如果 p 是角点就设置为 Ture，如果不是就设置为 False。
利用特征值向量p，目标值是Kp，训练ID3 树（决策树分类器）。
将构建好的决策树运用于其他图像的快速的检测。

1.1.3 非极大值抑制

在筛选出来的候选角点中有很多是紧挨在一起的，需要通过非极大值抑制来消除这种影响。

为所有的候选角点都确定一个打分函数V ， V的值可这样计算：先分别计算Ip与圆上16个点的像素值差值，取绝对值，再将这16个绝对值相加，就得到了V的值

V = \sum_{i}^{16}|I_p-I_i|

最后比较毗邻候选角点的 V 值，把V值较小的候选角点pass掉。

FAST算法的思想与我们对角点的直观认识非常接近，化繁为简。FAST算法比其它角点的检测算法快，但是在噪声较高时不够稳定，这需要设置合适的阈值。

1-2 实现

OpenCV中的FAST检测算法是用传统方法实现的，

1.实例化fast

fast = =cv.FastFeatureDetector_create( threshold, nonmaxSuppression)

参数：

threshold：阈值t，有默认值10
nonmaxSuppression：是否进行非极大值抑制，默认值True

Fast：创建的FastFeatureDetector对象

2.利用fast.detect检测关键点，没有对应的关键点描述

kp = fast.detect(grayImg, None)

参数：

gray: 进行关键点检测的图像，注意是灰度图像

kp: 关键点信息，包括位置，尺度，方向信息

3.将关键点检测结果绘制在图像上，与在sift中是一样的

cv.drawKeypoints(image, keypoints, outputimage, color, flags)

示例：

import numpy as np
import cv2 as cv
from matplotlib import pyplot as plt
# 1 读取图像img = cv.imread('./image/tv.jpg')
# 2 Fast角点检测# 2.1 创建一个Fast对象，传入阈值，注意：可以处理彩色空间图像fast = cv.FastFeatureDetector_create(threshold=30)
# 2.2 检测图像上的关键点kp = fast.detect(img,None)
# 2.3 在图像上绘制关键点img2 = cv.drawKeypoints(img, kp, None, color=(0,0,255))
# 2.4 输出默认参数print( "Threshold: {}".format(fast.getThreshold()) )
print( "nonmaxSuppression:{}".format(fast.getNonmaxSuppression()) )
print( "neighborhood: {}".format(fast.getType()) )
print( "Total Keypoints with nonmaxSuppression: {}".format(len(kp)) )
# 2.5 关闭非极大值抑制fast.setNonmaxSuppression(0)
kp = fast.detect(img,None)
print( "Total Keypoints without nonmaxSuppression: {}".format(len(kp)) )
# 2.6 绘制为进行非极大值抑制的结果img3 = cv.drawKeypoints(img, kp, None, color=(0,0,255))
# 3 绘制图像fig,axes=plt.subplots(nrows=1,ncols=2,figsize=(10,8),dpi=100)
axes[0].imshow(img2[:,:,::-1])
axes[0].set_title("加入非极大值抑制")
axes[1].imshow(img3[:,:,::-1])
axes[1].set_title("未加入非极大值抑制")
plt.show()

结果：

image-20191010120822413

3-5 ORB 算法

2.1 原理

SIFT和SURF算法是受专利保护的，在使用他们时我们是要付费的，但是ORB（Oriented Fast and Rotated Brief）不需要，它可以用来对图像中的关键点快速创建特征向量，并用这些特征向量来识别图像中的对象。

2.1.1 ORB算法流程

ORB算法结合了Fast和Brief算法，提出了构造金字塔，为Fast特征点添加了方向，从而使得关键点具有了尺度不变性和旋转不变性。具体流程描述如下：

构造尺度金字塔，金字塔共有n层，与SIFT不同的是，每一层仅有一幅图像。第s层的尺度为：

σs = σ0s

σ0

是初始尺度，默认为1.2，原图在第0层。

image-20191010145652681

第s层图像的大小：

SIZE = (H*\frac{1}{\sigma_s})\times(W*\frac{1}{\sigma_s})

在不同的尺度上利用Fast算法检测特征点，采用Harris角点响应函数，根据角点的响应值排序，选取前N个特征点，作为本尺度的特征点。
计算特征点的主方向，计算以特征点为圆心半径为r的圆形邻域内的灰度质心位置，将从特征点位置到质心位置的方向做特征点的主方向。

计算方法如下: mpq = ∑x, yxpyqI(x,y) 质心位置：

C=(\frac{m_{10}}{m_{00}},\frac{m_{01}}{m_{10}})

主方向： θ = arctan(m01,m10)

为了解决旋转不变性，将特征点的邻域旋转到主方向上利用Brief算法构建特征描述符，至此就得到了ORB的特征描述向量。

2.1.2 BRIEF算法

BRIEF是一种特征描述子提取算法，并非特征点的提取算法，一种生成二值化描述子的算法，不提取代价低，匹配只需要使用简单的汉明距离(Hamming Distance)利用比特之间的异或操作就可以完成。因此，时间代价低，空间代价低，效果还挺好是最大的优点。

算法的步骤介绍如下：

图像滤波：原始图像中存在噪声时，会对结果产生影响，所以需要对图像进行滤波，去除部分噪声。
选取点对：以特征点为中心，取S*S的邻域窗口，在窗口内随机选取N组点对，一般N=128,256,512，默认是256，关于如何选取随机点对，提供了五种形式，结果如下图所示：
- x,y方向平均分布采样
- x,y均服从Gauss(0,S^2/25)各向同性采样
- x服从Gauss(0,S2/25)，y服从Gauss(0,S2/100)采样
- x,y从网格中随机获取
- x一直在(0,0)，y从网格中随机选取
  image-20191010153907973
图中一条线段的两个端点就是一组点对，其中第二种方法的结果比较好。
构建描述符：假设x,y是某个点对的两个端点，p(x),p(y)是两点对应的像素值，则有：

t(x,y)=\begin{cases}1 &if p(x)>p(y)\\ 0& else\end{cases}

对每一个点对都进行上述的二进制赋值，形成BRIEF的关键点的描述特征向量，该向量一般为 128-512 位的字符串，其中仅包含 1 和 0，如下图所示：

![](https://www.notion.soPython3%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0.assets/image-20191010161944491-17063575560517.png)

image-20191010161944491

2-2 实现

在OPenCV中实现ORB算法，使用的是：

1.实例化ORB

orb = cv.xfeatures2d.orb_create(nfeatures)

参数：

nfeatures: 特征点的最大数量

2.利用orb.detectAndCompute()检测关键点并计算

kp,des = orb.detectAndCompute(gray,None)

参数：

gray: 进行关键点检测的图像，注意是灰度图像

kp: 关键点信息，包括位置，尺度，方向信息
des: 关键点描述符，每个关键点BRIEF特征向量，二进制字符串，

3.将关键点检测结果绘制在图像上

cv.drawKeypoints(image, keypoints, outputimage, color, flags)

示例：

import numpy as np
import cv2 as cv
from matplotlib import pyplot as plt
# 1 图像读取img = cv.imread('./image/tv.jpg')
# 2 ORB角点检测# 2.1 实例化ORB对象orb = cv.ORB_create(nfeatures=500)
# 2.2 检测关键点,并计算特征描述符kp,des = orb.detectAndCompute(img,None)
print(des.shape)
# 3 将关键点绘制在图像上img2 = cv.drawKeypoints(img, kp, None, color=(0,0,255), flags=0)
# 4. 绘制图像plt.figure(figsize=(10,8),dpi=100)
plt.imshow(img2[:,:,::-1])
plt.xticks([]), plt.yticks([])
plt.show()

image-20240127201959110

4，视频操作

4-1 视频读写

4-1-1 从文件中读取视频并播放

在OpenCV中我们要获取一个视频，需要创建一个VideoCapture对象，指定你要读取的视频文件：

1-1 创建读取视频的对象

cap = cv.VideoCapture(filepath)

参数：

filepath: 视频文件路径

视频的属性信息

2.1. 获取视频的某些属性，

retval = cap.get(propId)

参数：

propId: 从0到18的数字，每个数字表示视频的属性
常用属性有：
image-20240127220126914

2.2 修改视频的属性信息

cap.set(propId，value)

参数：

proid: 属性的索引，与上面的表格相对应
value: 修改后的属性值

判断图像是否读取成功
```
isornot = cap.isOpened()
```
- 若读取成功则返回true，否则返回False
获取视频的一帧图像
```
ret, frame = cap.read()
```
参数：
- ret: 若获取成功返回True，获取失败，返回False
- Frame: 获取到的某一帧的图像
调用cv.imshow()显示图像，在显示图像时使用cv.waitkey()设置适当的持续时间，如果太低视频会播放的非常快，如果太高就会播放的非常慢，通常情况下我们设置25ms就可以了。
最后，调用cap.realease()将视频释放掉

示例：

import numpy as np
import cv2 as cv
# 1.获取视频对象cap = cv.VideoCapture('DOG.wmv')
# 2.判断是否读取成功while(cap.isOpened()):
    # 3.获取每一帧图像    ret, frame = cap.read()
    # 4. 获取成功显示图像    if ret == True:
        cv.imshow('frame',frame)
    # 5.每一帧间隔为25ms    if cv.waitKey(25) & 0xFF == ord('q'):
        break# 6.释放视频对象cap.release()
cv.destoryAllwindows()

4-1-2 保存视频

在OpenCV中我们保存视频使用的是VedioWriter对象，在其中指定输出文件的名称，如下所示：

创建视频写入的对象

out = cv2.VideoWriter(filename,fourcc, fps, frameSize)

参数：

filename：视频保存的位置
fourcc：指定视频编解码器的4字节代码
fps：帧率
frameSize：帧大小
设置视频的编解码器，如下所示，
```
retval = cv2.VideoWriter_fourcc( c1, c2, c3, c4 )
```
参数：
- c1,c2,c3,c4: 是视频编解码器的4字节代码，在fourcc.org中找到可用代码列表，与平台紧密相关，常用的有：
  在Windows中：DIVX（.avi）
  在OS中：MJPG（.mp4），DIVX（.avi），X264（.mkv）。
利用cap.read()获取视频中的每一帧图像，并使用out.write()将某一帧图像写入视频中。
使用cap.release()和out.release()释放资源。

示例：

import cv2 as cv
import numpy as np
# 1. 读取视频cap = cv.VideoCapture("DOG.wmv")
# 2. 获取图像的属性（宽和高，）,并将其转换为整数frame_width = int(cap.get(3))
frame_height = int(cap.get(4))
# 3. 创建保存视频的对象，设置编码格式，帧率，图像的宽高等out = cv.VideoWriter('outpy.avi',cv.VideoWriter_fourcc('M','J','P','G'), 10, (frame_width,frame_height))
while(True):
    # 4.获取视频中的每一帧图像    ret, frame = cap.read()
    if ret == True:
        # 5.将每一帧图像写入到输出文件中        out.write(frame)
    else:
        break
# 6.释放资源cap.release()
out.release()
cv.destroyAllWindows()

总结

读取视频：
- 读取视频：cap = cv.VideoCapture()
- 判断读取成功：cap.isOpened()
- 读取每一帧图像：ret,frame = cap.read()
- 获取属性：cap.get(proid)
- 设置属性：cap.set(proid,value)
- 资源释放：cap.release()
保存视频
- 保存视频： out = cv.VideoWrite()
- 视频写入：out.write()
- 资源释放：out.release()

import numpy as np
import cv2 as cv
# 1 获取视频cap = cv.VideoCapture('image/DOG.wmv')
# 2 指定追踪目标ret,frame = cap.read()
r,h,c,w=197,141,0,208win = (c,r,w,h)
roi = frame[r:r+h,c:c+w]
# 3 计算直方图hsv_roi = cv.cvtColor(roi,cv.COLOR_BGR2HSV)
roi_hist = cv.calcHist([hsv_roi],[0],None,[180],[0,180])
cv.normalize(roi_hist,roi_hist,0,255,cv.NORM_MINMAX)
# 4 目标追踪term = (cv.TERM_CRITERIA_EPS|cv.TERM_CRITERIA_COUNT,10,1)
while(True):
    ret,frame = cap.read()
    if ret ==True:
        hst = cv.cvtColor(frame,cv.COLOR_BGR2HSV)
        dst = cv.calcBackProject([hst],[0],roi_hist,[0,180],1)
        ret,win = cv.meanShift(dst,win,term)
        x,y,w,h = win
        img2 = cv.rectangle(frame,(x,y),(x+w,y+h),255,2)
        cv.imshow("frame",img2)
        if cv.waitKey(60)&0xFF ==ord('q'):
            break# 5 释放资源cap.release()
cv.destroyAllWindows()

5，人脸识别案例

5-1 基础

我们使用机器学习的方法完成人脸检测，首先需要大量的正样本图像（面部图像）和负样本图像（不含面部的图像）来训练分类器。我们需要从其中提取特征。下图中的 Haar 特征会被使用，就像我们的卷积核，每一个特征是一个值，这个值等于黑色矩形中的像素值之后减去白色矩形中的像素值之和。

image-20240127223249553

Haar特征值反映了图像的灰度变化情况。例如：脸部的一些特征能由矩形特征简单的描述，眼睛要比脸颊颜色要深，鼻梁两侧比鼻梁颜色要深，嘴巴比周围颜色要深等。

Haar特征可用于于图像任意位置，大小也可以任意改变，所以矩形特征值是矩形模版类别、矩形位置和矩形大小这三个因素的函数。故类别、大小和位置的变化，使得很小的检测窗口含有非常多的矩形特征。

image-20240127223300408

得到图像的特征后，训练一个决策树构建的adaboost级联决策器来识别是否为人脸。

image-20240127223312363

5-2.实现

OpenCV中自带已训练好的检测器，包括面部，眼睛，猫脸等，都保存在XML文件中，我们可以通过以下程序找到他们：

import cv2 as cv
print(cv.__file__)

找到的文件如下所示：

image-20240127223338348

那我们就利用这些文件来识别人脸，眼睛等。检测流程如下：

读取图片，并转换成灰度图

实例化人脸和眼睛检测的分类器对象

# 实例化级联分类器classifier =cv.CascadeClassifier( "haarcascade_frontalface_default.xml" )
# 加载分类器classifier.load('haarcascade_frontalface_default.xml')

进行人脸和眼睛的检测
```
rect = classifier.detectMultiScale(gray, scaleFactor, minNeighbors, minSize,maxsize)
```
参数：
- Gray: 要进行检测的人脸图像
- scaleFactor: 前后两次扫描中，搜索窗口的比例系数
- minneighbors：目标至少被检测到minNeighbors次才会被认为是目标
- minsize和maxsize: 目标的最小尺寸和最大尺寸
将检测结果绘制出来就可以了。

主程序如下所示：

import cv2 as cv
import matplotlib.pyplot as plt
# 1.以灰度图的形式读取图片img = cv.imread("16.jpg")
gray = cv.cvtColor(img,cv.COLOR_BGR2GRAY)
# 2.实例化OpenCV人脸和眼睛识别的分类器face_cas = cv.CascadeClassifier( "haarcascade_frontalface_default.xml" )
face_cas.load('haarcascade_frontalface_default.xml')
eyes_cas = cv.CascadeClassifier("haarcascade_eye.xml")
eyes_cas.load("haarcascade_eye.xml")
# 3.调用识别人脸faceRects = face_cas.detectMultiScale( gray, scaleFactor=1.2, minNeighbors=3, minSize=(32, 32))
for faceRect in faceRects:
    x, y, w, h = faceRect
    # 框出人脸    cv.rectangle(img, (x, y), (x + h, y + w),(0,255,0), 3)
    # 4.在识别出的人脸中进行眼睛的检测    roi_color = img[y:y+h, x:x+w]
    roi_gray = gray[y:y+h, x:x+w]
    eyes = eyes_cas.detectMultiScale(roi_gray)
    for (ex,ey,ew,eh) in eyes:
        cv.rectangle(roi_color,(ex,ey),(ex+ew,ey+eh),(0,255,0),2)
# 5. 检测结果的绘制plt.figure(figsize=(8,6),dpi=100)
plt.imshow(img[:,:,::-1]),plt.title('检测结果')
plt.xticks([]), plt.yticks([])
plt.show()

结果：

image-20240127223403034

import cv2 as cv
import matplotlib.pyplot as plt
img = cv.imread('./img/yangzi.jpg')
gray = cv.cvtColor(img,cv.COLOR_BGR2GRAY)
# 实例化检测器face_cas = cv.CascadeClassifier( "D:\\Users\\anaconda3\\Lib\\site-packages\\cv2\\data\\haarcascade_frontalface_default.xml" )
face_cas.load('D:\\Users\\anaconda3\\Lib\\site-packages\\cv2\\data\\haarcascade_frontalface_default.xml')
eyes_cas = cv.CascadeClassifier("D:\\Users\\anaconda3\\Lib\\site-packages\cv2\\data\\haarcascade_eye.xml")
eyes_cas.load("D:\\Users\\anaconda3\\Lib\\site-packages\cv2\\data\\haarcascade_eye.xml")
# 人脸检测face_rects = face_cas.detectMultiScale(gray,scaleFactor =1.2,minNeighbors = 3,minSize=(32,32))
# 绘制人脸检测眼睛for facerect in face_rects:
    x,y,w,h = facerect
    cv.rectangle(img,(x,y),(x+w,y+h),(0,255,0),3)
    roi_color = img[y:y+h,x:x+w]
    roi_gray = gray[y:y+h,x:x+w]
    eyes = eyes_cas.detectMultiScale(roi_gray)
    for (ex,ey,ew,eh) in eyes:
        cv.rectangle(roi_color,(ex,ey),(ex+ew,ey+eh),(0,255,0),3)
plt.figure(figsize=(8,6),dpi=100)
plt.imshow(img[:,:,::-1]),plt.title('检测结果')
plt.xticks([]), plt.yticks([])
plt.imshow(img[:,:,::-1])

我们也可在视频中对人脸进行检测：

import cv2 as cv
import matplotlib.pyplot as plt
# 1.读取视频cap = cv.VideoCapture("movie.mp4")
# 2.在每一帧数据中进行人脸识别while(cap.isOpened()):
    ret, frame = cap.read()
    if ret==True:
        gray = cv.cvtColor(frame, cv.COLOR_BGR2GRAY)
        # 3.实例化OpenCV人脸识别的分类器        face_cas = cv.CascadeClassifier( "haarcascade_frontalface_default.xml" )
        face_cas.load('haarcascade_frontalface_default.xml')
        # 4.调用识别人脸        faceRects = face_cas.detectMultiScale(gray, scaleFactor=1.2, minNeighbors=3, minSize=(32, 32))
        for faceRect in faceRects:
            x, y, w, h = faceRect
            # 框出人脸            cv.rectangle(frame, (x, y), (x + h, y + w),(0,255,0), 3)
        cv.imshow("frame",frame)
        if cv.waitKey(1) & 0xFF == ord('q'):
            break# 5. 释放资源cap.release()
cv.destroyAllWindows()

总结

opencv中人脸识别的流程是：

读取图片，并转换成灰度图
实例化人脸和眼睛检测的分类器对象

# 实例化级联分类器classifier =cv.CascadeClassifier( "haarcascade_frontalface_default.xml" )
# 加载分类器classifier.load('haarcascade_frontalface_default.xml')

进行人脸和眼睛的检测

rect = classifier.detectMultiScale(gray, scaleFactor, minNeighbors, minSize,maxsize)

将检测结果绘制出来就可以了。

我们也可以在视频中进行人脸识别

import numpy as np
print ('13 的位反转，其中 ndarray 的 dtype 是 uint8：')
print (np.invert(np.array([13], dtype = np.uint8)))
print ('\n')
# 比较 13 和 242 的二进制表示，我们发现了位的反转print ('13 的二进制表示：')
print (np.binary_repr(13, width = 8))
print ('\n')
print ('242 的二进制表示：')
print (np.binary_repr(242, width = 8))

13 的位反转，其中 ndarray 的 dtype 是 uint8：
[242]

13 的二进制表示：
00001101

242 的二进制表示：
11110010

import numpy as np
print ('将 40 右移两位：')
print (np.right_shift(40,2))
print ('\n')
print ('40 的二进制表示：')
print (np.binary_repr(40, width = 8))
print ('\n')
print ('10 的二进制表示：')
print (np.binary_repr(10, width = 8))
#  '00001010' 中的两位移动到了右边，并在左边添加了两个 0。

numpy.char.encode() 函数对数组中的每个元素调用 str.encode 函数。默认编码是 utf-8，可以使用标准 Python 库中的编解码器。

b'\x99\xa4\x95\x96\x96\x82'runoob

2-1 numpy.around()

import numpy as np
a = np.array([-1.7,  1.5,  -0.2,  0.6,  10])
print  ('提供的数组：')
print (a)
print ('\n')
print ('修改后的数组：')
print (np.ceil(a))