c/c++的opencv均值模糊

whoarethenext2025-05-21 20:38

深入理解与实现图像均值模糊：C/C++与OpenCV实践

图像模糊是计算机视觉和图像处理领域中最基础也最常用的操作之一。它的主要目的是平滑图像、去除噪声，或者在某些应用中（如背景虚化）创造特定的视觉效果。在各种模糊算法中，均值模糊 (Mean Blur) ，也称为盒状模糊 (Box Blur) 或 平均模糊 (Average Blur)，因其原理简单、计算速度快而得到了广泛应用。本文将深入探讨均值模糊的原理，并结合C/C++语言以及强大的计算机视觉库OpenCV，详细介绍其实现方法，包括从零开始手动实现和利用OpenCV内置函数实现。

什么是均值模糊？🤔

均值模糊的核心思想非常直观：对于图像中的每一个像素点，将其邻域内所有像素的平均值作为该点的新像素值 。这个"邻域"通常是一个固定大小的矩形窗口，称为卷积核 (Kernel) 或 滤波器窗口 (Filter Window)。

想象一下，我们有一个 m × n m \times n m×n 大小的卷积核。当这个卷积核在图像上滑动时，对于图像中被卷积核中心覆盖的像素，其新的像素值计算如下：

  1. 选取该像素周围一个 m × n m \times n m×n 的矩形区域（即卷积核覆盖的区域）。
  2. 将这个区域内所有像素的对应通道值（例如，对于灰度图像是灰度值，对于彩色图像是R、G、B三个通道的值分别计算）相加。
  3. 将得到的总和除以像素点的数量（即 m × n m \times n m×n）。
  4. 得到的结果就是中心像素的新像素值。

这个过程会有效地"平均掉"像素间的剧烈变化，从而使得图像看起来更平滑，细节信息减少，噪声也被一定程度地抑制。卷积核的大小是均值模糊效果的关键参数：核越大，模糊程度越高，图像细节损失也越多；核越小，模糊程度越低，对细节的保留也更好。

举个例子：

假设我们有一个3x3的均值模糊卷积核，以及图像中一个像素点及其3x3邻域的灰度值如下：

10 20 30
40 50 60
70 80 90

中心像素点的值是50。应用均值模糊后，新的中心像素值计算如下：

新值 = (10 + 20 + 30 + 40 + 50 + 60 + 70 + 80 + 90) / (3 * 3)

= 450 / 9

= 50

在这个特例中，由于数值分布均匀，中心值没有改变。但如果邻域内的值有较大波动，例如：

10 200 30
40 50 60
70 5 90

新值 = (10 + 200 + 30 + 40 + 50 + 60 + 70 + 5 + 90) / 9

= 555 / 9

≈ 61.67

可以看到，中心像素值从50变为了约61.67，更接近其邻域的平均水平。

均值模糊的数学表示 📐

从数学角度看，均值模糊可以被视为一种卷积 (Convolution) 操作。对于一个大小为 ( 2 k + 1 ) × ( 2 k + 1 ) (2k+1) \times (2k+1) (2k+1)×(2k+1) 的均值滤波器（其中 k ≥ 0 k \ge 0 k≥0），其卷积核 H H H 可以表示为一个所有元素都相等的矩阵，通常为了归一化，每个元素的值为 1 ( 2 k + 1 ) 2 \frac{1}{(2k+1)^2} (2k+1)21。

例如，一个 3 × 3 3 \times 3 3×3 的均值滤波核可以表示为：

H = 1 9 [ 1 1 1 1 1 1 1 1 1 ] H = \frac{1}{9} \begin{bmatrix} 1 & 1 & 1 \\ 1 & 1 & 1 \\ 1 & 1 & 1 \end{bmatrix} H=91 111111111

如果输入图像为 I I I，输出图像为 I ′ I' I′，那么在点 ( x , y ) (x, y) (x,y) 处的模糊操作可以表示为：

I ′ ( x , y ) = ∑ i = − k k ∑ j = − k k I ( x + i , y + j ) ⋅ H ( i , j ) I'(x, y) = \sum_{i=-k}^{k} \sum_{j=-k}^{k} I(x+i, y+j) \cdot H(i, j) I′(x,y)=i=−k∑kj=−k∑kI(x+i,y+j)⋅H(i,j)

由于均值滤波核 H ( i , j ) H(i, j) H(i,j) 的所有元素都等于 1 ( 2 k + 1 ) 2 \frac{1}{(2k+1)^2} (2k+1)21，所以上式可以简化为：

I ′ ( x , y ) = 1 ( 2 k + 1 ) 2 ∑ i = − k k ∑ j = − k k I ( x + i , y + j ) I'(x, y) = \frac{1}{(2k+1)^2} \sum_{i=-k}^{k} \sum_{j=-k}^{k} I(x+i, y+j) I′(x,y)=(2k+1)21i=−k∑kj=−k∑kI(x+i,y+j)

这正是在 ( 2 k + 1 ) × ( 2 k + 1 ) (2k+1) \times (2k+1) (2k+1)×(2k+1) 窗口内像素值的平均。

处理边界像素：

当卷积核移动到图像边界时，部分核窗口可能会超出图像范围。处理这种情况有几种常见策略：

  1. 忽略边界 (Shrinking Output / Valid Convolution): 只对那些卷积核完全落在图像内部的像素进行计算。这会导致输出图像的尺寸小于输入图像。
  2. 填充边界 (Padding / Same Convolution): 在图像边界外部虚拟地扩展像素。常用的填充方式有：
    • 零填充 (Zero Padding): 用0填充边界外的像素。
    • 边界复制 (Replicate Padding / Border Replicate): 用最接近的边界像素值填充。
    • 镜像填充 (Reflect Padding): 以边界为轴，镜像复制图像内容。
    • 对称填充 (Wrap Padding / Border Reflect 101): 类似于镜像，但边界像素本身不被重复。

在实际应用中，为了保持输出图像尺寸与输入一致，通常会采用某种形式的边界填充。OpenCV默认情况下会使用边界复制的方式。

C/C++ 手动实现均值模糊 (不使用OpenCV Mat) 🖼️

在了解了原理之后，我们尝试用纯C/C++（不依赖OpenCV的cv::Mat结构，但为了图像加载和显示，最终还是会用到OpenCV的I/O功能）来实现一个针对灰度图像的均值模糊。我们将图像数据视为一个二维数组或一维数组（按行存储）。

假设：

  • 输入图像是8位单通道灰度图。
  • 图像数据以一维数组 unsigned char* imageData 的形式存储，按行优先。
  • 图像宽度 width 和高度 height 已知。
  • 卷积核大小为 kernel_size (奇数，例如3, 5, 7... 表示 kernel_size x kernel_size 的窗口)。
cpp 复制代码 
#include <iostream>
#include <vector>
#include <numeric> // For std::accumulate (optional)

// 辅助函数：处理边界像素（这里采用边界复制策略）
unsigned char getPixelValue(const unsigned char* imageData, int width, int height, int x, int y) {
    // 边界检查和复制
    if (x < 0) x = 0;
    if (x >= width) x = width - 1;
    if (y < 0) y = 0;
    if (y >= height) y = height - 1;
    return imageData[y * width + x];
}

// 手动实现均值模糊函数
std::vector<unsigned char> meanBlurManual(const unsigned char* inputImage, int width, int height, int kernel_size) {
    if (kernel_size % 2 == 0) {
        std::cerr << "错误：卷积核大小应为奇数!" << std::endl;
        return {}; // 返回空向量表示错误
    }
    if (!inputImage || width <= 0 || height <= 0) {
        std::cerr << "错误：无效的输入图像数据!" << std::endl;
        return {};
    }

    std::vector<unsigned char> outputImage(width * height);
    int kernel_radius = kernel_size / 2; // 例如 kernel_size=3, radius=1

    for (int y = 0; y < height; ++y) {
        for (int x = 0; x < width; ++x) {
            unsigned int sum = 0;
            int count = 0;

            // 遍历卷积核覆盖的区域
            for (int ky = -kernel_radius; ky <= kernel_radius; ++ky) {
                for (int kx = -kernel_radius; kx <= kernel_radius; ++kx) {
                    int current_x = x + kx;
                    int current_y = y + ky;

                    sum += getPixelValue(inputImage, width, height, current_x, current_y);
                    count++; // 实际参与计算的像素数量，对于均值模糊，count 总是 kernel_size * kernel_size
                }
            }
            // 计算平均值并赋值给输出图像
            // count 理论上总是 kernel_size * kernel_size，因为 getPixelValue 处理了边界
            outputImage[y * width + x] = static_cast<unsigned char>(sum / (kernel_size * kernel_size));
        }
    }
    return outputImage;
}

// 为了演示，我们需要一个加载和保存图像的简单方式 (这里将使用OpenCV的I/O)
#include <opencv2/opencv.hpp>

int main_manual() {
    // --- 图像加载 ---
    cv::Mat image = cv::imread("your_image_path.png", cv::IMREAD_GRAYSCALE); // 替换为你的图片路径
    if (image.empty()) {
        std::cerr << "错误: 无法加载图片!" << std::endl;
        return -1;
    }

    int width = image.cols;
    int height = image.rows;
    unsigned char* imageData = image.data; // 获取指向图像数据的指针

    // --- 设置模糊参数 ---
    int kernelSize = 5; // 例如，5x5的均值模糊核

    std::cout << "开始手动均值模糊处理 (核大小: " << kernelSize << "x" << kernelSize << ")..." << std::endl;
    std::vector<unsigned char> blurredImageData = meanBlurManual(imageData, width, height, kernelSize);
    std::cout << "手动均值模糊处理完成。" << std::endl;

    if (blurredImageData.empty()) {
        return -1;
    }

    // --- 创建输出图像并显示/保存 ---
    cv::Mat outputMat(height, width, CV_8UC1, blurredImageData.data());

    cv::imshow("原始灰度图像", image);
    cv::imshow("手动均值模糊", outputMat);
    cv::waitKey(0);
    cv::destroyAllWindows();

    // cv::imwrite("manual_blurred_image.png", outputMat); // 可选：保存结果

    return 0;
}

代码解释 (meanBlurManual)：

  1. 参数检查： 确保卷积核大小是奇数，输入图像数据有效。
  2. 初始化输出： 创建一个与输入图像同样大小的 std::vector<unsigned char> 来存储模糊后的像素数据。
  3. 计算核半径： kernel_radius = kernel_size / 2，例如，对于3x3的核，半径是1；对于5x5的核，半径是2。这方便了后续邻域像素的索引。
  4. 遍历像素： 使用两层嵌套循环遍历输入图像的每一个像素 (x, y)。
  5. 邻域求和： 对于当前像素 (x, y)，再使用两层嵌套循环（kx, ky）遍历其由 kernel_size 定义的邻域。
    • current_x = x + kx 和 current_y = y + ky 计算邻域像素的实际坐标。
    • getPixelValue 函数用于获取这些坐标处的像素值，它内部处理了边界情况（超出图像范围时，返回最近的边界像素值）。
    • 将获取到的邻域像素值累加到 sum。
  6. 计算平均值： 遍历完邻域后，sum 除以总像素数 (kernel_size * kernel_size) 得到平均值。
  7. 赋值： 将计算得到的平均值（转换为 unsigned char）存入 outputImage 中对应 (x, y) 的位置。
  8. 返回结果： 返回包含模糊后图像数据的 std::vector。

main_manual 函数演示了如何加载一张灰度图像，将其数据指针传递给 meanBlurManual 函数，然后将返回的模糊数据重新包装成 cv::Mat 以便显示。

手动实现的优缺点：

  • 优点：
    • 更好地理解算法底层原理。
    • 不依赖特定的图像处理库（除了I/O部分），有更好的平台移植性（理论上）。
    • 可以灵活定制边界处理等细节。
  • 缺点：
    • 代码量较大，实现复杂，容易出错。
    • 性能通常远不如高度优化的库函数。对于大型图像和大的卷积核，效率低下。
    • 需要手动处理彩色图像的多个通道（对每个通道分别进行模糊）。

C/C++ 使用OpenCV实现均值模糊 🚀

OpenCV 提供了 cv::blur() 函数，可以非常方便高效地实现均值模糊。

cv::blur() 函数原型：

cpp 复制代码 
void cv::blur(
    cv::InputArray src,         // 输入图像 (可以是单通道或多通道)
    cv::OutputArray dst,        // 输出图像，与src具有相同的尺寸和类型
    cv::Size ksize,             // 卷积核大小 (cv::Size(width, height))
    cv::Point anchor = cv::Point(-1,-1), // 核的锚点，即核的中心。默认(-1,-1)表示中心
    int borderType = cv::BORDER_DEFAULT // 边界填充模式
);
  • src: 输入图像。
  • dst: 输出图像。
  • ksize: cv::Size 对象，表示模糊核的宽度和高度，例如 cv::Size(5, 5) 表示一个5x5的核。
  • anchor: 核的锚点，默认是核的中心 (-1, -1)。通常不需要修改。
  • borderType: 边界填充方式，默认是 cv::BORDER_DEFAULT (实际为 BORDER_REFLECT_101)。其他可选值有 BORDER_CONSTANT, BORDER_REPLICATE, BORDER_REFLECT, BORDER_WRAP 等。

使用 cv::blur() 的示例代码：

cpp 复制代码 
#include <opencv2/opencv.hpp>
#include <iostream>

int main_opencv() {
    // --- 图像加载 ---
    // 可以加载彩色图像或灰度图像
    cv::Mat image = cv::imread("your_image_path.png"); // 替换为你的图片路径
    if (image.empty()) {
        std::cerr << "错误: 无法加载图片!" << std::endl;
        return -1;
    }

    // --- 设置模糊参数 ---
    int kernelWidth = 7;
    int kernelHeight = 7;
    cv::Size kernelSize(kernelWidth, kernelHeight); // 定义核大小，例如7x7

    // --- 执行均值模糊 ---
    cv::Mat blurredImage;
    std::cout << "开始使用OpenCV cv::blur() 进行均值模糊处理 (核大小: "
              << kernelWidth << "x" << kernelHeight << ")..." << std::endl;

    cv::blur(image, blurredImage, kernelSize); // anchor和borderType使用默认值

    std::cout << "OpenCV均值模糊处理完成。" << std::endl;

    // --- 显示结果 ---
    cv::imshow("原始图像", image);
    cv::imshow("OpenCV均值模糊", blurredImage);
    cv::waitKey(0);
    cv::destroyAllWindows();

    // cv::imwrite("opencv_blurred_image.png", blurredImage); // 可选：保存结果

    return 0;
}

// 如果想在同一个main函数中调用，可以这样做：
int main() {
    std::cout << "--- 手动实现演示 ---" << std::endl;
    // main_manual(); // 如果要运行手动的，取消这行注释并确保图片路径正确
    std::cout << "\n--- OpenCV实现演示 ---" << std::endl;
    main_opencv(); // 确保图片路径正确
    return 0;
}

代码解释 (main_opencv)：

  1. 加载图像： 使用 cv::imread() 加载图像。这次我们可以直接加载彩色图像，cv::blur() 可以处理多通道图像（它会对每个通道独立进行模糊）。
  2. 定义核大小： 使用 cv::Size(kernelWidth, kernelHeight) 定义卷积核的尺寸。
  3. 调用 cv::blur()： 一行代码即可完成模糊操作。image 是输入，blurredImage 是输出，kernelSize 是核大小。
  4. 显示结果： 使用 cv::imshow() 显示原始图像和模糊后的图像。

OpenCV实现的优缺点：

  • 优点：
    • 简洁高效： 代码量极少，一行核心代码即可实现。
    • 高性能： OpenCV的函数通常经过了底层优化（例如SIMD指令集、多线程等），性能远超手动实现。
    • 功能完善： 支持多通道图像，提供多种边界处理选项。
    • 稳定可靠： 经过广泛测试和使用。
  • 缺点：
    • 黑盒操作： 底层实现对用户不透明（除非查看源码）。
    • 依赖库： 需要链接OpenCV库。

优化与进一步探讨 💡

1. 可分离滤波器 (Separable Filter)

对于均值模糊，其卷积核是可分离的。这意味着一个二维的均值模糊操作可以分解为两个一维的均值模糊操作：首先在水平方向上对每一行进行一维均值模糊，然后在垂直方向上对结果的每一列进行一维均值模糊（或者反过来）。

例如，一个 3 t i m e s 3 3 \\times 3 3times3 的均值滤波核：

H = 1 9 [ 1 1 1 1 1 1 1 1 1 ] = 1 3 [ 1 1 1 ] × 1 3 [ 1 1 1 ] H = \frac{1}{9} \begin{bmatrix} 1 & 1 & 1 \\ 1 & 1 & 1 \\ 1 & 1 & 1 \end{bmatrix} = \frac{1}{3} \begin{bmatrix} 1 \\ 1 \\ 1 \end{bmatrix} \times \frac{1}{3} \begin{bmatrix} 1 & 1 & 1 \end{bmatrix} H=91 111111111 =31 111 ×31[111]这里， b e g i n b m a t r i x 1 1 1 e n d b m a t r i x \\begin{bmatrix} 1 \\ 1 \\ 1 \\end{bmatrix} beginbmatrix111endbmatrix 是一个列向量（垂直滤波器），KaTeX parse error: Expected 'EOF', got '&' at position 20: ...gin{bmatrix} 1 &̲ 1 & 1 \\end{bm... 是一个行向量（水平滤波器）。

为什么可分离滤波器更优？

假设图像大小为 N t i m e s N N \\times N NtimesN，卷积核大小为 M t i m e s M M \\times M MtimesM。

  • 二维卷积的计算复杂度大约是 O ( N 2 c d o t M 2 ) O(N^2 \\cdot M^2) O(N2cdotM2)。
  • 使用可分离滤波器，先进行 M t i m e s 1 M \\times 1 Mtimes1 的列卷积（或 1 t i m e s M 1 \\times M 1timesM 的行卷积），复杂度为 O ( N 2 c d o t M ) O(N^2 \\cdot M) O(N2cdotM)。再进行 1 t i m e s M 1 \\times M 1timesM 的行卷积（或 M t i m e s 1 M \\times 1 Mtimes1 的列卷积），复杂度也为 O ( N 2 c d o t M ) O(N^2 \\cdot M) O(N2cdotM)。总复杂度为 O ( N 2 c d o t 2 M ) O(N^2 \\cdot 2M) O(N2cdot2M)。

当 M M M 较大时， 2 M 2M 2M 远小于 M 2 M^2 M2，因此可分离滤波可以显著提高计算效率。OpenCV的 cv::blur() 内部很可能利用了这种可分离性进行优化。在手动实现时，如果追求性能，可以考虑实现可分离的一维均值模糊。

2. 积分图 (Integral Image / Summed-Area Table)

对于计算矩形区域内像素和这类操作，积分图 是一种非常高效的数据结构。积分图 I I ( x , y ) II(x,y) II(x,y) 中每个点的值定义为原始图像 I I I 中左上角 ( 0 , 0 ) (0,0) (0,0) 到点 ( x , y ) (x,y) (x,y) 之间所有像素值的总和：

I I ( x , y ) = s u m _ x ′ l e x , y ′ l e y I ( x ′ , y ′ ) II(x,y) = \\sum\_{x' \\le x, y' \\le y} I(x',y') II(x,y)=sum_x′lex,y′leyI(x′,y′)积分图可以在 O ( N 2 ) O(N^2) O(N2) 的时间内（对于 N t i m e s N N \\times N NtimesN 图像）预计算出来。

一旦有了积分图，任何矩形区域（例如，由点 A, B, C, D 定义的矩形，其中A为左上角，B为右上角，C为左下角，D为右下角）的像素和S可以通过以下公式在常数时间 O ( 1 ) O(1) O(1) 内计算出来：
S = I I ( D ) − I I ( B ) − I I ( C ) + I I ( A ) S = II(D) - II(B) - II(C) + II(A) S=II(D)−II(B)−II(C)+II(A)

(这里需要注意索引，通常积分图的索引会比原图多一行一列以便于计算)。

利用积分图，计算任意大小均值模糊核覆盖区域的像素总和都只需要4次查表和3次加减法。这使得均值模糊的复杂度与卷积核大小无关（预计算积分图后），对于大核模糊尤其高效。OpenCV的某些函数（如 cv::integral 用于计算积分图，cv::boxFilter 在使用 -normalize=true 时等效于均值模糊，且可能使用积分图优化）可能利用了此技术。

3. 彩色图像的均值模糊

如前所述，cv::blur() 直接支持彩色图像。它会对图像的每个颜色通道（例如B, G, R）独立地应用相同的均值模糊操作。如果手动实现彩色图像的均值模糊，你需要：

  1. 分离颜色通道。
  2. 对每个通道应用灰度图像的均值模糊算法。
  3. 合并处理后的通道以形成最终的彩色模糊图像。

或者，在遍历像素时，直接对每个通道的邻域值分别求和并平均。

均值模糊的应用场景 🎯

  • 降噪： 尤其对于随机噪声，均值模糊可以有效地平滑掉这些突兀的像素点。但它也会模糊边缘，这是一个缺点。
  • 图像平滑： 降低图像细节，使其看起来更柔和。
  • 预处理： 在进行更复杂的图像分析（如边缘检测、特征提取）之前，有时会先用均值模糊来减少噪声干扰。
  • 缩小图像前的抗混叠： 在对图像进行下采样（缩小）之前，先进行适当的模糊可以减少混叠效应（锯齿状边缘）。
  • 创建简单的艺术效果： 例如，大核的均值模糊可以产生强烈的朦胧感。

总结与展望 ✨

均值模糊作为一种基础的图像平滑技术，其原理简单直观，易于实现。通过本文，我们：

  1. 理解了均值模糊的基本概念、数学表示及其与卷积的关系。
  2. 探讨了边界像素的处理策略。
  3. 从零开始用C/C++手动实现了一个针对灰度图像的均值模糊算法，并分析了其优缺点。
  4. 学习了如何使用OpenCV提供的 cv::blur() 函数高效地进行均值模糊，并了解了其便利性。
  5. 简要介绍了可分离滤波器和积分图等优化均值模糊计算的思路。
  6. 概述了均值模糊的主要应用场景。

虽然均值模糊效果直接，但它有一个明显的缺点：它对所有像素（包括边缘像素和噪声像素）一视同仁地进行平均，这会导致图像边缘也变得模糊不清。为了解决这个问题，后续发展出了更多高级的模糊/平滑技术，例如：

  • 高斯模糊 (Gaussian Blur): 使用高斯函数作为权重，离中心点越近的像素权重越大，能更好地保留边缘。
  • 中值模糊 (Median Blur): 用邻域像素的中值代替平均值，对去除椒盐噪声特别有效，且对边缘的保护相对较好。
  • 双边滤波 (Bilateral Filter): 同时考虑空间邻近度和像素值相似度，能够在降噪的同时保持边缘清晰。

掌握均值模糊是学习更复杂图像处理技术的重要一步。希望本文能帮助你对均值模糊有一个全面而深入的理解，并能在C/C++项目中灵活运用。无论是为了学术研究还是实际应用开发，理解这些基础算法的原理和实现都至关重要。

Happy coding and image processing! 🚀

复制代码
相关推荐
liuzhangfeiabc2 小时前
[luogu12541] [APIO2025] Hack! - 交互 - 构造 - 数论 - BSGS
c++·算法·题解
学习使我变快乐2 小时前
C++：迭代器
开发语言·c++·windows
好想有猫猫2 小时前
【Redis】List 列表
数据库·c++·redis·分布式·缓存·list
lucky_lyovo4 小时前
OpenCV图像边缘检测
人工智能·opencv·计算机视觉
superior tigre4 小时前
C++学习：六个月从基础到就业——C++11/14：其他语言特性
c++·学习
天堂的恶魔9465 小时前
C++ - 仿 RabbitMQ 实现消息队列（2）（Protobuf 和 Muduo 初识）
c++·rabbitmq·ruby
休息一下接着来5 小时前
进程间通信（IPC）常用方式对比
linux·c++·进程间通讯
虾球xz5 小时前
游戏引擎学习第288天:继续完成Brains
c++·学习·游戏引擎
John_ToDebug5 小时前
Chromium 浏览器核心生命周期剖析：从 BrowserProcess 全局管理到 Browser 窗口实例
c++·chrome·性能优化
那雨倾城5 小时前
使用 OpenCV 实现万花筒效果
图像处理·人工智能·opencv·计算机视觉
热门推荐
01从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑02KGG转MP3工具|非KGM文件|解密音频03YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】04【SpeedAI科研小助手】2分钟极速解决知网维普重复率、AIGC率过高，一键全文降！文件格式不变，公式都保留的！05组基轨迹建模 GBTM的介绍与实现（Stata 或 R）06DeepSeek各版本说明与优缺点分析07VMware虚拟机安装Win7专业版保姆级教程（附镜像包）08YOLOv5改进 | 添加CA注意力机制 + 增加预测层 + 更换损失函数之GIoU09Coze扣子平台完整体验和实践（附国内和国际版对比）10Windows下Qt5.14.2连接华为IoTDA平台