OpenCV (C++) 提速技巧（以Haar小波变换为例）

最近在写利用小波变换进行图像融合的算法，该算法对性能有要求，因此整理了两点能够简单快速提升算法速度的技巧，以下以笔者写的小波变换代码为例。
并行计算

cv::parallel_for_()是OpenCV的一个并行框架，其利用OpenMP、Windows并发、pthreads等并行框架构建。当调用cv::parallel_for_() 函数时，OpenCV会基于线程池分配CPU资源，将任务划分为多个独立且并行执行的较小子任务。但是需要注意的是，如果在嵌套循环的每层都使用并行化，可能会导致线程过多，反而增加调度开销，降低性能。
以下是未经优化的原始Haar小波变换及逆变换算法。

1. struct WaveletCoeffs {
2.   cv::Mat cA;  // 低频分量
3.   cv::Mat cH;  // 水平高频
4.   cv::Mat cV;  // 垂直高频
5.   cv::Mat cD;  // 对角高频
6. };
8. WaveletCoeffs dwt(const cv::Mat& img) {
9.   cv::Mat img_float{};
10.   img.convertTo(img_float, CV_32FC1);
12.   const int h = img_float.rows;
13.   const int w = img_float.cols;
14.   const int pad_h = (h % 2 != 0) ? 1 : 0;
15.   const int pad_w = (w % 2 != 0) ? 1 : 0;
16.   cv::copyMakeBorder(img_float, img_float, 0, pad_h, 0, pad_w, cv::BORDER_REFLECT_101);
18.   const int half_rows = img_float.rows / 2;
19.   const int half_cols = img_float.cols / 2;
20.   cv::Mat cA = cv::Mat::zeros(half_rows, half_cols, CV_32FC1);
21.   cv::Mat cH = cv::Mat::zeros(half_rows, half_cols, CV_32FC1);
22.   cv::Mat cV = cv::Mat::zeros(half_rows, half_cols, CV_32FC1);
23.   cv::Mat cD = cv::Mat::zeros(half_rows, half_cols, CV_32FC1);
25.   for (int r = 0; r < half_rows; r++) {
26.     for (int c = 0; c < half_cols; c++) {
27.       const float b00 = img_float.at<float>(2 * r, 2 * c);
28.       const float b01 = img_float.at<float>(2 * r, 2 * c + 1);
29.       const float b10 = img_float.at<float>(2 * r + 1, 2 * c);
30.       const float b11 = img_float.at<float>(2 * r + 1, 2 * c + 1);
32.       cA.at<float>(r, c) = (b00 + b01 + b10 + b11) * 0.5f;
33.       cH.at<float>(r, c) = (b00 - b01 + b10 - b11) * 0.5f;
34.       cV.at<float>(r, c) = (b00 + b01 - b10 - b11) * 0.5f;
35.       cD.at<float>(r, c) = (b00 - b01 - b10 + b11) * 0.5f;
36.     }
37.   }
39.   return {cA, cH, cV, cD};
40. }
42. cv::Mat idwt(const WaveletCoeffs& coeffs) {
43.   const cv::Mat& cA = coeffs.cA;
44.   const cv::Mat& cH = coeffs.cH;
45.   const cv::Mat& cV = coeffs.cV;
46.   const cv::Mat& cD = coeffs.cD;
48.   const int half_rows = cA.rows;
49.   const int half_cols = cA.cols;
50.   const int rows = half_rows * 2;
51.   const int cols = half_cols * 2;
52.   cv::Mat recovered = cv::Mat::zeros(rows, cols, CV_32FC1);
54.   for (int r = 0; r < half_rows; r++) {
55.     for (int c = 0; c < half_cols; c++) {
56.       const float val_cA = cA.at<float>(r, c);
57.       const float val_cH = cH.at<float>(r, c);
58.       const float val_cV = cV.at<float>(r, c);
59.       const float val_cD = cD.at<float>(r, c);
61.       recovered.at<float>(2 * r, 2 * c) = (val_cA + val_cH + val_cV + val_cD) * 0.5f;
62.       recovered.at<float>(2 * r, 2 * c + 1) = (val_cA - val_cH + val_cV - val_cD) * 0.5f;
63.       recovered.at<float>(2 * r + 1, 2 * c) = (val_cA + val_cH - val_cV - val_cD) * 0.5f;
64.       recovered.at<float>(2 * r + 1, 2 * c + 1) = (val_cA - val_cH - val_cV + val_cD) * 0.5f;
65.     }
66.   }
67.   cv::Mat result{};
68.   recovered.convertTo(result, CV_8UC1);
70.   return result;
71. }

复制代码

在这里，笔者使用两张1800x1800分辨率的灰度（单通道）图像，利用小波变换进行多对焦图像融合，预热并运行三次输出平均融合时间。

1. const auto start_fuse_time = cv::getTickCount();
2. cv::Mat fused_img = fusion(img_lst);
3. const auto fuse_time = cv::getTickCount();
4. std::cout << "融合耗时："
5.   << static_cast<double>(fuse_time - start_fuse_time) / cv::getTickFrequency() * 1000
6.   << " ms" << std::endl;
8. // >>> 融合耗时：29.1 ms

复制代码

可以看到，速度提升了大约56%，那如果两层嵌套循环都使用并行化对于速度提升会有帮助吗，笔者的CPU为AMD 9900X，硬件层面来讲供线程调度的核心数是管够的。以下为伪代码。

1. WaveletCoeffs dwt(const cv::Mat& img) {
2.   cv::Mat img_float{};
3.   img.convertTo(img_float, CV_32FC1);
5.   const int h = img_float.rows;
6.   const int w = img_float.cols;
7.   const int pad_h = (h % 2 != 0) ? 1 : 0;
8.   const int pad_w = (w % 2 != 0) ? 1 : 0;
9.   cv::copyMakeBorder(img_float, img_float, 0, pad_h, 0, pad_w, cv::BORDER_REFLECT_101);
11.   const int half_rows = img_float.rows / 2;
12.   const int half_cols = img_float.cols / 2;
13.   cv::Mat cA = cv::Mat::zeros(half_rows, half_cols, CV_32FC1);
14.   cv::Mat cH = cv::Mat::zeros(half_rows, half_cols, CV_32FC1);
15.   cv::Mat cV = cv::Mat::zeros(half_rows, half_cols, CV_32FC1);
16.   cv::Mat cD = cv::Mat::zeros(half_rows, half_cols, CV_32FC1);
18.   // 在这里采用并行化
19.   cv::parallel_for_(cv::Range(0, half_rows), [&](const cv::Range& range) {
20.     for (int r = range.start; r < range.end; r++) {
21.       for (int c = 0; c < half_cols; c++) {
22.         const float b00 = img_float.at<float>(2 * r, 2 * c);
23.         const float b01 = img_float.at<float>(2 * r, 2 * c + 1);
24.         const float b10 = img_float.at<float>(2 * r + 1, 2 * c);
25.         const float b11 = img_float.at<float>(2 * r + 1, 2 * c + 1);
27.         cA.at<float>(r, c) = (b00 + b01 + b10 + b11) * 0.5f;
28.         cH.at<float>(r, c) = (b00 - b01 + b10 - b11) * 0.5f;
29.         cV.at<float>(r, c) = (b00 + b01 - b10 - b11) * 0.5f;
30.         cD.at<float>(r, c) = (b00 - b01 - b10 + b11) * 0.5f;
31.       }
32.     }
33.   });
35.   return {cA, cH, cV, cD};
36. }
38. cv::Mat idwt(const WaveletCoeffs& coeffs) {
39.   const cv::Mat& cA = coeffs.cA;
40.   const cv::Mat& cH = coeffs.cH;
41.   const cv::Mat& cV = coeffs.cV;
42.   const cv::Mat& cD = coeffs.cD;
44.   const int half_rows = cA.rows;
45.   const int half_cols = cA.cols;
46.   const int rows = half_rows * 2;
47.   const int cols = half_cols * 2;
48.   cv::Mat recovered = cv::Mat::zeros(rows, cols, CV_32FC1);
50.   // 在这里采用并行化
51.   cv::parallel_for_(cv::Range(0, half_rows), [&](const cv::Range& range) {
52.     for (int r = range.start; r < range.end; r++) {
53.       for (int c = 0; c < half_cols; c++) {
54.         const float val_cA = cA.at<float>(r, c);
55.         const float val_cH = cH.at<float>(r, c);
56.         const float val_cV = cV.at<float>(r, c);
57.         const float val_cD = cD.at<float>(r, c);
59.         recovered.at<float>(2 * r, 2 * c) = (val_cA + val_cH + val_cV + val_cD) * 0.5f;
60.         recovered.at<float>(2 * r, 2 * c + 1) = (val_cA - val_cH + val_cV - val_cD) * 0.5f;
61.         recovered.at<float>(2 * r + 1, 2 * c) = (val_cA + val_cH - val_cV - val_cD) * 0.5f;
62.         recovered.at<float>(2 * r + 1, 2 * c + 1) = (val_cA - val_cH - val_cV + val_cD) * 0.5f;
63.       }
64.     }
65.   });
67.   cv::Mat result{};
68.   recovered.convertTo(result, CV_8UC1);
70.   return result;
71. }
73. // >>> 融合耗时：12.6 ms

复制代码

可以看出速度并没有明显提升，有可能是上下文切换开销过高或者是线程调度不均匀导致的。
指针访问

另一种提升算法速度的便是在访问像素点时采用指针的形式访问。在OpenCV中访问矩阵的某个像素常采用的方式是mat.at();，在以上代码中则以const float val_cA = cA.at(r, c);形式出现。这种方法会先对该位置进行边界检查，再去访问。如果访问过于频繁，无疑会拖慢运行速度。因此在确保循环边界的情况下，可以直接使用指针操作来避免边界检查，形式如auto* r = mat.ptr();。不过需要注意，通过指针访问其参数只能有一个，即按行/列访问。
以下为仅将原版算法改为使用指针访问的小波变换算法。

1. cv::parallel_for_(cv::Range(0, half_rows), [&](const cv::Range& range) {
2.   for (int r = range.start; r < range.end; r++) {
3.     cv::parallel_for_(cv::Range(0, half_cols), [&](const cv::Range& range2) {
4.         for (int c = range2.start; c < range.end; c++) {
5.           ...
6.         }
7.     });
8.   }
9. });
11. // 融合耗时：12.8 ms

复制代码

可以看到，直接通过指针访问像素点，其运算速度已经达到了使用并行计算的速度，其效率提升是非常可观的。

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！