计算机视觉基础理论与实战应用指南

2.1.2 基础操作

包括调整尺寸、亮度对比度平衡、色彩校正以及裁剪旋转等。下面我们通过 OpenCV 看看具体怎么操作。

import cv2
import numpy as np

def read_image(image_path):
    image = cv2.imread(image_path)
    return image

def save_image(image, output_path):
    cv2.imwrite(output_path, image)

def resize_image(image, width, height):
    resized_image = cv2.resize(image, (width, height))
    return resized_image

def adjust_brightness_contrast(image, alpha=1.0, beta=0.0):
    adjusted_image = cv2.convertScaleAbs(image, alpha=alpha, beta=beta)
    return adjusted_image

def crop_image(image, x, y, width, height):
    cropped_image = image[y:y+height, x:x+width]
    return cropped_image

def rotate_image(image, angle):
    (h, w) = image.shape[:2]
    center = (w // 2, h // 2)
    M = cv2.getRotationMatrix2D(center, angle, 1.0)
    rotated_image = cv2.warpAffine(image, M, (w, h))
    return rotated_image

2.2 图像增强

增强旨在提升图像质量，便于后续处理。

2.2.1 直方图均衡化

通过调整直方图分布来增强对比度，使细节更清晰。

2.2.2 图像平滑

用于去除噪声，常见方法包括均值滤波、高斯滤波和中值滤波。

import cv2
import numpy as np

def histogram_equalization(image):
    gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    equalized_image = cv2.equalizeHist(gray_image)
    return equalized_image

def mean_filter(image, kernel_size=3):
    blurred_image = cv2.blur(image, (kernel_size, kernel_size))
    return blurred_image

def gaussian_filter(image, kernel_size=3, sigma=0):
    blurred_image = cv2.GaussianBlur(image, (kernel_size, kernel_size), sigma)
    return blurred_image

def median_filter(image, kernel_size=3):
    blurred_image = cv2.medianBlur(image, kernel_size)
    return blurred_image

2.3 图像滤波

滤波常用于边缘检测等任务。

2.3.1 边缘检测

利用 Sobel 算子或 Canny 算法提取图像轮廓。

import cv2
import numpy as np

def sobel_edge_detection(image):
    gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    sobel_x = cv2.Sobel(gray_image, cv2.CV_64F, 1, 0, ksize=3)
    sobel_y = cv2.Sobel(gray_image, cv2.CV_64F, 0, 1, ksize=3)
    sobel_combined = np.sqrt(sobel_x**2 + sobel_y**2)
    sobel_combined = np.uint8(sobel_combined / np.max(sobel_combined) * 255)
    return sobel_combined

def canny_edge_detection(image, threshold1=100, threshold2=200):
    gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    edges = cv2.Canny(gray_image, threshold1, threshold2)
    return edges

三、特征提取方法

3.1 HOG 特征

HOG（Histogram of Oriented Gradients）通过计算梯度方向直方图来描述局部形状，常用于行人检测。

import cv2
import numpy as np

def extract_hog_features(image):
    hog = cv2.HOGDescriptor()
    gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    features = hog.compute(gray_image)
    return features

3.2 SIFT 特征

SIFT（Scale-Invariant Feature Transform）具有尺度和旋转不变性，能检测关键点并计算描述符。

import cv2
import numpy as np

def extract_sift_features(image):
    sift = cv2.SIFT_create()
    gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    keypoints, descriptors = sift.detectAndCompute(gray_image, None)
    return keypoints, descriptors

3.3 ORB 特征

ORB（Oriented FAST and Rotated BRIEF）结合了 FAST 角点检测和 BRIEF 描述符，速度快且免费开源。

import cv2
import numpy as np

def extract_orb_features(image):
    orb = cv2.ORB_create()
    gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    keypoints, descriptors = orb.detectAndCompute(gray_image, None)
    return keypoints, descriptors

四、常用模型与架构

4.1 传统机器学习模型

• 支持向量机（SVM）：寻找最优超平面分离样本
• 决策树：通过树结构进行分类判断
• 随机森林：集成多个决策树提升性能

4.2 深度学习模型

• LeNet：早期卷积网络，奠定 CNN 基础
• AlexNet：引入 ReLU 激活函数，推动深度网络发展
• VGG：使用小卷积核堆叠加深网络
• ResNet：残差连接解决梯度消失，支持极深网络
• YOLO：单阶段目标检测，兼顾速度与精度

4.3 模型训练实战

这里以 PyTorch 为例，展示如何使用 ResNet 进行迁移学习训练。

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
from torchvision import datasets, transforms, models

def train_resnet_model(data_dir, num_classes=2, batch_size=32, num_epochs=10, lr=0.001):
    # 数据预处理
    data_transforms = {
        'train': transforms.Compose([
            transforms.RandomResizedCrop(224),
            transforms.RandomHorizontalFlip(),
            transforms.ToTensor(),
            transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
        ]),
        'val': transforms.Compose([
            transforms.Resize(256),
            transforms.CenterCrop(224),
            transforms.ToTensor(),
            transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
        ])
    }
    
    # 加载数据
    image_datasets = {x: datasets.ImageFolder(f'{data_dir}/{x}', data_transforms[x]) for x in ['train', 'val']}
    dataloaders = {x: DataLoader(image_datasets[x], batch_size=batch_size, shuffle=True, num_workers=4) for x in ['train', 'val']}
    dataset_sizes = {x: len(image_datasets[x]) for x in ['train', 'val']}
    class_names = image_datasets['train'].classes
    
    # 加载模型
    model = models.resnet18(pretrained=True)
    num_ftrs = model.fc.in_features
    model.fc = nn.Linear(num_ftrs, num_classes)
    
    # 定义损失函数和优化器
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.SGD(model.parameters(), lr=lr, momentum=0.9)
    scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=7, gamma=0.1)
    
    # 训练模型
    for epoch in range(num_epochs):
        print(f'Epoch {epoch}/{num_epochs - 1}')
        print('-' * 10)
        for phase in ['train', 'val']:
            if phase == 'train':
                model.train()
            else:
                model.eval()
            running_loss = 0.0
            running_corrects = 0
            for inputs, labels in dataloaders[phase]:
                optimizer.zero_grad()
                with torch.set_grad_enabled(phase == 'train'):
                    outputs = model(inputs)
                    _, preds = torch.max(outputs, 1)
                    loss = criterion(outputs, labels)
                    if phase == 'train':
                        loss.backward()
                        optimizer.step()
                running_loss += loss.item() * inputs.size(0)
                running_corrects += torch.sum(preds == labels.data)
            if phase == 'train':
                scheduler.step()
            epoch_loss = running_loss / dataset_sizes[phase]
            epoch_acc = running_corrects.double() / dataset_sizes[phase]
            print(f'{phase} Loss: {epoch_loss:.4f} Acc: {epoch_acc:.4f}')
    print('Training complete')
    return model

五、实战项目：计算机视觉应用开发

5.1 需求分析

我们需要构建一个桌面应用，支持图像输入、分类、检测及结果可视化。

• 用户目标：简单上传图像，选择功能，查看结果
• 功能范围：图像预处理、分类、检测、界面交互

5.2 系统架构

采用分层设计：

1. 用户界面层：Tkinter 实现交互
2. 应用逻辑层：控制流程
3. 图像处理层：OpenCV、PyTorch 核心算法
4. 数据存储层：本地文件存储

5.3 系统实现

5.3.1 环境搭建

确保安装必要的库：

pip install opencv-python
pip install pillow
pip install torch torchvision
pip install tensorflow

5.3.2 图像输入模块

使用 Tkinter 创建文件选择对话框，并显示预览图。

import tkinter as tk
from tkinter import filedialog
from PIL import Image, ImageTk

class ImageInputFrame(tk.Frame):
    def __init__(self, parent, on_image_selected):
        tk.Frame.__init__(self, parent)
        self.parent = parent
        self.on_image_selected = on_image_selected
        self.create_widgets()

    def create_widgets(self):
        self.image_label = tk.Label(self)
        self.image_label.pack(pady=10, padx=10, fill="both", expand=True)
        tk.Button(self, text="选择图像", command=self.select_image).pack(pady=10, padx=10)

    def select_image(self):
        file_path = filedialog.askopenfilename(filetypes=[("Image Files", "*.png *.jpg *.jpeg *.bmp")])
        if file_path:
            image = Image.open(file_path)
            image = image.resize((400, 300), Image.ANTIALIAS)
            photo = ImageTk.PhotoImage(image)
            self.image_label.configure(image=photo)
            self.image_label.image = photo
            self.on_image_selected(file_path)

5.3.3 图像分类功能

加载预训练模型，对上传图像进行推理。

import torch
from torchvision import transforms, models
from PIL import Image

def classify_image(image_path, model_path, class_names):
    data_transforms = transforms.Compose([
        transforms.Resize(256),
        transforms.CenterCrop(224),
        transforms.ToTensor(),
        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
    ])
    
    image = Image.open(image_path)
    image = data_transforms(image)
    image = image.unsqueeze(0)
    
    model = models.resnet18()
    num_ftrs = model.fc.in_features
    model.fc = torch.nn.Linear(num_ftrs, len(class_names))
    model.load_state_dict(torch.load(model_path))
    model.eval()
    
    with torch.no_grad():
        outputs = model(image)
        _, preds = torch.max(outputs, 1)
    return class_names[preds[0]]

5.3.4 目标检测功能

使用 Faster R-CNN 模型检测图像中的物体并绘制边界框。

import cv2
import numpy as np
import torch
from torchvision import transforms, models
from PIL import Image

def detect_objects(image_path, model_path, class_names):
    image = cv2.imread(image_path)
    image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
    image_pil = Image.fromarray(image_rgb)
    
    data_transforms = transforms.Compose([
        transforms.Resize((416, 416)),
        transforms.ToTensor(),
        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
    ])
    
    image_tensor = data_transforms(image_pil)
    image_tensor = image_tensor.unsqueeze(0)
    
    model = models.detection.fasterrcnn_resnet50_fpn(pretrained=False)
    in_features = model.roi_heads.box_predictor.cls_score.in_features
    model.roi_heads.box_predictor = models.detection.faster_rcnn.FastRCNNPredictor(in_features, len(class_names))
    model.load_state_dict(torch.load(model_path))
    model.eval()
    
    with torch.no_grad():
        outputs = model(image_tensor)
    
    boxes = outputs[0]['boxes'].cpu().numpy()
    scores = outputs[0]['scores'].cpu().numpy()
    labels = outputs[0]['labels'].cpu().numpy()
    
    for i in range(len(boxes)):
        if scores[i] > 0.5:
            box = boxes[i].astype(int)
            label = class_names[labels[i]]
            score = scores[i]
            cv2.rectangle(image, (box[0], box[1]), (box[2], box[3]), (0, 255, 0), 2)
            cv2.putText(image, f"{label}: {score:.2f}", (box[0], box[1]-10), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2)
    return image

5.3.5 结果可视化与主程序

整合各模块，构建完整的 GUI 应用入口。

import tkinter as tk
from tkinter import ttk, messagebox, filedialog
from PIL import Image, ImageTk
from image_input_frame import ImageInputFrame
from result_frame import ResultFrame
from cv_functions import classify_image, detect_objects

class CVApp:
    def __init__(self, root):
        self.root = root
        self.root.title("计算机视觉应用")
        self.class_names = ['猫', '狗']
        self.model_path = 'model.pth'
        self.create_widgets()

    def create_widgets(self):
        self.image_input_frame = ImageInputFrame(self.root, self.process_image)
        self.image_input_frame.pack(pady=10, padx=10, fill="both", expand=True)
        
        function_frame = tk.LabelFrame(self.root, text="功能选择")
        function_frame.pack(pady=10, padx=10, fill="x")
        self.function_var = tk.StringVar()
        self.function_var.set("图像分类")
        tk.Radiobutton(function_frame, text="图像分类", variable=self.function_var, value="图像分类").grid(row=0, column=0, padx=5, pady=5)
        tk.Radiobutton(function_frame, text="目标检测", variable=self.function_var, value="目标检测").grid(row=0, column=1, padx=5, pady=5)
        
        self.result_frame = ResultFrame(self.root)
        self.result_frame.pack(pady=10, padx=10, fill="both", expand=True)
        
        self.output_image_label = tk.Label(self.root)
        self.output_image_label.pack(pady=10, padx=10, fill="both", expand=True)

    def process_image(self, image_path):
        function = self.function_var.get()
        try:
            if function == "图像分类":
                result = classify_image(image_path, self.model_path, self.class_names)
                self.result_frame.display_result(result)
            elif function == "目标检测":
                result_image = detect_objects(image_path, self.model_path, self.class_names)
                result_image = cv2.cvtColor(result_image, cv2.COLOR_BGR2RGB)
                result_image_pil = Image.fromarray(result_image)
                result_image_pil = result_image_pil.resize((400, 300), Image.ANTIALIAS)
                photo = ImageTk.PhotoImage(result_image_pil)
                self.output_image_label.configure(image=photo)
                self.output_image_label.image = photo
            else:
                raise ValueError("未知功能")
        except Exception as e:
            messagebox.showerror("错误", f"处理失败：{str(e)}")

if __name__ == "__main__":
    root = tk.Tk()
    app = CVApp(root)
    root.mainloop()

5.4 运行与测试

1. 安装依赖库
2. 运行 cv_app.py
3. 选择测试图像（如包含猫狗的图片）
4. 切换功能并查看结果

六、总结

本章系统梳理了计算机视觉的核心知识体系。从基础概念出发，深入讲解了图像预处理、增强、滤波等关键技术，并详细剖析了 HOG、SIFT、ORB 等经典特征提取方法。同时，对比了 LeNet、ResNet、YOLO 等主流深度学习模型架构的特点与适用场景。

最后，通过一个完整的桌面应用开发案例，演示了如何整合 OpenCV 与 PyTorch，实现图像分类与目标检测功能。这不仅验证了理论知识的实用性，也为开发者提供了可复用的工程参考。掌握这些技能后，你将具备独立开发计算机视觉应用的能力，能够应对更多实际业务场景的挑战。