数字图像处理（四：图像如果当作矩阵，那加减乘除处理了矩阵，那图像咋变）：从LED冬奥会、奥运会及春晚等等大屏，到手机小屏，快来挖一挖里面都有什么

发布于：2025-07-21 ⋅ 阅读:(10) ⋅ 点赞:(0)

数字图像处理（四）

三、（准备工作：玩具咋玩）图像以矩阵形式存储，那矩阵一变、图像立刻跟着变？

你好！ 从LED冬奥会、奥运会及春晚等等大屏，到手机小屏，快来挖一挖里面都有什么。

废话不多说，上图，上代码，再上新图

原图

在这里插入图片描述

# %% [markdown]
# # 系统性图像矩阵处理实验
# **参考教材**：冈萨雷斯《数字图像处理》、现代颜色技术原理、图像画质算法
# 
# 实验顺序：
# 1. 图像加载与矩阵表示
# 2. 颜色通道分离与重组
# 3. 图像二值化（阈值处理）
# 4. 亮度调整（矩阵标量乘法）
# 5. 对比度调整（矩阵线性变换）
# 6. 图像翻转（矩阵索引操作）
# 7. 图像旋转（矩阵转置与重排）
# 8. 图像缩放（矩阵重采样）
# 9. 卷积滤波（矩阵卷积运算）
# 10. 边缘检测（梯度矩阵计算）

# %% [code]
# 安装必要库
!pip install opencv-python matplotlib numpy scikit-image

# %% [code]
import cv2
import numpy as np
import matplotlib.pyplot as plt
from google.colab import files
from skimage import transform

# 上传图像到Colab
uploaded = files.upload()
image_path = list(uploaded.keys())[0]

# %% [markdown]
# ## 实验1：图像加载与矩阵表示
# **核心原理**：图像本质是三维矩阵 [高度, 宽度, 通道]
# - 彩色图像：3通道 (B, G, R)
# - 灰度图像：单通道

# %% [code]
# 实验1：图像加载与矩阵表示
def experiment1(img_path):
    # 读取图像为NumPy矩阵
    img = cv2.imread(img_path)
    print("✅ 图像已加载为三维矩阵")
    print(f"矩阵形状: {img.shape} (高度, 宽度, 通道)")
    print(f"矩阵数据类型: {img.dtype}")
    print(f"像素值范围: {img.min()} ~ {img.max()}")
    
    # 显示原始图像
    plt.figure(figsize=(12, 6))
    
    # 彩色图像显示
    plt.subplot(121)
    plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
    plt.title('原始彩色图像')
    plt.axis('off')
    
    # 转换为灰度图像
    gray_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    print(f"\n灰度矩阵形状: {gray_img.shape} (高度, 宽度)")
    
    # 灰度图像显示
    plt.subplot(122)
    plt.imshow(gray_img, cmap='gray')
    plt.title('灰度图像矩阵')
    plt.axis('off')
    
    plt.tight_layout()
    plt.show()
    
    # 显示矩阵切片（左上角10x10区域）
    print("\n🔍 彩色图像左上角10x10x3矩阵切片:")
    print(img[:10, :10])
    
    print("\n🔍 灰度图像左上角10x10矩阵切片:")
    print(gray_img[:10, :10])
    
    return img, gray_img

# 执行实验1
original_img, gray_img = experiment1(image_path)

# %% [markdown]
# ## 实验2：颜色通道分离与重组
# **核心原理**：彩色图像由BGR三个通道矩阵组成
# - 分离通道：提取单通道矩阵
# - 重组通道：改变通道组合顺序

# %% [code]
# 实验2：颜色通道分离与重组
def experiment2(img):
    # 分离BGR三个通道
    b, g, r = cv2.split(img)
    
    # 创建纯色通道矩阵
    zero_channel = np.zeros_like(b)
    
    # 重组不同通道组合
    red_only = cv2.merge([zero_channel, zero_channel, r])
    green_only = cv2.merge([zero_channel, g, zero_channel])
    blue_only = cv2.merge([b, zero_channel, zero_channel])
    swapped_channels = cv2.merge([r, g, b])  # RGB顺序
    
    # 可视化
    plt.figure(figsize=(15, 10))
    
    # 原始图像
    plt.subplot(231)
    plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
    plt.title('原始图像')
    plt.axis('off')
    
    # 红色通道
    plt.subplot(232)
    plt.imshow(cv2.cvtColor(red_only, cv2.COLOR_BGR2RGB))
    plt.title('仅红色通道')
    plt.axis('off')
    
    # 绿色通道
    plt.subplot(233)
    plt.imshow(cv2.cvtColor(green_only, cv2.COLOR_BGR2RGB))
    plt.title('仅绿色通道')
    plt.axis('off')
    
    # 蓝色通道
    plt.subplot(234)
    plt.imshow(cv2.cvtColor(blue_only, cv2.COLOR_BGR2RGB))
    plt.title('仅蓝色通道')
    plt.axis('off')
    
    # 通道交换 (BGR → RGB)
    plt.subplot(235)
    plt.imshow(cv2.cvtColor(swapped_channels, cv2.COLOR_BGR2RGB))
    plt.title('通道交换 (BGR→RGB)')
    plt.axis('off')
    
    # 创建特殊通道组合
    custom_channels = cv2.merge([b, r, g])  # 蓝+红+绿
    plt.subplot(236)
    plt.imshow(cv2.cvtColor(custom_channels, cv2.COLOR_BGR2RGB))
    plt.title('自定义通道组合 (B+R+G)')
    plt.axis('off')
    
    plt.tight_layout()
    plt.show()
    
    # 矩阵变化说明
    print("\n🎨 通道分离与重组矩阵操作说明:")
    print("1. 分离通道: b, g, r = cv2.split(img)")
    print("2. 创建零矩阵: zero_channel = np.zeros_like(b)")
    print("3. 重组通道: cv2.merge([ch1, ch2, ch3])")
    print("4. 通道交换改变了颜色信息的排列顺序")

# 执行实验2
experiment2(original_img)

# %% [markdown]
# ## 实验3：图像二值化（阈值处理）
# **核心原理**：通过阈值将灰度矩阵转换为二值矩阵
# - 矩阵元素值：0(黑) 或 255(白)
# - 公式：dst(x,y) = { 255 if src(x,y) > thresh else 0 }

# %% [code]
# 实验3：图像二值化
def experiment3(gray_img):
    # 设置不同阈值
    thresholds = [50, 100, 150]
    
    plt.figure(figsize=(15, 8))
    
    # 原始灰度图像
    plt.subplot(141)
    plt.imshow(gray_img, cmap='gray')
    plt.title('原始灰度图像')
    plt.axis('off')
    
    # 不同阈值二值化
    for i, thresh in enumerate(thresholds):
        # 二值化矩阵操作
        _, binary_img = cv2.threshold(gray_img, thresh, 255, cv2.THRESH_BINARY)
        
        plt.subplot(1, 4, i+2)
        plt.imshow(binary_img, cmap='gray')
        plt.title(f'阈值={thresh}')
        plt.axis('off')
        
        # 打印矩阵变化信息
        print(f"\n🔲 阈值={thresh}时矩阵变化:")
        print(f"像素值>={thresh}的像素比例: {np.mean(binary_img == 255)*100:.1f}%")
    
    plt.tight_layout()
    plt.show()
    
    # 矩阵操作说明
    print("\n⚙️ 二值化矩阵操作:")
    print("_, binary = cv2.threshold(gray_img, threshold_value, 255, cv2.THRESH_BINARY)")
    print("本质是: binary_matrix = np.where(gray_matrix >= threshold, 255, 0)")

# 执行实验3
experiment3(gray_img)

# %% [markdown]
# ## 实验4：亮度调整（矩阵标量乘法）
# **核心原理**：通过标量乘法调整整个矩阵值
# - 公式：dst = src * alpha + beta
# - alpha: 增益（控制对比度）
# - beta: 偏置（控制亮度）

# %% [code]
# 实验4：亮度调整
def experiment4(img):
    # 创建调整参数
    adjustments = [
        ("变暗", 0.7, -20),
        ("原始", 1.0, 0),
        ("变亮", 1.3, 30),
        ("高对比度", 1.8, -50)
    ]
    
    plt.figure(figsize=(15, 10))
    
    for i, (title, alpha, beta) in enumerate(adjustments):
        # 矩阵运算: dst = img * alpha + beta
        adjusted = cv2.convertScaleAbs(img, alpha=alpha, beta=beta)
        
        # 可视化
        plt.subplot(2, 2, i+1)
        plt.imshow(cv2.cvtColor(adjusted, cv2.COLOR_BGR2RGB))
        plt.title(f'{title}\n(alpha={alpha}, beta={beta})')
        plt.axis('off')
        
        # 计算矩阵变化
        diff = adjusted.astype(np.float32) - img.astype(np.float32)
        print(f"\n💡 {title}矩阵变化统计:")
        print(f"平均亮度变化: {np.mean(diff):.1f}")
        print(f"最大亮度变化: {np.max(diff):.1f}")
    
    plt.tight_layout()
    plt.show()
    
    # 矩阵操作说明
    print("\n🔧 亮度调整矩阵操作:")
    print("adjusted = cv2.convertScaleAbs(img, alpha=alpha, beta=beta)")
    print("等效于: adjusted_matrix = np.clip(img_matrix * alpha + beta, 0, 255).astype(np.uint8)")

# 执行实验4
experiment4(original_img)

# %% [markdown]
# ## 实验5：对比度调整（矩阵线性变换）
# **核心原理**：通过分段线性变换调整对比度
# - 增强特定亮度范围的对比度
# - 压缩其他范围的对比度

# %% [code]
# 实验5：对比度调整
def experiment5(img):
    # 创建对比度调整矩阵操作
    def adjust_contrast(matrix, low=0, high=255, new_low=0, new_high=255):
        # 线性变换公式
        slope = (new_high - new_low) / (high - low)
        adjusted = matrix.astype(np.float32)
        adjusted = (adjusted - low) * slope + new_low
        return np.clip(adjusted, 0, 255).astype(np.uint8)
    
    # 创建调整参数
    adjustments = [
        ("原始对比度", 0, 255, 0, 255),
        ("增强中间调", 50, 200, 0, 255),
        ("压暗高光", 0, 200, 0, 255),
        ("提高阴影", 50, 255, 0, 255)
    ]
    
    plt.figure(figsize=(15, 10))
    
    for i, (title, low, high, new_low, new_high) in enumerate(adjustments):
        adjusted = adjust_contrast(img, low, high, new_low, new_high)
        
        # 可视化
        plt.subplot(2, 2, i+1)
        plt.imshow(cv2.cvtColor(adjusted, cv2.COLOR_BGR2RGB))
        plt.title(f'{title}\n输入范围:[{low},{high}]→输出:[{new_low},{new_high}]')
        plt.axis('off')
        
        # 打印变换函数
        print(f"\n📊 {title}变换函数:")
        print(f"y = (x - {low}) * {(new_high-new_low)/(high-low):.2f} + {new_low}")
    
    plt.tight_layout()
    plt.show()

# 执行实验5
experiment5(original_img)

# %% [markdown]
# ## 实验6：图像翻转（矩阵索引操作）
# **核心原理**：通过矩阵索引重排实现图像翻转
# - 水平翻转：matrix[:, ::-1, :]
# - 垂直翻转：matrix[::-1, :, :]
# - 对角线翻转：matrix[::-1, ::-1, :]

# %% [code]
# 实验6：图像翻转
def experiment6(img):
    # 矩阵翻转操作
    flip_horizontal = img[:, ::-1, :]  # 水平翻转
    flip_vertical = img[::-1, :, :]    # 垂直翻转
    flip_both = img[::-1, ::-1, :]     # 对角线翻转
    
    plt.figure(figsize=(15, 10))
    
    # 原始图像
    plt.subplot(221)
    plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
    plt.title('原始图像')
    plt.axis('off')
    
    # 水平翻转
    plt.subplot(222)
    plt.imshow(cv2.cvtColor(flip_horizontal, cv2.COLOR_BGR2RGB))
    plt.title('水平翻转 (矩阵列索引反转)')
    plt.axis('off')
    
    # 垂直翻转
    plt.subplot(223)
    plt.imshow(cv2.cvtColor(flip_vertical, cv2.COLOR_BGR2RGB))
    plt.title('垂直翻转 (矩阵行索引反转)')
    plt.axis('off')
    
    # 对角线翻转
    plt.subplot(224)
    plt.imshow(cv2.cvtColor(flip_both, cv2.COLOR_BGR2RGB))
    plt.title('对角线翻转 (行列索引同时反转)')
    plt.axis('off')
    
    plt.tight_layout()
    plt.show()
    
    # 矩阵操作说明
    print("\n🔄 翻转矩阵操作说明:")
    print("水平翻转: flipped = img[:, ::-1, :]")
    print("垂直翻转: flipped = img[::-1, :, :]")
    print("对角线翻转: flipped = img[::-1, ::-1, :]")
    print("原理：通过NumPy索引操作重新排列像素位置")

# 执行实验6
experiment6(original_img)

# %% [markdown]
# ## 实验7：图像旋转（矩阵转置与重排）
# **核心原理**：通过旋转矩阵进行坐标变换
# - 90°旋转：矩阵转置 + 翻转
# - 任意角度：仿射变换矩阵

# %% [code]
# 实验7：图像旋转
def experiment7(img):
    # 90°倍数旋转
    rotate_90 = cv2.rotate(img, cv2.ROTATE_90_CLOCKWISE)       # 顺时针90°
    rotate_180 = cv2.rotate(img, cv2.ROTATE_180)               # 180°
    rotate_270 = cv2.rotate(img, cv2.ROTATE_90_COUNTERCLOCKWISE)  # 逆时针90°
    
    # 任意角度旋转（45°）
    h, w = img.shape[:2]
    center = (w//2, h//2)
    M = cv2.getRotationMatrix2D(center, 45, 1.0)  # 旋转矩阵
    rotate_45 = cv2.warpAffine(img, M, (w, h))
    
    plt.figure(figsize=(15, 12))
    
    # 原始图像
    plt.subplot(231)
    plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
    plt.title('原始图像')
    plt.axis('off')
    
    # 90°旋转
    plt.subplot(232)
    plt.imshow(cv2.cvtColor(rotate_90, cv2.COLOR_BGR2RGB))
    plt.title('顺时针90°旋转')
    plt.axis('off')
    
    # 180°旋转
    plt.subplot(233)
    plt.imshow(cv2.cvtColor(rotate_180, cv2.COLOR_BGR2RGB))
    plt.title('180°旋转')
    plt.axis('off')
    
    # 270°旋转
    plt.subplot(234)
    plt.imshow(cv2.cvtColor(rotate_270, cv2.COLOR_BGR2RGB))
    plt.title('逆时针90°旋转')
    plt.axis('off')
    
    # 任意角度旋转
    plt.subplot(235)
    plt.imshow(cv2.cvtColor(rotate_45, cv2.COLOR_BGR2RGB))
    plt.title('45°旋转')
    plt.axis('off')
    
    # 旋转矩阵可视化
    plt.subplot(236)
    plt.text(0.1, 0.5, f"旋转矩阵(45°):\n{M}", fontsize=12)
    plt.axis('off')
    
    plt.tight_layout()
    plt.show()
    
    # 矩阵操作说明
    print("\n🔄 旋转矩阵操作说明:")
    print("90°旋转: 使用cv2.rotate()函数")
    print("任意角度: 创建旋转矩阵 + cv2.warpAffine()")
    print("旋转矩阵本质是坐标变换: x' = a*x + b*y + c, y' = d*x + e*y + f")

# 执行实验7
experiment7(original_img)

# %% [markdown]
# ## 实验8：图像缩放（矩阵重采样）
# **核心原理**：通过插值算法重新采样矩阵
# - 最近邻插值：快速，有锯齿
# - 双线性插值：平滑，质量较好
# - 区域重采样：保持纹理特征

# %% [code]
# 实验8：图像缩放
def experiment8(img):
    # 设置缩放比例
    scale_factors = [0.5, 1.5, 2.0]
    methods = [
        ("最近邻", cv2.INTER_NEAREST),
        ("双线性", cv2.INTER_LINEAR),
        ("区域重采样", cv2.INTER_AREA)
    ]
    
    plt.figure(figsize=(15, 12))
    
    # 原始图像
    plt.subplot(331)
    plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
    plt.title('原始图像')
    plt.axis('off')
    
    # 不同缩放方法
    row = 1
    for scale in scale_factors:
        for col, (name, interp) in enumerate(methods):
            # 计算新尺寸
            new_size = (int(img.shape[1] * scale), int(img.shape[0] * scale)
            
            # 执行缩放
            resized = cv2.resize(img, new_size, interpolation=interp)
            
            # 可视化
            plt.subplot(3, 3, row)
            plt.imshow(cv2.cvtColor(resized, cv2.COLOR_BGR2RGB))
            plt.title(f'{name}缩放 {scale}x')
            plt.axis('off')
            
            # 显示矩阵信息
            print(f"\n🖼️ {name}缩放 {scale}x: 新矩阵形状 {resized.shape}")
            
            row += 1
    
    plt.tight_layout()
    plt.show()
    
    # 矩阵操作说明
    print("\n📐 缩放矩阵操作说明:")
    print("缩放本质是重采样: 根据新尺寸重新计算每个像素值")
    print("不同插值方法影响重采样质量:")
    print("1. 最近邻: 取最近像素值，速度快但质量低")
    print("2. 双线性: 4个最近像素加权平均，平衡速度质量")
    print("3. 区域重采样: 考虑像素区域关系，适合缩小图像")

# 执行实验8
experiment8(original_img)

# %% [markdown]
# ## 实验9：卷积滤波（矩阵卷积运算）
# **核心原理**：使用核矩阵与图像进行卷积运算
# - 滤波核：3x3或5x5矩阵
# - 卷积操作：核矩阵与图像局部区域点乘后求和

# %% [code]
# 实验9：卷积滤波
def experiment9(img):
    # 定义滤波核
    kernels = {
        "模糊": np.ones((5,5), np.float32)/25,
        "锐化": np.array([[0, -1, 0], [-1, 5, -1], [0, -1, 0]], np.float32),
        "边缘检测": np.array([[-1, -1, -1], [-1, 8, -1], [-1, -1, -1]], np.float32),
        "浮雕": np.array([[-2, -1, 0], [-1, 1, 1], [0, 1, 2]], np.float32)
    }
    
    plt.figure(figsize=(15, 10))
    
    # 原始图像
    plt.subplot(231)
    plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
    plt.title('原始图像')
    plt.axis('off')
    
    # 应用不同滤波器
    for i, (name, kernel) in enumerate(kernels.items()):
        # 执行卷积
        filtered = cv2.filter2D(img, -1, kernel)
        
        # 可视化
        plt.subplot(2, 3, i+2)
        plt.imshow(cv2.cvtColor(filtered, cv2.COLOR_BGR2RGB))
        plt.title(f'{name}滤波')
        plt.axis('off')
        
        # 显示核矩阵
        print(f"\n🔶 {name}滤波核:")
        print(kernel)
    
    plt.tight_layout()
    plt.show()
    
    # 矩阵操作说明
    print("\n🌀 卷积滤波矩阵操作说明:")
    print("卷积公式: dst(x,y) = Σ(kernel(i,j) * src(x+i, y+j))")
    print("本质：核矩阵在图像上滑动，计算局部区域的加权和")

# 执行实验9
experiment9(original_img)

# %% [markdown]
# ## 实验10：边缘检测（梯度矩阵计算）
# **核心原理**：通过计算图像梯度矩阵检测边缘
# - Sobel算子：计算x/y方向梯度
# - Canny算法：多阶段边缘检测

# %% [code]
# 实验10：边缘检测
def experiment10(gray_img):
    # Sobel边缘检测
    sobel_x = cv2.Sobel(gray_img, cv2.CV_64F, 1, 0, ksize=5)
    sobel_y = cv2.Sobel(gray_img, cv2.CV_64F, 0, 1, ksize=5)
    sobel_combined = np.sqrt(sobel_x**2 + sobel_y**2)
    
    # Canny边缘检测
    edges = cv2.Canny(gray_img, 100, 200)
    
    plt.figure(figsize=(15, 10))
    
    # 原始灰度图像
    plt.subplot(231)
    plt.imshow(gray_img, cmap='gray')
    plt.title('原始灰度图像')
    plt.axis('off')
    
    # Sobel X方向
    plt.subplot(232)
    plt.imshow(np.abs(sobel_x), cmap='gray')
    plt.title('Sobel X方向梯度')
    plt.axis('off')
    
    # Sobel Y方向
    plt.subplot(233)
    plt.imshow(np.abs(sobel_y), cmap='gray')
    plt.title('Sobel Y方向梯度')
    plt.axis('off')
    
    # Sobel组合
    plt.subplot(234)
    plt.imshow(sobel_combined, cmap='gray')
    plt.title('Sobel梯度幅值')
    plt.axis('off')
    
    # Canny边缘检测
    plt.subplot(235)
    plt.imshow(edges, cmap='gray')
    plt.title('Canny边缘检测')
    plt.axis('off')
    
    # 梯度矩阵说明
    plt.subplot(236)
    plt.text(0.1, 0.4, 
             "梯度矩阵计算原理:\n"
             "Gx = Sobel_x * I (水平变化率)\n"
             "Gy = Sobel_y * I (垂直变化率)\n"
             "|G| = √(Gx² + Gy²)\n"
             "Canny算法使用双阈值检测边缘",
             fontsize=12)
    plt.axis('off')
    
    plt.tight_layout()
    plt.show()
    
    # 矩阵操作说明
    print("\n📈 边缘检测矩阵操作说明:")
    print("Sobel算子：计算图像在x/y方向的导数")
    print("Canny算法：高斯滤波 → 梯度计算 → 非极大值抑制 → 双阈值检测")

# 执行实验10
experiment10(gray_img)

# %% [markdown]
# ## 知识体系总结
# 通过以上10个实验，我们系统性地学习了：
# 
# 1. **图像本质**：图像即矩阵（三维：高度×宽度×通道）
# 2. **基础操作**：通道分离、二值化、亮度/对比度调整
# 3. **几何变换**：翻转、旋转、缩放（矩阵索引与重采样）
# 4. **图像增强**：线性变换、卷积滤波
# 5. **特征提取**：边缘检测（梯度计算）
# 
# > 掌握这些核心矩阵操作后，您可以自由组合创造更复杂的图像处理效果！

# %% [code]
# 保存所有实验代码到文件
with open('image_matrix_experiments.py', 'w') as f:
    f.write("""
# 图像矩阵处理实验完整代码
# 包含10个核心实验，可直接运行
import cv2
import numpy as np
import matplotlib.pyplot as plt
# ...（此处包含上面所有实验函数）""")

# 下载代码文件
files.download('image_matrix_experiments.py')

发挥了钞能力之后的图

在这里插入图片描述

上述代码包含 10 个图像处理实验，每个实验会生成对应处理后的图像，以下为各实验对应生成图像的大致情况：

实验 1：生成原始彩色图像和灰度图像，还会展示彩色与灰度图像的矩阵切片信息。
实验 2：生成原始图像、仅红色通道、仅绿色通道、仅蓝色通道、通道交换（BGR→RGB ）、自定义通道组合（B + R + G ）的图像。
实验 3：生成原始灰度图像，以及阈值为 50、100、150 的二值化图像 。
实验 4：生成变暗（alpha = 0.7，beta = -20 ）、原始、变亮（alpha = 1.3，beta = 30 ）、高对比度（alpha = 1.8，beta = -50 ）调整后的图像。
实验 5：生成原始对比度、增强中间调（输入范围 [50,200]→输出 [0,255] ）、压暗高光（输入范围 [0,200]→输出 [0,255] ）、提高阴影（输入范围 [50,255]→输出 [0,255] ）调整后的图像。
实验 6：生成原始图像、水平翻转、垂直翻转、对角线翻转后的图像。
实验 7：生成原始图像、顺时针 90° 旋转、180° 旋转、逆时针 90° 旋转、45° 旋转后的图像，还有旋转矩阵可视化图。
实验 8：以不同插值方法（最近邻、双线性、区域重采样 ），对图像进行 0.5 倍、1.5 倍、2.0 倍缩放，会生成对应缩放后的多组图像。
实验 9：生成原始图像，以及经模糊、锐化、边缘检测、浮雕卷积滤波后的图像。
实验 10：生成原始灰度图像、Sobel X 方向梯度、Sobel Y 方向梯度、Sobel 梯度幅值、Canny 边缘检测的图像，还有梯度矩阵原理说明图 。

邓爷爷也说过，理论和实际相结合嘛。咱们做了一波实验，然后再学点理论，再做实验…反反复复，这快慢慢随着我的老年斑的增长，经验值是不是就上来了

如果想了解一些成像系统、图像、人眼、颜色等等的小知识，快去看看视频吧 ：

  • GodWarrior、抖音号：59412983611
  • B站：宇宙第一AIYWM
    • 认准一个头像，保你不迷路：
      在这里插入图片描述

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布