计算机视觉和图像处理

1. Tensorflow入门
2. 深度神经网络
3. 图像分类
4. 目标检测
5. 图像分割
6. OpenCV
7. Pytorch
8. NLP自然语言处理

一、OpenCV简介

1.1 简介

OpenCV是⼀个计算机视觉处理开源软件库，⽀持与计算机视觉和机器学习相关的众多算法。

1.2 OpenCV部署

1. 创建虚拟环境
   在Anaconda终端中创建虚拟环境OpenCV_env

conda create --name OpenCV_env

2. 激活虚拟环境

conda activate OpenCV_env

3. 安装OpenCV

安装OpenCV之前需要先安装numpy, matplotlib

pip install opencv-python -i https://pypi.tuna.tsinghua.edu.cn/simple

如果我们要利用SIFT和SURF算法进行特征提取时，还需安装：

pip install opencv-contrib-python -i https://pypi.tuna.tsinghua.edu.cn/simple

4. 查看是否安装成功

import cv2
cv2.__version__

1.3 OpenCV模块

• core模块实现了最核心的数据结构及其基本运算，如绘图函数、数组操作相关函数等。
• highgui模块实现了视频与图像的读取、显示、存储等接口。
• imgproc模块实现了图像处理的基础方法，包括图像滤波、图像的几何变换、平滑、阈值分割、形态学处理、边缘检测、目标检测、运动分析和对象跟踪等。
• features2d模块用于提取图像特征以及特征匹配，nonfree模块实现了一些专利算法，如sift特征。
• objdetect模块实现了一些目标检测的功能，经典的基于Haar、LBP特征的人脸检测，基于HOG的行人、汽车等目标检测，分类器使用CascadeClassification（级联分类）和Latent SVM等。

二、OpenCV基本操作

2.1 图像的基本操作

2.1.1 图像的IO操作

# 读取图像
import numpy as np
import cv2 as cv
import matplotlib.pyplot as plt

#以灰度图的方式读取图像
img = cv.imread("dog.jpg",0)

# 显示图像
# Jupyter Notebook 是一个基于 Web 的交互式计算环境，不支持传统的 GUI 窗口显示
# cv.imshow('image',img)
# cv.waitKey(0)
plt.imshow(img,cmap='gray')

# 以彩色图的方式读取图像
img1 = cv.imread("dog.jpg",1)
# img1[:,:,::-1]将BGR图像转换为RGB图像
plt.imshow(img1[:,:,::-1])

使用cv.imread()读取的图像是BGR，而matplot使用是的RGB图像

img.shape

# 图像保存
cv.imwrite('dog1.jpg',img)

2.1.2 绘制几何图像

# 创建图像
img = np.zeros((512,512,3),np.uint8)

# 直线的起点、终点、颜色、宽度
cv.line(img,(0,0),(512,512),(255,0,0),5)
# 圆形的圆心、半径、颜色、填充、宽度
cv.circle(img,(250,250),130,(0,255,0),-1,5)
# 矩形的左上角、右下角、颜色、宽度
cv.rectangle(img,(50,50),(450,450),(0,0,255),5)
# 图像中添加文字  文本、位置、字体、字体大小、颜色、宽度
cv.putText(img,"OpenCV",(130,250),cv.FONT_HERSHEY_COMPLEX,2,(255,0,255),2)
plt.imshow(img[:,:,::-1])
plt.show()

2.1.3 获取并修改图像的像素点

img2 = np.zeros((250,250,3),np.uint8)
plt.imshow(img2[:,:,::-1])

# 获取位置（50，200）的像素点
img2[50,200]

#获取位置（50，100）蓝色通道的强度值，0表示蓝色，1表示绿色，2表示红色
img2[50,100,0]

# 修改位置（50，100）的像素值
img2[50,100] = [255,0,0]

plt.imshow(img2[:,:,::-1])

2.1.4 获取图像的属性

img2.shape

img2.size

img2.dtype

2.1.5 图像通道的拆分和合并

# 通道拆分
b,g,r = cv.split(img1)

plt.imshow(b,cmap='gray')

# 通道合并
img3 = cv.merge((b,g,r))

plt.imshow(img3[:,:,::-1])

2.1.6 色彩空间的改变

# 将BGR通道图像转变为HSV通道图像
img3 = cv.cvtColor(img1,cv.COLOR_BGR2HSV)

plt.imshow(img3[:,:,::-1])

# 将BGR通道图像变为GRAY通道图像
img4 = cv.cvtColor(img1,cv.COLOR_BGR2GRAY)

plt.imshow(img4,cmap='gray')

2.2 算数操作

2.2.1 图像的加法

# 读取图像
img_sun = cv.imread('sun.jpg')
img_tree = cv.imread('tree.jpg')

plt.imshow(img_tree[:,:,::-1])

plt.imshow(img_sun[:,:,::-1])

# 查看图像形状
img_sun.shape,img_tree.shape

形状相同才能进行相加

# 缩小图形形状
img_sun = cv.resize(img_sun,(350,251))

img_sun.shape

# 加法操作
img_cvadd = cv.add(img_sun,img_tree)
img_add = img_sun+img_tree

fig,axes = plt.subplots(1,2,figsize=(10,8))
axes[0].imshow(img_cvadd[:,:,::-1])
axes[0].set_title("cv中的加法")
axes[1].imshow(img_add[:,:,::-1])
axes[1].set_title("直接相加")
plt.show()

2.2.2 图像的混合

# 读取图像
img_sun = cv.imread('sun.jpg')
img_tree = cv.imread('tree.jpg')

# 缩小图形形状
img_sun = cv.resize(img_sun,(350,251))

# 图像混合，gamma参数会影响最终图像的亮度
img5 = cv.addWeighted(img_sun,0.3,img_tree,0.7,0)

# 图像的显示
plt.imshow(img5[:,:,::-1])
plt.show()

三、OpenCV图像处理

3.1 图像的几何变换

import cv2 as cv
import matplotlib.pyplot as plt

1. 图像缩放

# 读取图片
img = cv.imread('dog.jpg')

# 图像缩放
# 绝对尺寸
rows,cols = img.shape[:2]
res = cv.resize(img,(2*cols,2*rows))
# 相对尺寸
res1 = cv.resize(img,None,fx=0.5,fy=0.5)

# 图像显示
fig,axes = plt.subplots(1,3,figsize=(10,8))
axes[0].imshow(img[:,:,::-1])
axes[0].set_title("原始图像")
axes[1].imshow(res[:,:,::-1])
axes[1].set_title("绝对尺寸")
axes[2].imshow(res1[:,:,::-1])
axes[2].set_title("相对尺寸")
plt.show()

2. 图像平移

import numpy as np

img = cv.imread('dog.jpg')

# 像素点平移（50，100）
rows,cols = img.shape[:2]
# 平移矩阵
m = np.float32([[1,0,50],[0,1,100]])
res = cv.warpAffine(img,m,(cols,rows))

fig,axes = plt.subplots(1,2,figsize=(10,8))
axes[0].imshow(img[:,:,::-1])
axes[0].set_title("原始图像")
axes[1].imshow(res[:,:,::-1])
axes[1].set_title("平移后图像")
plt.show()

3. 图像旋转

img = cv.imread("dog.jpg")

rows,cols = img.shape[:2]
# 旋转矩阵
m = cv.getRotationMatrix2D((cols//2,rows//2),90,0.5)
res = cv.warpAffine(img,m,(cols,rows))

fig,axes = plt.subplots(1,2,figsize=(10,8))
axes[0].imshow(img[:,:,::-1])
axes[0].set_title("原始图像")
axes[1].imshow(res[:,:,::-1])
axes[1].set_title("旋转后图像")
plt.show()

4. 仿射变换

rows,cols = img.shape[:2]
# 原点集
pts1 = np.float32([[50,50],[200,50],[50,200]])
# 目标点集
pts2 = np.float32([[100,100],[200,50],[100,250]])
# 仿射变化矩阵
m = cv.getAffineTransform(pts1,pts2)

res = cv.warpAffine(img,m,(cols,rows))

fig,axes = plt.subplots(1,2,figsize=(10,8))
axes[0].imshow(img[:,:,::-1])
axes[0].set_title("原始图像")
axes[1].imshow(res[:,:,::-1])
axes[1].set_title("仿射后图像")
plt.show()

5. 投射变换

img = cv.imread("dog.jpg")

rows,cols = img.shape[:2]
# 投射变换矩阵
pts1 = np.float32([[56,65],[368,52],[28,387],[389,390]])
pts2 = np.float32([[100,145],[300,100],[80,290],[310,300]])
m = cv.getPerspectiveTransform(pts1,pts2)
# 进行变换
res = cv.warpPerspective(img,m,(cols,rows))

fig,axes = plt.subplots(1,2,figsize=(10,8))
axes[0].imshow(img[:,:,::-1])
axes[0].set_title("原图像")
axes[1].imshow(res[:,:,::-1])
axes[1].set_title("仿射后图像")
plt.show()

6. 图像金字塔

img = cv.imread("dog.jpg")

# 上采样
img_up = cv.pyrUp(img)
# 下采样
img_down = cv.pyrDown(img)

fig,axes = plt.subplots(1,3,figsize=(10,8))
axes[0].imshow(img[:,:,::-1])
axes[0].set_title("原图像")
axes[1].imshow(img_up[:,:,::-1])
axes[1].set_title("上采样图像")
axes[2].imshow(img_down[:,:,::-1])
axes[2].set_title("下采样图像")
plt.show()

3.2 图像的形态学操作

1. 膨胀和腐蚀

img = cv.imread("img_five.jpg")

# 创建核结构
kernel = np.ones((5,5),np.uint8)

# 腐蚀
erode = cv.erode(img,kernel)
# 膨胀
dilate = cv.dilate(img,kernel)

fig,axes = plt.subplots(1,3,figsize=(10,8))
axes[0].imshow(img[:,:,::-1])
axes[0].set_title("原图像")
axes[1].imshow(erode[:,:,::-1])
axes[1].set_title("腐蚀后图像")
axes[2].imshow(dilate[:,:,::-1])
axes[2].set_title("膨胀后图像")
plt.show()

2. 开闭运算

img_1 = cv.imread('img1.png')
img_2 = cv.imread('img2.png')

kernel = np.ones((10,10),np.uint8)
Open = cv.morphologyEx(img_1,cv.MORPH_OPEN,kernel)
Close = cv.morphologyEx(img_2,cv.MORPH_CLOSE,kernel)

fig,axes = plt.subplots(2,2,figsize=(10,8))
axes[0][0].imshow(img_1[:,:,::-1])
axes[0][0].set_title("原图像")
axes[0,1].imshow(Open[:,:,::-1])
axes[0,1].set_title("开运算图像")
axes[1,0].imshow(img_2[:,:,::-1])
axes[1,0].set_title("原图像")
axes[1,1].imshow(Close[:,:,::-1])
axes[1,1].set_title("闭运算图像")
plt.show()

3. 礼貌和黑帽

img_1 = cv.imread("img1.png")
img_2 = cv.imread("img2.png")

kernel = np.ones((10,10),np.uint8)
Open = cv.morphologyEx(img_1,cv.MORPH_TOPHAT,kernel)
Close = cv.morphologyEx(img_2,cv.MORPH_BLACKHAT,kernel)

fig,axes = plt.subplots(2,2,figsize=(10,8))
axes[0][0].imshow(img_1[:,:,::-1])
axes[0][0].set_title("原图像")
axes[0,1].imshow(Open[:,:,::-1])
axes[0,1].set_title("礼帽运算结果")
axes[1,0].imshow(img_2[:,:,::-1])
axes[1,0].set_title("原图像")
axes[1,1].imshow(Close[:,:,::-1])
axes[1,1].set_title("黑帽运算结果")
plt.show()

3.3 图像的平滑

img_girl= cv.imread("girl_img.png")

# 均值滤波
blur = cv.blur(img_girl,(7,7))
# 高斯滤波
gaublur = cv.GaussianBlur(img_girl,(9,9),0)
# 中值滤波
medblur = cv.medianBlur(img_girl,5)

fig,axes = plt.subplots(2,2,figsize=(10,8))
axes[0][0].imshow(img_girl[:,:,::-1])
axes[0][0].set_title("原图像")
axes[0,1].imshow(blur[:,:,::-1])
axes[0,1].set_title("均值滤波运算结果")
axes[1,0].imshow(gaublur[:,:,::-1])
axes[1,0].set_title("高斯滤波结果")
axes[1,1].imshow(medblur[:,:,::-1])
axes[1,1].set_title("中值滤波结果")
plt.show()

3.4 直方图

3.1.4 灰度直方图

1. 直方图的计算和绘制

img_dog = cv.imread("dog.jpg",0)

# 统计灰度图
histr = cv.calcHist(img_dog,[0],None,[256],[0,256])

fig,axes = plt.subplots(1,2,figsize=(18,6))
axes[0].imshow(img_dog,cmap='gray')
axes[1].plot(histr)
axes[1].grid()
axes[1].set_xlabel('Pixel Value')
axes[1].set_ylabel('Frequency')
# 调整布局
plt.tight_layout()
plt.show()

2. 掩码的应用

img_dog1 = cv.imread("dog.jpg",0)

# 创建遮挡
mask = np.zeros(img_dog1.shape[:2],np.uint8)
mask[50:130,150:230] = 255

# 进行按位与运算
mask_img = cv.bitwise_and(img_dog1,img_dog1,mask=mask)

mask_histr = cv.calcHist([img_dog1],[0],mask,[256],[0,256])

fig,axes = plt.subplots(2,2,figsize=(10,8))
axes[0,0].imshow(img_dog1,cmap='gray')
axes[0,0].set_title("原图")
axes[0,1].imshow(mask,cmap='gray')
axes[0,1].set_title("遮挡")
axes[1,0].imshow(mask_img,cmap="gray")
axes[1,0].set_title("遮挡后数据")
axes[1,1].plot(mask_histr)
axes[1,1].set_title("灰度直方图")
plt.show()

3.1.5 直方图均衡化

1. 应用

img_dog = cv.imread("dog.jpg",0)

dst = cv.equalizeHist(img_dog)

fig,axes = plt.subplots(1,2,figsize=(18,6))
axes[0].imshow(img_dog,cmap='gray')
axes[0].set_title("原图")
axes[1].imshow(dst,cmap='gray')
axes[1].set_title("均衡化后的结果")
# plt.tight_layout()
plt.show()

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

img_dog = cv.imread("dog.jpg",0)

clahe = cv.createCLAHE(clipLimit=2,tileGridSize=(12,12))
cl1 = clahe.apply(img_dog)

fig,axes = plt.subplots(1,2,figsize=(10,8))
axes[0].imshow(img_dog,cmap="gray")
axes[0].set_title("原图")
axes[1].imshow(cl1,cmap="gray")
axes[1].set_title("自适应后图像")
plt.show()

3.5 边缘检测

3.5.1 Sobel检测算子

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

img_horse = cv.imread("horse.jpg",0)

# 计算Sobel卷积结果（边缘检测）
x = cv.Sobel(img_horse,cv.CV_16S,1,0)
y = cv.Sobel(img_horse,cv.CV_16S,0,1)

# 数据转换（将其缩放到uint8）
scale_x = cv.convertScaleAbs(x)
scale_y = cv.convertScaleAbs(y)

# 结果合成 gamma为正亮度增加，0亮度不变，负数亮度降低
res = cv.addWeighted(scale_x,0.5,scale_y,0.5,0)

fig,axes = plt.subplots(1,2,figsize=(9,10))
axes[0].imshow(img_horse,cmap='gray')
axes[0].set_title("原图")
axes[1].imshow(res,cmap=plt.cm.gray)
axes[1].set_title("Sobel滤波后结果")
plt.show()

# ksize为-1时，使用3x3的Scharr滤波器
x = cv.Sobel(img_horse,cv.CV_16S,1,0,ksize=-1)
y = cv.Sobel(img_horse,cv.CV_16S,0,1,ksize=-1)

scale_x = cv.convertScaleAbs(x)
scale_y = cv.convertScaleAbs(y)
res = cv.addWeighted(scale_x,0.5,scale_y,0.5,0)

fig,axes = plt.subplots(1,2,figsize=(9,10))
axes[0].imshow(img_horse,cmap='gray')
axes[0].set_title("原图")
axes[1].imshow(res,cmap=plt.cm.gray)
axes[1].set_title("Scharr滤波后结果")
plt.show()

3.5.2 Laplacian算子

img_horse = cv.imread("horse.jpg",0)

res = cv.Laplacian(img_horse,cv.CV_16S,ksize=3)
scale_res = cv.convertScaleAbs(res)

fig,axes = plt.subplots(1,2,figsize=(9,10))
axes[0].imshow(img_horse,cmap='gray')
axes[0].set_title("原图")
axes[1].imshow(scale_res,cmap=plt.cm.gray)
axes[1].set_title("Laplacian滤波后结果")
plt.show()

3.5.3 Canny边缘检测

img_horse = cv.imread("horse.jpg",0)

# Canny边缘检测，min_threshold最小阈值
min_threshold = 20
max_threshold = 100
res = cv.Canny(img_horse,min_threshold,max_threshold)

fig,axes = plt.subplots(1,2,figsize=(9,10))
axes[0].imshow(img_horse,cmap='gray')
axes[0].set_title("原图")
axes[1].imshow(res,cmap=plt.cm.gray)
axes[1].set_title("Canny滤波后结果")
plt.show()

3.6 模板匹配和霍夫变换的应用

3.6.1 模板匹配

img_party = cv.imread("party.jpg")
template = cv.imread("template.jpg")

h,w = template.shape[:2]

# 模板匹配
res = cv.matchTemplate(img_party,template,cv.TM_SQDIFF)
# 返回图像最佳匹配位置，确定左上角的坐标
min_val,max_val,min_loc,max_loc = cv.minMaxLoc(res)

# 使用平方差时(cv.TM_SQDIFF)最小值为最佳匹配位置
top_left = min_loc
bottom_right = (top_left[0]+h,top_left[1]+w)

cv.rectangle(img_party,top_left,bottom_right,(0,255,0),2)
fig,axes = plt.subplots(1,2,figsize=(10,8),gridspec_kw={'width_ratios': [1, 6]})
axes[0].imshow(template[:,:,::-1])
axes[0].set_title("匹配模板")
axes[1].imshow(img_party[:,:,::-1])
axes[1].set_title("匹配结果")
plt.tight_layout()
plt.show()

3.6.2 霍夫变换

# 读取图像
img_rili = cv.imread("rili.jpg")

# 使用Canny转换为二值图
gray = cv.cvtColor(img_rili,cv.COLOR_BGR2GRAY)
edges = cv.Canny(gray,100,200)

# 霍夫直线变换
lines = cv.HoughLines(edges,0.8,np.pi/180,150)

# 检查是否检测到直线
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_rili, (x1, y1), (x2, y2), (0, 0, 255), 2)

# 使用matplotlib显示图像
plt.imshow(img_rili[:, :, ::-1])
plt.xticks([]), plt.yticks([])
plt.title("霍夫变换直线检测")
plt.show()

3.7 图像变化

3.7.1 傅里叶变换

读取图像： 读取图像并转换为灰度图像。 傅里叶变换： 正变换：将图像转换为频域表示。 频谱中心化：将频谱的低频部分移到中心，高频部分移到四周。 计算频谱和相位谱：将复数形式的频谱转换为幅度和相位，并对幅度谱进行对数变换。 傅里叶逆变换： 反变换：将频域表示转换回时域（或空域）。 计算灰度值：计算逆变换后的图像的幅度。 显示结果： 使用 matplotlib 显示原始图像、频谱图和逆变换后的图像。

img_dog= cv.imread("dog.jpg",0)

# 傅里叶正变换,cv.DFT_COMPLEX_OUTPUT：指定输出为复数形式
dft = cv.dft(np.float32(img_dog),flags=cv.DFT_COMPLEX_OUTPUT)
# 频谱中心化
dft_shift = np.fft.fftshift(dft)

# 计算频谱和相位谱
mag,angle = cv.cartToPolar(dft_shift[:,:,0],dft_shift[:,:,-1],angleInDegrees=True)
# 对幅度谱进行对数变换，以便更好地可视化。对数变换可以压缩动态范围，使图像的细节更明显。
mag = 20 * np.log(mag)

# 傅里叶反变换
img_back = cv.idft(dft)
img_back = cv.magnitude(img_back[:,:,0],img_back[:,:,1])

fig,axes = plt.subplots(2,2,figsize=(10,8))
axes[0,0].imshow(img_dog,cmap='gray')
axes[0,0].set_title("原图")
axes[0,1].imshow(mag,cmap='gray')
axes[0,1].set_title("频谱")
axes[1,0].imshow(angle,cmap='gray')
axes[1,0].set_title("相位谱")
axes[1,1].imshow(img_back,cmap='gray')
axes[1,1].set_title("逆变换结果")
plt.show()

3.7.2 高通和低通滤波

# 高通滤波
dog_img = cv.imread("dog.jpg",0)

rows,cols = dog_img.shape
mask = np.ones((rows,cols,2),np.uint8)
mask[int(rows/2)-30:int(rows/2)+30,int(cols/2)-30:int(cols/2)+30,:] = 0

# 正变换
dft = cv.dft(np.float32(dog_img),flags=cv.DFT_COMPLEX_OUTPUT)
# 频谱中心化
dft_shift = np.fft.fftshift(dft)
# 滤波(移除低频)
dft_shift = dft_shift * mask
# 频谱中心化
dft_shift = np.fft.fftshift(dft_shift)

# 反变化
img_back = cv.idft(dft_shift)
# 计算灰度值
img_back = cv.magnitude(img_back[:,:,0],img_back[:,:,1])

fig,axes = plt.subplots(1,2,figsize=(10,8))
axes[0].imshow(dog_img, cmap = 'gray') 
axes[0].set_title('原图')
axes[1].imshow(img_back, cmap = 'gray')
axes[1].set_title('高通滤波结果')
plt.show()

# 低通滤波
dog_img = cv.imread("dog.jpg",0)

rows,cols = dog_img.shape
mask = np.zeros((rows,cols,2),np.uint8)
mask[int(rows/2)-30:int(rows/2)+30,int(cols/2)-30:int(cols/2)+30,:] = 1

# 正变换
dft = cv.dft(np.float32(dog_img),flags=cv.DFT_COMPLEX_OUTPUT)
# 频谱中心化
dft_shift = np.fft.fftshift(dft)
# 滤波(移除低频)
dft_shift = dft_shift * mask
# 频谱中心化
dft_shift = np.fft.fftshift(dft_shift)

# 反变化
img_back = cv.idft(dft_shift)
# 计算灰度值
img_back = cv.magnitude(img_back[:,:,0],img_back[:,:,1])

fig,axes = plt.subplots(1,2,figsize=(10,8))
axes[0].imshow(dog_img, cmap = 'gray') 
axes[0].set_title('原图')
axes[1].imshow(img_back, cmap = 'gray')
axes[1].set_title('低通滤波结果')
plt.show()

3.7.3 带通和带阻滤波

# 带通滤波
dog_img = cv.imread("dog.jpg",0)

rows,cols = dog_img.shape
mask1 = np.ones((rows,cols,2),np.uint8)
mask1[int(rows/2)-8:int(rows/2)+8,int(cols/2)-8:int(cols/2)+8] = 0
mask2 = np.zeros((rows,cols,2),np.uint8)
mask2[int(rows/2)-80:int(rows/2)+80,int(cols/2)-80:int(cols/2)+80] = 1
mask = mask1*mask2

# 正变换
dft = cv.dft(np.float32(dog_img),flags=cv.DFT_COMPLEX_OUTPUT)
# 频谱中心化
dft_shift = np.fft.fftshift(dft)
# 滤波(移除低频)
dft_shift = dft_shift * mask
# 频谱中心化
dft_shift = np.fft.fftshift(dft_shift)

# 反变化
img_back = cv.idft(dft_shift)
# 计算灰度值
img_back = cv.magnitude(img_back[:,:,0],img_back[:,:,1])

fig,axes = plt.subplots(1,2,figsize=(10,8))
axes[0].imshow(dog_img, cmap = 'gray') 
axes[0].set_title('原图')
axes[1].imshow(img_back, cmap = 'gray')
axes[1].set_title('带通滤波结果')
plt.show()

# 带阻滤波
dog_img = cv.imread("dog.jpg",0)

rows,cols = dog_img.shape
mask = np.ones((rows,cols,2),np.uint8)
mask[int(rows/2)+60:int(rows/2)+130,int(cols/2)-130:int(cols/2)+130] = 0
mask[int(rows/2)-130:int(rows/2)-60,int(cols/2)-130:int(cols/2)+130] = 0
mask[int(rows/2)-130:int(rows/2)+130,int(cols/2)+60:int(cols/2)+130] = 0
mask[int(rows/2)-130:int(rows/2)+130,int(cols/2)-130:int(cols/2)-60] = 0

# 正变换
dft = cv.dft(np.float32(dog_img),flags=cv.DFT_COMPLEX_OUTPUT)
# 频谱中心化
dft_shift = np.fft.fftshift(dft)
# 滤波(移除低频)
dft_shift = dft_shift * mask
# 频谱中心化
dft_shift = np.fft.fftshift(dft_shift)

# 反变化
img_back = cv.idft(dft_shift)
# 计算灰度值
img_back = cv.magnitude(img_back[:,:,0],img_back[:,:,1])

fig,axes = plt.subplots(1,2,figsize=(10,8))
axes[0].imshow(dog_img, cmap = 'gray') 
axes[0].set_title('原图')
axes[1].imshow(img_back, cmap = 'gray')
axes[1].set_title('带阻滤波结果')
plt.show()

3.8 轮廓检测与轮廓特征

3.8.1 轮廓检测

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

ditu = cv.imread("ditu.jpg")
# 复制原图
img_ditu = ditu.copy()
imggray = cv.cvtColor(ditu,cv.COLOR_BGR2GRAY)
canny = cv.Canny(imggray,120,255)

# 轮廓提取
contours,hierarchy = cv.findContours(canny,cv.RETR_TREE,cv.CHAIN_APPROX_SIMPLE)
# 将轮廓绘制在图形上
img = cv.drawContours(ditu,contours,-1,(0,0,255),2)

fig,axes = plt.subplots(1,2,figsize=(10,8))
axes[0].imshow(img_ditu[:,:,::-1])
axes[0].set_title("原图")
axes[1].imshow(img[:,:,::-1])
axes[1].set_title("轮廓")
plt.show()

3.8.2 轮廓特征

1. 轮廓面积

area = sum(cv.contourArea(cnt) for cnt in contours)
area

2. 轮廓周长

perimeter = sum(cv.arcLength(cnt,True) for cnt in contours)
perimeter

3. 轮廓近似

# 读取图像
img = cv.imread("jinsi.jpg")

# 灰度转换
imggray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)

# 二值化处理
ret, thresh = cv.threshold(imggray, 127, 255, cv.THRESH_BINARY)

# 轮廓提取
contours, hierarchy = cv.findContours(thresh, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE)

# 初始化绘制图像
img_contours = img.copy()
img_approx = img.copy()

# 处理所有轮廓
for cnt in contours:
    # 计算轮廓的弧长
    arc_length = cv.arcLength(cnt, True)
    
    # 计算近似多边形
    epsilon = 0.1 * arc_length
    approx = cv.approxPolyDP(cnt, epsilon, True)
    
    # 绘制原始轮廓和近似多边形(-1表示绘制所有轮廓)
    img_contours = cv.drawContours(img_contours, [cnt], -1, (0, 255, 0), 2)
    img_approx = cv.drawContours(img_approx, [approx], -1, (0, 255, 0), 2)

# 显示图像
fig, axes = plt.subplots(1, 3, figsize=(10, 13))
axes[0].imshow(ditu[:, :, ::-1])
axes[0].set_title("原图")
axes[1].imshow(img_contours[:, :, ::-1])
axes[1].set_title("原始轮廓")
axes[2].imshow(img_approx[:, :, ::-1])
axes[2].set_title("近似多边形")
plt.show()

4. 凸包

star = cv.imread("star.jpg")

# 灰度处理
imggray = cv.cvtColor(star,cv.COLOR_BGR2GRAY)
# 边缘检测
canny = cv.Canny(imggray,50,200)

# 获取轮廓
contours,hierarchy = cv.findContours(canny,cv.RETR_TREE,cv.CHAIN_APPROX_SIMPLE)

# 图像复制
img_star = star.copy()

#凸包检测
Hulls = []
for cnt in contours:
    hull = cv.convexHull(cnt)
    Hulls.append(hull)

# 绘制图形
img_contour = cv.drawContours(star,contours,-1,(255,0,0),2)
img_hull = cv.drawContours(img_star,Hulls,-1,(255,0,0),2)

fig,axes = plt.subplots(1,2,figsize=(10,8))
axes[0].imshow(img_contour[:,:,::-1])
axes[0].set_title("轮廓检测结果")
axes[1].imshow(img_hull[:,:,::-1])
axes[1].set_title("凸包结果")
plt.show()

5. 边界矩形

rect = cv.imread("rect.jpg")

# 灰度处理
imggray = cv.cvtColor(rect,cv.COLOR_BGR2GRAY)
# 转换为二值化
ret,thresh = cv.threshold(imggray,127,255,0)

# 轮廓提取
contours,hierarchy = cv.findContours(thresh,cv.RETR_TREE,cv.CHAIN_APPROX_SIMPLE)

# 图像复制
rect_img = rect.copy()

# 直边界矩形
bounding_box = []
for cnt in contours:
    x,y,w,h = cv.boundingRect(cnt)
    bounding_box.append((x,y,w,h))
for x,y,w,h in bounding_box:
    cv.rectangle(rect,(x,y),(x+w,y+h),(0,255,0),2)


# 旋转边界矩形
min_area_rects = []
for cnt in contours:
    rect_min = cv.minAreaRect(cnt)
    box = cv.boxPoints(rect_min)
    box = np.int0(box)
    min_area_rects.append(box)
for box in min_area_rects:
    cv.polylines(rect_img,[box],True,(0,255,0),2)


fig,axes = plt.subplots(1,2,figsize=(10,8))
axes[0].imshow(rect[:,:,::-1])
axes[0].set_title("直边界矩形")
axes[0].set_xticks([]),axes[0].set_yticks([])
axes[1].imshow(rect_img[:,:,::-1])
axes[1].set_title("旋转边界矩形")
axes[1].set_xticks([]),axes[1].set_yticks([])
plt.show()

6. 最小外接圆

img = cv.imread("rect.jpg")

imggray = cv.cvtColor(img,cv.COLOR_BGR2GRAY)
ret,thresh = cv.threshold(imggray,127,255,0)

contours,hierarchy = cv.findContours(thresh,cv.RETR_TREE,cv.CHAIN_APPROX_SIMPLE)

boundings = []
for cnt in contours:
    (x,y),radius = cv.minEnclosingCircle(cnt)
    center = (int(x),int(y))
    radius = int(radius)
    boundings.append((center,radius))
for center,radius in boundings:
    cv.circle(img,center,radius,(0,255,0),2)

plt.imshow(img[:,:,::-1])
plt.xticks([])
plt.yticks([])
plt.show()

7. 椭圆拟合

img = cv.imread("rect.jpg")

imggray = cv.cvtColor(img,cv.COLOR_BGR2GRAY)
ret,thresh = cv.threshold(imggray,127,255,0)

contours,hierarchy = cv.findContours(thresh,cv.RETR_TREE,cv.CHAIN_APPROX_SIMPLE)

boundings = []
for cnt in contours:
    # 过滤掉点数少于5个和面积过小的轮廓
    if len(cnt) >= 5 and cv.contourArea(cnt) > 100:
        ellipse = cv.fitEllipse(cnt)
        boundings.append(ellipse)
for ellipse in boundings:
    cv.ellipse(img,ellipse,(0,255,0),2)

plt.imshow(img[:,:,::-1])
plt.xticks([])
plt.yticks([])
plt.show()

3.9 图像分割

3.9.1 全阈值分割

img = cv.imread("gradient.jpg",0)

ret,thresh1 = cv.threshold(img,127,255,cv.THRESH_BINARY)
ret,thresh2 = cv.threshold(img,127,255,cv.THRESH_BINARY_INV)
ret,thresh3 = cv.threshold(img,127,255,cv.THRESH_TRUNC)
ret,thresh4 = cv.threshold(img,127,255,cv.THRESH_TOZERO)
ret,thresh5 = cv.threshold(img,127,255,cv.THRESH_TOZERO_INV)

titles = ["原图","阈值二值化","阈值反二值化","截断","阈值取零","阈值反取零"]
images = [img,thresh1,thresh2,thresh3,thresh4,thresh5]
plt.figure(figsize=(10,8))
for i in range(6):
    plt.subplot(2,3,i+1)
    plt.imshow(images[i],cmap='gray')
    plt.title(titles[i])

plt.show()

3.9.2 自适应阈值分割

fruit = cv.imread("fruit.jpg",0)

# 固定阈值
ret,threshold = cv.threshold(fruit,127,225,cv.THRESH_BINARY)
# 自适应阈值
# 领域内求平均值
th1 = cv.adaptiveThreshold(fruit,255,cv.ADAPTIVE_THRESH_MEAN_C,cv.THRESH_BINARY,11,4)
# 领域内高斯加权
th2 = cv.adaptiveThreshold(fruit,255,cv.ADAPTIVE_THRESH_GAUSSIAN_C,cv.THRESH_BINARY,17,6)

title = ["原图","固定阈值","自适应阈值(求均值)","自适应阈值(高斯加权)"]
images = [fruit,threshold,th1,th2]

plt.figure(figsize=(10,8))
for i in range(4):
    plt.subplot(2,2,i+1)
    plt.imshow(images[i],cmap="gray")
    plt.title(title[i])
plt.show()

3.9.3 Ostu阈值（大律法）

littledog = cv.imread("littledog.jpg",0)

# 固定阈值
ret,thresh = cv.threshold(littledog,40,255,cv.THRESH_BINARY)
# ostu分割
ret1,thresh2 = cv.threshold(littledog,0,255,cv.THRESH_BINARY+cv.THRESH_OTSU)

fig,axes = plt.subplots(1,3,figsize=(10,8))
axes[0].imshow(littledog,cmap="gray")
axes[0].set_title("原图")
axes[1].imshow(thresh,cmap="gray")
axes[1].set_title("全阈值分割")
axes[2].imshow(thresh2,cmap="gray")
axes[2].set_title("OStu分割")
plt.show()

3.9.4 分水岭算法

img = cv.imread("horse.jpg")

imggray = cv.cvtColor(img,cv.COLOR_BGR2GRAY)
# 边缘检测
canny = cv.Canny(imggray,127,255)
# 轮廓检测
contours,hierarchy = cv.findContours(canny,cv.RETR_TREE,cv.CHAIN_APPROX_SIMPLE)
# 初始化标记图像
marks = np.zeros(img.shape[:2],np.int32)

# 绘制轮廓
for index in range(len(contours)):
    # index：-1 绘制所有的轮廓，非负数：要绘制的轮廓的索引
    marks = cv.drawContours(marks,contours,index,(index,index,index),1,8,hierarchy)

# 使用分水岭算法
# img必须是8位无符号整数的三通道图像，marks必须是32位有符号整数的单通道图像
# 返回值：正整数：表示该像素属于某个特定区域，-1表示该像素是区域的边界
marks = cv.watershed(img,marks)

# 生成随机颜色
colours = np.zeros((np.max(marks) + 1,3))
for i in  range(len(colours)):
    aa = np.random.uniform(0,255)
    bb = np.random.uniform(0,255)
    cc = np.random.uniform(0,255)
    colours[i] = np.array([aa,bb,cc],np.uint8)

# 对每个区域进行颜色填充
bgrimg = np.zeros(img.shape,np.uint8)
index = 0
for i in range(marks.shape[0]):
    for j in range(marks.shape[1]):
        index = marks[i][j]
        if index == -1:
            bgrimg[i][j] = np.array([255,255,255])
        else:
            bgrimg[i][j] = colours[index]

plt.imshow(bgrimg[:,:,::-1])
plt.title("图像分割结果")
plt.show()

3.9.5 GrabCut算法

img = cv.imread("liying.jpg")

masks = np.zeros(img.shape[:2],np.uint8)
# 矩形窗口，指定前景区域
rect = [260,50,740,730]

# 前景和背景分割
cv.grabCut(img,masks,tuple(rect),None,None,30,cv.GC_INIT_WITH_RECT)

# 抠取图像
mask2 = np.where((masks==2)|(masks==0),0,1).astype("uint8")
img_show = img * mask2[:,:,np.newaxis]
# 将矩形绘制在图像上
cv.rectangle(img,(260,50),(1000,780),(255,0,0),2)

fig,axes = plt.subplots(1,2,figsize=(10,8))
axes[0].imshow(img[:,:,::-1])
axes[0].set_title("矩形框选位置")
axes[1].imshow(img_show[:,:,::-1])
axes[1].set_title("扣取结果")
plt.show()

四、图像的特征提取与描述

1. 图像特征要有区分性，容易被比较。一般认为角点、斑点等是比较好的图像特征
2. 特征检测：找到图像中的特征
3. 特征描述：对特征及其周围的区域描述

4.1 Harris角点检测

Harris角点检测的思想是通过图像的局部的小窗口观察图像，角点的特征是窗口沿任意方向移动都会导致图像灰度明显变化。

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

# 对棋盘进行角点检测
qipan = cv.imread("qipan.jpg")

gray = cv.cvtColor(qipan,cv.COLOR_BGR2GRAY)
gray = np.float32(gray)
# Harris角点检测
# 2,blockSize计算每个像素的角点响应时考虑的窗口大小
# 3,Sobel 算子用于计算图像的梯度，进而用于计算角点响应。
# 0.04,用于平衡角点检测的灵敏度
dst = cv.cornerHarris(gray,2,3,0.04)
# 设置阈值，选择 dst 中角点响应值大于阈值的像素位置
qipan[dst > 0.001*dst.max()] = [0,255,0]

plt.figure(figsize=(10,8))
plt.imshow(qipan[:,:,::-1])
plt.show()

4.2 Shi-Tomasi角点检测

tv = cv.imread("tv.jpg")
gray = cv.cvtColor(tv,cv.COLOR_BGR2GRAY)

# 提取角坐标
conners = cv.goodFeaturesToTrack(gray,1000,0.01,10)
# 绘制角点
for i in conners:
    # 将坐标展平为一维
    x,y = i.ravel()
    x,y = int(x),int(y)
    cv.circle(tv,(x,y),3,(0,255,0),-1)

plt.figure(figsize=(10,8))
plt.imshow(tv[:,:,::-1])
plt.show()

4.3 sift算法

通过多尺度空间检测极值点作为关键点，确保尺度不变性；再对关键点邻域进行方向赋值，确保旋转不变性，从而实现对图像特征的稳定提取。

tv = cv.imread("tv.jpg")

gray = cv.cvtColor(tv,cv.COLOR_BGR2GRAY)

# 实例化shif
sift = cv.xfeatures2d.SIFT_create()
# 角点检测：kp角点的信息包括坐标，方向等   des角点描述
kp, des = sift.detectAndCompute(gray,None)
# 绘制角点
cv.drawKeypoints(tv,kp,tv,flags=cv.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)

plt.figure(figsize=(10,8))
plt.imshow(tv[:,:,::-1])
plt.show()

4.4 fast检测算法

若一个像素周围有一定数量的像素与该点像素值不同，则认为其为角点

tv = cv.imread("tv.jpg")

# 实例化fast对象
fast = cv.FastFeatureDetector_create(threshold=30)
# 检测关键的
kp = fast.detect(tv,None)
# 绘制关键点，默认开启非极大值抑制，抑制候选角点的重叠
img1 = cv.drawKeypoints(tv,kp,None,(0,0,255))

# 关闭非极大值抑制
fast.setNonmaxSuppression(0)
kp = fast.detect(tv,None)
img2 = cv.drawKeypoints(tv,kp,None,(0,0,255))

plt.figure(figsize=(10,8))
plt.subplot(121)
plt.imshow(img1[:,:,::-1])
plt.title("开启非极大值抑制")
plt.subplot(122)
plt.imshow(img2[:,:,::-1])
plt.title("关闭非极大值抑制")
plt.show()

4.5 orb角点检测

tv = cv.imread("tv.jpg")

# 实例化ORB
# nfeatures设置要检测的最大特征点数量
orb = cv.ORB_create(nfeatures=200)
# 角点检测 
kp,des = orb.detectAndCompute(tv,None)
# 绘制角点
cv.drawKeypoints(tv,kp,tv,(0,255,0))

plt.figure(figsize=(5,4))
plt.imshow(tv[:,:,::-1])
plt.show()

五、视频操作

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

5.1 视频读写

video_ying = cv.VideoCapture("赵丽颖.mp4")

# 查看是否捕获成功
video_ying.isOpened()

# 判断是否读取成功
while(video_ying.isOpened()):
    # 获取每一帧图像
    ret,frame = video_ying.read()
    if ret == True:
        cv.imshow("frame",frame)
    # 每一帧间隔50秒，按q退出
    if cv.waitKey(50) & 0xFF == ord('q'):
        break
# 释放VideoCapture对象，关闭视频文件
video_ying.release()
# 关闭OpenCV所创建的窗口
cv.destroyAllWindows()

5.2 视频保存

# 读取视频
cap = cv.VideoCapture("赵丽颖.mp4")

# 获取图像的属性（宽度和高度），并将其转换为整数
frame_width = int(cap.get(3))
frame_height = int(cap.get(4))

# 创建保存视频的对象，设置编码格式，帧率，图像的宽度和高度
out = cv.VideoWriter('outpy.avi', cv.VideoWriter_fourcc('M', 'J', 'P', 'G'), 10, (frame_width, frame_height))

# 循环读取视频中的每一帧图像
while True:
    # 获取视频中的每一帧图像
    ret, frame = cap.read()    
    # 如果读取成功，将每一帧图像写入到输出文件中
    if ret == True:
        out.write(frame)
    else:
        break

# 释放资源
cap.release()
out.release()
cv.destroyAllWindows()

5.3 视频追踪

目标：追踪视频中的小柯基

5.3.1 meanshift算法

简单，迭代次数少。但不能适应运动目标的形状和大小的变化

import cv2 as cv
import numpy as np
# 视频捕获
video_dog = cv.VideoCapture('dog.mp4')

# 获取第一帧图像，并指定目标位置
ret, frame = video_dog.read()

# 目标位置（行，高，列，宽）
r, h, c, w = 140, 230, 300, 150
track_window = (c, r, w, h)

# 指定目标的感兴趣区域
roi = frame[r:r+h, c:c+w]

# 计算直方图
# 转换色彩空间（HSV）
hsv_roi = cv.cvtColor(roi, cv.COLOR_BGR2HSV)

# 去除低亮度的值(色调，饱和度，亮度)
mask = cv.inRange(hsv_roi, np.array((0, 100, 52)), np.array((180, 255, 255)))

# 计算直方图
# [0] 只计算第一个通道，即色调(hue)通道的直方图
# [180] 定义直方图bin数量
# [0,180] 计算从0到180之间的色调值的直方图
roi_hist = cv.calcHist([hsv_roi],[0],mask,[180],[0,180])

# 归一化
cv.normalize(roi_hist, roi_hist, 0, 255, cv.NORM_MINMAX)

# 目标追踪
# 设置窗口搜索终止条件：最大迭代次数，窗口中心漂移最小值
term_crit = (cv.TERM_CRITERIA_EPS | cv.TERM_CRITERIA_COUNT, 10, 1)

while True:
    # 获取每一帧图像
    ret, frame = video_dog.read()
    if ret:
        # 算直方图的反向投影，生成一个概率图 dst，指示当前帧中哪些区域最可能包含目标。
        hsv = cv.cvtColor(frame, cv.COLOR_BGR2HSV)
        dst = cv.calcBackProject([hsv], [0], roi_hist, [0, 180], 1)

        # 进行Meanshift追踪
        ret, track_window = cv.meanShift(dst, track_window, term_crit)

        # 追踪的位置绘制在视频上，并进行显示
        x, y, w, h = track_window
        img2 = cv.rectangle(frame, (x, y), (x + w, y + h), 255, 2)
        cv.imshow('frame', img2)

        if cv.waitKey(65) & 0xFF == ord('q'):
            break
    else:
        break

video_dog.release()
cv.destroyAllWindows()

5.3.2 camshift算法

camshift算法可以适应目标大小形状的改变，具有较好的追踪效果。但当背景色和目标颜色接近时，容易使目标的区域变大。

import cv2 as cv
import numpy as np

video_dog = cv.VideoCapture('dog.mp4')

# 获取第一帧图像，并指定目标位置
ret, frame = video_dog.read()

# 目标位置
r, h, c, w = 170, 150, 350, 90
track_window = (c, r, w, h)

# 指定目标区域
roi = frame[r:r+h, c:c+w]

# 计算直方图
# 转换色彩空间（HSV）
hsv_roi = cv.cvtColor(roi, cv.COLOR_BGR2HSV)

# 去除低亮度的值(色调，饱和度，亮度)
mask = cv.inRange(hsv_roi, np.array((0, 100, 50)), np.array((180, 255, 255)))

# 计算直方图
# [0] 只计算第一个通道，即色调(hue)通道的直方图
# [180] 定义直方图bin数量
# [0,180] 计算从0到180之间的色调值的直方图
roi_hist = cv.calcHist([hsv_roi],[0],mask,[180],[0,180])

# 归一化
cv.normalize(roi_hist, roi_hist, 0, 255, cv.NORM_MINMAX)

# 目标追踪
# 设置窗口搜索终止条件：最大迭代次数，窗口中心漂移最小值
term_crit = (cv.TERM_CRITERIA_EPS | cv.TERM_CRITERIA_COUNT, 10, 1)

while True:
    ret, frame = video_dog.read()
    if ret:
        # 计算直方图的反向投影，生成一个概率图 dst，指示当前帧中哪些区域最可能包含目标。
        hsv = cv.cvtColor(frame, cv.COLOR_BGR2HSV)
        dst = cv.calcBackProject([hsv], [0], roi_hist, [0, 180], 1)

        # CamShift追踪
        ret, track_window = cv.CamShift(dst, track_window, term_crit)

        # 将追踪的位置绘制在视频上，并进行显示
        # pst矩形框的四个坐标
        pts = cv.boxPoints(ret)
        pts = np.intp(pts)
        img2 = cv.polylines(frame,[pts],True, 255,2)
        # 显示图像
        cv.imshow('frame', img2)
        
        if cv.waitKey(60) & 0xFF == ord('q'):
            break
    else:
        break

video_dog.release()
cv.destroyAllWindows()

六、人脸、眼睛检测案例

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

import cv2 as cv
print(cv.__file__)

所有的XML文件都在D:\Anaconda\Lib\site-packages\cv2\data\中

6.1 人脸以及眼睛检测(图片)

img = cv.imread("liying2.jpg")
gray = cv.cvtColor(img,cv.COLOR_BGR2GRAY)

# 定义训练器路径
cascade_path = "D:\\Anaconda\\Lib\\site-packages\\cv2\\data\\haarcascade_frontalface_default.xml"
eye_cascade_path = "D:\\Anaconda\\Lib\\site-packages\\cv2\\data\\haarcascade_eye.xml"

# 实例化人脸级联分类器
face_cas = cv.CascadeClassifier(cascade_path)
# 实例化眼睛级联分类器
eyes_cas = cv.CascadeClassifier(eye_cascade_path)

# 人脸检测
faceRects = face_cas.detectMultiScale(gray,scaleFactor=1.05,minNeighbors=5,minSize=(20,20))
# 遍历人脸
for faceRect in faceRects:
    x,y,w,h = faceRect
    cv.rectangle(img,(x,y),(x+w,y+h),(0,255,0),2)
    roi_color = img[x:x+w,y:y+h]
    roi_gray = gray[x:x+w,y:y+h]
    eyes = eyes_cas.detectMultiScale(roi_gray,scaleFactor=1.2, minNeighbors=5, minSize=(30, 30), maxSize=(100, 100))
    for x,y,w,h in eyes:
        cv.rectangle(roi_color,(x,y),(x+w,y+h),(255,0,0),2)

plt.figure(figsize=(7,4))
plt.imshow(img[:,:,::-1])
plt.title("检测结果")
plt.show()

6.2 人脸以及眼睛检测(视频)

import cv2 as cv
import matplotlib.pyplot as plt

video = cv.VideoCapture("赵丽颖.mp4")

cascade_path = "D:\\Anaconda\\Lib\\site-packages\\cv2\\data\\haarcascade_frontalface_default.xml"
eyes_cascade_path = "D:\\Anaconda\\Lib\\site-packages\\cv2\\data\\haarcascade_eye.xml"

while True:
    ret,frame = video.read()

    if ret==True:
        gray = cv.cvtColor(frame,cv.COLOR_BGR2GRAY)
        # 实例化人脸级联分类器
        face_cas = cv.CascadeClassifier(cascade_path)
        # 实例化眼睛级联分类器
        eyes_cas = cv.CascadeClassifier(eyes_cascade_path)
        # 检测人脸
        faceRects = face_cas.detectMultiScale(gray,scaleFactor=1.2,minNeighbors=3,minSize=(60,60))
        for faceRect in faceRects:
            x,y,w,h = faceRect
            cv.rectangle(frame,(x,y),(x+w,y+h),(0,255,0),2)

            roi_color = frame[y:y+h,x:x+w]
            # 定位人脸上半部分
            roi_gray = gray[y:y+int(h*0.7),x:x+w]
            
            eyes = eyes_cas.detectMultiScale(roi_gray,scaleFactor=1.3,minNeighbors=5, minSize=(20,20), maxSize=(100, 100))
            for x,y,w,h in eyes:
                cv.rectangle(roi_color,(x,y),(x+w,y+h),(255,0,0),2)
        cv.imshow("frame",frame)
        if cv.waitKey(20) & 0xFF==ord('q'):
            break
    else:
        break
video.release()
cv.destroyAllWindows()

由于运行结果是视频所以无法展示