第1章 计算机视觉基础¶

import cv2
import numpy as np

# 加载预训练的人脸检测模型
face_cascade = cv2.CascadeClassifier(
    cv2.data.haarcascades + 'haarcascade_frontalface_default.xml'
)

# 读取图像
image = cv2.imread('face.jpg')
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

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

# 绘制检测结果
for (x, y, w, h) in faces:
    cv2.rectangle(image, (x, y), (x+w, y+h), (0, 255, 0), 2)

cv2.imshow('Face Detection', image)
cv2.waitKey(0)
cv2.destroyAllWindows()

import torch
import torch.nn as nn
from torchvision import models, transforms
from PIL import Image

# 加载预训练的ResNet模型
model = models.resnet50(weights=models.ResNet50_Weights.DEFAULT)
model.fc = nn.Linear(model.fc.in_features, 2)  # 二分类：COVID/正常

# 图像预处理
transform = 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('xray.jpg')
input_tensor = transform(image).unsqueeze(0)  # unsqueeze增加一个维度
output = model(input_tensor)
prediction = torch.argmax(output, dim=1).item()  # 将单元素张量转为Python数值

print(f"诊断结果: {'COVID-19' if prediction == 1 else '正常'}")

import cv2
import numpy as np

def detect_defects(image):
    """检测PCB板缺陷"""
    # 转换为灰度图
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

    # 二值化
    _, binary = cv2.threshold(gray, 128, 255, cv2.THRESH_BINARY)

    # 形态学操作
    kernel = np.ones((3, 3), np.uint8)
    opening = cv2.morphologyEx(binary, cv2.MORPH_OPEN, kernel)

    # 边缘检测
    edges = cv2.Canny(opening, 50, 150)

    # 查找轮廓
    contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

    defects = []
    for contour in contours:
        area = cv2.contourArea(contour)
        if area > 100:  # 阈值过滤
            x, y, w, h = cv2.boundingRect(contour)
            defects.append((x, y, w, h))

    return defects

# 使用
image = cv2.imread('pcb.jpg')
defects = detect_defects(image)
print(f"检测到 {len(defects)} 个缺陷")

import numpy as np

# 图像表示
image = np.random.randint(0, 256, (100, 100, 3), dtype=np.uint8)

# 矩阵乘法（卷积的基础）
A = np.array([[1, 2], [3, 4]])  # np.array创建NumPy数组
B = np.array([[5, 6], [7, 8]])
C = np.dot(A, B)  # 或 A @ B

# 特征值和特征向量（PCA的基础）
eigenvalues, eigenvectors = np.linalg.eig(A)  # np.linalg线性代数运算

import numpy as np
from scipy.stats import norm

# 高斯分布（噪声模型）
mu, sigma = 0, 1
x = np.linspace(-3, 3, 100)
pdf = norm.pdf(x, mu, sigma)

# 添加高斯噪声
image = np.random.randint(0, 256, (100, 100), dtype=np.uint8)
noise = np.random.normal(0, 25, image.shape).astype(np.uint8)
noisy_image = cv2.add(image, noise)

import sympy as sp

# 符号计算
x = sp.symbols('x')
f = x**2 + 2*x + 1
df_dx = sp.diff(f, x)  # 求导
print(df_dx)  # 2*x + 2

# 数值梯度
def numerical_gradient(f, x, h=1e-5):
    return (f(x + h) - f(x - h)) / (2 * h)

def gradient_descent(f, df, x0, learning_rate=0.01, max_iter=1000):
    """梯度下降算法"""
    x = x0
    for i in range(max_iter):
        gradient = df(x)
        x = x - learning_rate * gradient
    return x

# 示例：最小化 f(x) = x^2
f = lambda x: x**2  # lambda匿名函数
df = lambda x: 2*x
x_opt = gradient_descent(f, df, x0=10)
print(f"最优解: {x_opt}")  # 接近0

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

# 方法1：使用OpenCV
def opencv_example():
    # 读取图像
    image = cv2.imread('example.jpg')

    # 检查是否成功
    if image is None:
        print("无法读取图像")
        return

    # 显示图像信息
    print(f"图像尺寸: {image.shape}")
    print(f"数据类型: {image.dtype}")

    # 显示图像
    cv2.imshow('Image', image)
    cv2.waitKey(0)
    cv2.destroyAllWindows()

# 方法2：使用Matplotlib
def matplotlib_example():
    # 读取图像（OpenCV读取是BGR，需要转换为RGB）
    image = cv2.imread('example.jpg')
    image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

    # 显示图像
    plt.figure(figsize=(10, 8))
    plt.imshow(image_rgb)
    plt.axis('off')
    plt.title('First CV Image')
    plt.show()

# 运行
if __name__ == '__main__':
    opencv_example()
    matplotlib_example()

import cv2
import numpy as np
import matplotlib.pyplot as plt
from pathlib import Path

class ImageAnalyzer:
    """图像分析工具类"""

    def __init__(self, image_path):
        self.image_path = image_path
        self.image = None
        self.gray_image = None
        self.load_image()

    def load_image(self):
        """加载图像"""
        self.image = cv2.imread(self.image_path)
        if self.image is None:
            raise ValueError(f"无法加载图像: {self.image_path}")
        self.gray_image = cv2.cvtColor(self.image, cv2.COLOR_BGR2GRAY)

    def get_basic_info(self):
        """获取基本信息"""
        height, width, channels = self.image.shape
        total_pixels = height * width

        info = {
            '文件路径': self.image_path,
            '图像尺寸': f"{width}x{height}",
            '通道数': channels,
            '总像素数': total_pixels,
            '数据类型': str(self.image.dtype),
            '文件大小': f"{Path(self.image_path).stat().st_size / 1024:.2f} KB"
        }
        return info

    def get_color_distribution(self):
        """获取颜色分布"""
        colors = ['B', 'G', 'R']
        distributions = {}

        for i, color in enumerate(colors):  # enumerate同时获取索引和元素
            hist = cv2.calcHist([self.image], [i], None, [256], [0, 256])
            distributions[color] = hist.flatten()

        return distributions

    def get_statistics(self):
        """获取统计信息"""
        stats = {
            '亮度均值': np.mean(self.gray_image),
            '亮度标准差': np.std(self.gray_image),
            '亮度最小值': np.min(self.gray_image),
            '亮度最大值': np.max(self.gray_image),
            '亮度中位数': np.median(self.gray_image)
        }
        return stats

    def visualize_info(self):
        """可视化信息"""
        fig, axes = plt.subplots(2, 2, figsize=(15, 12))

        # 原始图像
        image_rgb = cv2.cvtColor(self.image, cv2.COLOR_BGR2RGB)
        axes[0, 0].imshow(image_rgb)
        axes[0, 0].set_title('原始图像')
        axes[0, 0].axis('off')

        # 灰度图像
        axes[0, 1].imshow(self.gray_image, cmap='gray')
        axes[0, 1].set_title('灰度图像')
        axes[0, 1].axis('off')

        # 颜色直方图
        colors = ['b', 'g', 'r']
        for i, color in enumerate(colors):
            hist = cv2.calcHist([self.image], [i], None, [256], [0, 256])
            axes[1, 0].plot(hist, color=color, label=f'{color.upper()}通道')
        axes[1, 0].set_title('颜色直方图')
        axes[1, 0].set_xlabel('像素值')
        axes[1, 0].set_ylabel('像素数量')
        axes[1, 0].legend()

        # 灰度直方图
        axes[1, 1].hist(self.gray_image.ravel(), bins=256, color='gray')
        axes[1, 1].set_title('灰度直方图')
        axes[1, 1].set_xlabel('像素值')
        axes[1, 1].set_ylabel('像素数量')

        plt.tight_layout()
        plt.savefig('image_analysis.png', dpi=300, bbox_inches='tight')
        plt.show()

    def generate_report(self):
        """生成分析报告"""
        print("=" * 50)
        print("图像分析报告")
        print("=" * 50)

        # 基本信息
        print("\n【基本信息】")
        basic_info = self.get_basic_info()
        for key, value in basic_info.items():
            print(f"{key}: {value}")

        # 统计信息
        print("\n【统计信息】")
        stats = self.get_statistics()
        for key, value in stats.items():
            print(f"{key}: {value:.2f}")

        print("\n【可视化】")
        print("已生成图像分析可视化: image_analysis.png")

        print("\n" + "=" * 50)

# 使用示例
if __name__ == '__main__':
    # 创建测试图像
    test_image = np.random.randint(0, 256, (480, 640, 3), dtype=np.uint8)
    cv2.imwrite('test_image.jpg', test_image)

    # 分析图像
    analyzer = ImageAnalyzer('test_image.jpg')
    analyzer.generate_report()
    analyzer.visualize_info()