如何用C++11 std::vector优化大尺寸cv::Mat运算以提升速度？

嘿，我来帮你搞定这个性能问题！你的OpenCV代码慢主要是因为中间临时矩阵占用太多内存，加上通用函数的额外开销，还有没利用多核CPU。下面我把原逻辑拆解，用C++11的std::vector实现一个高效版本，应该能大幅提速。

首先先明确你原来的代码做了什么：

1. 将img（应该是1×512的float矩阵）重复rows次（也就是800000次），得到和Mat_B同尺寸的Mat_A
2. 逐元素计算Mat_A - Mat_B的差值
3. 对差值逐元素平方
4. 按行求和，得到每行的平方和向量
5. 找出平方和最小的行及其对应值

• 内存爆炸：每个800000×512的float矩阵占1.6GB内存，原代码中repeat、subtract、pow都会生成临时矩阵，瞬间占用4.8GB以上内存，触发系统内存交换（swap），这是速度慢的核心原因
• 通用函数开销：OpenCV的repeat、reduce等函数是通用实现，要处理各种类型、尺寸、内存布局的矩阵，有不少额外检查和分支
• 单线程运行：默认情况下OpenCV很多函数是单线程的，没利用你的MacBook Pro的多核CPU

下面是针对你的场景优化的代码，直接操作连续内存，利用多核并行，避免临时内存浪费：

完整代码示例 #

#include <vector>
#include <numeric>
#include <limits>
#include <thread>
#include <algorithm>
#include <opencv2/opencv.hpp>

void compute_min_distance(const cv::Mat& img, const cv::Mat& mat_b, float& min_dis, cv::Point& min_point) {
    const int rows = mat_b.rows;
    const int cols = mat_b.cols; // 固定为512

    // 把1×512的img转成vector，方便快速访问
    std::vector<float> img_vec(cols);
    std::copy(img.begin<float>(), img.end<float>(), img_vec.begin());

    // 确保Mat_B是连续内存（如果不是，先克隆成连续的）
    cv::Mat mat_b_cont = mat_b.isContinuous() ? mat_b : mat_b.clone();
    // 把Mat_B转成一维连续vector，行优先存储
    std::vector<float> mat_b_vec(rows * cols);
    std::copy(mat_b_cont.begin<float>(), mat_b_cont.end<float>(), mat_b_vec.begin());

    // 存储每行的平方和，仅需3.2MB内存（800000×4字节）
    std::vector<float> row_sums(rows, 0.0f);

    // 利用多核CPU并行计算，自动适配核心数
    const int num_threads = std::thread::hardware_concurrency();
    std::vector<std::thread> threads;
    const int rows_per_thread = rows / num_threads;

    for (int t = 0; t < num_threads; ++t) {
        int start_row = t * rows_per_thread;
        // 最后一个线程处理剩余所有行
        int end_row = (t == num_threads - 1) ? rows : (t + 1) * rows_per_thread;

        // 每个线程处理自己的行区间
        threads.emplace_back([&, start_row, end_row]() {
            for (int i = start_row; i < end_row; ++i) {
                float sum = 0.0f;
                // 直接定位到当前行的起始位置，连续访问缓存命中率高
                const float* b_row_ptr = &mat_b_vec[i * cols];
                for (int j = 0; j < cols; ++j) {
                    const float diff = img_vec[j] - b_row_ptr[j];
                    sum += diff * diff;
                }
                row_sums[i] = sum;
            }
        });
    }

    // 等待所有线程完成计算
    for (auto& thread : threads) {
        thread.join();
    }

    // 查找最小平方和及其对应的行号
    min_dis = std::numeric_limits<float>::max();
    min_point = cv::Point(0, 0);
    for (int i = 0; i < rows; ++i) {
        if (row_sums[i] < min_dis) {
            min_dis = row_sums[i];
            min_point.y = i; // 对应原代码的point.y（行号）
        }
    }
}

// 调用示例
int main() {
    // 假设你已经有了img（1×512 float）和Mat_B（800000×512 float）
    cv::Mat img = ...;
    cv::Mat Mat_B = ...;

    float dis;
    cv::Point point;
    compute_min_distance(img, Mat_B, dis, point);

    // 输出结果
    std::cout << "最小距离: " << dis << ", 对应行号: " << point.y << std::endl;
    return 0;
}

可选简化：用OpenMP代替手动线程管理 #

如果你编译器支持OpenMP（Clang/GCC都支持，Xcode需要开启OpenMP选项），可以把并行部分换成更简洁的代码，不需要手动创建线程：

// 替换原来的线程创建和join部分
#pragma omp parallel for
for (int i = 0; i < rows; ++i) {
    float sum = 0.0f;
    const float* b_row_ptr = mat_b_cont.ptr<float>(i);
    for (int j = 0; j < cols; ++j) {
        const float diff = img_vec[j] - b_row_ptr[j];
        sum += diff * diff;
    }
    row_sums[i] = sum;
}

1. 内存优化：仅保留必要的内存，避免临时大矩阵，将内存占用从4.8GB降到1.6GB（Mat_B）+3.2MB（row_sums）+2KB（img_vec），彻底避免内存交换
2. 缓存友好：一维vector的连续内存访问充分利用CPU缓存预取，比OpenCV的Mat行访问效率更高
3. 多核并行：利用所有CPU核心同时计算不同行的平方和，这能让速度提升数倍（比如8核CPU理论上能快6-7倍）
4. 无通用开销：代码针对你的特定场景（float类型、固定512列）优化，去掉了OpenCV通用函数的额外检查和分支

在你的2.4GHz MacBook Pro上，这个版本应该能把耗时从4秒降到500毫秒以内（具体取决于核心数和内存速度），提升非常明显。

内容的提问来源于stack exchange，提问作者Lisa