OpenCV

早期计算机处理的数据有2种：文本数据、图像数据。其中文本数据又称为序列数据，图像数据又称为网格数据。

计算机视觉（Computer Vision）是人工智能的一个重要分支，它研究如何让计算机“看”和“理解”图像和视频。也叫机器视觉（Machine Vision）。

早在深度学习之前，人们就开始探索图像的处理了，OpenCV 诞生于深度学习之前，是功能最全面的开源库。它提供了从最基础的图像读写、处理到复杂的特征匹配、目标跟踪、校准等一系列工具。其核心优势在于传统的计算机视觉算法，如图像处理、滤波、形态学操作等。

它向前承接传统以数组为单位的图像处理，向后允许你加载一些现成的算法、模型，是传统图像处理与深度学习之间重要的桥梁。

目前OpenCV主要用于图像的预处理作为深度学习模型的输入。

安装

opencv（opensource computer vision）开源计算机视觉库，包含大量的图像处理函数。

opencv-python需要根据环境选择正确的包

有4个不同的包，你只能选择其中的一个。不要在同一环境中安装多个不同的包。

所有包都使用相同的名称空间（cv2）。如果你在同一环境中安装了多个不同的包，请使用 pip uninstall 卸载所有包，然后只重新安装一个包。

a. 针对标准桌面环境的包（适用于 Windows、macOS、几乎所有 GNU/Linux 发行版）

选项 1 - 主模块包：pip install opencv-python
选项 2 - 完整包（包含主模块和 contrib/extra 模块）：pip install opencv-contrib-python（请参考 OpenCV 文档中的 contrib/extra 模块列表）

b. 针对服务器（无窗口）环境的包（例如 Docker、云环境等），无 GUI 库依赖

这些包比前面两种包更小，因为它们不包含任何图形用户界面功能（未编译 Qt 或其他 GUI 组件）。这意味着这些包避免了对 X11 库的庞大依赖，从而例如可以生成更小的 Docker 镜像。如果你不使用 cv2.imshow 等函数，或者你使用其他包（例如 PyQt）来构建界面而非 OpenCV，则应始终使用这些包。

选项 3 - 无窗口主模块包：pip install opencv-python-headless
选项 4 - 无窗口完整包（包含主模块和 contrib/extra 模块）：pip install opencv-contrib-python-headless（请参考 OpenCV 文档中的 contrib/extra 模块列表）

OpenCv作为开源软件，自然有大量的教程，我读过一些纸质书籍，也看过一些开源教程，总体来说，对于入门与进阶来说，需要的是细致的基础讲解、完整的处理流程，非常推荐官方的OpenCV-Python教程。

图像读取与显示

图像读取

函数签名：cv2.imread(filename, flags=cv2.IMREAD_COLOR) -> image

参数说明：

filename：要读取的文件名
flags：读取标志，默认值为cv2.IMREAD_COLOR，表示读取为BGR格式。可选参数：
- cv2.IMREAD_COLOR：读取为BGR格式，默认值。对应数值为1。
- cv2.IMREAD_GRAYSCALE：读取为灰度图，对应数值为0。
- cv2.IMREAD_UNCHANGED：读取为原图，包含alpha通道，对应数值为-1。

返回值：

返回读取的图像对象, 如果读取失败, 不报错，返回None
CV2默认使用系统编码，如果文件路径含中文无法正常读取，需要把系统编码改为utf-8。

图像对象的常用属性：

shape：图像的形状，(height, width, channels) 其中channels为3、4，表示通道数为RGB、RGBA（A是透明度），如果是灰度、二值图，通道数为1的情况会只返回(height, width)。
size：图像的像素数，height * width * channels
dtype：图像的数据类型
ndim：图像的维度
itemsize：图像的元素大小
nbytes：图像的内存大小

import cv2
path= "10.jpg"
img = cv2.imread(path)
print(img.shape) 

图像保存

函数签名：cv2.imwrite(filename, img, [params])

参数说明：

filename：要保存的文件名
img：要保存的图像对象(数据)
params：可选参数，用于指定保存的格式和质量，可选参数：
- cv2.IMWRITE_JPEG_QUALITY：JPEG图像质量，范围为0-100，默认值为95
- cv2.IMWRITE_PNG_COMPRESSION：PNG图像压缩级别，范围为0-9，默认值为3
- cv2.IMWRITE_PXM_BINARY：PPM/PGM/PBM图像格式，默认值为False

import cv2
path= "10.jpg"
img = cv2.imread(path)
cv2.imwrite('new_img.jpg',img, [cv2.IMWRITE_JPEG_QUALITY, 100])

图像显示、等待按键、关闭窗口

cv2.imshow函数签名：cv2.imshow(winname, img)

参数说明：

winname：窗口名称
img：要显示的图像对象

cv2.waitKey函数签名：cv2.waitKey([delay]) -> retval

参数说明：

delay：等待时间，单位为毫秒。当值为0时，表示无限等待。

返回值：

返回按键的ASCII码（大小写敏感），如果到时间没有按键按下，则返回-1。

注意：

如果设置了中文输入法，键盘的捕获会被输入法占用，导致无法正常等待按键按下。
如果弹出多个相同名称的窗口，只会显示一个窗口，窗口内的图像内容会被覆盖。

上面两个函数是成对出现的，cv2.imshow用于显示图像，cv2.waitKey用于等待按键按下或者到时间自动关闭窗口。

下面两个函数都表示关闭窗口，区别在于destroyWindow是关闭指定窗口，而destroyAllWindows是关闭所有窗口。

destroyWindow函数签名：cv2.destroyWindow(winname) 参数说明：

winname：要关闭的窗口名称

destroyAllWindows函数签名：cv2.destroyAllWindows()

import cv2
path= "10.jpg"
img = cv2.imread(path)
# 显示图片, 参数：img: 图像对象, 'Image': 窗口名称
# 如果窗口名称重复，则不会创建新的窗口，而是将图像显示在已有的窗口中
cv2.imshow('Image', img)
# 等待按键按下，0表示无限等待，其他数字表示等待时间（毫秒）
# 这个方法会阻塞程序，直到按键按下，返回值为按键的ASCII码。如果设置了中文输入法，键盘的捕获会被输入法占用，导致无法正常等待按键按下。
key = cv2.waitKey(0)    
# 如果按键为q，则退出
if key == ord('q'):
    # 关闭指定窗口
    cv2.destroyWindow('Image') 
# 关闭所有窗口
cv2.destroyAllWindows()

动态图像

视频读取与显示

# cv2.VideoCapture(参数)：参数可以是整数、字符串、流媒体

# 整数:表示摄像头的编号
# 0:表示默认摄像头
# 1:表示第二个摄像头

# 字符串:表示视频文件的路径（绝对相对都可以）：1.mp4

# 流媒体:表示视频流： http://192.168.1.100:8080

cap = cv2.VideoCapture(0) # 摄像头的语柄
if not cap.isOpened():
    print("Error: Could not open video.")
    cap.release() # 释放摄像头
while True:
    ret,frame = cap.read() # 读取视频帧
    # ret:表示是否读取成功（True/False）
    # frame:表示读取到的视频帧数据（numpy数组）
    if not ret:
        print("Error: Could not read frame.")
        break
    cv2.imshow("frame",frame) # 显示视频帧。同个窗口名称，会覆盖窗口内容，而不是新开窗口。
    if cv2.waitKey(1) == ord('q'): # 按q键退出循环
        break
cap.release() # 释放摄像头
cv2.destroyAllWindows() # 关闭所有窗口

视频保存

函数签名：cv2.VideoWriter(filename, fourcc, fps, frameSize)

参数说明：

filename：视频文件名
fourcc：视频编码格式
fps：帧率
frameSize：帧大小

import cv2
import numpy as np
# cv2.VideoCapture(参数)：参数可以是整数、字符串、流媒体

# 整数:表示摄像头的编号
# 0:表示默认摄像头
# 1:表示第二个摄像头

# 字符串:表示视频文件的路径（绝对相对都可以）：1.mp4

# 流媒体:表示视频流：rtsp://192.168.1.100:8554/test 或者 http://192.168.1.100:8080

cap = cv2.VideoCapture(0) # 摄像头的语柄

# 视频的编码格式
fourcc = cv2.VideoWriter_fourcc(*'mp4v')
# 视频的输出路径
out = cv2.VideoWriter('output.mp4', fourcc, 20.0, (640,480))


if not cap.isOpened():
    print("Error: Could not open video.")
    cap.release() # 释放摄像头
while True:
    ret,frame = cap.read() # 读取视频帧
    # ret:表示是否读取成功（True/False）
    # frame:表示读取到的视频帧数据（numpy数组）
    if not ret:
        print("Error: Could not read frame.")
        break
    out.write(frame) # 写入视频帧
    cv2.imshow("frame",frame) # 显示视频帧。同个窗口名称，会覆盖窗口内容，而不是新开窗口。
    if cv2.waitKey(1) == ord('q'): # 按q键退出循环
        break
out.release() # 释放视频
cap.release() # 释放摄像头
cv2.destroyAllWindows() # 关闭所有窗口

图像绘制

绘制直线、矩形

line函数签名：cv2.line(img, pt1, pt2, color, thickness, lineType, shift)
rectangle函数签名：cv2.rectangle(img, pt1, pt2, color, thickness, lineType, shift)

参数说明：

img：图像对象
pt1：起点坐标
pt2：终点坐标
color：颜色
thickness：线宽
lineType：线型
shift：位移，默认为0，表示坐标是整数，如果大于1，则表示坐标是浮点数，例如shift=2，则表示坐标是浮点数。可用于实现亚像素精度绘图。
对于矩形来说，pt1是左上角，pt2是右下角。

圆形、椭圆

circle函数签名：cv2.circle(img, center, radius, color, thickness, lineType, shift)
ellipse函数签名：cv2.ellipse(img, center, axes, angle, startAngle, endAngle, color, thickness, lineType, shift)

参数说明：

img：图像对象
center：圆心坐标
radius：半径
axes：椭圆长轴和短轴长度
angle：椭圆旋转角度
startAngle：椭圆起始角度
endAngle：椭圆结束角度
color：颜色
thickness：线宽
lineType：线型
shift：位移，默认为0，表示坐标是整数，如果大于1，则表示坐标是浮点数，例如shift=2，则表示坐标是浮点数。可用于实现亚像素精度绘图。

多边形

polylines函数签名：cv2.polylines(img, pts, isClosed, color, thickness, lineType, shift)

参数说明：

img：图像对象
pts：顶点列表
isClosed：是否闭合
color：颜色
thickness：线宽
lineType：线型
shift：位移，默认为0，表示坐标是整数，如果大于1，则表示坐标是浮点数，例如shift=2，则表示坐标是浮点数。可用于实现亚像素精度绘图。

# 导入库
import cv2
# 读取图片
img = cv2.imread('10.jpg')
# 绘制直线
# 参数：img: 图像对象, (100, 100): 起点坐标, (200, 200): 终点坐标, (0, 0, 255): 颜色, 2: 线宽
cv2.line(img, (100, 100), (200, 200), (0, 0, 255), 2)
# 绘制矩形
# 参数：img: 图像对象, (100, 100): 左上角坐标, (200, 200): 右下角坐标, (0, 0, 255): 颜色, 2: 线宽
cv2.rectangle(img, (100, 100), (200, 200), (0, 0, 255), 2)
# 绘制圆形
# 参数：img: 图像对象, (150, 150): 圆心坐标, 50: 半径, (0, 0, 255): 颜色, 2: 线宽
cv2.circle(img, (150, 150), 50, (0, 0, 255), 2)
# 绘制多边形
# 参数：img: 图像对象, [pts]: 顶点列表, True: 是否闭合, (0, 0, 255): 颜色, 2: 线宽
pts = np.array([[100, 100], [200, 100], [200, 200], [100, 200]])
cv2.polylines(img, [pts], True, (0, 0, 255), 2)
# 绘制椭圆
# 参数：img: 图像对象, (150, 150): 椭圆中心坐标, (100, 50): 椭圆长轴和短轴长度, 0: 椭圆旋转角度, 0: 椭圆起始角度, 360: 椭圆结束角度, (0, 0, 255): 颜色, 2: 线宽
cv2.ellipse(img, (150, 150), (100, 50), 0, 0, 360, (0, 0, 255), 2)
# 显示图片
cv2.imshow('Image', img)
# 等待按键按下
cv2.waitKey(0)
# 关闭所有窗口
cv2.destroyAllWindows()

绘制文字

函数签名：cv2.putText(img, text, org, fontFace, fontScale, color, thickness, lineType, bottomLeftOrigin)

参数说明：

img：图像对象
text：要绘制的文字
org：文字的左下角坐标
fontFace：字体类型
fontScale：字体缩放比例（大于1时，文字会变大、0~1时，文字会变小，小于0时，文本将倒置）
color：文字颜色
thickness：文字粗细
lineType：线型
bottomLeftOrigin：是否从左下角开始绘制

函数直接作用于图像对象，不需要返回值。

import cv2

# 读取图片
img = cv2.imread('10.jpg')
# 绘制文字：Hello, World! 位置为(100, 100)，字体为cv2.FONT_HERSHEY_SIMPLEX，字体缩放比例为1，颜色为红色，粗细为2
cv2.putText(img, 'Hello, World!', (100, 100), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
# 显示图片
cv2.imshow('Image', img)
# 展示1秒
cv2.waitKey(1000)
# 关闭所有窗口
cv2.destroyAllWindows()

绘制箭头

函数签名：cv2.arrowedLine(img, start_point, end_point, color, thickness, tipLength) -> img

参数说明：

img：图像对象
start_point：起点坐标
end_point：终点坐标
color：颜色
thickness：线宽
tipLength：箭头占比

import cv2
img = cv2.imread("top.png")

# 假设 Agent 决定点击 (800, 450)
start_point = (0, 0)   # 从下往上画一支箭，更像人伸手
end_point   = (100, 250)   # 指向目标按钮

img_with_arrow = cv2.arrowedLine(
    img, start_point, end_point,
    color=(0, 255, 255),      # 黄箭头
    thickness=8,              # 粗箭头，摄像头里都看得清
    tipLength=0.3             # 箭头占比，越大越明显
)

cv2.imwrite("agent_intent.jpg", img_with_arrow)

PIL库绘制中文

cv2的在图片上的绘制语法主要缺陷为无法绘制中文，需要使用PIL库来绘制中文。

字体文件：一种可以把码点转换为像素显示的超大型字典。

import cv2
import numpy as np
from PIL import Image, ImageDraw, ImageFont
# 打开图片
img = Image.open('imgs/img/10.jpg')  # 替换为你的图片路径
# 设置字体（确保路径正确，Windows下常见字体路径如下）
font_path = "simhei.ttf"  # 黑体
font_size = 60
font = ImageFont.truetype(font_path, font_size)
# 要绘制的文字
text = "机器视觉"
# 创建绘图对象
draw = ImageDraw.Draw(img)
# 计算文字尺寸
text_width, text_height = draw.textsize(text, font=font)
# 计算图片中心
img_width, img_height = img.size
x = (img_width - text_width) // 2
y = (img_height - text_height) // 2
# 绘制文字（可设置颜色和描边等）
draw.text((x, y), text, font=font, fill=(255, 0, 0))  # 红色
# 保存或显示图片
img.show()
# img.save('output.jpg')

图像运算

加减法的前提是两张图片的尺寸相同。

图像加法、图像减法

import cv2
import numpy as np
path = "xxx.bmp"
def draw_add(path):
    img = cv2.imread(path)
    img_height, img_width = img.shape[:2]
    # 创建一个全白的mask_img
    mask_img = np.zeros((img_height, img_width, 3), dtype=np.uint8) + 255
    # 在mask_img上写上Showcase
    cv2.putText(mask_img, "Showcase", (img_width//4, img_height//2), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 0), 5)
    # 将mask_img和img相加
    img3 = cv2.add(img, mask_img)
    cv2.imwrite(f"add_{path}", img3)

def draw_subtract(path):
    img = cv2.imread(path)
    img_height, img_width = img.shape[:2]
    # 创建一个全白的mask_img
    mask_img = np.zeros((img_height, img_width, 3), dtype=np.uint8) + 255
    # 在mask_img上画一个圆
    cv2.circle(mask_img, (img_width//2, img_height//2), int(min(img_width, img_height)*0.45), (0, 0, 0), -1)
    # 将mask_img和img相减
    img3 = cv2.subtract(img, mask_img)
    cv2.imwrite(f"subtract_{path}", img3)

draw_add(path)
draw_subtract(path)

info

图像加权cv2.addWeighted

函数签名：cv2.addWeighted(src1, alpha, src2, beta, gamma) -> dst

参数说明：

src1：图像1
alpha：图像1的强度，范围为0-1
src2：图像2
beta：图像2的强度，范围为0-1
gamma：偏移量（即图像在加权后，整体增加的值，一般为0）

图像1和图像2的强度不需要合起来等于1，可以大于1，也可以小于1。

import cv2
import numpy as np

img1 = cv2.imread("green.png")
img2 = cv2.imread("red.png")

img3 = cv2.addWeighted(img1, 1, img2, 1,0)

cv2.imshow("img4", img3)
cv2.waitKey(0)

图像横向与纵向拼接

图像拼接的前提是两张图片在拼接方向上的尺寸相同（横向拼接要求高度相同，纵向拼接要求宽度相同）。

横向拼接函数签名：cv2.hconcat(src, dst) -> dst 或 np.hstack((img1, img2, ...)) -> dst

纵向拼接函数签名：cv2.vconcat(src, dst) -> dst 或 np.vstack((img1, img2, ...)) -> dst

参数说明：

src：图像列表或元组
dst：输出图像

import cv2
import numpy as np

# 读取两张图片
img1 = cv2.imread("img1.jpg")
img2 = cv2.imread("img2.jpg")

# 确保两张图片高度相同（横向拼接）
h1, w1 = img1.shape[:2]
h2, w2 = img2.shape[:2]
if h1 != h2:
    # 将高度较小的图片调整到与高度较大的图片相同
    if h1 < h2:
        img1 = cv2.resize(img1, (w1, h2))
    else:
        img2 = cv2.resize(img2, (w2, h1))

# 方法1：使用 cv2.hconcat 横向拼接
img_horizontal = cv2.hconcat([img1, img2])

# 方法2：使用 np.hstack 横向拼接（效果相同）
# img_horizontal = np.hstack((img1, img2))

# 确保两张图片宽度相同（纵向拼接）
h1, w1 = img1.shape[:2]
h2, w2 = img2.shape[:2]
if w1 != w2:
    # 将宽度较小的图片调整到与宽度较大的图片相同
    if w1 < w2:
        img1 = cv2.resize(img1, (w2, h1))
    else:
        img2 = cv2.resize(img2, (w1, h2))

# 方法1：使用 cv2.vconcat 纵向拼接
img_vertical = cv2.vconcat([img1, img2])

# 方法2：使用 np.vstack 纵向拼接（效果相同）
# img_vertical = np.vstack((img1, img2))

# 显示结果
cv2.imshow("Horizontal", img_horizontal)
cv2.imshow("Vertical", img_vertical)
cv2.waitKey(0)
cv2.destroyAllWindows()

# 保存结果
cv2.imwrite("horizontal.jpg", img_horizontal)
cv2.imwrite("vertical.jpg", img_vertical)

tip

如果图片尺寸不一致，需要先使用 cv2.resize() 调整尺寸，确保在拼接方向上尺寸相同。

基础图像操作

图像缩放

函数签名：cv2.resize(src, dsize, fx, fy, interpolation) -> dst

参数说明：

src：源图像
dsize：目标图像大小，如果为None，则根据fx和fy计算，传入的是(width, height)
fx：水平缩放比例
fy：垂直缩放比例
interpolation：插值方式，默认值为cv2.INTER_LINEAR:双线性插值

当resize指定的新尺寸大于原尺寸时，会使用插值方式来填充新产生的像素。

import cv2
import numpy as np

img1 = cv2.imread("xxx.png")
# 固定值缩放
img2 = cv2.resize(img1, (100, 100))
# 按比例缩放
img2 = cv2.resize(img1, dsize = None, fx = 0.5, fy = 0.5)

拆分与合并通道

拆分通道函数签名：cv2.split(img) -> list

合并通道函数签名：cv2.merge(list) -> img

参数说明：

img：图像对象

返回值：

list：不同通道的图像对象

import cv2
import numpy as np

img = cv2.imread("xxx.png")
b, g, r = cv2.split(img)

img2 = cv2.merge([b, g, r])

cv2.imshow("img", img)
cv2.imshow("img2", img2)
cv2.waitKey(0)
cv2.destroyAllWindows()

图像翻转

函数签名：cv2.flip(src, flipCode) -> dst

参数说明：

src：源图像
flipCode：翻转方式，可选参数：
- 0：上下翻转（垂直翻转）
- 1：左右翻转（水平翻转）
- -1：上下左右翻转（垂直水平翻转）

返回值：

翻转后的图像对象

import cv2

img = cv2.imread("xxx.png")

# 上下翻转（垂直翻转）
img_vertical = cv2.flip(img, 0)

# 左右翻转（水平翻转）
img_horizontal = cv2.flip(img, 1)

# 上下左右翻转（垂直水平翻转）
img_both = cv2.flip(img, -1)

cv2.imshow("Original", img)
cv2.imshow("Vertical Flip", img_vertical)
cv2.imshow("Horizontal Flip", img_horizontal)
cv2.imshow("Both Flip", img_both)
cv2.waitKey(0)
cv2.destroyAllWindows()

图像裁剪

图像裁剪使用NumPy数组切片操作，不需要专门的OpenCV函数。

操作语法：img[start_y:end_y, start_x:end_x]

参数说明：

start_y：裁剪区域的起始行（y坐标）
end_y：裁剪区域的结束行（y坐标）
start_x：裁剪区域的起始列（x坐标）
end_x：裁剪区域的结束列（x坐标）

注意：坐标系以图像左上角为原点，y轴向下，x轴向右

import cv2

img = cv2.imread("xxx.png")

# 获取图像尺寸
height, width = img.shape[:2]

# 裁剪图像上半部分
top_half = img[0:height//2, 0:width]

# 裁剪图像右下角四分之一
bottom_right = img[height//2:height, width//2:width]

# 知道左上角 + 宽高
x, y, w, h = 100, 200, 300, 400
cropped = img[y:y+h, x:x+w]

# 知道左上角和右下角坐标
x1, y1 = 100, 200
x2, y2 = 400, 600
cropped = img[y1:y2, x1:x2]

# 知道中心点 + 宽高（比如 YOLO 检测框）
center_x, center_y = 320, 240
w, h = 200, 300
x = int(center_x - w/2)
y = int(center_y - h/2)
cropped = img[y:y+h, x:x+w]

# 防止越界（生产必加，防止 crash）
h_img, w_img = img.shape[:2]
x = max(0, x)
y = max(0, y)
w = min(w, w_img - x)
h = min(h, h_img - y)
cropped = img[y:y+h, x:x+w]   

图像平移

函数签名：cv2.warpAffine(src, M, dsize, flags, borderMode, borderValue) -> dst

参数说明：

src：源图像
M：2×3的仿射变换矩阵
dsize：输出图像的大小，格式为(width, height)
flags：插值方法，默认为cv2.INTER_LINEAR
borderMode：边界处理方式，默认为cv2.BORDER_CONSTANT
borderValue：边界填充值，默认为0

变换矩阵格式：[[1, 0, dx], [0, 1, dy]]，其中dx为x方向位移，dy为y方向位移

import cv2
import numpy as np

img = cv2.imread("xxx.png")
height, width = img.shape[:2]

# 向右平移100像素，向下平移50像素
M = np.float32([[1, 0, 100], [0, 1, 50]])
translated_img = cv2.warpAffine(img, M, (width, height))

# 向左平移50像素，向上平移30像素
M2 = np.float32([[1, 0, -50], [0, 1, -30]])
translated_img2 = cv2.warpAffine(img, M2, (width, height))

cv2.imshow("Original", img)
cv2.imshow("Translated Right-Down", translated_img)
cv2.imshow("Translated Left-Up", translated_img2)
cv2.waitKey(0)
cv2.destroyAllWindows()

图像旋转

旋转矩阵函数签名：cv2.getRotationMatrix2D(center, angle, scale) -> M

参数说明：

center：旋转中心点坐标，格式为(x, y)
angle：旋转角度（度数），正值表示逆时针旋转
scale：缩放比例，1.0表示不缩放

应用旋转需要配合cv2.warpAffine函数使用。

import cv2
import numpy as np

img = cv2.imread("xxx.png")
height, width = img.shape[:2]

# 以图像中心为旋转点，逆时针旋转45度，不缩放
center = (width // 2, height // 2)
M = cv2.getRotationMatrix2D(center, 45, 1.0)
rotated_img = cv2.warpAffine(img, M, (width, height))

# 以图像中心为旋转点，顺时针旋转30度，放大1.5倍
M2 = cv2.getRotationMatrix2D(center, -30, 1.5)
rotated_scaled_img = cv2.warpAffine(img, M2, (width, height))

cv2.imshow("Original", img)
cv2.imshow("Rotated 45°", rotated_img)
cv2.imshow("Rotated -30° Scaled 1.5x", rotated_scaled_img)
cv2.waitKey(0)
cv2.destroyAllWindows()

仿射变换

仿射变换矩阵函数签名：cv2.getAffineTransform(src, dst) -> M

参数说明：

src：源图像中的三个点坐标，numpy数组格式
dst：目标图像中对应的三个点坐标，numpy数组格式

返回值：

2×3的仿射变换矩阵

仿射变换能够实现旋转、平移、缩放和错切等变换的组合。

import cv2
import numpy as np

img = cv2.imread("xxx.png")
height, width = img.shape[:2]

# 定义源图像中的三个点（左上角、右上角、左下角）
pts1 = np.float32([[0, 0], [width-1, 0], [0, height-1]])

# 定义目标图像中对应的三个点（实现错切变换）
pts2 = np.float32([[0, height*0.33], [width*0.85, height*0.25], [width*0.15, height*0.7]])

# 计算仿射变换矩阵
M = cv2.getAffineTransform(pts1, pts2)

# 应用仿射变换
affine_img = cv2.warpAffine(img, M, (width, height))

# 在原图上标记三个关键点
cv2.circle(img, (0, 0), 5, (255, 0, 0), -1)
cv2.circle(img, (width-1, 0), 5, (255, 0, 0), -1)
cv2.circle(img, (0, height-1), 5, (255, 0, 0), -1)

cv2.imshow("Original", img)
cv2.imshow("Affine Transform", affine_img)
cv2.waitKey(0)
cv2.destroyAllWindows()

透视变换

透视变换矩阵函数签名：cv2.getPerspectiveTransform(src, dst) -> M

透视变换函数签名：cv2.warpPerspective(src, M, dsize, flags, borderMode, borderValue) -> dst

参数说明：

src：源图像中的四个点坐标，numpy数组格式
dst：目标图像中对应的四个点坐标，numpy数组格式
M：3×3的透视变换矩阵
dsize：输出图像的大小，格式为(width, height)

透视变换能够模拟三维空间中的投影效果，常用于文档矫正、鸟瞰图变换等。

import cv2
import numpy as np

img = cv2.imread("xxx.png")
height, width = img.shape[:2]

# 定义源图像中的四个点（矩形的四个角）
pts1 = np.float32([[0, 0], [width, 0], [0, height], [width, height]])

# 定义目标图像中对应的四个点（梯形效果）
pts2 = np.float32([[0, 0], [width, 0], [width*0.3, height], [width*0.7, height]])

# 计算透视变换矩阵
M = cv2.getPerspectiveTransform(pts1, pts2)

# 应用透视变换
perspective_img = cv2.warpPerspective(img, M, (width, height))

cv2.imshow("Original", img)
cv2.imshow("Perspective Transform", perspective_img)
cv2.waitKey(0)
cv2.destroyAllWindows()

图像扩边

函数签名：cv2.copyMakeBorder(src, top, bottom, left, right, borderType, value) -> dst

参数说明：

src：源图像
top：上边框宽度（像素）
bottom：下边框宽度（像素）
left：左边框宽度（像素）
right：右边框宽度（像素）
borderType：边框类型，常用类型：
- cv2.BORDER_CONSTANT：常数边框，需要指定value参数
- cv2.BORDER_REFLECT：反射边框
- cv2.BORDER_REPLICATE：复制边框
- cv2.BORDER_WRAP：包装边框
value：边框颜色值（当borderType为BORDER_CONSTANT时使用）

import cv2

img = cv2.imread("xxx.png")

# 添加常数边框（黑色）
border_constant = cv2.copyMakeBorder(img, 50, 50, 50, 50, cv2.BORDER_CONSTANT, value=(0, 0, 0))

# 添加常数边框（红色）
border_red = cv2.copyMakeBorder(img, 30, 30, 30, 30, cv2.BORDER_CONSTANT, value=(0, 0, 255))

# 添加反射边框
border_reflect = cv2.copyMakeBorder(img, 50, 50, 50, 50, cv2.BORDER_REFLECT)

# 添加复制边框
border_replicate = cv2.copyMakeBorder(img, 50, 50, 50, 50, cv2.BORDER_REPLICATE)

# 添加包装边框
border_wrap = cv2.copyMakeBorder(img, 50, 50, 50, 50, cv2.BORDER_WRAP)

cv2.imshow("Original", img)
cv2.imshow("Constant Border (Black)", border_constant)
cv2.imshow("Constant Border (Red)", border_red)
cv2.imshow("Reflect Border", border_reflect)
cv2.imshow("Replicate Border", border_replicate)
cv2.imshow("Wrap Border", border_wrap)
cv2.waitKey(0)
cv2.destroyAllWindows()

色彩处理

info

科普：什么是HSV？

HSV：相比RGB相比，HSV能更好的表示同个颜色的不同值（饱和度和明度）

H: 色调，取值范围是0-180，表示颜色
S: 饱和度，取值范围是0-255，表示颜色的纯度
V: 明度，取值范围是0-255，表示颜色的亮度

info

什么是24位真彩屏？

每个像素点的取值返回是0~255，即在二进制中需要8位来表示（2的8次方）

那么 R G B 三个通道就需要 8 + 8 + 8 = 24 位来表示

难道还有假彩屏？

是的，因为人眼并不能分辨出 255 * 255 * 255 种颜色，所以可以适当的减少一些颜色，也不影响人眼感知

所以就有了16bit屏幕（单片机常用）^?

灰度图

灰度图适用于图像处理，如边缘检测及其应用：图像分割、轮廓检测

只有1个通道，取值范围是0-255，表示颜色的亮度

import numpy as np
import cv2

# 方式1 （支持自定义权重）
img = cv2.imread("xxx.png")
B,G,R = cv2.split(img)
gray = R*0.299 + G*0.587 + B*0.114
gray = gray.astype(np.uint8)

# 方式2 (最简单，最常用)
gray = cv2.imread("xxx.png",0)

# 方式3 （可以转化为各种色彩空间）
img = cv2.imread("xxx.png")
gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)


cv2.imshow("gray",gray)
cv2.waitKey(0)
cv2.destroyAllWindows()

二值化图

二值化图，适用于图像压缩。只有1个通道，取值范围是0或1

方法	核心思想	如何工作？	优点	缺点	适用场景
固定阈值法	设置一个固定的“分界线”来区分黑白。	你先设定一个固定的数值，比如 127。然后程序会遍历图像中的每一个像素点：如果像素值大于 127，就把它变成纯白色（255）。如果像素值小于或等于 127，就变成纯黑色（0）。最后，再把白色变为 1，黑色变为 0。	简单粗暴，速度快。就像给所有学生设一条及格线，谁分数高谁就及格。	太死板，不灵活。面对一张整体很暗的照片，大部分像素可能都低于 127，结果整个图都变成黑的了。对光线不均匀的图片完全无效。	适合处理光线均匀、对比度高的简单图像，比如扫描的黑白文档。
全局平均值法	自动计算图像的“平均分数”作为分界线。	程序会先计算整张图片的所有像素值的平均值，并把这个平均值作为动态的阈值。然后按照固定阈值法的方式进行二值化。	更智能。它会根据图片本身的亮度来决定阈值，所以对整体偏亮或偏暗的图片效果更好。	忽略局部差异。如果一张图片既有明亮的区域（比如太阳光），又有很暗的区域（比如阴影），这个方法就不太行了，因为它只用一个平均值来判断所有地方。	适合处理整体亮度统一，但亮度值不确定的图片。
自适应均值法	“因地制宜”，为每个小区域设置不同的分界线。	程序会把图片分成很多个小格子。然后，它会只看每个格子里的像素，计算这个小区域的平均值，并把这个值作为这个小格子的阈值。	最灵活，效果好。完美解决了局部光线不均的问题，比如在有阴影的纸张上，文字依然能被清晰地二值化。	计算量大。因为要处理很多个小区域，所以比前两种方法慢一些。同时，你需要设置小格子的大小，这个参数的选择会影响最终效果。	广泛应用于文档识别、车牌识别、自动驾驶等对局部细节要求高的场景。
自适应高斯法	“加权平均”，为每个小区域设置更智能的分界线。	类似于自适应均值法，也是将图像分成小格子。但不同的是，它会给离中心点更近的像素更高的权重，来计算区域的加权平均值，作为阈值。这样中心像素的影响更大。	相比自适应均值法，它对噪声的敏感度更低，能得到更平滑的二值化结果。	计算量比自适应均值法更大，因为要进行加权计算。	图像中有较多噪声或细节，需要更平滑二值化效果的场景。
Otsu's 方法	寻找一个最佳阈值，让图像的“黑白对比度”最大。	它会通过分析图像的灰度直方图（用来展示像素分布的图）来寻找最佳阈值。这个方法假设图像只有两类像素（前景和背景），然后找到一个阈值，让这两类像素之间的差异最大。	全自动，效果好。无需手动设置任何参数，就能找到一个最优的阈值，特别适合那些背景和前景对比度很明显的图片。	有前提限制。如果图片的前景和背景混合得很复杂，或者灰度直方图不是明显的双峰形状，这个方法的表现就会变差。	适合处理对比度高的图片，特别是那些有清晰前景和背景的图片。

info

什么是直方图？

横坐标：表示的是像素的数值，最左边是0，最右边是255

纵坐标：表示的是像素的个数

常用于观察图片的像素分布

info

归一化（Normalization）是一种常见的数据预处理技术

用于改变数据的范围以使其落在一个特定的区间,通常是[0,1]或者[-1,1]。

归一化的目的是消除数据量纲和尺度的影响，使得不同尺度或单位的数据可以在同一水平上进行比较或处理。

函数签名：cv2.threshold(img, thresh, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU) -> retval, dst

参数说明：

img：输入灰度图像
thresh：阈值（Otsu方法中通常设为0，会自动计算最佳阈值）
255：当像素值超过阈值时赋予的新值（maxValue）
cv2.THRESH_BINARY + cv2.THRESH_OTSU：二值化类型，OTSU会自动计算最佳阈值

主要用于缺陷检测

函数签名：cv2.adaptiveThreshold(img, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 11, 2) -> dst

参数说明：

img：输入灰度图像
255：当像素值超过阈值时赋予的新值（maxValue）
cv2.ADAPTIVE_THRESH_GAUSSIAN_C：自适应方法，使用高斯加权
11：用于计算阈值的邻域大小（blockSize，必须为奇数）
2：从平均值或加权和中减去的常数（C）

主要用于光照不均匀的场景

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

# 确保能找到图片，请将 'xxx.bmp' 替换为你自己的图片路径
IMAGE_PATH = 'xxx.bmp'

def show_all_images(original_img, binary_images, titles):
    """
    使用 matplotlib 同时显示原始图像和所有二值化图像。
    :param original_img: 原始灰度图像
    :param binary_images: 二值化图像列表
    :param titles: 图像标题列表
    """
    num_images = len(binary_images) + 1  # +1 for original image
    
    # 计算子图的行数和列数 (尽量接近正方形布局)
    cols = int(np.ceil(np.sqrt(num_images)))
    rows = int(np.ceil(num_images / cols))
    
    fig, axes = plt.subplots(rows, cols, figsize=(15, 10))
    fig.suptitle('Image Thresholding Comparison', fontsize=16)
    
    # 如果只有一个子图，将axes转换为列表
    if num_images == 1:
        axes = [axes]
    else:
        axes = axes.flatten()
    
    # 显示原始图像
    axes[0].imshow(original_img, cmap='gray')
    axes[0].set_title('Original Grayscale Image')
    axes[0].axis('off')
    
    # 显示二值化图像
    for i, (binary_img, title) in enumerate(zip(binary_images, titles)):
        axes[i + 1].imshow(binary_img, cmap='gray')
        axes[i + 1].set_title(title)
        axes[i + 1].axis('off')
    
    # 隐藏多余的子图
    for i in range(num_images, len(axes)):
        axes[i].axis('off')
    
    plt.tight_layout()
    plt.show()

def get_binary_image(img, method, *args, **kwargs):
    """
    根据不同方法获取二值化图像。
    :param img: 原始灰度图像
    :param method: 阈值处理方法，可选 'fixed', 'global_mean', 'adaptive_mean', 'adaptive_gaussian', 'otsu'
    """
    if method == 'fixed':
        # 固定阈值法
        _, binary = cv2.threshold(img, 127, 255, cv2.THRESH_BINARY)
    elif method == 'global_mean':
        # 全局平均值法
        _, binary = cv2.threshold(img, img.mean(), 255, cv2.THRESH_BINARY)
    elif method == 'adaptive_mean':
        # 自适应均值阈值法（光照不均匀时效果更好）
        binary = cv2.adaptiveThreshold(img, 255, cv2.ADAPTIVE_THRESH_MEAN_C, 
                                       cv2.THRESH_BINARY, 11, 2)
    elif method == 'adaptive_gaussian':
        # 自适应高斯阈值法（光照不均匀时效果更好）
        binary = cv2.adaptiveThreshold(img, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, 
                                       cv2.THRESH_BINARY, 11, 2)
    elif method == 'otsu':
        # Otsu's 方法
        _, binary = cv2.threshold(img, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
    else:
        raise ValueError("Invalid method. Choose from 'fixed', 'global_mean', 'adaptive_mean', 'adaptive_gaussian', 'otsu'")

    # 将二值图的像素值从 0/255 转换为 0/1，以便于分析和存储
    return (binary / 255).astype(int)

def main():
    """主函数，演示不同二值化方法。"""
    
    # 读取灰度图像
    img = cv2.imread(IMAGE_PATH, cv2.IMREAD_GRAYSCALE)
    if img is None:
        print(f"Error: Could not read image at {IMAGE_PATH}")
        return

    # 准备各种二值化方法
    methods = [
        ('fixed', 'Fixed Thresholding (127)'),
        ('global_mean', 'Global Mean Thresholding'),
        ('adaptive_mean', 'Adaptive Mean Thresholding'),
        ('adaptive_gaussian', 'Adaptive Gaussian Thresholding'),
        ('otsu', "Otsu's Thresholding")
    ]
    
    # 生成所有二值化图像
    binary_images = []
    titles = []
    for method, title in methods:
        binary_image = get_binary_image(img, method)
        binary_images.append(binary_image)
        titles.append(title)
    
    # 同时显示所有图像
    show_all_images(img, binary_images, titles)

if __name__ == "__main__":
    main()

形态学处理

膨胀和腐蚀

膨胀函数签名：cv2.dilate(img,kernel,iterations=5)

腐蚀函数签名：cv2.erode(img,kernel,iterations=5)

参数：

img：输入图像
kernel：膨胀和腐蚀的核
iterations：膨胀和腐蚀的迭代次数

膨胀工作原理：类似卷积操作，将核覆盖在图像上，如果核的中心点在图像的范围内，则将核的中心点替换为核的最大值。

腐蚀工作原理与膨胀相反，将核覆盖在图像上，如果核的中心点在图像的范围内，则将核的中心点替换为核的最小值。

import cv2
import numpy as np
img = cv2.imread("dt2.png")
# 膨胀和腐蚀的操作
kernel = np.ones((3,3),np.uint8)
# 腐蚀
erode = cv2.erode(img,kernel,iterations=5)
# 膨胀
dilate = cv2.dilate(img,kernel,iterations=5)
cv2.imshow("img",img)
cv2.imshow("dilate",dilate)
cv2.waitKey(0)
cv2.destroyAllWindows()

info

开运算: 先腐蚀后膨胀，用于去除图像中的小噪声
闭运算: 先膨胀后腐蚀，用于填充图像中的小孔洞
形态学梯度: 膨胀 - 腐蚀，用于提取图像中的边缘
顶帽: 原图 - 开运算，用于提取图像中的小噪声
黑帽: 闭运算 - 原图，用于填充图像中的小孔洞

开运算和闭运算

开运算和闭运算主要用于去除图像中的小噪声和小孔洞、粘连断裂。

开运算函数签名：cv2.morphologyEx(img, cv2.MORPH_OPEN, kernel) -> dst

闭运算函数签名：cv2.morphologyEx(img, cv2.MORPH_CLOSE, kernel) -> dst

参数说明：

img：输入图像
cv2.MORPH_OPEN：开运算操作类型（先腐蚀后膨胀）
cv2.MORPH_CLOSE：闭运算操作类型（先膨胀后腐蚀）
kernel：形态学操作的核

import cv2
import numpy as np

img = cv2.imread("dt2.png")
kernel = np.ones((3, 3), np.uint8)

# 开运算：先腐蚀后膨胀，用于去除图像中的小噪声
opening = cv2.morphologyEx(img, cv2.MORPH_OPEN, kernel)

# 闭运算：先膨胀后腐蚀，用于填充图像中的小孔洞
closing = cv2.morphologyEx(img, cv2.MORPH_CLOSE, kernel)

cv2.imshow("Original", img)
cv2.imshow("Opening", opening)
cv2.imshow("Closing", closing)
cv2.waitKey(0)
cv2.destroyAllWindows()

模糊

模糊的原理：让像素点的混在一起：即每个像素点不再是自己，而是自己与周围像素点的混合值。

常见的有：

高斯模糊：cv2.GaussianBlur
中值滤波：cv2.medianBlur
Box滤波：cv2.boxFilter
均值滤波：cv2.blur（Box滤波的归一化版本）
双边滤波：cv2.bilateralFilter
矩阵卷积（自定义卷积核）：cv2.filter2D

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.font_manager import FontProperties
import cv2

# 设置中文字体
# 替换为你系统中支持中文的字体路径(windows)
font_path = r'C:\Windows\Fonts\simhei.ttf'  
# mac（如果有的话）
# font_path = '/System/Library/Fonts/STHeiti Light.ttc' 
font_prop = FontProperties(fname=font_path)

# 读取灰度图像
image = np.array(cv2.imread('xxx.bmp',cv2.IMREAD_GRAYSCALE))

# 定义卷积核
kernels = {
    '水平边缘': np.array([[-1, -1, -1], [0, 0, 0], [1, 1, 1]]),
    '垂直边缘': np.array([[-1, 0, 1], [-1, 0, 1], [-1, 0, 1]]),
    'Sobel水平': np.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]]),
    'Sobel垂直': np.array([[1, 2, 1], [0, 0, 0], [-1, -2, -1]]),
    '拉普拉斯': np.array([[0, 1, 0], [1, -4, 1], [0, 1, 0]]),
    '锐化': np.array([[0, -1, 0], [-1, 5, -1], [0, -1, 0]]),
    '高斯模糊3x3': np.array([[1, 2, 1], [2, 4, 2], [1, 2, 1]]) / 16,
    '边缘增强': np.array([[-1, -1, -1], [-1, 9, -1], [-1, -1, -1]]),
    'Box滤波': np.array([[2, 2, 2], [2, 2, 2], [2, 2, 2]]) / 9
    '均值滤波': np.array([[1, 1, 1], [1, 1, 1], [1, 1, 1]]) / 9,
}

# 使用NumPy实现卷积操作
def convolve2d(image, kernel):
    # 获取图像和卷积核的尺寸
    i_height, i_width = image.shape
    k_height, k_width = kernel.shape
    
    # 计算输出图像的尺寸
    o_height = i_height - k_height + 1
    o_width = i_width - k_width + 1
    
    # 创建输出图像
    output = np.zeros((o_height, o_width))
    
    # 执行卷积操作
    for y in range(o_height):
        for x in range(o_width):
            # 提取图像区域
            region = image[y:y+k_height, x:x+k_width]
            # 计算卷积值
            output[y, x] = np.sum(region * kernel)
    
    return output

# 应用卷积核
results = {}
for name, kernel in kernels.items():
    # 为了处理边界，先对图像进行填充
    if kernel.shape[0] == 5:  # 对于5x5卷积核
        pad_width = 2
    else:  # 对于3x3卷积核
        pad_width = 1
    
    padded_image = np.pad(image, pad_width, mode='constant')
    filtered_image = convolve2d(padded_image, kernel)
    
    # 归一化处理，确保像素值在有效范围内
    filtered_image = np.clip(filtered_image, 0, 255).astype(np.uint8)
    results[name] = filtered_image

# 显示结果
plt.figure(figsize=(15, 8))
for i, (name, result) in enumerate(results.items()):
    plt.subplot(3, 4, i + 1)
    plt.imshow(result, cmap='gray')
    plt.title(name, fontproperties=font_prop)
    plt.axis('off')

plt.tight_layout()
plt.show()

边缘与轮廓

边缘检测cv2.Canny

获取轮廓cv2.findContours

轮廓属性cv2.contourArea、cv2.arcLength

import cv2
img = cv2.imread("xxx.png")
# 边缘检测
# 低阈值、高阈值：
# 强边缘：梯度值 > 高阈值 → 确定保留
# 弱边缘：低阈值 < 梯度值 < 高阈值 → 条件保留
# 噪声：梯度值 < 低阈值 → 丢弃（不保留）
canny = cv2.Canny(img,threshold1=100,threshold2=200)

# 轮廓检测
contours,hierarchy = cv2.findContours(canny,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)

# 轮廓的面积
area = cv2.contourArea(contours[0])
# 轮廓的周长
perimeter = cv2.arcLength(contours[0],True)

max_area = max([cv2.contourArea(contour) for contour in contours])
for contour in contours:
    if cv2.contourArea(contour) >= max_area:
        # 绘制轮廓
        cv2.drawContours(img,contour,-1,(0,0,255),1)

cv2.imshow("img",img)
cv2.waitKey(0)
cv2.destroyAllWindows()

算法指路

下面是Opencv常用的算法，每个算法都比较复杂且可能随时间变化出现新的算法，因此随用随学即可。另外，大部分算法也有深度学习的版本，效果更好。

想获得认证可以参与OpenCV Bootcamp

模板匹配

模板匹配（Template Matching）是一种在图像中寻找指定模板位置的技术。它通过在目标图像中滑动模板图像，计算相似度来找到最佳匹配位置。

应用场景：

目标检测：在图像或视频中查找特定对象
图像识别：识别图像中的图标、按钮等
自动化测试：UI自动化中的元素定位
文档处理：在扫描文档中查找特定区域

函数签名：cv2.matchTemplate(image, templ, method[, result[, mask]]) -> result

参数说明：

image：目标图像（待搜索的图像），必须是单通道或三通道图像
templ：模板图像（要查找的小图像），尺寸必须小于等于目标图像
method：匹配方法，使用归一化的方法效果通常更好，常用的有：
- cv2.TM_CCOEFF_NORMED：归一化相关系数匹配，返回0-1之间的值，值越大越匹配
- cv2.TM_CCORR_NORMED：归一化相关匹配
- cv2.TM_SQDIFF_NORMED：归一化平方差匹配，值越小越匹配
result：可选，输出结果图像
mask：可选，掩码图像

返回值：

result：匹配结果图像，尺寸为 (W-w+1, H-h+1)，其中 (W, H) 是目标图像尺寸，(w, h) 是模板图像尺寸

获取最佳匹配位置：使用 cv2.minMaxLoc() 函数获取匹配结果中的最值及其位置

函数签名：cv2.minMaxLoc(src[, mask]) -> minVal, maxVal, minLoc, maxLoc

返回值：

minVal：最小值
maxVal：最大值
minLoc：最小值位置 (x, y)
maxLoc：最大值位置 (x, y)

注意：

对于 TM_SQDIFF 和 TM_SQDIFF_NORMED 方法，最小值位置是最佳匹配
对于其他方法，最大值位置是最佳匹配

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

# 读取目标图像和模板图像
image = cv2.imread('target.jpg')  # 目标图像（大图）
template = cv2.imread('template.jpg')  # 模板图像（小图）

# 将图像转换为灰度图（模板匹配通常在灰度图上进行）
image_gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
template_gray = cv2.cvtColor(template, cv2.COLOR_BGR2GRAY)

# 执行模板匹配
# 使用归一化相关系数匹配方法
result = cv2.matchTemplate(image_gray, template_gray, cv2.TM_CCOEFF_NORMED)

# 获取最佳匹配位置
min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(result)

# 由于使用 TM_CCOEFF_NORMED，最大值位置是最佳匹配
top_left = max_loc
h, w = template_gray.shape
bottom_right = (top_left[0] + w, top_left[1] + h)

# 在原图上绘制匹配区域
image_copy = image.copy()
cv2.rectangle(image_copy, top_left, bottom_right, (0, 255, 0), 2)
cv2.putText(image_copy, f'Match: {max_val:.3f}', 
            (top_left[0], top_left[1] - 10),
            cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2)

# 显示结果
plt.figure(figsize=(15, 5))

plt.subplot(1, 3, 1)
plt.imshow(cv2.cvtColor(template, cv2.COLOR_BGR2RGB))
plt.title('Template')
plt.axis('off')

plt.subplot(1, 3, 2)
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.title('Target Image')
plt.axis('off')

plt.subplot(1, 3, 3)
plt.imshow(cv2.cvtColor(image_copy, cv2.COLOR_BGR2RGB))
plt.title(f'Match Result (Score: {max_val:.3f})')
plt.axis('off')

plt.tight_layout()
plt.show()

# 如果需要找到所有匹配位置（设置阈值）
threshold = 0.8  # 匹配阈值
locations = np.where(result >= threshold)
locations = list(zip(*locations[::-1]))  # 转换为 (x, y) 格式

print(f'Found {len(locations)} matches above threshold {threshold}')
for loc in locations:
    cv2.rectangle(image_copy, loc, (loc[0] + w, loc[1] + h), (255, 0, 0), 2)

特征点校准

特征点校准主要用于图像校准、图像拼接、图像匹配等场景。

"""
图像配准（Image Registration）程序
功能：将一张扫描的表单图像与标准表单图像对齐
应用场景：文档处理、图像拼接、消除扫描时产生的旋转、平移、缩放等变形

图片地址：
https://www.dropbox.com/s/zuwnn6rqe0f4zgh/opencv_bootcamp_assets_NB8.zip?dl=1

程序流程：
1. 读取参考图像和待对齐图像
2. 转换为灰度图像
3. 使用ORB算法检测特征点
4. 匹配两幅图像的特征点
5. 计算单应性变换矩阵
6. 对待对齐图像进行透视变换
7. 保存对齐后的结果图像
"""

# 导入必要的库
import cv2              # OpenCV库，用于计算机视觉和图像处理
import numpy as np      # 数值计算库，用于处理数组和矩阵运算
import matplotlib.pyplot as plt  # 绘图库，用于显示图像

# 读取参考图像（标准表单）
refFilename = "form.jpg"
print("Reading reference image:", refFilename)
im1 = cv2.imread(refFilename, cv2.IMREAD_COLOR)  # 读取彩色图像
# 将BGR颜色空间转换为RGB颜色空间
# OpenCV默认使用BGR（蓝绿红）顺序，matplotlib使用RGB（红绿蓝）顺序
im1 = cv2.cvtColor(im1, cv2.COLOR_BGR2RGB)

# 读取待对齐的图像（扫描的表单）
imFilename = "scanned-form.jpg"
print("Reading image to align:", imFilename)
im2 = cv2.imread(imFilename, cv2.IMREAD_COLOR)  # 读取彩色图像
# 同样进行BGR到RGB的颜色空间转换
im2 = cv2.cvtColor(im2, cv2.COLOR_BGR2RGB)

# 将彩色图像转换为灰度图像
# 特征检测算法通常在灰度图像上工作更好，计算更快，对光照变化更稳定
im1_gray = cv2.cvtColor(im1, cv2.COLOR_BGR2GRAY)
im2_gray = cv2.cvtColor(im2, cv2.COLOR_BGR2GRAY)

# 创建ORB特征检测器
MAX_NUM_FEATURES = 500  # 设置最大特征点数量为500个
# ORB (Oriented FAST and Rotated BRIEF) 是一种特征检测算法
# 它能够找到图像中的"关键点"（特征点），通常是角点、边缘等具有独特特征的位置
orb = cv2.ORB_create(MAX_NUM_FEATURES)
# 同时检测关键点和计算描述符
# keypoints：特征点的位置信息
# descriptors：每个特征点的描述符（数字化"指纹"）
keypoints1, descriptors1 = orb.detectAndCompute(im1_gray, None)
keypoints2, descriptors2 = orb.detectAndCompute(im2_gray, None)

# 显示第一个特征点的描述符示例
print(descriptors1[0])
"""
每个ORB描述符是一个32字节（256位）的二进制向量
这些数字是该二进制向量的十进制表示
这个描述符唯一地描述了图像中某个特征点周围的纹理模式
简单来说，这些数字就是计算机"看到"的某个图像特征点的数字化"指纹"！
描述符就像人的指纹一样，每个特征点都有独特的数字"指纹"
计算机通过比较这些"指纹"来找到两幅图像中的相同特征点

[  2 233  53 155 108 141 186 164 142 121  81  73 172 220  44  73 134  91
  31  71 194  48  74 245 164  24  74 242  28  27 129 217]
"""

# 在图像上绘制检测到的特征点
# color=(255, 0, 0)：用红色标记特征点
# DRAW_RICH_KEYPOINTS：绘制带方向和尺度信息的特征点
im1_display = cv2.drawKeypoints(im1, keypoints1, outImage=np.array([]), 
                                color=(255, 0, 0), flags=cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)

im2_display = cv2.drawKeypoints(im2, keypoints2, outImage=np.array([]), 
                                color=(255, 0, 0), flags=cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)

# 显示特征点图像（注释掉了，如需显示可取消注释）
# cv2.imshow("im1_display", im1_display)
# cv2.imshow("im2_display", im2_display)
# cv2.waitKey(0)
# cv2.destroyAllWindows()

# 创建特征匹配器
# 暴力匹配器会把第一幅图像的每个特征点与第二幅图像的所有特征点进行比较
# 找出最相似的特征点对，HAMMING距离用于比较二进制描述符的相似性
matcher = cv2.DescriptorMatcher_create(cv2.DESCRIPTOR_MATCHER_BRUTEFORCE_HAMMING)
print(cv2.DESCRIPTOR_MATCHER_BRUTEFORCE)
print(cv2.DESCRIPTOR_MATCHER_BRUTEFORCE_HAMMING)


# 进行特征匹配，转换为列表以便排序（元组是不可变对象）
matches = list(matcher.match(descriptors1, descriptors2, None))

# 按匹配距离排序（距离越小，匹配越好）
matches.sort(key=lambda x: x.distance, reverse=False)

# 筛选最佳匹配点，只保留前10%的最佳匹配
# 这样做是因为不是所有匹配都是准确的，保留最好的匹配点可以提高后续计算的准确性
numGoodMatches = int(len(matches) * 0.1)
matches = matches[:numGoodMatches]

# 提取匹配点的坐标
# 创建两个数组存储匹配点的坐标
points1 = np.zeros((len(matches), 2), dtype=np.float32)  # 参考图像中的点坐标
points2 = np.zeros((len(matches), 2), dtype=np.float32)  # 待对齐图像中的对应点坐标

# 从匹配结果中提取对应点的(x,y)坐标
for i, match in enumerate(matches):
    points1[i, :] = keypoints1[match.queryIdx].pt    # 参考图像中的特征点坐标
    points2[i, :] = keypoints2[match.trainIdx].pt    # 待对齐图像中的特征点坐标

# 计算单应性矩阵（Homography）
# 单应性矩阵是一个3x3的变换矩阵，描述了两个图像之间的投影变换关系
# 简单说就是：如何把第二幅图像变形成第一幅图像的样子
# RANSAC算法用于排除错误匹配点的干扰
h, mask = cv2.findHomography(points2, points1, cv2.RANSAC)

# 对图像进行透视变换以实现对齐
height, width, channels = im1.shape  # 获取参考图像的尺寸
# 使用单应性矩阵对第二幅图像进行透视变换
# warpPerspective函数会根据计算出的变换矩阵，将待对齐的图像扭曲变形，使其与参考图像对齐
im2_reg = cv2.warpPerspective(im2, h, (width, height))

# 保存对齐后的图像
cv2.imwrite("im2_reg.jpg", im2_reg)


[
  (0,0),
  (223,232),
  (131,391),
  (383,390)
]

HDR

HDR（高动态范围）技术主要应用于摄影、监控系统和医学影像中，通过多次曝光融合提升图像细节表现。

HDR 是一种图像处理技术，用于提高图像的动态范围，使得图像中的高光和阴影细节更加清晰。给定多张不同曝光的图像，通过算法将这些图像融合成一张高动态范围的图像。

"""
图片地址：
https://www.dropbox.com/s/qa1hsyxt66pvj02/opencv_bootcamp_assets_NB10.zip?dl=1
"""

import os
import cv2
import numpy as np

def readImagesAndTimes():
    # 文件名需要保证是按照曝光时间排序的
    filenames = ["img_0.033.jpg", "img_0.25.jpg", "img_2.5.jpg", "img_15.jpg"]

    # List of exposure times
    times = np.array([1 / 30.0, 0.25, 2.5, 15.0], dtype=np.float32)

    # Read images
    images = []
    for filename in filenames:
        im = cv2.imread(filename)
        images.append(im)

    return images, times

# 对齐图片。不对齐的话，图片会重影

images, times = readImagesAndTimes()

# Align Images
alignMTB = cv2.createAlignMTB()
alignMTB.process(images, images)

# 估计相机响应函数
calibrateDebevec = cv2.createCalibrateDebevec()
responseDebevec = calibrateDebevec.process(images, times)

# 将曝光合并到 HDR 图像中
mergeDebevec = cv2.createMergeDebevec()
hdrDebevec = mergeDebevec.process(images, times, responseDebevec)

# 色调映射

# 方法1
tonemapDrago = cv2.createTonemapDrago(1.0, 0.7)
ldrDrago = tonemapDrago.process(hdrDebevec)
ldrDrago = 3 * ldrDrago

# 方法2
tonemapReinhard = cv2.createTonemapReinhard(1.5, 0, 0, 0)
ldrReinhard = tonemapReinhard.process(hdrDebevec)

# 方法3
tonemapMantiuk = cv2.createTonemapMantiuk(2.2, 0.85, 1.2)
ldrMantiuk = tonemapMantiuk.process(hdrDebevec)
ldrMantiuk = 3 * ldrMantiuk

# Saving image
cv2.imwrite("ldr-Drago.jpg", 255*ldrDrago)
cv2.imwrite("ldr-Reinhard.jpg", 255*ldrReinhard)
cv2.imwrite("ldr-Mantiuk.jpg", 255*ldrMantiuk)

全景拼接

全景拼接技术广泛应用于虚拟旅游、房地产展示、地图服务和VR/AR场景构建中。

可以实现多张图片的拼接，形成一张完整的全景图。支持拼接为环形。

"""
图片地址：
https://www.dropbox.com/s/0o5yqql1ynx31bi/opencv_bootcamp_assets_NB9.zip?dl=1
"""
import os
import cv2
import math
import glob
import numpy as np


def find_largest_rectangle(mask):
    """
    在二值掩码中找到最大的矩形区域
    使用直方图方法高效计算最大矩形面积
    """
    def largest_rectangle_in_histogram(heights):
        stack = []
        max_area = 0
        best_rect = (0, 0, 0, 0)  # (x, y, w, h)
        
        for i, h in enumerate(heights):
            start = i
            while stack and stack[-1][1] > h:
                index, height = stack.pop()
                area = height * (i - index)
                if area > max_area:
                    max_area = area
                    best_rect = (index, 0, i - index, height)
                start = index
            stack.append((start, h))
        
        # 处理栈中剩余元素
        for index, height in stack:
            area = height * (len(heights) - index)
            if area > max_area:
                max_area = area
                best_rect = (index, 0, len(heights) - index, height)
        
        return best_rect, max_area
    
    # 将掩码转换为灰度图
    if len(mask.shape) == 3:
        mask = cv2.cvtColor(mask, cv2.COLOR_BGR2GRAY)
    
    height, width = mask.shape
    
    # 计算每行的直方图
    histogram = np.zeros(width, dtype=np.int32)
    max_area = 0
    best_rect = (0, 0, 0, 0)
    
    for row in range(height):
        # 更新直方图
        for col in range(width):
            if mask[row, col] > 0:  # 有效像素
                histogram[col] += 1
            else:  # 无效像素，重置高度
                histogram[col] = 0
        
        # 在当前直方图中找最大矩形
        rect, area = largest_rectangle_in_histogram(histogram)
        if area > max_area:
            max_area = area
            best_rect = (rect[0], row - rect[3] + 1, rect[2], rect[3])
    
    return best_rect


def create_valid_mask(image, threshold=10):
    """
    创建有效区域掩码，标识非黑色区域
    """
    # 转换为灰度图
    if len(image.shape) == 3:
        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    else:
        gray = image.copy()
    
    # 创建掩码：非黑色区域为255，黑色区域为0
    mask = np.where(gray > threshold, 255, 0).astype(np.uint8)
    
    # 形态学操作，填充小的空洞和去除噪声
    kernel = np.ones((5, 5), np.uint8)
    mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel)  # 填充小空洞
    mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel)   # 去除小噪声
    
    return mask


def smart_crop_panorama(image, threshold=10, padding=5):
    """
    智能裁剪全景图，去除黑色填充区域
    """
    print(f"原始图像尺寸: {image.shape}")
    
    # 创建有效区域掩码
    mask = create_valid_mask(image, threshold)
    
    # 找到最大矩形
    x, y, w, h = find_largest_rectangle(mask)
    
    # 应用内边距
    x = max(0, x + padding)
    y = max(0, y + padding)
    w = min(image.shape[1] - x, w - 2 * padding)
    h = min(image.shape[0] - y, h - 2 * padding)
    
    if w <= 0 or h <= 0:
        return image
    cropped_image = image[y:y+h, x:x+w]
    return cropped_image


# 读取图像文件
# 把需要拼接图片放到boat文件夹中
imagefiles = glob.glob(f"boat{os.sep}*")
imagefiles.sort()

images = []
for filename in imagefiles:
    img = cv2.imread(filename)
    images.append(img)

stitcher = cv2.Stitcher_create()
status, result = stitcher.stitch(images)

if status == cv2.Stitcher_OK:
    cv2.imwrite("result_raw.png", result)
    cropped_result = smart_crop_panorama(result, threshold=10, padding=5)
    cv2.imwrite("result.png", cropped_result)

对象跟踪

对象跟踪技术应用于视频监控、体感交互、体育分析、无人机导航和增强现实等场景。

"""
图片地址：
https://www.dropbox.com/s/ld535c8e0vueq6x/opencv_bootcamp_assets_NB11.zip?dl=1
"""
import os
import sys
import cv2
import numpy as np
import matplotlib.pyplot as plt

from zipfile import ZipFile
from urllib.request import urlretrieve

from IPython.display import HTML
from matplotlib.animation import FuncAnimation

from IPython.display import YouTubeVideo, display, HTML
from base64 import b64encode
video_input_file_name = "race_car.mp4"


def drawRectangle(frame, bbox):
    p1 = (int(bbox[0]), int(bbox[1]))
    p2 = (int(bbox[0] + bbox[2]), int(bbox[1] + bbox[3]))
    cv2.rectangle(frame, p1, p2, (255, 0, 0), 2, 1)


def displayRectangle(frame, bbox):
    plt.figure(figsize=(20, 10))
    frameCopy = frame.copy()
    drawRectangle(frameCopy, bbox)
    frameCopy = cv2.cvtColor(frameCopy, cv2.COLOR_RGB2BGR)
    plt.imshow(frameCopy)
    plt.axis("off")


def drawText(frame, txt, location, color=(50, 170, 50)):
    cv2.putText(frame, txt, location, cv2.FONT_HERSHEY_SIMPLEX, 1, color, 3)

# Set up tracker
tracker_types = [
    "BOOSTING",
    "MIL",
    "KCF",
    "CSRT",
    "TLD",
    "MEDIANFLOW",
    "GOTURN",
    "MOSSE",
]

# Change the index to change the tracker type
tracker_type = tracker_types[2]

if tracker_type == "BOOSTING":
    tracker = cv2.legacy.TrackerBoosting.create()
elif tracker_type == "MIL":
    tracker = cv2.legacy.TrackerMIL.create()
elif tracker_type == "KCF":
    tracker = cv2.TrackerKCF.create()
elif tracker_type == "CSRT":
    tracker = cv2.TrackerCSRT.create()
elif tracker_type == "TLD":
    tracker = cv2.legacy.TrackerTLD.create()
elif tracker_type == "MEDIANFLOW":
    tracker = cv2.legacy.TrackerMedianFlow.create()
elif tracker_type == "GOTURN":
    tracker = cv2.TrackerGOTURN.create()
else:
    tracker = cv2.legacy.TrackerMOSSE.create()

# Read video
video = cv2.VideoCapture(video_input_file_name)
ok, frame = video.read()

# Exit if video not opened
if not video.isOpened():
    print("Could not open video")
    sys.exit()
else:
    width = int(video.get(cv2.CAP_PROP_FRAME_WIDTH))
    height = int(video.get(cv2.CAP_PROP_FRAME_HEIGHT))

video_output_file_name = "race_car-" + tracker_type + ".mp4"
video_out = cv2.VideoWriter(video_output_file_name, cv2.VideoWriter_fourcc(*"XVID"), 10, (width, height))


# Define a bounding box
bbox = (1300, 405, 160, 120)
# bbox = cv2.selectROI(frame, False)
# print(bbox)
displayRectangle(frame, bbox)


ok = tracker.init(frame, bbox)

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

    if not ok:
        break

    # Start timer
    timer = cv2.getTickCount()

    # Update tracker
    ok, bbox = tracker.update(frame)

    # Calculate Frames per second (FPS)
    fps = cv2.getTickFrequency() / (cv2.getTickCount() - timer)

    # Draw bounding box
    if ok:
        drawRectangle(frame, bbox)
    else:
        drawText(frame, "Tracking failure detected", (80, 140), (0, 0, 255))

    # Display Info
    drawText(frame, tracker_type + " Tracker", (80, 60))
    drawText(frame, "FPS : " + str(int(fps)), (80, 100))

    # Write frame to video
    video_out.write(frame)

video.release()
video_out.release()

人脸检测

人脸检测算法广泛应用于身份验证、考勤系统、社交媒体标记、美颜相机和安防监控中。

这段程序首先会读取摄像头，并自动截取一定数量的人脸用作训练。
然后将截取的人脸进行训练，生成一个训练模型。
最后通过摄像头实时识别人脸

使用下方代码时，需要保证当前文件夹存在以下内容。（如必须在非当前目录执行，请替换相关路径为绝对路径，你可能需要根据自己的摄像头修改代码中的CID = 0的值）

dataSet文件夹
如不存在可自行创建一个空文件夹，注意大小写敏感。
haarcascade_frontalface_default.xml文件可以通过 everthing 搜索，移动到当前目录。

import os
import cv2
import numpy as np

# 摄像头被分配到的设备ID，window通常为0，linux通常为1，AIBox通常为9~13
CID = 0


# 输入人脸,id为人脸对应的id，同个id的人脸会被识别为同一个人
def get_face(id="1"):
    faceDetect = cv2.CascadeClassifier("haarcascade_frontalface_default.xml")
    cam = cv2.VideoCapture(CID)
    sampleNum = 0
    while True:
        ret, img = cam.read()
        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
        faces = faceDetect.detectMultiScale(gray, 1.3, 5)
        for x, y, w, h in faces:
            sampleNum = sampleNum + 1
            cv2.imwrite(
                "dataSet/User." + str(id) + "." + str(sampleNum) + ".png",
                gray[y : y + h, x : x + w],
            )
            cv2.rectangle(img, (x, y), (x + w, y + h), (0, 0, 255), 2)
            cv2.waitKey(100)
        cv2.imshow("Face", img)
        cv2.waitKey(1)
        if sampleNum > 20:
            break
    cam.release()
    cv2.destroyAllWindows()


# 训练数据
def trainer_face(path="dataSet"):
    recognizer = cv2.face.LBPHFaceRecognizer_create()
    imagePaths = [os.path.join(path, f) for f in os.listdir(path)]
    faces = []
    IDs = []
    for imagePath in imagePaths:
        faceImg = cv2.imread(imagePath,0)
        faceNp = np.array(faceImg, "uint8")
        ID = int(os.path.split(imagePath)[-1].split(".")[1])
        faces.append(faceNp)
        IDs.append(ID)
        cv2.imshow("training", faceNp)
        cv2.waitKey(10)
    recognizer.train(faces, np.array(IDs))
    recognizer.save("trainningData.yml")
    cv2.destroyAllWindows()


# 识别人脸
def recognizer(labels={"p1": 1, "p2": 2}):
    # 加载人脸识别器
    face_cascade = cv2.CascadeClassifier("haarcascade_frontalface_default.xml")

    # 加载已训练的人脸识别模型
    recognizer = cv2.face.LBPHFaceRecognizer_create()
    recognizer.read("trainningData.yml")

    # 初始化摄像头
    cap = cv2.VideoCapture(CID)
    font = cv2.FONT_HERSHEY_COMPLEX_SMALL
    while True:
        ret, frame = cap.read()
        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

        # 检测人脸
        faces = face_cascade.detectMultiScale(
            gray, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30)
        )

        rgb_color = (0, 0, 0)
        for x, y, w, h in faces:
            # 识别人脸
            id, confidence = recognizer.predict(gray[y : y + h, x : x + w])
            person = ""
            if confidence < 100:
                for name, label in labels.items():
                    if label == id:
                        person = name
                        break
                confidence = int(100 - confidence)
                if int(confidence) > 40:
                    rgb_color = (0, 255, 0)  # 绿色
                    person = f"{person}: {confidence}%"

                elif 0 < int(confidence) < 40:
                    rgb_color = (255, 0, 0)  # 红色
                    person = "unkonw"
            cv2.putText(
                frame,
                str(person),
                (x, y + h),
                cv2.FONT_HERSHEY_SIMPLEX,
                1,
                (0, 0, 255),
                2,
            )  # 更新为cv2.putText()
            cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2)
        cv2.imshow("Face Recognition", frame)
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break

    cap.release()
    cv2.destroyAllWindows()


if __name__ == "__main__":
    get_face(id="1")
    trainer_face(path="dataSet")
    recognizer()

YOLO

原始的 YOLOv1~v3 由 Joseph Redmon 用 C+Darknet 实现，他已在2020年退出该领域。

目前最主流、最活跃的 YOLO 系列实现是 Ultralytics YOLO（YOLOv11），它完全基于 PyTorch 开发和维护（与原始作者 Joseph Redmon 无关）。

如果说PyTorch是强大的深度学习“工具箱”，那么Ultralytics YOLO就是用这个工具箱造好的一台“目标检测成品机器”，开箱即用。

如果你不想从头写模型，直接使用 Ultralytics YOLO（v11）是目前最推荐的工业级方案。

tip

训练好的 PyTorch / YOLO 模型都可以导出为 ONNX 格式，并用 OpenCV DNN 模块加载推理。

经过测试：opencv加载YOLOv11模型，与原生yolo的FPS一致、内存占用一致。Opencv的CPU占用率更高。

所以使用OpenCV的唯一原因是打包为可执行文件后体积更小。

导出模型

from ultralytics import YOLO
import os
import shutil

def export_yolo_to_onnx(model_path, output_path, imgsz=640, batch_size=1):
    model = YOLO(model_path)
    model.export(
        format='onnx',
        imgsz=imgsz,
        batch=batch_size,
        simplify=True,
        opset=11,
        dynamic=False,
        half=False
    )
    
    # 重命名到指定路径
    base_name = os.path.splitext(model_path)[0]
    auto_path = base_name + '.onnx'
    if os.path.exists(auto_path) and auto_path != output_path:
        shutil.move(auto_path, output_path)
    
    print(f"导出完成: {output_path}")


if __name__ == "__main__":
    # 导出yolo11n.pt模型（官方模板）为onnx格式
    export_yolo_to_onnx("yolo11n.pt", "yolo11n.onnx", imgsz=640, batch_size=1)

使用模型

Ultralytics
OpenCV

from ultralytics import YOLO
import cv2
import time

# 加载YOLO模型（使用.pt文件，原生格式）
model = YOLO("yolo11n.pt")  # 或者使用 "yolo11n.onnx" 也可以

# 打开摄像头
cap = cv2.VideoCapture(0)

if not cap.isOpened():
    print("无法打开摄像头！")
    exit()

print("摄像头已打开，按 'q' 键退出")

# 实时检测循环
pTime = 0
while True:
    ret, frame = cap.read()
    if not ret:
        print("无法读取摄像头画面")
        break
    
    # 记录开始时间（计算整个循环的FPS，包括所有操作）
    loop_start = time.time()
    
    # YOLO原生推理（自动处理预处理和后处理）
    results = model(frame, verbose=False)
    
    # 绘制检测结果
    annotated_frame = results[0].plot()
    
    # 计算整个循环的FPS（公平比较）
    cTime = time.time()
    fps = 1.0 / (cTime - pTime) if (cTime - pTime) > 0 else 0
    pTime = cTime
    
    # 显示FPS和推理时间（可选）
    inference_time = results[0].speed['inference']  # ms
    cv2.putText(annotated_frame, f"FPS: {fps:.1f} (Loop)", (10, 30), 
                cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2)
    cv2.putText(annotated_frame, f"Inference: {inference_time:.1f}ms", (10, 60), 
                cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 0), 2)
    
    # 显示画面
    cv2.imshow("YOLO 实时检测", annotated_frame)
    
    # 按 'q' 键退出
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

# 释放资源
cap.release()
cv2.destroyAllWindows()
print("已关闭摄像头")

import cv2
import numpy as np
import time

# 配置
ONNX_PATH = "yolo11n.onnx"
CONF_THRESHOLD = 0.45
INPUT_SIZE = 640
USE_CUDA = True

# COCO类名
COCO_CLASSES = ['person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus', 'train', 'truck', 'boat', 'traffic light',
    'fire hydrant', 'stop sign', 'parking meter', 'bench', 'bird', 'cat', 'dog', 'horse', 'sheep', 'cow',
    'elephant', 'bear', 'zebra', 'giraffe', 'backpack', 'umbrella', 'handbag', 'tie', 'suitcase', 'frisbee',
    'skis', 'snowboard', 'sports ball', 'kite', 'baseball bat', 'baseball glove', 'skateboard', 'surfboard',
    'tennis racket', 'bottle', 'wine glass', 'cup', 'fork', 'knife', 'spoon', 'bowl', 'banana', 'apple',
    'sandwich', 'orange', 'broccoli', 'carrot', 'hot dog', 'pizza', 'donut', 'cake', 'chair', 'couch',
    'potted plant', 'bed', 'dining table', 'toilet', 'tv', 'laptop', 'mouse', 'remote', 'keyboard', 'cell phone',
    'microwave', 'oven', 'toaster', 'sink', 'refrigerator', 'book', 'clock', 'vase', 'scissors', 'teddy bear',
    'hair drier', 'toothbrush']

# 加载模型
net = cv2.dnn.readNetFromONNX(ONNX_PATH)
if USE_CUDA and cv2.cuda.getCudaEnabledDeviceCount() > 0:
    net.setPreferableBackend(cv2.dnn.DNN_BACKEND_CUDA)
    net.setPreferableTarget(cv2.dnn.DNN_TARGET_CUDA_FP16)

# 打开摄像头
cap = cv2.VideoCapture(0)
pTime = 0

while True:
    ret, frame = cap.read()
    if not ret:
        break
    
    # 推理
    t0 = time.time()
    blob = cv2.dnn.blobFromImage(frame, 1/255.0, (INPUT_SIZE, INPUT_SIZE), swapRB=True)
    net.setInput(blob)
    output = np.squeeze(net.forward()).T
    
    # 后处理
    boxes, scores = output[:, :4], output[:, 4:84]
    max_scores = np.max(scores, axis=1)
    class_ids = np.argmax(scores, axis=1)
    mask = max_scores > CONF_THRESHOLD
    
    # 坐标转换
    h, w = frame.shape[:2]
    scale_x, scale_y = w / INPUT_SIZE, h / INPUT_SIZE
    boxes_masked = boxes[mask]
    final_boxes = [[int((cx - bw/2) * scale_x), int((cy - bh/2) * scale_y), 
                    int(bw * scale_x), int(bh * scale_y)] 
                   for cx, cy, bw, bh in boxes_masked]
    
    # NMS并绘制
    scores_masked = max_scores[mask]
    class_ids_masked = class_ids[mask]
    indices = cv2.dnn.NMSBoxes(final_boxes, scores_masked.tolist(), CONF_THRESHOLD, 0.5)
    if len(indices) > 0:
        for i in indices.flatten():
            x, y, bw, bh = final_boxes[i]
            label = f"{COCO_CLASSES[class_ids_masked[i]]} {scores_masked[i]:.2f}"
            cv2.rectangle(frame, (x, y), (x+bw, y+bh), (0, 255, 0), 2)
            cv2.putText(frame, label, (x, y-10), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 2)
    
    # FPS
    cTime = time.time()
    fps = 1 / (cTime - pTime) if (cTime - pTime) > 0 else 0
    pTime = cTime
    cv2.putText(frame, f"FPS: {fps:.1f}", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 255), 2)
    cv2.putText(frame, f"Inference: {(time.time()-t0)*1000:.1f}ms", (10, 60), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 0), 2)
    
    cv2.imshow("YOLO Webcam", frame)
    if cv2.waitKey(1) == 27:
        break

cap.release()
cv2.destroyAllWindows()

安装​

图像读取与显示​

图像读取​

图像保存​

图像显示、等待按键、关闭窗口​

动态图像​

视频读取与显示​

视频保存​

图像绘制​

绘制直线、矩形​

圆形、椭圆​

多边形​

绘制文字​

绘制箭头​

PIL库绘制中文​

图像运算​

图像加法、图像减法​

图像横向与纵向拼接​

基础图像操作​

图像缩放​

拆分与合并通道​

图像翻转​

图像裁剪​

图像平移​

图像旋转​

仿射变换​

透视变换​

图像扩边​

色彩处理​

灰度图​

二值化图​

形态学处理​

膨胀和腐蚀​

开运算和闭运算​

模糊​

边缘与轮廓​

边缘检测cv2.Canny​

获取轮廓cv2.findContours​

轮廓属性cv2.contourArea、cv2.arcLength​

算法指路​

模板匹配​

特征点校准​

HDR​

全景拼接​

对象跟踪​

人脸检测​

YOLO​

导出模型​

使用模型​

安装

图像读取与显示

图像读取

图像保存

图像显示、等待按键、关闭窗口

动态图像

视频读取与显示

视频保存

图像绘制

绘制直线、矩形

圆形、椭圆

多边形

绘制文字

绘制箭头

PIL库绘制中文

图像运算

图像加法、图像减法

图像横向与纵向拼接

基础图像操作

图像缩放

拆分与合并通道

图像翻转

图像裁剪

图像平移

图像旋转

仿射变换

透视变换

图像扩边

色彩处理

灰度图

二值化图

形态学处理

膨胀和腐蚀

开运算和闭运算

模糊

边缘与轮廓

边缘检测cv2.Canny

获取轮廓cv2.findContours

轮廓属性cv2.contourArea、cv2.arcLength

算法指路

模板匹配

特征点校准

HDR

全景拼接

对象跟踪

人脸检测

YOLO

导出模型

使用模型