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

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

边缘检测也是滤波的重要应用，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

三、特征提取方法

在深度学习普及之前，传统特征提取方法依然具有实用价值。HOG、SIFT 和 ORB 是三种经典的描述子。

3.1 HOG 特征

HOG（方向梯度直方图）通过计算局部区域的梯度方向分布来表征形状，常用于行人检测。

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 与 ORB 特征

SIFT（尺度不变特征变换）对尺度和旋转具有不变性，但计算量较大。ORB 则是 SIFT 的快速替代方案，结合了 FAST 关键点检测和 BRIEF 描述符。

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

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：早期卷积网络鼻祖。
• AlexNet：引入 ReLU 激活函数，推动 CNN 爆发。
• 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 开发环境

确保安装必要的依赖库：

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

5.3 核心功能实现

图像输入模块

使用 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)

图像分类功能

基于预训练的 ResNet 模型进行推理：

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]]

目标检测功能

利用 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

主程序入口

整合上述模块，形成完整应用：

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()

六、总结

本文梳理了计算机视觉的技术脉络，从基础的图像预处理到复杂的深度学习模型训练，再到实际应用的封装。掌握这些技能后，你不仅能理解机器如何'看'世界，还能亲手构建出具备视觉能力的软件系统。建议在实际项目中多尝试不同的模型架构，并根据具体场景优化参数，这样才能真正发挥技术的价值。