SSE算法优化系列4：使用SSE优化Sobel边缘检测算法，加速比9.5倍

最新推荐文章于 2023-07-13 10:52:00 发布
最新推荐文章于 2023-07-13 10:52:00 发布
阅读量2.7k 收藏 14
点赞数 1
分类专栏： 数字图像处理论文和算法复现 SSE图像算法优化
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/just_sort/article/details/96282437
版权

前言

仍然是学习Imageshop的文章，https://www.cnblogs.com/Imageshop/p/7285564.html 。做了一个小总结，并且完整实现了这个SSE优化的算法，可以关注我专门用SIMD优化图像处理算法的工程：https://github.com/BBuf/Image-processing-algorithm-Speed

传统的Sobel算法实现

我之前写过Sobel边缘检测算法如何产生X方向和方向的系数，https://blog.csdn.net/just_sort/article/details/85015054 。具体原理就不再赘述，这里原理就不再叙述了，给出指针版本实现的边缘检测算法。

inline unsigned char IM_ClampToByte(int Value)
{
	if (Value < 0)
		return 0;
	else if (Value > 255)
		return 255;
	else
		return (unsigned char)Value;
	//return ((Value | ((signed int)(255 - Value) >> 31)) & ~((signed int)Value >> 31));
}

void Sobel_FLOAT(unsigned char *Src, unsigned char *Dest, int Width, int Height, int Stride) {
	int Channel = Stride / Width;
	unsigned char *RowCopy = (unsigned char*)malloc((Width + 2) * 3 * Channel);
	unsigned char *First = RowCopy;
	unsigned char *Second = RowCopy + (Width + 2) * Channel;
	unsigned char *Third = RowCopy + (Width + 2) * 2 * Channel;
	//拷贝第二行数据，边界值填充
	memcpy(Second, Src, Channel);
	memcpy(Second + Channel, Src, Width*Channel);
	memcpy(Second + (Width + 1)*Channel, Src + (Width - 1)*Channel, Channel);
	//第一行和第二行一样
	memcpy(First, Second, (Width + 2) * Channel);
	//拷贝第三行数据，边界值填充
	memcpy(Third, Src + Stride, Channel);
	memcpy(Third + Channel, Src + Stride, Width * Channel);
	memcpy(Third + (Width + 1) * Channel, Src + Stride + (Width - 1) * Channel, Channel);

	for (int Y = 0; Y < Height; Y++) {
		unsigned char *LinePS = Src + Y * Stride;
		unsigned char *LinePD = Dest + Y * Stride;
		if (Y != 0) {
			unsigned char *Temp = First;
			First = Second;
			Second = Third;
			Third = Temp;
		}
		if (Y == Height - 1) {
			memcpy(Third, Second, (Width + 2) * Channel);
		}
		else {
			memcpy(Third, Src + (Y + 1) * Stride, Channel);
			memcpy(Third + Channel, Src + (Y + 1) * Stride, Width * Channel);                            //    由于备份了前面一行的数据，这里即使Src和Dest相同也是没有问题的
			memcpy(Third + (Width + 1) * Channel, Src + (Y + 1) * Stride + (Width - 1) * Channel, Channel);
		}
		if (Channel == 1) {
			for (int X = 0; X < Width; X++)
			{
				int GX = First[X] - First[X + 2] + (Second[X] - Second[X + 2]) * 2 + Third[X] - Third[X + 2];
				int GY = First[X] + First[X + 2] + (First[X + 1] - Third[X + 1]) * 2 - Third[X] - Third[X + 2];
				LinePD[X] = IM_ClampToByte(sqrtf(GX * GX + GY * GY + 0.0F));
			}
		}
		else
		{
			for (int X = 0; X < Width * 3; X++)
			{
				int GX = First[X] - First[X + 6] + (Second[X] - Second[X + 6]) * 2 + Third[X] - Third[X + 6];
				int GY = First[X] + First[X + 6] + (First[X + 3] - Third[X + 3]) * 2 - Third[X] - Third[X + 6];
				LinePD[X] = IM_ClampToByte(sqrtf(GX * GX + GY * GY + 0.0F));
			}
		}
	}
	free(RowCopy);
}

这个边缘检测算的代码写得很好，因为这个代码不仅仅支持了In-Place操作（就是Src核Dest可以是同一块内存），而且支持图像边界处理。这段代码使用I7-8770CPU测试得速度为192.01ms。

优化1：去掉浮点数

由于该Sobel的过程最后是把数据用图像的方式记录下来，因此，IM_ClampToByte(sqrtf(GX * GX + GY * GY + 0.0F))可以用查表的方式来实现。简单改成如下的版本， 避免了浮点计算。

void Sobel_INT(unsigned char *Src, unsigned char *Dest, int Width, int Height, int Stride) {
	int Channel = Stride / Width;
	unsigned char *RowCopy = (unsigned char*)malloc((Width + 2) * 3 * Channel);
	unsigned char *First = RowCopy;
	unsigned char *Second = RowCopy + (Width + 2) * Channel;
	unsigned char *Third = RowCopy + (Width + 2) * 2 * Channel;
	//拷贝第二行数据，边界值填充
	memcpy(Second, Src, Channel);
	memcpy(Second + Channel, Src, Width*Channel);
	memcpy(Second + (Width + 1)*Channel, Src + (Width - 1)*Channel, Channel);
	//第一行和第二行一样
	memcpy(First, Second, (Width + 2) * Channel);
	//拷贝第三行数据，边界值填充
	memcpy(Third, Src + Stride, Channel);
	memcpy(Third + Channel, Src + Stride, Width * Channel);
	memcpy(Third + (Width + 1) * Channel, Src + Stride + (Width - 1) * Channel, Channel);

	unsigned char Table[65026];
	for (int Y = 0; Y < 65026; Y++) Table[Y] = (sqrtf(Y + 0.0f) + 0.5f);
	for (int Y = 0; Y < Height; Y++) {
		unsigned char *LinePS = Src + Y * Stride;
		unsigned char *LinePD = Dest + Y * Stride;
		if (Y != 0) {
			unsigned char *Temp = First;
			First = Second;
			Second = Third;
			Third = Temp;
		}
		if (Y == Height - 1) {
			memcpy(Third, Second, (Width + 2) * Channel);
		}
		else {
			memcpy(Third, Src + (Y + 1) * Stride, Channel);
			memcpy(Third + Channel, Src + (Y + 1) * Stride, Width * Channel);                            //    由于备份了前面一行的数据，这里即使Src和Dest相同也是没有问题的
			memcpy(Third + (Width + 1) * Channel, Src + (Y + 1) * Stride + (Width - 1) * Channel, Channel);
		}
		if (Channel == 1) {
			for (int X = 0; X < Width; X++)
			{
				int GX = First[X] - First[X + 2] + (Second[X] - Second[X + 2]) * 2 + Third[X] - Third[X + 2];
				int GY = First[X] + First[X + 2] + (First[X + 1] - Third[X + 1]) * 2 - Third[X] - Third[X + 2];
				LinePD[X] = Table[min(GX * GX + GY * GY, 65025)];
			}
		}
		else
		{
			for (int X = 0; X < Width * 3; X++)
			{
				int GX = First[X] - First[X + 6] + (Second[X] - Second[X + 6]) * 2 + Third[X] - Third[X + 6];
				int GY = First[X] + First[X + 6] + (First[X + 3] - Third[X + 3]) * 2 - Third[X] - Third[X + 6];
				LinePD[X] = Table[min(GX * GX + GY * GY, 65025)];
			}
		}
	}
	free(RowCopy);
}

速度测试的结果是91.20ms，比浮点数计算快了大概2倍，还是很不错的。

优化2：SSE优化

在第二段代码的基础上，我们来考虑一下SSE优化的位置，对于灰度图的优化是没有必要，因为在计算的时候每次只和3个像素相关。而我们来看BGR图的计算时，

for (int X = 0; X < Width * 3; X++)
			{
				int GX = First[X] - First[X + 6] + (Second[X] - Second[X + 6]) * 2 + Third[X] - Third[X + 6];
				int GY = First[X] + First[X + 6] + (First[X + 3] - Third[X + 3]) * 2 - Third[X] - Third[X + 6];
				LinePD[X] = Table[min(GX * GX + GY * GY, 65025)];
}

里面涉及到了8个不同的像素，考虑计算的特性和数据的范围，在内部计算时这个int可以用short代替，也就是要把加载的字节图像数据转换为short类型先，这样SSE优化方式为用8个SSE变量分别记录8个连续的像素风量的颜色值，每个颜色值用16位数据表达。这可以使用_mm_unpacklo_epi8配合_mm_loadl_epi64实现：

__m128i FirstP0 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i *)(First + X)), Zero);
__m128i FirstP1 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i *)(First + X + 3)), Zero);
__m128i FirstP2 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i *)(First + X + 6)), Zero);

__m128i SecondP0 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i *)(Second + X)), Zero);
__m128i SecondP2 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i *)(Second + X + 6)), Zero);

__m128i ThirdP0 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i *)(Third + X)), Zero);
__m128i ThirdP1 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i *)(Third + X + 3)), Zero);
__m128i ThirdP2 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i *)(Third + X + 6)), Zero);

接下来就是对GX和GY的计算：

__m128i GX16 = _mm_abs_epi16(_mm_add_epi16(_mm_add_epi16(_mm_sub_epi16(FirstP0, FirstP2), _mm_slli_epi16(_mm_sub_epi16(SecondP0, SecondP2), 1)), _mm_sub_epi16(ThirdP0, ThirdP2)));
__m128i GY16 = _mm_abs_epi16(_mm_sub_epi16(_mm_add_epi16(_mm_add_epi16(FirstP0, FirstP2), _mm_slli_epi16(_mm_sub_epi16(FirstP1, ThirdP1), 1)), _mm_add_epi16(ThirdP0, ThirdP2)));

这个时候的GX16和GY16里保存的是8个16位的中间结果，由于SSE只提供了浮点数的sqrt操作，我们必须将它们转换为浮点数，那么这个转换的第一步就必须是先将它们转换为int的整形数，这样，就必须一个拆成2个，即：

__m128i GX32L = _mm_unpacklo_epi16(GX16, Zero);
__m128i GX32H = _mm_unpackhi_epi16(GX16, Zero);
__m128i GY32L = _mm_unpacklo_epi16(GY16, Zero);
__m128i GY32H = _mm_unpackhi_epi16(GY16, Zero);

接下来分别对高位低位进行平方运算：

__m128i ResultL = _mm_cvtps_epi32(_mm_sqrt_ps(_mm_cvtepi32_ps(_mm_add_epi32(_mm_mullo_epi32(GX32L, GX32L), _mm_mullo_epi32(GY32L, GY32L)))));
				__m128i ResultH = _mm_cvtps_epi32(_mm_sqrt_ps(_mm_cvtepi32_ps(_mm_add_epi32(_mm_mullo_epi32(GX32H, GX32H), _mm_mullo_epi32(GY32H, GY32H)))));

最后一步，得到8个int型的结果，这个结果有要转换为字节类型的，并且这些数据有可能会超出字节所能表达的范围，所以就需要用到SSE自带的抗饱和向下打包函数了，如下所示：

_mm_storel_epi64((__m128i *)(LinePD + X), _mm_packus_epi16(_mm_packus_epi32(ResultL, ResultH), Zero));

这里如ImageShop指出的需要特别注意一个细节。
转自ImageShop：
　通常，我们都是对像素的字节数据进行向上扩展，他们都是正数，所以用unpack之类的配合zero把高8位或高16位的数据填充为0就可以了，但是在本例中，GX16或者GY16很有可能是负数，而负数的最高位是符号位，如果都填充为0，则变为正数了，明显改变原始的数据了，所以得到了错误的结果。
　　那如何解决问题呢，对于本例，很简单，因为后面只有一个平方操作，因此，对GX先取绝对值是不会改变计算的结果的，这样就不会出现负的数据了，修改之后，果然结果正确。

还有更加高级的优化方式，可以减少SIMD指令的个数：
在这里插入图片描述我实现了使用_mm_madd_epi16的优化，代码在github: https://github.com/BBuf/Image-processing-algorithm-Speed/blob/master/speed_sobel_edgedetection_sse.cpp 。

最后的速度测试结果为21.14ms。相对于原始的C语言实现加速了9倍。

给个效果图

在这里插入图片描述在这里插入图片描述

参考博客

https://www.cnblogs.com/Imageshop/p/7285564.html

just_sort
关注
  • 1
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 9
    评论
专栏目录
卷积运算--Sobel算子边缘提取代码复现---python（tensorflow）
qq_37588821的博客
04-28 1394
概述 卷积 从公式可以看出来对原函数平移并与核相乘，就是信号与系统中学的卷积运算。 在图像卷积中，即每个核的中心点对应的位置进行卷积，滑窗方法就是上面的卷积公式。 sobel算子是一种经典的边缘提取算子，以sobel为例进行卷积运算。 代码 # -*- coding: utf-8 -*- """ Created on Fri Apr 26 03:01:26 2019 sobel ...
数字集成电路设计-8-一个简单sobel图像边缘检测加速器的设计，实现，仿真与综合
Rill的专栏
10-09 6281
引言图像视频处理等多媒体领域是FPGA应用的最主要的方面之一，而在图像处理中，边缘检测是图像处理和计算机视觉中的基本问题，所以也是最常用的，随着数据量的不断增加以及对实时性的要求，一般软件已经不能满足实际需要，这时，就需要专门的硬件来实现加速。本小节就实现一个简单的sobel边缘检测加速器，为了便于对比，我们还编写对应的软件算法。1，基本思想与算法Sobel检测法通过一个叫做卷积的过程来估计每个像
【AI PC端算法优化】四，一步步将Sobel边缘检测加速22倍
I good vegetable a!
04-16 1956
1. 前言 继续优化技术的探索，今天以一个3×33\times 33×3的Sobel算子进行边缘检测的算法为例来看看如何使用SSE指令集对其进行优化。 2. 原理介绍 众所周知，在传统的图像边缘检测算法中，最常用的一种算法是利用Sobel算子完成的。Sobel算子一共有222个，一个是检测水平边缘的算子，另一个是检测垂直边缘的算子。 Sobel算子的优点是可以利用快速卷积函数，简单有效，且对领域像...
SSE指令集算法优化
weixin_40593924的博客
03-19 1109
先挖个坑，记录下资料。 REF 1、（c/c++ 代码中使用sse指令集加速）https://www.cnblogs.com/dragon2012/p/5200698.html 2、SSE指令指令集进行程序加速、DCT的优化处理（https://blog.csdn.net/yangdashi888/article/detail...
SSE优化引擎
06-27 2553
<br />周末在家尝试着使用sse对引擎进行优化。<br /> <br />关于如何使用sse这里并不多说，有很多资料，这里提一下，使用sse无非就是直接使用汇编或是使用函数指令，如果是诸如解码器核心之类的推荐使用汇编直接进行优化，毕竟可以将核心全部用汇编实现，其他情况下使用sse函数指令即可。<br /> <br />接下来说一下sse在3D引擎中的优化。可优化的地方很多，但总的来说绝大部分优化都集中在了数学运算，3D游戏的数学运算基本上都是向量运算非常适合进行sse优化，一般情况下把数学模块优化好也基
SSE 优化
vicavo的专栏
08-21 1720
SSE 是Intel公司的单指令多数据流式扩展（SSE，Streaming SIMD Extensions）技术能够有效增强CPU浮点运算的能力。 在写算法的过程中可以对算法进行提速。 参考如下： https://www.cnblogs.com/Imageshop/category/535367.html https://www.cnblogs.com/mqxs/p/3715832....
使用SSE指令集来优化程序
百里杨的博客
08-24 3882
SSE和SSE2的指令系统非常相似，SSE2比SSE多的仅是少量的额外浮点处理功能、64位浮点数运算支持和64位整数运算支持。 SSE为什么会比传统的浮点运算更快呢？因为它使用了128位的存储单元，这对于32位的浮点数来讲，是可以存下4个的，也就是说，SSE中的所有计算都是一次性针对4个浮点数来完成的。 虽然SSE从理论上来讲要比传统的浮点运算会快，但是所受的限制也很多，首先，虽然它执行一次相当于四次，会比传统的浮点运算执行4次的速度要快，但是它执行一次的速度却并没有想象中的那...
基于FPGA的Sobel图像边缘检测算法-论文
05-19
Sobel算法是一种广泛使用的图像边缘检测方法，它通过计算图像亮度的梯度来识别边缘。本文中详细阐述了如何使用FPGA来实现Sobel边缘检测算法，并通过MATLAB软件联合仿真，以验证FPGA图像处理的可靠性并得到满意的效果...
基于matlab的八个方向sobel图像边缘检测算法
05-15
**基于MATLAB的八个方向Sobel图像边缘检测算法详解** Sobel边缘检测是一种常见的数字图像处理技术，用于识别图像中的边缘。它通过计算图像中像素的梯度强度和方向来定位边缘。在MATLAB中实现Sobel边缘检测，我们...
Sobel边缘检测算法
08-01
Sobel边缘检测算法是计算机视觉领域中一种经典的图像处理技术，主要用于识别图像的边缘，从而帮助提取出图像的重要特征。边缘检测是图像分析的关键步骤，它有助于减少数据量，同时保留图像的主要结构信息。 Sobel...
SSE指令集SSE优化手册
12-18
SSE指令集SSE优化手册，SSE指令 SIMD优化
sse浮点运算优化实例
04-02
这是一个浮点运算的sse优化实例 c++,计算速度提高4倍
sobel算子_【AI PC端算法优化】四，一步步将Sobel边缘检测加速22倍
weixin_39988197的博客
12-04 539
1. 前言继续优化技术的探索，今天以一个的Sobel算子进行边缘检测的算法为例来看看如何使用SSE指令集对其进行优化。2. 原理介绍众所周知，在传统的图像边缘检测算法中，最常用的一种算法是利用Sobel算子完成的。Sobel算子一共有个，一个是检测水平边缘的算子，另一个是检测垂直边缘的算子。Sobel算子的优点是可以利用快速卷积函数，简单有效，且对领域像素位置的影响做了加权，可以降低边缘模糊程度，...
SSE指令优化一例
slamer的专栏
03-11 3269
前两天为了加速一段求梯度的代码，用了SSE指令，在实验室PMH大侠的指导下，最终实现了3倍速度提升（极限是4倍，因为4个浮点数一起计算）。在这里写一下心得，欢迎拍砖。 SSE加速的几个关键是 (1) 用于并行计算的数据结构要16字节对齐 (2) 直接写汇编，不要用SSE的Load Store指令 (3) 对于SSE本身不提供的三角函数等指令，可以用查表法，但要用SSE来算索引号
SSE优化系列十一：SSE优化三次卷积插值算法
I good vegetable a!
08-28 2113
前言
SSE图像算法优化系列三十一：RGB2HSL/RGB2HSV及HSL2RGB/HSV2RGB的指令集优化-上。
最新发布
PixelDemon的博客
07-13 249
RGB和HSL/HSV颜色空间的相互转换在我们的图像处理中是有着非常广泛的应用的，无论是是图像调节，还是做一些肤色算法，HSL/HSV颜色空间都非常有用，他提供了RGB颜色空间不具有的一些独特的特性，但是由于HSL/HSV颜色空间的复杂性，他们之间的转换的效率一直不是很高的，有一些基于定点算法的尝试，对速度有一定的提升，但一个是提升不是特别的明显，另外就是对结果的精度有一定的影响。...
optimize_aop.hdev对sobel边缘检测算子 AOP的对不同大小图像并行加速效果 相关例程学习
SRT字符不够的博客
10-09 1174
index:.../System/Parallelization/optimize_aop.hdev * This example program shows the difference of AOP (automatic * operator parallelization) models that can be trained using * optimize_aop. The
FPGA实现Sobel边缘检测算法在水文监测中的应用
Sobel边缘检测算法是一种广泛使用的局部差分算子，适用于检测图像中的阶梯状、屋顶状和线性边缘。该算法通过计算图像的水平和垂直方向的梯度，结合这两个方向的梯度信息，确定边缘的位置。Sobel算子的优势在于其平滑...
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值