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

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

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（方向梯度直方图）通过统计局部区域的梯度方向分布来描述物体形状，常用于行人检测。

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 则是对 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 深度学习模型

现代 CV 主要依赖卷积神经网络（CNN）：

• LeNet：早期经典结构。
• AlexNet：引入 ReLU 激活函数，推动深度学习爆发。
• VGG：使用小卷积核堆叠深度网络。
• ResNet：残差连接解决了深层网络的梯度消失问题。
• YOLO：单阶段目标检测算法，速度快。

4.3 模型训练实战（PyTorch）

以下代码展示了如何使用 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 需求与架构

构建一个桌面应用，支持图像上传、分类、检测及结果可视化。系统采用分层设计：UI 层、逻辑层、处理层和数据存储层。

5.2 环境搭建

需安装 Python 及相关库：

pip install opencv-python pillow torch torchvision tensorflow

5.3 核心功能实现

图像输入与 UI

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

图像分类

利用预训练模型进行推理。

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

六、总结

本章系统梳理了计算机视觉的核心知识体系。从基础的图像预处理到高级的特征提取，再到经典的深度学习模型架构，最后通过一个完整的桌面应用案例，将理论转化为实践。掌握这些技能后，开发者能够独立构建具备图像理解能力的智能系统，应对实际业务中的视觉任务挑战。