当前位置：首页 > news >正文

OpenCV编程入门：从零开始的计算机视觉之旅

news 2025/10/19 6:28:12

作者：AI技术分享

专栏：OpenCV计算机视觉实战

发布时间：2025年1月

前言

在人工智能和计算机视觉飞速发展的今天，OpenCV（Open Source Computer Vision Library）作为最强大的开源计算机视觉库之一，已经成为了图像处理和计算机视觉领域的事实标准。无论你是想要进行人脸识别、物体检测、图像增强，还是视频处理，OpenCV都能为你提供强大的支持。

本系列文章将从零开始，手把手教你掌握OpenCV编程。第一篇，我们将完成环境搭建，理解OpenCV的基本概念，并实现几个有趣的图像处理功能。

一、什么是OpenCV？

1.1 OpenCV简介

OpenCV是一个基于BSD许可证发行的跨平台计算机视觉库，由Intel公司于1999年发起并参与开发。它包含了超过2500个优化的算法，这些算法可以用来：

图像处理：滤波、边缘检测、形态学操作等
特征检测：角点检测、SIFT、SURF、ORB等
目标检测：人脸检测、行人检测、物体识别等
视频分析：光流、背景建模、目标跟踪等
机器学习：支持向量机、决策树、神经网络等

1.2 为什么选择OpenCV？

跨平台支持：支持Windows、Linux、MacOS、Android、iOS等
多语言接口：C++、Python、Java、MATLAB等
高性能：底层用C/C++编写，经过高度优化
活跃的社区：大量的教程、示例和第三方扩展
免费开源：可商用，无需支付许可费

二、环境搭建（Python版）

本教程以Python为主要编程语言，因为Python语法简洁，非常适合快速原型开发。

2.1 安装Python

首先确保你的系统已安装Python 3.7或更高版本。打开命令行输入：

python --version

如果未安装，请访问 python.org 下载安装。

2.2 安装OpenCV

使用pip安装OpenCV非常简单：

# 安装OpenCV主模块
pip install opencv-python# 安装OpenCV扩展模块（包含SIFT、SURF等专利算法）
pip install opencv-contrib-python# 安装其他常用库
pip install numpy matplotlib pillow

2.3 验证安装

创建一个测试文件 test_opencv.py：

import cv2
import numpy as np# 打印OpenCV版本
print(f"OpenCV版本: {cv2.__version__}")# 创建一个简单的图像
img = np.zeros((300, 300, 3), dtype=np.uint8)
img[:, :] = [255, 0, 0]  # 蓝色背景# 显示图像
cv2.imshow('Test Window', img)
cv2.waitKey(0)
cv2.destroyAllWindows()print("OpenCV安装成功！")

运行这个脚本，如果能看到一个蓝色窗口并打印出版本信息，说明安装成功。

三、OpenCV基础概念

3.1 图像在计算机中的表示

在计算机中，图像被表示为数字矩阵：

灰度图像：二维矩阵，每个元素代表像素的亮度（0-255）
彩色图像：三维矩阵，第三个维度表示颜色通道（BGR或RGB）

import cv2
import numpy as np# 创建一个3x3的灰度图像
gray_img = np.array([[0, 127, 255],[64, 128, 192],[32, 96, 160]
], dtype=np.uint8)print("灰度图像矩阵：")
print(gray_img)
print(f"形状: {gray_img.shape}")
print(f"数据类型: {gray_img.dtype}")# 创建一个2x2的彩色图像
color_img = np.array([[[255, 0, 0], [0, 255, 0]],    # 蓝色、绿色[[0, 0, 255], [255, 255, 255]]  # 红色、白色
], dtype=np.uint8)print("\n彩色图像矩阵：")
print(color_img)
print(f"形状: {color_img.shape}")  # (2, 2, 3)

3.2 OpenCV的坐标系统

OpenCV使用的坐标系统：

原点(0,0)在图像左上角
x轴向右为正
y轴向下为正

3.3 颜色空间

OpenCV默认使用BGR颜色顺序（不是RGB！），这是一个常见的坑：

import cv2
import numpy as np
import matplotlib.pyplot as plt# 创建一个红色方块（在OpenCV中是BGR顺序）
img_bgr = np.zeros((100, 100, 3), dtype=np.uint8)
img_bgr[:, :] = [0, 0, 255]  # BGR中的红色# 如果直接用matplotlib显示（它期望RGB），颜色会错误
plt.figure(figsize=(10, 4))plt.subplot(1, 3, 1)
plt.imshow(img_bgr)
plt.title('直接显示BGR（错误）')
plt.axis('off')# 转换为RGB
img_rgb = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2RGB)
plt.subplot(1, 3, 2)
plt.imshow(img_rgb)
plt.title('转换为RGB后（正确）')
plt.axis('off')# OpenCV显示（它理解BGR）
plt.subplot(1, 3, 3)
# 为了在matplotlib中模拟OpenCV的显示效果
plt.imshow(cv2.cvtColor(img_bgr, cv2.COLOR_BGR2RGB))
plt.title('OpenCV中的显示效果')
plt.axis('off')plt.tight_layout()
plt.show()

四、第一个OpenCV程序：图像读取、显示与保存

4.1 完整示例代码

创建 first_opencv_program.py：

import cv2
import numpy as np
import osdef main():# 1. 读取图像# 准备一个示例图像（如果没有，创建一个）if not os.path.exists('sample.jpg'):create_sample_image()# 读取图像img = cv2.imread('sample.jpg')# 检查图像是否成功读取if img is None:print("错误：无法读取图像文件")returnprint(f"图像尺寸: {img.shape}")print(f"高度: {img.shape[0]} 像素")print(f"宽度: {img.shape[1]} 像素")print(f"通道数: {img.shape[2]}")# 2. 图像基本操作# 转换为灰度图gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)# 调整图像大小resized = cv2.resize(img, (300, 300))# 图像翻转flipped_horizontal = cv2.flip(img, 1)  # 水平翻转flipped_vertical = cv2.flip(img, 0)    # 垂直翻转flipped_both = cv2.flip(img, -1)       # 同时翻转# 3. 显示图像cv2.imshow('Original Image', img)cv2.imshow('Gray Image', gray)cv2.imshow('Resized Image', resized)cv2.imshow('Flipped Horizontal', flipped_horizontal)print("\n按任意键保存处理后的图像，按ESC退出...")key = cv2.waitKey(0)# 4. 保存图像if key != 27:  # 27是ESC键的ASCII码cv2.imwrite('output_gray.jpg', gray)cv2.imwrite('output_resized.jpg', resized)cv2.imwrite('output_flipped.jpg', flipped_horizontal)print("图像已保存！")# 5. 清理窗口cv2.destroyAllWindows()def create_sample_image():"""创建一个示例图像用于演示"""# 创建一个渐变色图像img = np.zeros((400, 600, 3), dtype=np.uint8)# 添加渐变色for i in range(400):img[i, :, 0] = int(255 * (i / 400))  # 蓝色渐变img[i, :, 1] = 128                    # 绿色固定img[i, :, 2] = int(255 * (1 - i / 400))  # 红色反向渐变# 添加一些几何图形cv2.rectangle(img, (50, 50), (200, 150), (255, 255, 255), 3)cv2.circle(img, (400, 200), 80, (0, 255, 255), -1)cv2.putText(img, 'OpenCV Demo', (250, 350), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2)cv2.imwrite('sample.jpg', img)print("已创建示例图像 sample.jpg")if __name__ == "__main__":main()

4.2 代码详解

读取图像

img = cv2.imread('image.jpg')  # 默认以彩色模式读取
img_gray = cv2.imread('image.jpg', 0)  # 以灰度模式读取
img_unchanged = cv2.imread('image.jpg', -1)  # 包含alpha通道

显示图像

cv2.imshow('窗口名称', img)
cv2.waitKey(0)  # 等待按键，0表示无限等待
cv2.destroyAllWindows()  # 关闭所有窗口

保存图像

success = cv2.imwrite('output.jpg', img)
# 可以指定压缩质量（JPEG）
cv2.imwrite('output.jpg', img, [cv2.IMWRITE_JPEG_QUALITY, 95])

五、实战项目：图像滤波器应用

5.1 项目目标

实现一个图像滤波器应用，包含多种滤波效果：

高斯模糊
中值滤波
双边滤波
锐化滤波
边缘检测

5.2 完整代码实现

创建 image_filter_app.py：

import cv2
import numpy as np
from enum import Enumclass FilterType(Enum):ORIGINAL = 0GAUSSIAN_BLUR = 1MEDIAN_BLUR = 2BILATERAL = 3SHARPEN = 4EDGE_CANNY = 5EDGE_SOBEL = 6EMBOSS = 7MOTION_BLUR = 8class ImageFilterApp:def __init__(self, image_path):"""初始化图像滤波器应用"""self.original = cv2.imread(image_path)if self.original is None:raise ValueError(f"无法读取图像: {image_path}")# 调整图像大小以适应屏幕max_height = 600if self.original.shape[0] > max_height:scale = max_height / self.original.shape[0]new_width = int(self.original.shape[1] * scale)self.original = cv2.resize(self.original, (new_width, max_height))self.filtered = self.original.copy()self.filter_type = FilterType.ORIGINALself.kernel_size = 5# 创建窗口和滑动条self.window_name = "Image Filter App"cv2.namedWindow(self.window_name)cv2.createTrackbar("Filter Type", self.window_name, 0, 8, self.on_filter_change)cv2.createTrackbar("Kernel Size", self.window_name, 5, 21, self.on_kernel_change)def on_filter_change(self, value):"""滤波器类型改变时的回调函数"""self.filter_type = FilterType(value)self.apply_filter()def on_kernel_change(self, value):"""核大小改变时的回调函数"""# 确保核大小是奇数self.kernel_size = value if value % 2 == 1 else value + 1if self.kernel_size < 3:self.kernel_size = 3self.apply_filter()def apply_filter(self):"""应用选定的滤波器"""if self.filter_type == FilterType.ORIGINAL:self.filtered = self.original.copy()elif self.filter_type == FilterType.GAUSSIAN_BLUR:self.filtered = cv2.GaussianBlur(self.original, (self.kernel_size, self.kernel_size), 0)elif self.filter_type == FilterType.MEDIAN_BLUR:self.filtered = cv2.medianBlur(self.original, self.kernel_size)elif self.filter_type == FilterType.BILATERAL:self.filtered = cv2.bilateralFilter(self.original, self.kernel_size, self.kernel_size * 2, self.kernel_size / 2)elif self.filter_type == FilterType.SHARPEN:kernel = np.array([[0, -1, 0],[-1, 5, -1],[0, -1, 0]], dtype=np.float32)self.filtered = cv2.filter2D(self.original, -1, kernel)elif self.filter_type == FilterType.EDGE_CANNY:gray = cv2.cvtColor(self.original, cv2.COLOR_BGR2GRAY)edges = cv2.Canny(gray, 50, 150)self.filtered = cv2.cvtColor(edges, cv2.COLOR_GRAY2BGR)elif self.filter_type == FilterType.EDGE_SOBEL:gray = cv2.cvtColor(self.original, cv2.COLOR_BGR2GRAY)grad_x = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=3)grad_y = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=3)magnitude = np.sqrt(grad_x**2 + grad_y**2)magnitude = np.uint8(np.clip(magnitude, 0, 255))self.filtered = cv2.cvtColor(magnitude, cv2.COLOR_GRAY2BGR)elif self.filter_type == FilterType.EMBOSS:kernel = np.array([[-2, -1, 0],[-1, 1, 1],[0, 1, 2]], dtype=np.float32)self.filtered = cv2.filter2D(self.original, -1, kernel)self.filtered = cv2.add(self.filtered, 128)elif self.filter_type == FilterType.MOTION_BLUR:size = self.kernel_sizekernel = np.zeros((size, size))kernel[int((size-1)/2), :] = np.ones(size)kernel = kernel / sizeself.filtered = cv2.filter2D(self.original, -1, kernel)self.display_result()def display_result(self):"""显示原图和处理后的图像"""# 创建对比显示h, w = self.original.shape[:2]combined = np.zeros((h, w*2 + 10, 3), dtype=np.uint8)combined[:, :w] = self.originalcombined[:, w+10:] = self.filtered# 添加文字说明cv2.putText(combined, "Original", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2)cv2.putText(combined, f"{self.filter_type.name}", (w+20, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2)# 添加参数信息info_text = f"Kernel Size: {self.kernel_size}"cv2.putText(combined, info_text, (10, h-10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1)cv2.imshow(self.window_name, combined)def save_result(self):"""保存处理后的图像"""filename = f"filtered_{self.filter_type.name.lower()}.jpg"cv2.imwrite(filename, self.filtered)print(f"已保存: {filename}")def run(self):"""运行应用主循环"""print("图像滤波器应用")print("-" * 40)print("操作说明：")print("1. 使用滑动条选择滤波器类型")print("2. 调整核大小参数")print("3. 按 's' 保存当前效果")print("4. 按 'ESC' 退出")print("-" * 40)self.apply_filter()while True:key = cv2.waitKey(1) & 0xFFif key == 27:  # ESCbreakelif key == ord('s'):self.save_result()cv2.destroyAllWindows()def create_test_image():"""创建一个测试图像"""img = np.zeros((400, 600, 3), dtype=np.uint8)# 添加噪声noise = np.random.randint(0, 50, (400, 600, 3))img = cv2.add(img, noise.astype(np.uint8))# 添加一些形状和文字cv2.rectangle(img, (50, 50), (250, 200), (0, 255, 0), -1)cv2.circle(img, (400, 150), 80, (255, 0, 0), -1)cv2.putText(img, 'OpenCV Filters', (150, 300), cv2.FONT_HERSHEY_SIMPLEX, 1.5, (255, 255, 255), 3)# 添加一些线条用于边缘检测测试for i in range(5):y = 350 + i * 10cv2.line(img, (50, y), (550, y), (200, 200, 200), 2)cv2.imwrite('test_image.jpg', img)return 'test_image.jpg'if __name__ == "__main__":# 如果没有指定图像，创建一个测试图像import sysif len(sys.argv) > 1:image_path = sys.argv[1]else:print("未指定图像文件，创建测试图像...")image_path = create_test_image()try:app = ImageFilterApp(image_path)app.run()except Exception as e:print(f"错误: {e}")

5.3 运行效果说明

运行这个程序后，你会看到：

双窗格显示：左侧是原图，右侧是滤波后的效果
实时调节：通过滑动条可以实时切换滤波器类型和调整参数
多种滤波器：
- 高斯模糊：平滑图像，去除噪声
- 中值滤波：去除椒盐噪声
- 双边滤波：保持边缘的平滑
- 锐化：增强图像细节
- Canny边缘检测：提取边缘
- Sobel边缘检测：计算梯度
- 浮雕效果：3D浮雕效果
- 运动模糊：模拟运动造成的模糊

六、深入理解：卷积核与图像滤波原理

6.1 什么是卷积？

卷积是图像处理的核心操作。它使用一个小矩阵（称为卷积核或滤波器）在图像上滑动，计算局部加权和。

import cv2
import numpy as np
import matplotlib.pyplot as pltdef visualize_convolution():"""可视化卷积操作过程"""# 创建一个简单的5x5图像img = np.array([[10, 20, 30, 40, 50],[60, 70, 80, 90, 100],[110, 120, 130, 140, 150],[160, 170, 180, 190, 200],[210, 220, 230, 240, 250]], dtype=np.float32)# 定义一个3x3的卷积核（边缘检测）kernel = np.array([[-1, -1, -1],[-1,  8, -1],[-1, -1, -1]], dtype=np.float32)print("原始图像：")print(img)print("\n卷积核：")print(kernel)# 手动计算卷积（为了演示原理）result = np.zeros((3, 3), dtype=np.float32)for i in range(3):for j in range(3):# 提取对应区域region = img[i:i+3, j:j+3]# 计算卷积（逐元素相乘后求和）conv_value = np.sum(region * kernel)result[i, j] = conv_valueprint(f"\n位置({i},{j})的计算过程：")print(f"区域:\n{region}")print(f"区域 * 核:\n{region * kernel}")print(f"求和结果: {conv_value}")print("\n卷积结果：")print(result)# 使用OpenCV进行卷积cv_result = cv2.filter2D(img, -1, kernel)print("\nOpenCV卷积结果：")print(cv_result)# 可视化fig, axes = plt.subplots(1, 3, figsize=(12, 4))axes[0].imshow(img, cmap='gray')axes[0].set_title('原始图像')axes[0].grid(True)axes[1].imshow(kernel, cmap='RdBu', vmin=-1, vmax=8)axes[1].set_title('卷积核')for i in range(3):for j in range(3):axes[1].text(j, i, f'{kernel[i,j]:.0f}', ha='center', va='center')axes[2].imshow(cv_result, cmap='gray')axes[2].set_title('卷积结果')axes[2].grid(True)plt.tight_layout()plt.show()# 运行演示
visualize_convolution()

6.2 常用卷积核详解

def demonstrate_kernels():"""演示不同卷积核的效果"""# 创建测试图像img = cv2.imread('test_image.jpg', 0)if img is None:img = np.random.randint(0, 255, (300, 300), dtype=np.uint8)cv2.rectangle(img, (50, 50), (250, 250), 255, -1)cv2.circle(img, (150, 150), 80, 0, -1)# 定义各种卷积核kernels = {'恒等': np.array([[0, 0, 0],[0, 1, 0],[0, 0, 0]], dtype=np.float32),'边缘检测1': np.array([[-1, -1, -1],[-1,  8, -1],[-1, -1, -1]], dtype=np.float32),'边缘检测2': np.array([[0,  1,  0],[1, -4,  1],[0,  1,  0]], dtype=np.float32),'锐化': np.array([[0, -1,  0],[-1,  5, -1],[0, -1,  0]], dtype=np.float32),'模糊': np.array([[1, 1, 1],[1, 1, 1],[1, 1, 1]], dtype=np.float32) / 9,'高斯模糊': np.array([[1, 2, 1],[2, 4, 2],[1, 2, 1]], dtype=np.float32) / 16,'浮雕': np.array([[-2, -1,  0],[-1,  1,  1],[0,  1,  2]], dtype=np.float32),'Sobel X': np.array([[-1,  0,  1],[-2,  0,  2],[-1,  0,  1]], dtype=np.float32),'Sobel Y': np.array([[-1, -2, -1],[0,  0,  0],[1,  2,  1]], dtype=np.float32),}# 应用卷积核并显示结果fig = plt.figure(figsize=(15, 10))for idx, (name, kernel) in enumerate(kernels.items(), 1):result = cv2.filter2D(img, -1, kernel)plt.subplot(3, 3, idx)plt.imshow(result, cmap='gray')plt.title(name)plt.axis('off')plt.tight_layout()plt.show()# 运行演示
demonstrate_kernels()

七、性能优化技巧

7.1 图像处理性能测试

import cv2
import numpy as np
import timedef performance_comparison():"""比较不同方法的性能"""# 创建一个大图像img = np.random.randint(0, 255, (1000, 1000, 3), dtype=np.uint8)# 测试不同大小的高斯模糊kernel_sizes = [3, 5, 7, 9, 11, 15, 21]times = []for ksize in kernel_sizes:start = time.time()for _ in range(10):cv2.GaussianBlur(img, (ksize, ksize), 0)elapsed = (time.time() - start) / 10times.append(elapsed)print(f"核大小 {ksize}x{ksize}: {elapsed*1000:.2f}ms")# 比较不同的模糊方法print("\n不同模糊方法比较（核大小=7）：")methods = {'GaussianBlur': lambda: cv2.GaussianBlur(img, (7, 7), 0),'medianBlur': lambda: cv2.medianBlur(img, 7),'bilateralFilter': lambda: cv2.bilateralFilter(img, 7, 50, 50),'blur': lambda: cv2.blur(img, (7, 7)),}for name, method in methods.items():start = time.time()for _ in range(10):method()elapsed = (time.time() - start) / 10print(f"{name}: {elapsed*1000:.2f}ms")# 运行性能测试
performance_comparison()

7.2 内存优化技巧

def memory_optimization_demo():"""演示内存优化技巧"""# 1. 使用合适的数据类型img_float64 = np.random.random((1000, 1000, 3))  # float64img_float32 = img_float64.astype(np.float32)     # float32img_uint8 = (img_float64 * 255).astype(np.uint8) # uint8print("内存使用对比：")print(f"float64: {img_float64.nbytes / 1024 / 1024:.2f} MB")print(f"float32: {img_float32.nbytes / 1024 / 1024:.2f} MB")print(f"uint8:   {img_uint8.nbytes / 1024 / 1024:.2f} MB")# 2. 原地操作img = np.random.randint(0, 255, (500, 500, 3), dtype=np.uint8)# 不推荐：创建新数组start = time.time()result1 = img + 50time1 = time.time() - start# 推荐：原地操作img_copy = img.copy()start = time.time()cv2.add(img_copy, 50, img_copy)  # 原地操作time2 = time.time() - startprint(f"\n操作时间对比：")print(f"创建新数组: {time1*1000:.3f}ms")print(f"原地操作:   {time2*1000:.3f}ms")# 3. ROI（感兴趣区域）处理large_img = np.random.randint(0, 255, (2000, 2000, 3), dtype=np.uint8)# 只处理部分区域roi = large_img[500:1000, 500:1000]processed_roi = cv2.GaussianBlur(roi, (21, 21), 0)large_img[500:1000, 500:1000] = processed_roiprint("\n只处理ROI可以显著提升性能")# 运行内存优化演示
memory_optimization_demo()

八、常见问题与解决方案

8.1 常见错误及解决

def common_errors_and_solutions():"""演示常见错误及其解决方案"""print("OpenCV常见错误及解决方案")print("=" * 50)# 错误1：图像路径错误print("\n1. 图像读取失败")img = cv2.imread('non_existent.jpg')if img is None:print("   错误：图像文件不存在或路径错误")print("   解决：检查文件路径，使用绝对路径或检查工作目录")# 错误2：数据类型错误print("\n2. 数据类型不匹配")try:img1 = np.random.random((100, 100, 3))  # float64img2 = np.random.randint(0, 255, (100, 100, 3), dtype=np.uint8)# 这会导致错误或意外结果result = cv2.add(img1, img2)except Exception as e:print(f"   错误：{e}")print("   解决：确保图像数据类型一致，使用astype()转换")# 错误3：通道数不匹配print("\n3. 通道数不匹配")gray = np.random.randint(0, 255, (100, 100), dtype=np.uint8)color = np.random.randint(0, 255, (100, 100, 3), dtype=np.uint8)try:# 不能直接相加result = gray + colorexcept:print("   错误：灰度图和彩色图通道数不同")print("   解决：转换为相同通道数")gray_3ch = cv2.cvtColor(gray, cv2.COLOR_GRAY2BGR)result = cv2.add(gray_3ch, color)  # 现在可以了# 错误4：坐标越界print("\n4. 访问越界")img = np.zeros((100, 100, 3), dtype=np.uint8)try:pixel = img[100, 100]  # 越界！except IndexError:print("   错误：坐标越界（索引从0开始）")print("   解决：使用shape属性检查图像尺寸")print(f"   图像尺寸: {img.shape}")print(f"   有效范围: x[0, {img.shape[1]-1}], y[0, {img.shape[0]-1}]")# 错误5：窗口未正确释放print("\n5. 窗口管理")print("   提示：始终在程序结束前调用cv2.destroyAllWindows()")print("   提示：使用cv2.waitKey()控制显示时间")# 运行常见错误演示
common_errors_and_solutions()

8.2 调试技巧

def debugging_tips():"""OpenCV调试技巧"""img = cv2.imread('test_image.jpg')if img is None:img = np.random.randint(0, 255, (300, 400, 3), dtype=np.uint8)print("OpenCV调试技巧")print("=" * 50)# 1. 检查图像属性print("\n1. 检查图像基本信息：")print(f"   形状: {img.shape}")print(f"   数据类型: {img.dtype}")print(f"   最小值: {img.min()}")print(f"   最大值: {img.max()}")print(f"   平均值: {img.mean():.2f}")# 2. 可视化中间结果print("\n2. 保存中间结果用于调试：")gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)cv2.imwrite('debug_gray.jpg', gray)print("   已保存debug_gray.jpg")# 3. 使用断言检查print("\n3. 使用断言验证假设：")assert img.dtype == np.uint8, "图像必须是uint8类型"assert len(img.shape) == 3, "图像必须是3通道"assert img.shape[2] == 3, "图像必须是3通道"print("   所有断言通过")# 4. 打印关键点信息print("\n4. 在关键步骤打印信息：")for i, operation in enumerate(['读取', '预处理', '主处理', '后处理']):print(f"   步骤{i+1}: {operation} - 完成")# 这里可以打印每步的图像统计信息# 运行调试技巧演示
debugging_tips()