【AI PC端算法优化】八，小半径中值滤波的SSE极速优化

最新推荐文章于 2021-09-03 09:43:36 发布
最新推荐文章于 2021-09-03 09:43:36 发布
阅读量872 收藏 4
点赞数 2
分类专栏： SSE图像算法优化
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/just_sort/article/details/106463160
版权

1. 前言

大家应该经常碰到这种需求，那就是使用 3 × 3 3\times 3 3×3或者 5 × 5 5\times 5 5×5这种相对比较小的窗口进行中值滤波，而如果在图像的分辨率比较大的情况下这种操作也是比较耗时的。所以在这种固定场景下定制一个优化算法是有意义的。（这里针对PC端，而非Arm端）。

2. 普通的3*3中值滤波实现

普通的实现没什么好说，就是直接在窗口区域内遍历寻找中位数即可，这里获取中值直接使用了c语言的qsort。代码实现如下：

int ComparisonFunction(const void *X, const void *Y) {
	unsigned char Dx = *(unsigned char *)X;
	unsigned char Dy = *(unsigned char *)Y;
	if (Dx < Dy) return -1;
	else if (Dx > Dy) return 1;
	else return 0;
}

void MedianBlur3X3_Ori(unsigned char *Src, unsigned char *Dest, int Width, int Height, int Stride) {
	int Channel = Stride / Width;
	if (Channel == 1) {
		unsigned char Array[9];
		for (int Y = 1; Y < Height - 1; Y++) {
			unsigned char *LineP0 = Src + (Y - 1) * Stride + 1;
			unsigned char *LineP1 = LineP0 + Stride;
			unsigned char *LineP2 = LineP1 + Stride;
			unsigned char *LinePD = Dest + Y * Stride + 1;
			for (int X = 1; X < Width - 1; X++) {
				Array[0] = LineP0[X - 1];        Array[1] = LineP0[X];    Array[2] = LineP0[X + 1];
				Array[3] = LineP1[X - 1];        Array[4] = LineP1[X];    Array[5] = LineP2[X + 1];
				Array[6] = LineP2[X - 1];        Array[7] = LineP2[X];    Array[8] = LineP2[X + 1];
				qsort(Array, 9, sizeof(unsigned char), &ComparisonFunction);
				LinePD[X] = Array[4];
			}
		}
	}
	else {
		unsigned char ArrayB[9], ArrayG[9], ArrayR[9];
		for (int Y = 1; Y < Height - 1; Y++) {
			unsigned char *LineP0 = Src + (Y - 1) * Stride + 3;
			unsigned char *LineP1 = LineP0 + Stride;
			unsigned char *LineP2 = LineP1 + Stride;
			unsigned char *LinePD = Dest + Y * Stride + 3;
			for (int X = 1; X < Width - 1; X++){
				ArrayB[0] = LineP0[-3];       ArrayG[0] = LineP0[-2];       ArrayR[0] = LineP0[-1];
				ArrayB[1] = LineP0[0];        ArrayG[1] = LineP0[1];        ArrayR[1] = LineP0[2];
				ArrayB[2] = LineP0[3];        ArrayG[2] = LineP0[4];        ArrayR[2] = LineP0[5];

				ArrayB[3] = LineP1[-3];       ArrayG[3] = LineP1[-2];       ArrayR[3] = LineP1[-1];
				ArrayB[4] = LineP1[0];        ArrayG[4] = LineP1[1];        ArrayR[4] = LineP1[2];
				ArrayB[5] = LineP1[3];        ArrayG[5] = LineP1[4];        ArrayR[5] = LineP1[5];

				ArrayB[6] = LineP2[-3];       ArrayG[6] = LineP2[-2];       ArrayR[6] = LineP2[-1];
				ArrayB[7] = LineP2[0];        ArrayG[7] = LineP2[1];        ArrayR[7] = LineP2[2];
				ArrayB[8] = LineP2[3];        ArrayG[8] = LineP2[4];        ArrayR[8] = LineP2[5];

				qsort(ArrayB, 9, sizeof(unsigned char), &ComparisonFunction);
				qsort(ArrayG, 9, sizeof(unsigned char), &ComparisonFunction);
				qsort(ArrayR, 9, sizeof(unsigned char), &ComparisonFunction);

				LinePD[0] = ArrayB[4];
				LinePD[1] = ArrayG[4];
				LinePD[2] = ArrayR[4];

				LineP0 += 3;
				LineP1 += 3;
				LineP2 += 3;
				LinePD += 3;
			}
		}
	}
}

来测一把耗时情况：

分辨率算法优化循环次数速度
4032x3024普通实现1008293.79 ms

3. 一个简单的改进

由于排序耗时是非常多的，而这里实际上就是在9个元素中找到中位数，这个其实不需要排序就可以办到，只要我们按照下面的方法进行比较就可以获得中位数。事实上只需要19次比较，就可以获得中位数，我们先看源码：

void Swap(int &X, int &Y) {
	X ^= Y;
	Y ^= X;
	X ^= Y;
}

void MedianBlur3X3_Faster(unsigned char *Src, unsigned char *Dest, int Width, int Height, int Stride) {
	int Channel = Stride / Width;
	if (Channel == 1) {

		for (int Y = 1; Y < Height - 1; Y++) {
			unsigned char *LineP0 = Src + (Y - 1) * Stride + 1;
			unsigned char *LineP1 = LineP0 + Stride;
			unsigned char *LineP2 = LineP1 + Stride;
			unsigned char *LinePD = Dest + Y * Stride + 1;
			for (int X = 1; X < Width - 1; X++) {
				int Gray0, Gray1, Gray2, Gray3, Gray4, Gray5, Gray6, Gray7, Gray8;
				Gray0 = LineP0[X - 1];        Gray1 = LineP0[X];    Gray2 = LineP0[X + 1];
				Gray3 = LineP1[X - 1];        Gray4 = LineP1[X];    Gray5 = LineP1[X + 1];
				Gray6 = LineP2[X - 1];        Gray7 = LineP2[X];    Gray8 = LineP2[X + 1];

				if (Gray1 > Gray2) Swap(Gray1, Gray2);
				if (Gray4 > Gray5) Swap(Gray4, Gray5);
				if (Gray7 > Gray8) Swap(Gray7, Gray8);
				if (Gray0 > Gray1) Swap(Gray0, Gray1);
				if (Gray3 > Gray4) Swap(Gray3, Gray4);
				if (Gray6 > Gray7) Swap(Gray6, Gray7);
				if (Gray1 > Gray2) Swap(Gray1, Gray2);
				if (Gray4 > Gray5) Swap(Gray4, Gray5);
				if (Gray7 > Gray8) Swap(Gray7, Gray8);
				if (Gray0 > Gray3) Swap(Gray0, Gray3);
				if (Gray5 > Gray8) Swap(Gray5, Gray8);
				if (Gray4 > Gray7) Swap(Gray4, Gray7);
				if (Gray3 > Gray6) Swap(Gray3, Gray6);
				if (Gray1 > Gray4) Swap(Gray1, Gray4);
				if (Gray2 > Gray5) Swap(Gray2, Gray5);
				if (Gray4 > Gray7) Swap(Gray4, Gray7);
				if (Gray4 > Gray2) Swap(Gray4, Gray2);
				if (Gray6 > Gray4) Swap(Gray6, Gray4);
				if (Gray4 > Gray2) Swap(Gray4, Gray2);

				LinePD[X] = Gray4;
			}
		}

	}
	else {
		for (int Y = 1; Y < Height - 1; Y++) {
			unsigned char *LineP0 = Src + (Y - 1) * Stride + 3;
			unsigned char *LineP1 = LineP0 + Stride;
			unsigned char *LineP2 = LineP1 + Stride;
			unsigned char *LinePD = Dest + Y * Stride + 3;
			for (int X = 1; X < Width - 1; X++) {
				int Blue0, Blue1, Blue2, Blue3, Blue4, Blue5, Blue6, Blue7, Blue8;
				int Green0, Green1, Green2, Green3, Green4, Green5, Green6, Green7, Green8;
				int Red0, Red1, Red2, Red3, Red4, Red5, Red6, Red7, Red8;
				Blue0 = LineP0[-3];        Green0 = LineP0[-2];    Red0 = LineP0[-1];
				Blue1 = LineP0[0];        Green1 = LineP0[1];        Red1 = LineP0[2];
				Blue2 = LineP0[3];        Green2 = LineP0[4];        Red2 = LineP0[5];

				Blue3 = LineP1[-3];        Green3 = LineP1[-2];    Red3 = LineP1[-1];
				Blue4 = LineP1[0];        Green4 = LineP1[1];        Red4 = LineP1[2];
				Blue5 = LineP1[3];        Green5 = LineP1[4];        Red5 = LineP1[5];

				Blue6 = LineP2[-3];        Green6 = LineP2[-2];    Red6 = LineP2[-1];
				Blue7 = LineP2[0];        Green7 = LineP2[1];        Red7 = LineP2[2];
				Blue8 = LineP2[3];        Green8 = LineP2[4];        Red8 = LineP2[5];

				if (Blue1 > Blue2) Swap(Blue1, Blue2);
				if (Blue4 > Blue5) Swap(Blue4, Blue5);
				if (Blue7 > Blue8) Swap(Blue7, Blue8);
				if (Blue0 > Blue1) Swap(Blue0, Blue1);
				if (Blue3 > Blue4) Swap(Blue3, Blue4);
				if (Blue6 > Blue7) Swap(Blue6, Blue7);
				if (Blue1 > Blue2) Swap(Blue1, Blue2);
				if (Blue4 > Blue5) Swap(Blue4, Blue5);
				if (Blue7 > Blue8) Swap(Blue7, Blue8);
				if (Blue0 > Blue3) Swap(Blue0, Blue3);
				if (Blue5 > Blue8) Swap(Blue5, Blue8);
				if (Blue4 > Blue7) Swap(Blue4, Blue7);
				if (Blue3 > Blue6) Swap(Blue3, Blue6);
				if (Blue1 > Blue4) Swap(Blue1, Blue4);
				if (Blue2 > Blue5) Swap(Blue2, Blue5);
				if (Blue4 > Blue7) Swap(Blue4, Blue7);
				if (Blue4 > Blue2) Swap(Blue4, Blue2);
				if (Blue6 > Blue4) Swap(Blue6, Blue4);
				if (Blue4 > Blue2) Swap(Blue4, Blue2);

				if (Green1 > Green2) Swap(Green1, Green2);
				if (Green4 > Green5) Swap(Green4, Green5);
				if (Green7 > Green8) Swap(Green7, Green8);
				if (Green0 > Green1) Swap(Green0, Green1);
				if (Green3 > Green4) Swap(Green3, Green4);
				if (Green6 > Green7) Swap(Green6, Green7);
				if (Green1 > Green2) Swap(Green1, Green2);
				if (Green4 > Green5) Swap(Green4, Green5);
				if (Green7 > Green8) Swap(Green7, Green8);
				if (Green0 > Green3) Swap(Green0, Green3);
				if (Green5 > Green8) Swap(Green5, Green8);
				if (Green4 > Green7) Swap(Green4, Green7);
				if (Green3 > Green6) Swap(Green3, Green6);
				if (Green1 > Green4) Swap(Green1, Green4);
				if (Green2 > Green5) Swap(Green2, Green5);
				if (Green4 > Green7) Swap(Green4, Green7);
				if (Green4 > Green2) Swap(Green4, Green2);
				if (Green6 > Green4) Swap(Green6, Green4);
				if (Green4 > Green2) Swap(Green4, Green2);

				if (Red1 > Red2) Swap(Red1, Red2);
				if (Red4 > Red5) Swap(Red4, Red5);
				if (Red7 > Red8) Swap(Red7, Red8);
				if (Red0 > Red1) Swap(Red0, Red1);
				if (Red3 > Red4) Swap(Red3, Red4);
				if (Red6 > Red7) Swap(Red6, Red7);
				if (Red1 > Red2) Swap(Red1, Red2);
				if (Red4 > Red5) Swap(Red4, Red5);
				if (Red7 > Red8) Swap(Red7, Red8);
				if (Red0 > Red3) Swap(Red0, Red3);
				if (Red5 > Red8) Swap(Red5, Red8);
				if (Red4 > Red7) Swap(Red4, Red7);
				if (Red3 > Red6) Swap(Red3, Red6);
				if (Red1 > Red4) Swap(Red1, Red4);
				if (Red2 > Red5) Swap(Red2, Red5);
				if (Red4 > Red7) Swap(Red4, Red7);
				if (Red4 > Red2) Swap(Red4, Red2);
				if (Red6 > Red4) Swap(Red6, Red4);
				if (Red4 > Red2) Swap(Red4, Red2);

				LinePD[0] = Blue4;
				LinePD[1] = Green4;
				LinePD[2] = Red4;

				LineP0 += 3;
				LineP1 += 3;
				LineP2 += 3;
				LinePD += 3;
			}
		}
	}
}

其实上面的代码很好理解，我们将R,G,B三个通道分开看，每个通道执行的都是完全一样的操作，随着比较的不断执行，最后最小的4个数会排在前4个位置，最大的4个数会排在后4个位置，中位数恰好就在中间。这个算法的流水情况比第一个算法好多了，自然也会得到较大的速度提升。

同样来测试一下速度：

分辨率算法优化循环次数速度
4032x3024普通实现1008293.79ms
4032x3024逻辑优化，更好的流水10083.75ms

4. SSE优化

这里是本文的重点了，似乎这个算法看起来是不好做SSE优化的，因为窗口中像素的 9 9 9次比较不能直接用SIMD指令来做。根据ImageShop博主的提示，当我们看到下面这段代码https://github.com/ARM-software/ComputeLibrary/blob/master/src/core/NEON/kernels/NEMedian3x3Kernel.cpp#L113提示时，我们可以知道多个像素的比较是不相关的，（这个地方需要思考为什么不相关，因为我们比较的时候交换是使用临时变量，实际上是没有改变每个位置的像素的位置的）。所以SSE优化的思路就有了，现在可以一次性处理16个像素了。SSE优化的代码如下：

inline void _mm_sort_ab(__m128i &a, __m128i &b) {
	const __m128i min = _mm_min_epu8(a, b);
	const __m128i max = _mm_max_epu8(a, b);
	a = min;
	b = max;
}

void MedianBlur3X3_Fastest(unsigned char *Src, unsigned char *Dest, int Width, int Height, int Stride) {
	int Channel = Stride / Width;
	int BlockSize = 16, Block = ((Width - 2)* Channel) / BlockSize;
	for (int Y = 1; Y < Height - 1; Y++) {
		unsigned char *LineP0 = Src + (Y - 1) * Stride + Channel;
		unsigned char *LineP1 = LineP0 + Stride;
		unsigned char *LineP2 = LineP1 + Stride;
		unsigned char *LinePD = Dest + Y * Stride + Channel;
		for (int X = 0; X < Block * BlockSize; X += BlockSize, LineP0 += BlockSize, LineP1 += BlockSize, LineP2 += BlockSize, LinePD += BlockSize)
		{
			__m128i P0 = _mm_loadu_si128((__m128i *)(LineP0 - Channel));
			__m128i P1 = _mm_loadu_si128((__m128i *)(LineP0 - 0));
			__m128i P2 = _mm_loadu_si128((__m128i *)(LineP0 + Channel));
			__m128i P3 = _mm_loadu_si128((__m128i *)(LineP1 - Channel));
			__m128i P4 = _mm_loadu_si128((__m128i *)(LineP1 - 0));
			__m128i P5 = _mm_loadu_si128((__m128i *)(LineP1 + Channel));
			__m128i P6 = _mm_loadu_si128((__m128i *)(LineP2 - Channel));
			__m128i P7 = _mm_loadu_si128((__m128i *)(LineP2 - 0));
			__m128i P8 = _mm_loadu_si128((__m128i *)(LineP2 + Channel));

			_mm_sort_ab(P1, P2);		_mm_sort_ab(P4, P5);		_mm_sort_ab(P7, P8);
			_mm_sort_ab(P0, P1);		_mm_sort_ab(P3, P4);		_mm_sort_ab(P6, P7);
			_mm_sort_ab(P1, P2);		_mm_sort_ab(P4, P5);		_mm_sort_ab(P7, P8);
			_mm_sort_ab(P0, P3);		_mm_sort_ab(P5, P8);		_mm_sort_ab(P4, P7);
			_mm_sort_ab(P3, P6);		_mm_sort_ab(P1, P4);		_mm_sort_ab(P2, P5);
			_mm_sort_ab(P4, P7);		_mm_sort_ab(P4, P2);		_mm_sort_ab(P6, P4);
			_mm_sort_ab(P4, P2);

			_mm_storeu_si128((__m128i *)LinePD, P4);
		}

		for (int X = Block * BlockSize; X < (Width - 2) * Channel; X++, LinePD++) {
			int Gray0, Gray1, Gray2, Gray3, Gray4, Gray5, Gray6, Gray7, Gray8;
			Gray0 = LineP0[X - Block * BlockSize - Channel];        Gray1 = LineP0[X - Block * BlockSize];    Gray2 = LineP0[X - Block * BlockSize + Channel];
			Gray3 = LineP1[X - Block * BlockSize - Channel];        Gray4 = LineP1[X - Block * BlockSize];    Gray5 = LineP1[X - Block * BlockSize + Channel];
			Gray6 = LineP2[X - Block * BlockSize - Channel];        Gray7 = LineP2[X - Block * BlockSize];    Gray8 = LineP2[X - Block * BlockSize + Channel];

			if (Gray1 > Gray2) Swap(Gray1, Gray2);
			if (Gray4 > Gray5) Swap(Gray4, Gray5);
			if (Gray7 > Gray8) Swap(Gray7, Gray8);
			if (Gray0 > Gray1) Swap(Gray0, Gray1);
			if (Gray3 > Gray4) Swap(Gray3, Gray4);
			if (Gray6 > Gray7) Swap(Gray6, Gray7);
			if (Gray1 > Gray2) Swap(Gray1, Gray2);
			if (Gray4 > Gray5) Swap(Gray4, Gray5);
			if (Gray7 > Gray8) Swap(Gray7, Gray8);
			if (Gray0 > Gray3) Swap(Gray0, Gray3);
			if (Gray5 > Gray8) Swap(Gray5, Gray8);
			if (Gray4 > Gray7) Swap(Gray4, Gray7);
			if (Gray3 > Gray6) Swap(Gray3, Gray6);
			if (Gray1 > Gray4) Swap(Gray1, Gray4);
			if (Gray2 > Gray5) Swap(Gray2, Gray5);
			if (Gray4 > Gray7) Swap(Gray4, Gray7);
			if (Gray4 > Gray2) Swap(Gray4, Gray2);
			if (Gray6 > Gray4) Swap(Gray6, Gray4);
			if (Gray4 > Gray2) Swap(Gray4, Gray2);

			LinePD[X] = Gray4;
			LineP0 += 1;
			LineP1 += 1;
			LineP2 += 1;
		}
	}
}

来测一下速度：

分辨率算法优化循环次数速度
4032x3024普通实现1008293.79ms
4032x3024逻辑优化，更好的流水10083.75ms
4032x3024SSE优化10011.93ms

5. AVX优化

显然，我们可以将SSE版本稍加修改获得AVX指令优化的版本，这样我们就可以一次性处理32个元素了，代码如下：

inline void _mm_sort_AB(__m256i &a, __m256i &b) {
	const __m256i min = _mm256_min_epu8(a, b);
	const __m256i max = _mm256_max_epu8(a, b);
	a = min;
	b = max;
}

void MedianBlur3X3_Fastest_AVX(unsigned char *Src, unsigned char *Dest, int Width, int Height, int Stride) {
	int Channel = Stride / Width;
	int BlockSize = 32, Block = ((Width - 2)* Channel) / BlockSize;
	for (int Y = 1; Y < Height - 1; Y++) {
		unsigned char *LineP0 = Src + (Y - 1) * Stride + Channel;
		unsigned char *LineP1 = LineP0 + Stride;
		unsigned char *LineP2 = LineP1 + Stride;
		unsigned char *LinePD = Dest + Y * Stride + Channel;
		for (int X = 0; X < Block * BlockSize; X += BlockSize, LineP0 += BlockSize, LineP1 += BlockSize, LineP2 += BlockSize, LinePD += BlockSize)
		{
			__m256i P0 = _mm256_loadu_si256((const __m256i*)(LineP0 - Channel));
			__m256i P1 = _mm256_loadu_si256((const __m256i*)(LineP0 - 0));
			__m256i P2 = _mm256_loadu_si256((const __m256i*)(LineP0 + Channel));
			__m256i P3 = _mm256_loadu_si256((const __m256i*)(LineP1 - Channel));
			__m256i P4 = _mm256_loadu_si256((const __m256i*)(LineP1 - 0));
			__m256i P5 = _mm256_loadu_si256((const __m256i*)(LineP1 + Channel));
			__m256i P6 = _mm256_loadu_si256((const __m256i*)(LineP2 - Channel));
			__m256i P7 = _mm256_loadu_si256((const __m256i*)(LineP2 - 0));
			__m256i P8 = _mm256_loadu_si256((const __m256i*)(LineP2 + Channel));

			_mm_sort_AB(P1, P2);		_mm_sort_AB(P4, P5);		_mm_sort_AB(P7, P8);
			_mm_sort_AB(P0, P1);		_mm_sort_AB(P3, P4);		_mm_sort_AB(P6, P7);
			_mm_sort_AB(P1, P2);		_mm_sort_AB(P4, P5);		_mm_sort_AB(P7, P8);
			_mm_sort_AB(P0, P3);		_mm_sort_AB(P5, P8);		_mm_sort_AB(P4, P7);
			_mm_sort_AB(P3, P6);		_mm_sort_AB(P1, P4);		_mm_sort_AB(P2, P5);
			_mm_sort_AB(P4, P7);		_mm_sort_AB(P4, P2);		_mm_sort_AB(P6, P4);
			_mm_sort_AB(P4, P2);

			_mm256_storeu_si256((__m256i *)LinePD, P4);
		}

		for (int X = Block * BlockSize; X < (Width - 2) * Channel; X++, LinePD++) {
			int Gray0, Gray1, Gray2, Gray3, Gray4, Gray5, Gray6, Gray7, Gray8;
			Gray0 = LineP0[X - Block * BlockSize - Channel];        Gray1 = LineP0[X - Block * BlockSize];    Gray2 = LineP0[X - Block * BlockSize + Channel];
			Gray3 = LineP1[X - Block * BlockSize - Channel];        Gray4 = LineP1[X - Block * BlockSize];    Gray5 = LineP1[X - Block * BlockSize + Channel];
			Gray6 = LineP2[X - Block * BlockSize - Channel];        Gray7 = LineP2[X - Block * BlockSize];    Gray8 = LineP2[X - Block * BlockSize + Channel];

			if (Gray1 > Gray2) Swap(Gray1, Gray2);
			if (Gray4 > Gray5) Swap(Gray4, Gray5);
			if (Gray7 > Gray8) Swap(Gray7, Gray8);
			if (Gray0 > Gray1) Swap(Gray0, Gray1);
			if (Gray3 > Gray4) Swap(Gray3, Gray4);
			if (Gray6 > Gray7) Swap(Gray6, Gray7);
			if (Gray1 > Gray2) Swap(Gray1, Gray2);
			if (Gray4 > Gray5) Swap(Gray4, Gray5);
			if (Gray7 > Gray8) Swap(Gray7, Gray8);
			if (Gray0 > Gray3) Swap(Gray0, Gray3);
			if (Gray5 > Gray8) Swap(Gray5, Gray8);
			if (Gray4 > Gray7) Swap(Gray4, Gray7);
			if (Gray3 > Gray6) Swap(Gray3, Gray6);
			if (Gray1 > Gray4) Swap(Gray1, Gray4);
			if (Gray2 > Gray5) Swap(Gray2, Gray5);
			if (Gray4 > Gray7) Swap(Gray4, Gray7);
			if (Gray4 > Gray2) Swap(Gray4, Gray2);
			if (Gray6 > Gray4) Swap(Gray6, Gray4);
			if (Gray4 > Gray2) Swap(Gray4, Gray2);

			LinePD[X] = Gray4;
			LineP0 += 1;
			LineP1 += 1;
			LineP2 += 1;
		}
	}
}

同样，来测一下速度：

分辨率算法优化循环次数速度
4032x3024普通实现1008293.79ms
4032x3024逻辑优化，更好的流水10083.75ms
4032x3024SSE优化10011.93ms
4032x3024AVX优化1009.32ms

可以看到AVX虽然一次处理了32个像素，但速度的提升幅度并不是很大，只有2ms左右。

这里就不打算继续做AVX指令集的多线程优化和测速了，感兴趣的可以自行实验，基本上速度提升是很少了，

6. 总结

本文以一个 3 × 3 3\times 3 3×3的中值滤波作为切入点，讨论了一下针对这个具体问题的优化思路，速度也从最开始普通实现的8293.79ms优化到了9.32ms，还是有一定的参考意义的。

欢迎关注GiantPandaCV, 在这里你将看到独家的深度学习分享，坚持原创，每天分享我们学习到的新鲜知识。( • ̀ω•́ )✧

有对文章相关的问题，或者想要加入交流群，欢迎添加BBuf微信：

二维码
为了方便读者获取资料以及我们公众号的作者发布一些Github工程的更新，我们成立了一个QQ群，二维码如下，感兴趣可以加入。

公众号QQ交流群

just_sort
关注
专栏目录
中值滤波的改进算法
aoamca84802的博客
08-25 1471
中值滤波的算法很多，但通常数据排序量较大。需要消耗大量时间，不利于图像处理的实时性。 （1）窗口大小为3*3的快速排序算法 为了便于说明。将3*3窗口内的各个像素分别定义为M11，M12，M13，M21，M22，M23，M31，M32，M33。首先分别对窗口中的每一行计算最大值、中值、最小值，这样一共可以得到9个数值，分别包括3个最大值、3个中值、3个最小值： 第一行的最大值：Max1=...
SSE优化系列九：小半径中值滤波的SSE极速优化（比OpenCV3.1.0快9-10倍）
I good vegetable a!
08-06 1347
前言 在优化系列六:https://blog.csdn.net/just_sort/article/details/97280807 中提出了一个直方图算法处理框架，可以处理中值滤波，最大值滤波等，算法复杂度是和半径大小无关的。但是这里忽略了一个点在半径很小的时候，这个算法实际上是比直接暴力处理更慢的。而我们在日常图像处理过程中，小半径的中值滤波是最常用的例如3 * 3, 5 * 5 在PS中都...
中值滤波中位数优化算法
08-05 596
class MidSort(private val SIZE:Int=251) { private var index = 0 private var medIndex=SIZE shr 1 private val data=IntArray(SIZE) private val dataFlag=BooleanArray(SIZE){ it<medIndex } private var medValue = 0 fun init.
数字图像处理——中值滤波及其改进算法
沧海一升的博客
08-27 7141
中值滤波器是非线性滤波器的一个例子，它在保留图像特征方面非常有效。 但是，滤波器的窗口大小直接影响中值滤波器的性能。 较小的窗口保留了特征，但会导致噪声抑制的减少。 在较大窗口的情况下，噪声抑制很高，但图像内容保留有限。 随着对标准中值滤波器的研究，提出了许多滤波器，如加权中值滤波器和许多其他高级滤波器。
matlab中值滤波法算法,基于MATLAB中值滤波算法的优化与实现
weixin_35245427的博客
03-24 402
总第２３８期２０１４年第４期 舰 船 电 子 工 程 Ｓｈｉｐ　Ｅｌｅｃｔｒｏｎｉｃ　Ｅｎｇｉｎｅｅｒｉｎｇ Ｖｏｌ．３４Ｎｏ．４３７ 基于 ＭＡＴＬＡＢ中值滤波算法的优化与实现＊ 赵建春　刘力源 (陆军军官学院研究生管理大队　合肥　２３００３１) 摘　要　介绍了中值滤波的滤波特点，针对标准中值滤波在滤除椒盐噪声中的不足，提出了一种中值滤波优化算法，通过 ＭＡＴＬＡＢ软件仿真，结果表明该算法在有效...
均值滤波与中值滤波的应用_MATLAB中值滤波_均值滤波中值滤波的matlab代码_中值滤波_plandop_
09-30
通过了解均值滤波和中值滤波的基本原理以及在MATLAB中的实现，我们可以更好地理解和应用这些技术，优化图像处理任务。在`plandop`的项目中，这样的代码和应用示例将有助于学习和实践这两种滤波方法。
verilog实现中值滤波算法及仿真median.rar
08-14
本项目是用Verilog硬件描述语言实现的中值滤波算法，并进行了仿真验证，适用于FPGA（Field Programmable Gate Array）平台。在实际应用中，这个模块特别适合集成到视频监控系统，与OV系列传感器接口兼容。 首先，让...
用matlab实现窗口大小可变中值滤波
03-30
使用这个自定义的中值滤波器，用户可以自由调整窗口大小以适应不同的噪声环境，而且因为是自编代码，对算法的理解会更深刻，这对于理解和优化滤波效果是非常有益的。 这个M文件`program_1617067813`很可能是实现了...
快速中值滤波及c语言实现.docx
07-03
"快速中值滤波及C语言实现" 快速中值滤波是一种非线性信号处理技术，对抑制图像噪声非常有效。在二维形式下，中值滤波器是一个奇数个像素的滑动窗口，窗口正中的像素灰度值用窗口内各个像素的中值代替。在本文中，...
中值滤波算法改进之C语言实现
04-30
### 中值滤波算法改进之C语言实现 #### 概述 本文主要介绍了一种改进的中值滤波算法，并提供了其在C语言中的具体实现。中值滤波是一种常用的图像处理技术，主要用于去除图像中的噪声，特别是脉冲噪声（如椒盐噪声）...
中值滤波和快速中值滤波算法源代码（含图像显示和打开，且可计时比较）
05-11
经典的中值滤波算法要求对窗口内的像素进行排序，当窗口尺寸较大时，处理速度很慢，不能满足计算机对图像处理的实时性要求。本文探讨了中值滤波的快速算法，旨在提高中值滤波处理速度。结果表明，快速算法可是处理时间大大减小。
cuda实现的中值滤波介绍
05-29
高性能并行运算已经成为图像处理不可缺少的利器，越来越多的人开始使用cuda去加速自己的程序，本文采用cuda来加速中值滤波器的处理。取得了很好地效果。
矩阵相乘SSE优化算法
06-23
该代码实现采用SSE对矩阵相乘进行优化，一般的矩阵相乘算法与SSE优化算法耗时进行比较比较。
【算法随记三】小半径中值模糊的急速实现（16MB图7.5ms实现） + Photoshop中蒙尘和划痕算法解读。...
weixin_34342992的博客
06-26 535
　　在本人的博客里，分享了有关中值模糊的O(1)算法，详见：任意半径中值滤波（扩展至百分比滤波器）O(1)时间复杂度算法的原理、实现及效果，这里的算法的执行时间和参数是无关的。整体来说，虽然速度也很快，但是在某些特殊情况下我们还是需要更快的速度。特别是对于小半径的中值，我们有理由去对其进一步的优化的。本文我们进一步探讨这个问题。 　　一、3*3中值模糊 　　首先我们来看看半径为1的中值，此时...
SSE指令集算法优化
weixin_40593924的博客
03-19 1117
先挖个坑，记录下资料。 REF 1、（c/c++ 代码中使用sse指令集加速）https://www.cnblogs.com/dragon2012/p/5200698.html 2、SSE指令指令集进行程序加速、DCT的优化处理（https://blog.csdn.net/yangdashi888/article/detail...
OpenCV算法加速（2）使用SIMD指令集(MMX、SSE、AVX)和MIPP实现视觉算法优化
热门推荐
$firecat利白的代码足迹$
09-03 1万+
SIMD指令集 SSE/AVX https://blog.csdn.net/qq_32916805/article/details/117637192 MMX和SSE实现的opencv数据结构的图像反色算法优化 SSE图像算法优化系列一：一段BGR2Y的SIMD代码解析。 SSE图像算法优化系列七：基于SSE实现的极速的矩形核腐蚀和膨胀（最大值和最小值）算法。 ......
[C] 跨平台使用Intrinsic函数范例1——使用SSE、AVX指令集 处理 单精度浮点数组求和（支持vc、gcc，兼容Windows、Linux、Mac）...
weixin_33971205的博客
10-22 1139
作者：zyl910。 　　本文面对对SSE等SIMD指令集有一定基础的读者，以单精度浮点数组求和为例演示了如何跨平台使用SSE、AVX指令集。因使用了stdint、zintrin、ccpuid这三个模块，可以完全避免手工编写汇编代码，具有很高可移植性。支持vc、gcc编译器，在Windows、Linux、Mac这三大平台上成功运行。 一、问题背景 　　最初，我们只能使用汇编语言来编写SIMD...
单数据多指令(SIMD) MMX SSE AVX
dellme99的专栏
12-30 4263
概述 SIMD是指单指令多数据技术，它已经成为Intel处理器的重要性能扩展。目前Intel处理器支持的SIMD技术包括MMX,SSE,AVX. MMX提供了8个64bit的寄存器进行SIMD操作，SSE系列提供了128bit的8个寄存器进行SIMD指令操作。而最新的AVX指令则支持256bit的SIMD操作。 目前SIMD指令可以有四种方法进行使用分别是汇编语言，C++类，编译器Intri
cv::Mat 快速遍历与快速中值滤波
qq_25349629的博客
07-03 976
1.图像快速遍历 遍历方法：直接获取cv::Mat对象的像素块数据指针 void fasterTraversePixel(cv::Mat &src) { int w = src.cols; int h = src.rows; for (int row = 0; row < h; row++) { uchar* uc_pixel = src.data + row*s...
优化的中值滤波算法：多形状窗口下的快速实现
"这篇论文探讨了一种在多种形状窗口下的快速中值滤波算法，旨在优化图像处理中的中值滤波过程。通过巧妙设定滤波窗口的移动顺序，并利用相邻窗口的信息，显著降低了查找中值时的比较次数，从而提高了算法的效率。...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值