核心功能：如何使用 OpenCV parallel_for_ 实现代码并行化 OpenCV v4.8.0

已于 2023-10-08 14:04:18 修改
阅读量392 收藏
点赞数
分类专栏： OpenCV 4.8.0  说明文档 文章标签： opencv 人工智能 计算机视觉
于 2023-10-07 19:27:18 首次发布

上一个教程 ： 使用 XML 和 YAML 文件进行文件输入和输出

下一个教程 ： 使用通用内部函数矢量化代码

__
兼容性OpenCV >= 3.0

目标

本教程旨在演示如何使用 OpenCV parallel_for_ 框架轻松实现代码并行化。为了说明这一概念，我们将编写一个对图像进行卷积运算的程序。完整的教程代码在这里。

前提条件

并行框架

第一个先决条件是 OpenCV 采用并行框架。在 OpenCV 4.5 中，以下并行框架依次可用：

  • 英特尔线程构件（第三方库，应明确启用）
  • OpenMP（集成到编译器中，应明确启用）
  • APPLE GCD（系统范围，自动使用（仅限 APPLE）
  • Windows RT 并发（系统范围，自动使用（仅限 Windows RT）
  • Windows 并发（运行时的一部分，自动使用（仅限 Windows - MSVC++ >= 10）
  • Pthreads

如您所见，OpenCV 库中可使用多个并行框架。有些并行库是第三方库，必须在构建前在 CMake 中明确启用，而有些并行库则是平台自动提供的（如 APPLE GCD）。

竞赛条件

当多个线程同时尝试写入或读写特定内存位置时，就会出现竞赛条件。因此，我们可以将算法大致分为两类

  1. 只有一个线程向特定内存位置写入数据的算法。
    • 例如，在卷积中，即使多个线程在特定时间从一个像素读取数据，但只有一个线程向特定像素写入数据。
  2. 多个线程可写入单个内存位置的算法。
    • 查找轮廓、特征等。此类算法可能需要每个线程同时向全局变量添加数据。例如，在检测特征时，每个线程都会将各自图像部分的特征添加到一个公共向量中，从而产生竞争条件。

卷积

我们将以执行卷积为例，演示如何使用 parallel_for_ 来并行计算。这是一个不会导致竞赛条件的算法示例。

理论

卷积是一种广泛应用于图像处理的简单数学运算。在这里，我们在图像上滑动一个较小的矩阵（称为内核），像素值与内核中相应值的乘积之和就会得出输出中特定像素的值（称为内核的锚点）。根据内核中的值，我们可以得到不同的结果。在下面的示例中，我们使用了一个 3x3 内核（锚定在其中心），并对 5x5 矩阵进行卷积，生成一个 3x3 矩阵。输出的大小可以通过在输入中填充合适的值来改变。

在这里插入图片描述

卷积动画

有关不同内核及其作用的更多信息，请点击此处

在本教程中，我们将实现该函数的最简单形式，即接收灰度图像（1 个通道）和奇数长度的方形核并生成输出图像。该操作不会就地执行。

注意事项
我们可以临时存储一些相关像素，以确保在卷积过程中使用原始值，然后就地执行。不过，本教程的目的是介绍 parallel_for_函数，就地执行可能过于复杂。

伪代码

InputImage src, OutputImage dst, kernel(size n)
makeborder(src, n/2)
for each pixel (i, j) strictly inside borders, do:
{
    value := 0
    for k := -n/2 to n/2, do:
        for l := -n/2 to n/2, do:
            value += kernel[n/2 + k][n/2 + l]*src[i + k][j + l]

    dst[i][j] := value
}

对于 n 大小的内核，我们将添加一个 n/2 大小的边界来处理边缘情况。然后，我们运行两个循环，沿着内核移动，并将乘积相加求和。

实现

顺序执行

void conv_seq(Mat src, Mat &dst, Mat kernel)
{
 int rows = src.rows, cols = src.cols；
 dst = Mat(rows, cols, src.type())；
 // 处理边缘值
 // 使 border = kernel.rows / 2；
 int sz = kernel.rows / 2；
 copyMakeBorder(src, src, sz, sz, sz, sz, BORDER_REPLICATE)；
 for (int i = 0; i < rows; i++)
 {
 uchar *dptr = dst.ptr(i)；
 for (int j = 0; j < cols; j++)
 {
 double value = 0；
 for (int k = -sz; k <= sz; k++)
 {
 // 当我们创建一个 ptr 时，由于内存访问效率更高，结果会稍快一些。
 uchar *sptr = src.ptr(i + sz + k)；
 for (int l = -sz; l <= sz; l++)
 {
 value += kernel.ptr<double>(k + sz)[l + sz] * sptr[j + sz + l]；
 }
 }
 dptr[j] = saturate_cast<uchar>(value)；
 }
 }
}

我们首先制作一个与 src 大小相同的输出矩阵（dst），并为 src 图像添加边框（以处理边缘情况）。

 int rows = src.rows, cols = src.cols；
 dst = Mat(rows, cols, src.type())；
 // 处理边缘值
 // 使 border = kernel.rows / 2；
 int sz = kernel.rows / 2；
 copyMakeBorder(src, src, sz, sz, sz, sz, BORDER_REPLICATE);

然后，我们依次遍历源图像中的像素，计算内核值和邻近像素值。然后将值填入 dst 图像中的相应像素。

 for (int i = 0; i < rows; i++)
 {
 uchar *dptr = dst.ptr(i)；
 for (int j = 0; j < cols; j++)
 {
 double value = 0；
 for (int k = -sz; k <= sz; k++)
 {
 // 当我们创建一个 ptr 时，由于内存访问效率更高，结果会稍快一些。
 uchar *sptr = src.ptr(i + sz + k)；
 for (int l = -sz; l <= sz; l++)
 {
 value += kernel.ptr<double>(k + sz)[l + sz] * sptr[j + sz + l]；
 }
 }
 dptr[j] = saturate_cast<uchar>(value)；
 }
 }

并行执行

在查看顺序执行时，我们可以注意到每个像素都取决于多个相邻像素，但每次只编辑一个像素。因此，为了优化计算，我们可以利用现代处理器的多核架构，将图像分割成条状，并在每个条状上并行执行卷积。OpenCV cv::parallel_for_ 框架会自动决定如何高效地分割计算，并为我们完成大部分工作。

注意事项
虽然特定条纹中的像素值可能取决于条纹外的像素值，但这些操作只是只读操作，因此不会导致未定义的行为。

我们首先声明一个继承自 cv::ParallelLoopBody 的自定义类，并覆盖虚拟 void operator ()(const cv::Range& range) const。

class parallelConvolution : public ParallelLoopBody
{
private：
 Mat m_src, &m_dst；
 Mat m_kernel；
 int sz；
public：
 parallelConvolution(Mat src, Mat &dst, Mat kernel)
 ：m_src(src), m_dst(dst), m_kernel(kernel)
 {
 sz = kernel.rows / 2；
 }
 virtual void operator()(const Range &range) const CV_OVERRIDE
 {
 for (int r = range.start; r < range.end; r++)
 {
 int i = r / m_src.cols, j = r % m_src.cols；
 double value = 0；
 for (int k = -sz; k <= sz; k++)
 {
 uchar *sptr = m_src.ptr(i + sz + k)；
 for (int l = -sz; l <= sz; l++)
 {
 value += m_kernel.ptr<double>(k + sz)[l + sz] * sptr[j + sz + l]；
 }
 }
 m_dst.ptr(i)[j] = saturate_cast<uchar>(value)；
 }
 }
};

operator（）中的范围表示单个线程将处理的值的子集。根据需要，可能有不同的方法来分割范围，进而改变计算。

例如，我们可以

  1. 分割图像的整个遍历，并按以下方式获取 [row, col] 坐标（如上代码所示）：
 virtual void operator()(const Range &range) const CV_OVERRIDE
 {
 for (int r = range.start; r < range.end; r++)
 {
 int i = r / m_src.cols, j = r % m_src.cols；
 double value = 0；
 for (int k = -sz; k <= sz; k++)
 {
 uchar *sptr = m_src.ptr(i + sz + k)；
 for (int l = -sz; l <= sz; l++)
 {
 value += m_kernel.ptr<double>(k + sz)[l + sz] * sptr[j + sz + l]；
 }
 }
 m_dst.ptr(i)[j] = saturate_cast<uchar>(value)；
 }
 }

然后，我们将以下面的方式调用 parallel_for_ 函数：

 parallelConvolution obj(src, dst, kernel)；
 parallel_for_(Range(0, rows * cols), obj)；
  1. 分割行并计算每一行：
 virtual void operator()(const Range &range) const CV_OVERRIDE
 {
 for (int i = range.start; i < range.end; i++)
 {
 uchar *dptr = dst.ptr(i)；
 for (int j = 0; j < cols; j++)
 {
 double value = 0；
 for (int k = -sz; k <= sz; k++)
 {
 uchar *sptr = src.ptr(i+sz+k)；
 for (int l = -sz; l <= sz; l++)
 {
 value += kernel.ptr<double>(k + sz)[l + sz] * sptr[j + sz + l]；
 }
 }
 dptr[j] = saturate_cast<uchar>(value)；
 }
 }
 }

在这种情况下，我们使用不同的范围调用 parallel_for_ 函数：

 parallelConvolutionRowSplit obj(src, dst, kernel)；
 parallel_for_(Range(0, rows), obj)；

注释
在我们的案例中，两种实现方式的性能类似。在某些情况下，可能会有更好的内存访问模式或其他性能优势。

要设置线程数，可以使用：cv::setNumThreads。也可以使用 cv::parallel_for_ 中的 nstripes 参数指定分割的数量。例如，如果您的处理器有 4 个线程，设置 cv::setNumThreads(2) 或设置 nstripes=2 应该是一样的，因为默认情况下它将使用所有可用的处理器线程，但只在两个线程上分割工作负载。

注意事项
C++ 11 标准允许通过删除 parallelConvolution 类并用 lambda 表达式取而代之来简化并行执行：

 parallel_for_(Range(0, rows * cols), [&](const Range &range)
 {
 for (int r = range.start; r < range.end; r++)
 {
 int i = r / cols, j = r % cols；
 double value = 0；
 for (int k = -sz; k <= sz; k++)
 {
 uchar *sptr = src.ptr(i+sz+k)；
 for (int l = -sz; l <= sz; l++)
 {
 value += kernel.ptr<double>(k + sz)[l + sz] * sptr[j + sz + l]；
 }
 }
 dst.ptr(i)[j] = saturate_cast<uchar>(value)；
 }
 });

结果

  • 在 5x5 内核下， 512x512 输入
  5x5 内核的 512x512 输入上执行这两种实现所需的时间：
  该程序展示了如何使用 OpenCV parallel_for_ 函数，并比较了在一个 5x5 内核的 512x512 输入上顺序执行和并行执行的性能。
  的性能进行比较。
  卷积操作的性能
  使用方法
  ./a.out [image_path -- 默认为 lena.jpg］

  顺序执行： 0.0953564s
  并行执行： 0.0246762s 0.0246762s
  并行执行（行拆分）： 0.0248722s 0.0248722s
  • 使用 3x3 内核的 512x512 输入
  该程序展示了如何使用 OpenCV parallel_for_ 函数，并比较了顺序执行和并行执行的性能。
  的性能进行了比较。
  卷积操作的性能
  使用方法
  ./a.out [image_path -- 默认为 lena.jpg］

  顺序执行： 0.0301325s
  并行执行： 0.0117053s 0.0117053s
  并行执行（行拆分）： 0.0117894s 0.0117894s

并行执行的性能取决于 CPU 的类型。例如，在 4 核 8 线程 CPU 上，运行时间可能比顺序执行快 6 到 7 倍。有很多因素可以解释为什么我们没有达到 8 倍的速度：

  • 创建和管理线程的开销、
  • 并行运行的后台进程
  • 4 个硬件内核（每个内核 2 个逻辑线程）与 8 个硬件内核之间的差异。

在教程中，我们使用了水平渐变滤镜（如上面的动画所示），它能生成突出垂直边缘的图像。

在这里插入图片描述

HIRSHDZ327
关注
专栏目录
FFT.zip_FFT代码_fft opencv_opencv fft_opencv实现FFT
09-23
标题中的"FFT.zip_FFT代码_fft opencv_opencv fft_opencv实现FFT"表明这是一个关于使用OpenCV库在C++环境中实现快速傅里叶变换（Fast Fourier Transform, FFT）的代码集合。快速傅里叶变换是一种高效的算法，用于...
【opencv+OpenMP】OpenMP并行编程应用—加速OpenCV图像拼接算法
古月的博客
06-20 5471
OpenMP是一种应用于多处理器程序设计的并行编程处理方案，它提供了对于并行编程的高层抽象，只需要在程序中添加简单的指令，就可以编写高效的并行程序，而不用关心具体的并行实现细节，降低了并行编程的难度和复杂度。也正因为OpenMP的简单易用性，它并不适合于需要复杂的线程间同步和互斥的场合。 OpenCV中使用Sift或者Surf特征进行图像拼接的算法，需要分别对两幅或多幅图像进行特
opencv的并行处理cv::ParallelLoopBody
fb_941219的博客
02-28 1079
因此，cv::ParallelLoopBody 的作用就是实现并行处理算法，以提高图像或视频处理的速度。cv::Range 表示要处理的数据范围，这里是 cv::Range(0, image.rows)，表示从第 0 行到最后一行，这是对整个图像进行处理。函数接受两个参数：一个 cv::Range 对象和一个 cv::ParallelLoopBody 对象。类的自定义类，它的 operator() 函数将在多个线程上并行执行。函数，从而实现图像的并行处理。类的实例，也就是继承了。
OpenCV并行模块cv::parallel_for_选择并行后端
最新发布
qq_38429284的博客
09-09 525
项目使用到了opencv进行图像处理，其中有个函数需要对一个std::vector里面的图像进行图像处理，但是单张图像耗时较长导致整体处理耗时较长，此时可以用多线程的方式加快处理速度，偶然发现opencv有一个cv::parallel_for_模块可以快速实现这个效果。
OpenCV并行加速Parallel_for_与ParallelLoopBody教程
MIss-Y的博客
01-08 5624
前言：对于一些基本的循环运算，如果我们直接使用循环，即便是使用指针，运算效率也不高，如果我们使用并行计算，会大大提升运算效率，OpenCV里面的很多运算都是使用了并行加速的，本文主要介绍Parallel_for_与ParallelLoopBody教程的使用方法。我看了网上的很多教程，其实都是同一篇文章转来转去，而且版本比较低，决定自己写一篇，本文使用OpenCV4.1.1 ，需要使用 <...
opencv之并行计算多线程parallel_for_
整理ing
09-30 2440
需要注意的是，多线程处理可能会引入一些额外的开销，包括线程创建和管理、数据同步等。因此，在使用多线程之前，你需要仔细评估你的应用场景和代码性能，并根据实际情况进行调整和优化。在上面的示例中，我们创建了一个包含4个线程的线程池，并将图像传递给线程池中的任务进行并行处理。是的，OpenCV提供了多线程处理的API。25 // 在这里对图像进行处理，例如进行灰度转换。23 // 将图像传递给线程池中的任务进行并行处理。12 // 创建一个线程池，包含4个线程。
OpenCV对的并行处理
2301_81887304的博客
01-26 1045
在深入学习的同时，也可以探索自己感兴趣的方向，为求职面试打好基础。如果你从入门时就确认了未来的工作方向，可以在第二阶段就提前阅读相关入门书籍（对应“商业落地五大方向”中的前两本），然后再“哪里不会补哪里”。因此，第一阶段只推荐4本最必要的书（而且这些书到了第二、三阶段也能继续用），入门以后，在后续学习中再“哪里不会补哪里”即可。OpenCV 有自己的 DNN 推理模块，该模块具有自己的内置引擎，但也可以使用其他库来优化处理。中使用了以下构建选项，可以通过设置选项将这些额外的模块添加到最终构建中。
如何解决“library load load opencv_core_parallel_tbb460_64d.dll =＞FAILED”类的信息
qq_40276533的博客
02-16 5414
解决不使用tbb但是报tbb failed的信息
opencv4.8.0-opencv4.9.0-opencv-contrib4.8.0-opencv-contrib4.9.0
05-15
2. opencv_contrib 4.8.0和4.9.0的源代码，包含额外的模块和实验性功能。 3. 编译脚本和配置文件，帮助用户配置和构建OpenCV库。 4. 文档和示例代码，供用户学习和参考OpenCV的使用方法。 了解并掌握OpenCV库的这两...
opencv_videoio_ffmpeg.dll和opencv_videoio_ffmpeg_64.dll
01-12
为了充分利用OpenCV的视频处理功能，开发者需要了解如何正确配置这些库文件，并掌握如何使用`cv::VideoCapture`和`cv::VideoWriter`等核心类进行视频读取和写入。此外，深入理解FFmpeg的编码和解码机制，以及不同...
Visual C++ opencv.rar_.net_opencv C_visual c opencv_代码解析_识别
09-21
在本资源包中，我们关注的是使用OpenCV库在Visual C++环境中进行图像识别的实践。OpenCV（开源计算机视觉库）是一个强大的跨平台库，主要用于实时图像处理、计算机视觉以及机器学习。以下是对该主题的详细解释： 1....
opencv_videoio_ffmpeg_64.dll
02-26
在计算机视觉和人工智能领域，OpenCV（开源计算机视觉库）是一个广泛使用的工具，它提供了丰富的功能，包括图像处理、特征检测、对象识别等。而FFmpeg则是一个强大的多媒体处理框架，支持音频和视频的编码、解码以及...
OpenCV 并行计算函数 parallel_for_ 的使用
热门推荐
泠山的博客
07-22 1万+
任务描述：我要定义两个Mat矩阵的逐元素乘积，如下所示（1）自定义一个类继承自 ParallelLoopBody，并且重载括号运算class ParallelAdd : public ParallelLoopBody //参考官方给出的answer，构造一个并行的循环体类 {public :ParallelAdd(Mat & _src1 , Mat & _src2 , Mat _result) //构造函数 {
【竹篮打水】OpenCV4.x 中新增并行代码执行演示
关注微信公众号【OpenCV学堂】
02-26 386
本以为可以并行加速，结果难以如愿~~~~
load opencv videoio gstreamer453 64d dll failed 打开摄像头慢
uk346575290的博客
12-24 6322
环境：win10+opencv4.5.3+opencv_contrib-4.5.3+vs2019 状态：禁用笔记本自带摄像头，使用webcam 问题 配置好opencv和contrib库后，通过opencv打开webcam，发现无论debug还是release编译起图非常慢，而且有一些fail的提示。 #include <opencv2/opencv.hpp> #include <iostream> using namespace std; using namespace cv;
OpenCV并行化代码：使用parallel_for在C/C++中实现并行计算
PixelProX的博客
09-06 322
来定义要处理的像素范围，这里是图像像素的总数。在这个例子中，我们将像素从输入图像复制到输出图像。以上是一个简单示例，你可以根据自己的需求和具体的图像处理任务进行修改和扩展。此外，为了实现正确的并行化，我们需要确保并行执行的操作之间没有数据依赖性。在主函数中，我们加载图像并创建一个等大小的输出图像，用于存储处理后的结果。的函数，它可以帮助我们实现并行化计算。函数，我们可以将图像处理操作并行化，从而加快处理速度。函数显示输入图像和处理后的输出图像，并使用。接下来，我们定义一个函数，该函数将作为。
OpenCV 中的并行计算刍议
爱CV
07-13 1338
作者：江博文 （OpenCV中国团队实习生，澳门大学硕士研究生） 在 CPU 主频遭遇瓶颈的当下，为提高软件性能，减少循环次数，需要对代码进行并行优化。一般而言，并行计算会在以下三个不同维度进行： 矢量并行化：利用 CPU 内的矢量寄存器执行 SIMD 运算，单条指令对矢量中的多个数据进行操作，其目的是提高 CPU 单个核心的运算能力。 线程并行化：将单个进程分散到多条合作线程中，共同处理任务，其目的是提高多核 CPU 的运算能力。 分布式内存并行化：利用 MPI 在...
OpenCV算法加速的一些学习总结
Yangy_Jiaojiao的博客
04-17 5335
Opencv算子加速 TBB、SSE、OpenMP、AVX加速学习总结
cv::parallel_for_
06-07
cv::parallel_for_ 是 OpenCV 中的一个函数，用于在多个线程上并行执行一个 for 循环。它可以显著提高图像处理的效率。该函数的用法如下： ```cpp cv::parallel_for_(cv::Range(0, n), [&](const cv::Range& range) { for (int i = range.start; i < range.end; i++) { // 待并行执行的代码 } }); ``` 其中，第一个参数是一个 cv::Range 对象，用于指定循环的范围（从 0 到 n-1）。第二个参数是一个 lambda 函数，用于执行具体的操作。在 lambda 函数中，我们可以通过 range.start 和 range.end 访问当前线程需要处理的循环范围。需要注意的是，lambda 函数必须是可复制的，因为它会被多个线程同时执行。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值