TBB、OpenMP、SSE、AVX加速sobel算子

最新推荐文章于 2024-01-31 13:58:38 发布
最新推荐文章于 2024-01-31 13:58:38 发布
阅读量480 收藏 6
点赞数 3
文章标签： c++ opencv
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SweetBonk/article/details/130480235
版权
该文展示了使用TBB（ThreadingBuildingBlocks）、OpenMP、SSE（StreamingSIMDExtensions）和AVX（AdvancedVectorExtensions）四种技术加速图像处理中Sobel梯度运算的方法。通过并行计算优化，提高处理速度。
摘要由CSDN通过智能技术生成

TBB加速

#include <tbb\tbb.h>
double TBB_Sobel(Mat srcImage, int kernelSize, Mat &gradX, Mat &gradY){
	class GetGradient
	{
	public:
		Mat *gx, *gy;//x和y方向梯度图
		Mat src;
		void operator()(const tbb::blocked_range<int> &r) const{//这个方法保证本对象可以调用迭代器的参数
			int step = src.step;
			int stepxy = gx->step;
			uchar *psrcImage = src.data;
			uchar *px = gx->data;
			uchar *py = gy->data;
			for (int rindex = r.begin(); rindex != r.end(); ++rindex){//!=
				for (int j = 1; j < src.cols - 1; j++)
				{
					gx->ptr<short>(rindex)[j] = (psrcImage[((rindex - 1)*step + j + 1)] + psrcImage[(rindex*step + j + 1)] * 2 + psrcImage[((rindex + 1)*step + j + 1)] - psrcImage[((rindex - 1)*step + j - 1)] - psrcImage[(rindex*step + j - 1)] * 2 - psrcImage[((rindex + 1)*step + j - 1)]);
					gy->ptr<short>(rindex)[j] = (psrcImage[(rindex - 1)*step + j - 1] + psrcImage[(rindex - 1)*step + j] * 2 + psrcImage[(rindex - 1)*step + j + 1] - psrcImage[(rindex + 1)*step + j - 1] - psrcImage[(rindex + 1)*step + j] * 2 - psrcImage[(rindex + 1)*step + j + 1]);
					
				}
			}
			}
	};
	gradX = Mat::zeros(srcImage.size(), CV_16SC1);//定义相同尺寸的矩阵保存x方向梯度图
	gradY = Mat::zeros(srcImage.size(), CV_16SC1);//定义相同尺寸的矩阵保存y方向梯度图
	//遍历,跳过第一行第一列和最后一行最后一列
	//----------------------------------------------------------------------------------------//
	GetGradient m_GetGradient;
	m_GetGradient.gx = &gradX;
	m_GetGradient.gy = &gradY;
	m_GetGradient.src = srcImage;
	parallel_for(blocked_range<int>(1, srcImage.rows - 1), m_GetGradient, auto_partitioner());
	//---------------------------------------------------------------------------------------//记录算法运行时间
	//convertScaleAbs(gradX, gradX);
	//convertScaleAbs(gradY, gradY);//
	return 0;
}

OpenMP加速

#include "omp.h"
double OpenMP_Sobel(Mat srcImage, int kernelSize, Mat &gradX, Mat &gradY){
	if (srcImage.empty() || srcImage.channels() != 1)
	{
		return -1;
	}
	if (srcImage.cols <= 3 || srcImage.rows <= 3)
	{
		return -1;
	}
	if (kernelSize != 3)
	{
		return -1;
	}
	gradX = Mat::zeros(srcImage.size(), CV_16SC1);//定义相同尺寸的矩阵保存x方向梯度图
	gradY = Mat::zeros(srcImage.size(), CV_16SC1);//定义相同尺寸的矩阵保存y方向梯度图
	int step = srcImage.step;
	int stepxy = gradX.step;//可以快速定位像素点在Mat中的地址
	uchar *psrcImage = srcImage.data;
	uchar *px = gradX.data;
	uchar *py = gradY.data;
	//------------------------------------------------------------------------------//
	//遍历,跳过第一行第一列和最后一行最后一列
#pragma omp parallel for
	for (int i = 1; i < srcImage.rows - 1; i++)
	{
		#pragma omp parallel for
		for (int j = 1; j < srcImage.cols - 1; j++)
		{
			gradX.ptr<short>(i)[j] = (psrcImage[((i - 1)*step + j + 1)] + psrcImage[(i*step + j + 1)] * 2 + psrcImage[((i + 1)*step + j + 1)] - psrcImage[((i - 1)*step + j - 1)] - psrcImage[(i*step + j - 1)] * 2 - psrcImage[((i + 1)*step + j - 1)]);
			gradY.ptr<short>(i)[j] = (psrcImage[(i - 1)*step + j - 1] + psrcImage[(i - 1)*step + j] * 2 + psrcImage[(i - 1)*step + j + 1] - psrcImage[(i + 1)*step + j - 1] - psrcImage[(i + 1)*step + j] * 2 - psrcImage[(i + 1)*step + j + 1]);
		}
	}
	//--------------------------------------------------------------------------------//记录算法运行时间
	return 0;
}

SSE

double SEE_Sobel(Mat srcImage, int kernelSize, Mat &gradX, Mat &gradY){
	if (srcImage.empty() || srcImage.channels() != 1)
	{
		return -1;
	}
	if (srcImage.cols <= 3 || srcImage.rows <= 3)
	{
		return -1;
	}
	if (kernelSize != 3)
	{
		return -1;
	}
	gradX = Mat::zeros(srcImage.size(), CV_16SC1);//定义相同尺寸的矩阵保存x方向梯度图
	gradY = Mat::zeros(srcImage.size(), CV_16SC1);//定义相同尺寸的矩阵保存y方向梯度图
	int step = srcImage.step;
	int stepxy = gradX.step;//可以快速定位像素点在Mat中的地址
	uchar *psrcImage = srcImage.data;
	uchar *px = gradX.data;
	uchar *py = gradY.data;
	__m128i Zero = _mm_setzero_si128();//定义一个全0整形寄存器向量，用于将uchar扩充为short
	//------------------------------------------------------------------------------//
	//遍历,跳过第一行第一列和最后一行最后一列
	int BlockSize = 8;//四列为步长遍历
	int Block = (srcImage.cols - 2) / BlockSize;//循环次数
	for (int i = 1; i < srcImage.rows-1 ; i++)
	{	
		int j = 1;
		unsigned char *First = psrcImage + (i-1) * step;
		unsigned char *Second = psrcImage + i*step;
		unsigned char *Third = psrcImage + (i + 1)*step;
		for (; j < (Block-1)*BlockSize; j+=BlockSize)
		{	
			
			//--------------------获得当前像素周围的八个的值，放到寄存器里-----------------------//
			__m128i FirstP0 = _mm_unpacklo_epi8(_mm_loadu_si128((__m128i*)(First + j - 1)),Zero);//一个寄存器存相邻16个元素,前8个像素和0合并，目的是扩充数据类型为short
			__m128i FirstP1 = _mm_unpacklo_epi8(_mm_loadu_si128((__m128i*)(First + j)),Zero);
			__m128i FirstP2 = _mm_unpacklo_epi8(_mm_loadu_si128((__m128i*)(First + j + 1)),Zero);
			__m128i SecondP0 = _mm_unpacklo_epi8(_mm_loadu_si128((__m128i*)(Second + j - 1)),Zero);
			__m128i SecondP2 = _mm_unpacklo_epi8(_mm_loadu_si128((__m128i*)(Second + j + 1)),Zero);
			__m128i ThirdP0 = _mm_unpacklo_epi8(_mm_loadu_si128((__m128i*)(Third + j - 1)),Zero);
			__m128i ThirdP1 = _mm_unpacklo_epi8(_mm_loadu_si128((__m128i*)(Third + j)),Zero);
			__m128i ThirdP2 = _mm_unpacklo_epi8(_mm_loadu_si128((__m128i*)(Third + j + 1)),Zero);
			
			__m128i Gx = _mm_add_epi16(_mm_add_epi16(_mm_sub_epi16(FirstP2, FirstP0), _mm_slli_epi16(_mm_sub_epi16(SecondP2, SecondP0), 1)), _mm_sub_epi16(ThirdP2, ThirdP0));
			__m128i Gy = _mm_add_epi16(_mm_add_epi16(_mm_sub_epi16(FirstP0, ThirdP0), _mm_slli_epi16(_mm_sub_epi16(FirstP1, ThirdP1), 1)), _mm_sub_epi16(FirstP2, ThirdP2));
			//左移一位数值翻倍
			_mm_storeu_si128((__m128i*)(px + i*stepxy + j*(stepxy / step)), Gx);
			_mm_storeu_si128((__m128i*)(py + i*stepxy + j*(stepxy / step)), Gy);//保存结果	
		}
		for (; j < srcImage.cols - 1; j++)//j=j+4
		{	
			gradX.ptr<short>(i)[j] = (psrcImage[((i - 1)*step + j + 1)] + psrcImage[(i*step + j + 1)] * 2 + psrcImage[((i + 1)*step + j + 1)] - psrcImage[((i - 1)*step + j - 1)] - psrcImage[(i*step + j - 1)] * 2 - psrcImage[((i + 1)*step + j - 1)]);
			gradY.ptr<short>(i)[j] = (psrcImage[(i - 1)*step + j - 1] + psrcImage[(i - 1)*step + j] * 2 + psrcImage[(i - 1)*step + j + 1] - psrcImage[(i + 1)*step + j - 1] - psrcImage[(i + 1)*step + j] * 2 - psrcImage[(i + 1)*step + j + 1]);

		}
	}
	//--------------------------------------------------------------------------------//记录算法运行时间
	//convertScaleAbs(gradX, gradX);
	//convertScaleAbs(gradY, gradY);
	//printf("无加速情况下索贝尔算子运行时间：%lf秒\n", cost_time);
	return 0;
}

AVX

double AVX_Sobel(Mat srcImage, int kernelSize, Mat &gradX, Mat &gradY){
	if (srcImage.empty() || srcImage.channels() != 1)
	{
		return -1;
	}
	if (srcImage.cols <= 3 || srcImage.rows <= 3)
	{
		return -1;
	}
	if (kernelSize != 3)
	{
		return -1;
	}
	//gradX = Mat::zeros(srcImage.size(), CV_8UC1);
	gradX = Mat::zeros(srcImage.size(), CV_16SC1);//定义相同尺寸的矩阵保存x方向梯度图
	gradY = Mat::zeros(srcImage.size(), CV_16SC1);//定义相同尺寸的矩阵保存y方向梯度图
	
	int step = srcImage.step;
	int stepxy = gradX.step;//可以快速定位像素点在Mat中的地址
	uchar *psrcImage = srcImage.data;
	uchar *px = gradX.data;
	uchar *py = gradY.data;
	__m256i Zero = _mm256_setzero_si256();//定义一个全0整形寄存器向量，用于将uchar扩充为short
	//------------------------------------------------------------------------------//
	//遍历,跳过第一行第一列和最后一行最后一列
	int BlockSize =16;//AVX步长设置为32
	int Block = (srcImage.cols - 2) / BlockSize;//循环次数
	for (int i = 1; i < srcImage.rows - 1; i++)
	{
		int j = 1;
		unsigned char *First = psrcImage + (i - 1) * step;
		unsigned char *Second = psrcImage + i*step;
		unsigned char *Third = psrcImage + (i + 1)*step;
		for (; j < (Block)*BlockSize; j += BlockSize)
		{

			//--------------------获得当前像素周围的八个的值，放到寄存器里-----------------------//
			//一个YMM寄存器存相邻32个元素,第0-7和16-23个元素和0合并，目的是扩充数据类型为short
			__m256i FirstP0 = _mm256_unpacklo_epi8(_mm256_permute4x64_epi64(_mm256_loadu_si256((__m256i*)(First + j - 1)), 216), Zero);
			__m256i FirstP1 = _mm256_unpacklo_epi8(_mm256_permute4x64_epi64(_mm256_loadu_si256((__m256i*)(First + j)), 216), Zero);
			__m256i FirstP2 = _mm256_unpacklo_epi8(_mm256_permute4x64_epi64(_mm256_loadu_si256((__m256i*)(First + j + 1)), 216), Zero);
			__m256i SecondP0 = _mm256_unpacklo_epi8(_mm256_permute4x64_epi64(_mm256_loadu_si256((__m256i*)(Second + j - 1)), 216), Zero);
			__m256i SecondP2 = _mm256_unpacklo_epi8(_mm256_permute4x64_epi64(_mm256_loadu_si256((__m256i*)(Second + j + 1)), 216), Zero);
			__m256i ThirdP0 = _mm256_unpacklo_epi8(_mm256_permute4x64_epi64(_mm256_loadu_si256((__m256i*)(Third + j - 1)), 216), Zero);
			__m256i ThirdP1 = _mm256_unpacklo_epi8(_mm256_permute4x64_epi64(_mm256_loadu_si256((__m256i*)(Third + j)), 216), Zero);
			__m256i ThirdP2 = _mm256_unpacklo_epi8(_mm256_permute4x64_epi64(_mm256_loadu_si256((__m256i*)(Third + j + 1)), 216), Zero);
			//-------------------------------------------------------//

			//------------------------计算梯度-----------------------//
			__m256i Gx = _mm256_add_epi16(_mm256_add_epi16(_mm256_sub_epi16(FirstP2, FirstP0), _mm256_slli_epi16(_mm256_sub_epi16(SecondP2, SecondP0), 1)), _mm256_sub_epi16(ThirdP2, ThirdP0));
			__m256i Gy = _mm256_add_epi16(_mm256_add_epi16(_mm256_sub_epi16(FirstP0, ThirdP0), _mm256_slli_epi16(_mm256_sub_epi16(FirstP1, ThirdP1), 1)), _mm256_sub_epi16(FirstP2, ThirdP2));
		    //-------------------------重新排列-----------------------------//

			_mm256_storeu_si256((__m256i*)(px + i*stepxy + j*(stepxy / step)), Gx);
           	_mm256_storeu_si256((__m256i*)(py + i*stepxy + j*(stepxy / step)), Gy);//保存结果
		}

		for (; j < srcImage.cols - 1; j++)//j=j+4
		{
			gradX.ptr<short>(i)[j] = (psrcImage[((i - 1)*step + j + 1)] + psrcImage[(i*step + j + 1)] * 2 + psrcImage[((i + 1)*step + j + 1)] - psrcImage[((i - 1)*step + j - 1)] - psrcImage[(i*step + j - 1)] * 2 - psrcImage[((i + 1)*step + j - 1)]);
			gradY.ptr<short>(i)[j] = (psrcImage[(i - 1)*step + j - 1] + psrcImage[(i - 1)*step + j] * 2 + psrcImage[(i - 1)*step + j + 1] - psrcImage[(i + 1)*step + j - 1] - psrcImage[(i + 1)*step + j] * 2 - psrcImage[(i + 1)*step + j + 1]);
		}
		
	}
	//--------------------------------------------------------------------------------//记录算法运行时间
	//printf("无加速情况下索贝尔算子运行时间：%lf秒\n", cost_time);
	return 0;
}
SweetBonk
关注
  • 3
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Sobel算法优化 AVX2与GPU
千人斩的博客
10-07 895
sobel算法的优化，AVX2与GPU
tbb-2020.1-win.zip
02-15
然后，设置OpenCV的构建选项，使其使用TBB进行多线程加速： ```cmake set(OpenCV_THREADS tbb) ``` 在Visual Studio中，确保项目配置正确，选择合适的构建目标（如Release），以利用优化和并行化。完成配置后，...
Opencv(C++)学习 TBB与OPENMP的加速效果实验与ARM上的实践(二)
最新发布
lez1021的博客
01-31 1837
在RV1106上测试openmp的加速效果
【AI PC端算法优化】四，一步步将Sobel边缘检测加速22倍
I good vegetable a!
04-16 1921
1. 前言 继续优化技术的探索，今天以一个3×33\times 33×3的Sobel算子进行边缘检测的算法为例来看看如何使用SSE指令集对其进行优化。 2. 原理介绍 众所周知，在传统的图像边缘检测算法中，最常用的一种算法是利用Sobel算子完成的。Sobel算子一共有222个，一个是检测水平边缘的算子，另一个是检测垂直边缘的算子。 Sobel算子的优点是可以利用快速卷积函数，简单有效，且对领域像...
【OpenCV】【openMP】使用openMP对sobel边缘检测算子加速研究
iefenghao的博客
12-19 1809
Sobel 算子常用于图像的边缘检测，计算公式如下 OpenMP加速方法计算尺寸为2304X2304，8位灰度掌纹图像的梯度图（或自行选自其他图像），计算采用OpenMP带来的加速比。 图像信息： 原图像： 步骤： （1）读取图像，转化为Mat矩阵，src为原图像 原图像： （2）对原图像进行横向运算，找出纵向边缘 Gx图像： （3）对原图像进行纵向运算，找出横向边缘 Gy图像： ...
C++进行代码加速、多线程等知识点。pthread、openomp进行多线程加速、SSE进行加速
yangdeshun888的博客
07-10 4577
1、关于多线性进行全局变量的使用的时候为什么需要加锁？ a、在多线程中对全局变量进行处理的时候，如果涉及到在线程中对全局变量进行赋值的话，则需要进行加锁。 如果不加锁的话，容易导致全局变量在某个线程中被修改后，影响另一线程的数据处理。 b、全局变量不加锁主要是为了数据处理的正正确性，而不是为了防止导致多个线程同时操作同一个数据时出现程序崩溃。因为这种情况是不会产生的。 下面是一个多线程对多...
TBB、OpenMP对比
Stone_石头
01-18 4418
1、TBB需要相当可观的重新设计程序，而OpenMP足够简单； 2、TBB不太适合并行化已有的实现（软件），它为新设计的并行程序培养一种好的编程风格和更高的抽象层； 3、在论文的实验中，OpenMP稍稍超过TBB； 4、TBB只能针对C++,如果程序基于C或者Fortran就用不上了； 5、TBB提供了并行容器，使得结构上的并行更加简单方便； 6、如果您的并行模式主要用于内建类型的有...
mandelbrot_tbb_openmp.rar_MPI_openmp mandelbrot
09-24
标题中的"mandelbrot_tbb_openmp.rar_MPI_openmp mandelbrot"指的是一个包含使用多线程技术（如Intel Threading Building Blocks (TBB) 和OpenMP）以及Message Passing Interface (MPI)来实现Mandelbrot集的程序。...
TBB vs openMP.docx
10-15
为了加速矩阵乘法，人们开发了多种并行计算技术，包括 Intel 的 TBB（Threading Building Blocks）和 OpenMP（Open Multi-Processing）。本文将对比 TBB 和 OpenMP 两种技术在矩阵乘法中的应用。 TBB（Threading ...
TBB vs openMP.pdf
10-15
总的来说，TBB和OpenMP都是为了加速多核处理器上的计算密集型任务。TBB更注重任务调度的灵活性和智能分区，而OpenMP则提供了一种简单易用的接口，允许程序员通过编译器指令控制并行行为。在实际应用中，选择哪个库取...
opencv-4.5.3-x86-vc16-shared-avx2-world-tbb.zip
09-13
自编opencv库，opencv4.5.3,32位，vs2019,avx2指令集优化，tbb并行框架 详细介绍：https://mangoroom.cn/shared/opencv-4-5-3-x86-vc16-shared-avx2-world-tbb.html
TBB/OpenMP/raw thread三种并发编程的取舍分析
热门推荐
yuwei629的专栏
07-11 1万+
繁简程度考虑因素 与 OpenMP 或英特尔® 线程构建模块（TBB）相比，本地线程编程模式采用了更为复杂的代码，因而其维护工作的难度也就相对较大。这样，您在适当的情况下，不妨使用英特尔® TBB 或 OpenMP，利用这些 API 的优势帮您创建并管理线程池：自动实现线程同步，自动完成排程。 编程语言、编译器支持及自由迁移考虑因素 如果您的代码采用 C++ 编写，
关于高性能计算（并行计算）的知识记录汇总（OpenMP、OpenCL、CUDA、TBB）
lihiajiaose的专栏
06-12 823
所以OpenCL的程序主线程，会根据系统中是几个核的多核CPU，那种架构的CPU（arm或者x86），有没有GPU，哪种GPU?intel,nvidia,amd等多家硬件厂商支持OpenCL，但是同时也有自己的小九九，比如nvidia的cuda，就提供了针对自己的更多的功能，而且函数上据说也更为高级。他的基本原理就是系统里边内置一个类似编译器，好像llvm,API的东西，软件写完的代码只有到最后的硬件执行的时候进行最终编译，这个编译过程似乎是通过系统里边的硬件驱动Driver，现在都还需要另外安装，
Intel Threading Building Blocks （TBB入门）
南山牧笛的博客
08-24 2251
TBB入门   获取TBB TBB的官方网站在http://threadingbuildingblocks.org/，可以在它的Downloads页面里找到Commercial Aligned Release，最新版是tbb20_014，Windows上开发需要下载tbb20_014oss_src.tar.gz和tbb20_014oss_win.tar.gz。其它支持的平台有linux和ma
灵活运用SIMD指令16倍提升Sobel边缘检测的速度（4000*3000的24位图像时间由480ms降低到30ms）
weixin_39450742的博客
07-11 481
本篇博文来自博主Imageshop，打赏或想要查阅更多内容可以移步至Imageshop。 转载自：https://www.cnblogs.com/Imageshop/p/7285564.html 侵删 　　这半年多时间，基本都在折腾一些基本的优化，有很多都是十几年前的技术了，从随大流的角度来考虑，研究这些东西在很多人看来是浪费时间了，即不能赚钱，也对工作能力提升无啥帮助。可我觉得人类所谓的幸福，可以分为物质档次的享受，还有更为复杂的精神上的富有，哪怕这种富有只是存在于短暂的自我满足中也是值得的。..
SSE图像算法优化系列九：灵活运用SIMD指令16倍提升Sobel边缘检测的速度（4000*3000的24位图像时间由480ms降低到30ms）。...
weixin_33881041的博客
08-04 308
　　这半年多时间，基本都在折腾一些基本的优化，有很多都是十几年前的技术了，从随大流的角度来考虑，研究这些东西在很多人看来是浪费时间了，即不能赚钱，也对工作能力提升无啥帮助。可我觉得人类所谓的幸福，可以分为物质档次的享受，还有更为复杂的精神上的富有，哪怕这种富有只是存在于短暂的自我满足中也是值得的。       闲话少说， SIMD指令集，这个古老的东西，从第一代开始算起，也快有近20年的历史了，...
X86 SSE/AVX指令集加速学习
I good vegetable a!
10-03 2309
使用SSE指令实现了一些简单函数，可以自定义事件函数测试加速比 #include &amp;quot;xmmintrin.h&amp;quot; #include &amp;quot;windows.h&amp;quot; #include &amp;quot;math.h&amp;quot; #include &amp;quot;iostream&amp;quot; using namespace std; typedef uns
并行计算效率对比
sinat_38183777的博客
12-31 1955
//Qt #include <QtCore/QCoreApplication> #include <QtConcurrent/QtConcurrent> #include <QFuture> #include <QList> //C++ #include <iostream> //OpenMP #include <omp.h&gt...
opencv 3.0 DPM Cascade 检测 （附带TBB和openMP加速）
05-26
TBB和OpenMP是常用的多线程库，可以加速DPM Cascade的检测。在使用TBB和OpenMP之前，需要先安装它们。在Linux系统中，可以通过以下命令安装： ``` sudo apt-get install libtbb-dev sudo apt-get install libomp-...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值