【AI PC端算法优化】三，深入优化RGB转灰度图算法

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

0. 目录

  • 前言
  • RGB2GRAY最简单实现
  • RGB转GRAY优化第一版（float->INT）
  • RGB转GRAY优化第二版（手动4路并行）
  • RGB转GRAY优化第三版（OpenMP4线程）
  • RGB转GRAY优化第四版（SSE优化，一次处理12个像素）
  • RGB转GRAY优化第五版（SSE优化，一次处理15个像素）
  • RGB转GRAY优化第六版（AVX2优化，一次处理10个像素）
  • RGB转GRAY优化第七版（AVX2优化+std::async）

1. 前言

前几天发了一篇一步步优化RGB转灰度图算法，但实验做的并不完善，在上次的基础上我又补充了一些优化技巧，相对于传统实现将RGB转灰度图算法可以加速到近5倍左右。所以，这篇文章再次将所有涉及到的优化方法进行汇总，SSE优化相关的原理上一节已经讲得很清楚了，这里就不会再展开了，感兴趣可以查看上篇文章。【AI PC端算法优化】一，一步步优化RGB转灰度图算法 这一节的速度测试环境为：

测试CPU型号：Intel® Core™ i7-6700 CPU @ 3.40GHz

2. RGB转GRAY最简单实现

//origin
void RGB2Y(unsigned char *Src, unsigned char *Dest, int Width, int Height, int Stride) {
	for (int Y = 0; Y < Height; Y++) {
		unsigned char *LinePS = Src + Y * Stride;
		unsigned char *LinePD = Dest + Y * Width;
		for (int X = 0; X < Width; X++, LinePS += 3) {
			LinePD[X] = int(0.114 * LinePS[0] + 0.587 * LinePS[1] + 0.299 * LinePS[2]);
		}
	}
}

耗时信息如下：

分辨率优化循环次数速度
4032x3024原始实现100012.139ms

3. RGB转GRAY优化第一版

直接计算复杂度较高，考虑优化可以将小数转为整数，除法变为移位，乘法也变为移位，但是这种方法也会带来一定的精度损失，我们可以根据实际情况选择需要保留的精度位数。下面给出不同精度(2-20位)的计算公式：

Gray = (R*1 + G*2 + B*1) >> 2

Gray= (R*2 + G*5 + B*1) >> 3

Gray= (R*4 + G*10 + B*2) >> 4

Gray = (R*9 + G*19 + B*4) >> 5

Gray = (R*19 + G*37 + B*8) >> 6

Gray= (R*38 + G*75 + B*15) >> 7

Gray= (R*76 + G*150 + B*30) >> 8

Gray = (R*153 + G*300 + B*59) >> 9

Gray = (R*306 + G*601 + B*117) >> 10

Gray = (R*612 + G*1202 + B*234) >> 11

Gray = (R*1224 + G*2405 + B*467) >> 12

Gray= (R*2449 + G*4809 + B*934) >> 13

Gray= (R*4898 + G*9618 + B*1868) >> 14

Gray = (R*9797 + G*19235 + B*3736) >> 15

Gray = (R*19595 + G*38469 + B*7472) >> 16

Gray = (R*39190 + G*76939 + B*14943) >> 17

Gray = (R*78381 + G*153878 + B*29885) >> 18

Gray =(R*156762 + G*307757 + B*59769) >> 19

Gray= (R*313524 + G*615514 + B*119538) >> 20

下面测试一下保留8位精度的代码实现和速度测试：

//int
void RGB2Y_1(unsigned char *Src, unsigned char *Dest, int Width, int Height, int Stride) {
	const int B_WT = int(0.114 * 256 + 0.5);
	const int G_WT = int(0.587 * 256 + 0.5);
	const int R_WT = 256 - B_WT - G_WT;
	for (int Y = 0; Y < Height; Y++) {
		unsigned char *LinePS = Src + Y * Stride;
		unsigned char *LinePD = Dest + Y * Width;
		for (int X = 0; X < Width; X++, LinePS += 3) {
			LinePD[X] = (B_WT * LinePS[0] + G_WT * LinePS[1] + R_WT * LinePS[2]) >> 8;
		}
	}
}
分辨率优化循环次数速度
4032x3024原始实现100012.139ms
4032x3024第一版优化（float->INT）10007.629ms

这一优化将速度加速了10ms，还是比较可观的。

4. RGB转GRAY优化第二版

在第一版优化的基础上，使用4路并行，然后我们看看有没有进一步的加速效果。代码实现和速度测试如下：

//4路并行
void RGB2Y_2(unsigned char *Src, unsigned char *Dest, int Width, int Height, int Stride) {
	const int B_WT = int(0.114 * 256 + 0.5);
	const int G_WT = int(0.587 * 256 + 0.5);
	const int R_WT = 256 - B_WT - G_WT; // int(0.299 * 256 + 0.5)
	for (int Y = 0; Y < Height; Y++) {
		unsigned char *LinePS = Src + Y * Stride;
		unsigned char *LinePD = Dest + Y * Width;
		int X = 0;
		for (; X < Width - 4; X += 4, LinePS += 12) {
			LinePD[X + 0] = (B_WT * LinePS[0] + G_WT * LinePS[1] + R_WT * LinePS[2]) >> 8;
			LinePD[X + 1] = (B_WT * LinePS[3] + G_WT * LinePS[4] + R_WT * LinePS[5]) >> 8;
			LinePD[X + 2] = (B_WT * LinePS[6] + G_WT * LinePS[7] + R_WT * LinePS[8]) >> 8;
			LinePD[X + 3] = (B_WT * LinePS[9] + G_WT * LinePS[10] + R_WT * LinePS[11]) >> 8;
		}
		for (; X < Width; X++, LinePS += 3) {
			LinePD[X] = (B_WT * LinePS[0] + G_WT * LinePS[1] + R_WT * LinePS[2]) >> 8;
		}
	}
}
分辨率优化循环次数速度
4032x3024原始实现100012.139ms
4032x3024第一版优化（float->INT）10007.629ms
4032x3024第二版优化（手动4路并行）100010.528ms

这里测试的时候并没有加速效果，反而还慢了很多。

5. RGB转GRAY优化第三版

利用OpenMP进行4线程加速，代码如下：

//openmp
void RGB2Y_3(unsigned char *Src, unsigned char *Dest, int Width, int Height, int Stride) {
	const int B_WT = int(0.114 * 256 + 0.5);
	const int G_WT = int(0.587 * 256 + 0.5);
	const int R_WT = 256 - B_WT - G_WT;
	for (int Y = 0; Y < Height; Y++) {
		unsigned char *LinePS = Src + Y * Stride;
		unsigned char *LinePD = Dest + Y * Width;
#pragma omp parallel for num_threads(4)
		for (int X = 0; X < Width; X++) {
			LinePD[X] = (B_WT * LinePS[0 + X*3] + G_WT * LinePS[1 + X*3] + R_WT * LinePS[2 + X*3]) >> 8;
		}
	}
}
分辨率优化循环次数速度
4032x3024原始实现100012.139ms
4032x3024第一版优化（float->INT）10007.629ms
4032x3024第二版优化（手动4路并行）100010.528ms
4032x3024第三版优化（OpenMP4线程）10007.632ms

可以看到使用OpenMP进行多线程加速，算法的速度和第一版的速度也是差不多的，没有明显的加速效果。

6. RGB转GRAY优化第四版

这一次优化就是上篇推文讲的SSE优化，原理就不再多说了，可以去查看上篇推文，代码实现如下：

//sse 一次处理12个
void RGB2Y_4(unsigned char *Src, unsigned char *Dest, int Width, int Height, int Stride) {
	const int B_WT = int(0.114 * 256 + 0.5);
	const int G_WT = int(0.587 * 256 + 0.5);
	const int R_WT = 256 - B_WT - G_WT; // int(0.299 * 256 + 0.5)

	for (int Y = 0; Y < Height; Y++) {
		unsigned char *LinePS = Src + Y * Stride;
		unsigned char *LinePD = Dest + Y * Width;
		int X = 0;
		for (; X < Width - 12; X += 12, LinePS += 36) {
			__m128i p1aL = _mm_mullo_epi16(_mm_cvtepu8_epi16(_mm_loadu_si128((__m128i *)(LinePS + 0))), _mm_setr_epi16(B_WT, G_WT, R_WT, B_WT, G_WT, R_WT, B_WT, G_WT)); //1
			__m128i p2aL = _mm_mullo_epi16(_mm_cvtepu8_epi16(_mm_loadu_si128((__m128i *)(LinePS + 1))), _mm_setr_epi16(G_WT, R_WT, B_WT, G_WT, R_WT, B_WT, G_WT, R_WT)); //2
			__m128i p3aL = _mm_mullo_epi16(_mm_cvtepu8_epi16(_mm_loadu_si128((__m128i *)(LinePS + 2))), _mm_setr_epi16(R_WT, B_WT, G_WT, R_WT, B_WT, G_WT, R_WT, B_WT)); //3

			__m128i p1aH = _mm_mullo_epi16(_mm_cvtepu8_epi16(_mm_loadu_si128((__m128i *)(LinePS + 8))), _mm_setr_epi16(R_WT, B_WT, G_WT, R_WT, B_WT, G_WT, R_WT, B_WT));//4
			__m128i p2aH = _mm_mullo_epi16(_mm_cvtepu8_epi16(_mm_loadu_si128((__m128i *)(LinePS + 9))), _mm_setr_epi16(B_WT, G_WT, R_WT, B_WT, G_WT, R_WT, B_WT, G_WT));//5
			__m128i p3aH = _mm_mullo_epi16(_mm_cvtepu8_epi16(_mm_loadu_si128((__m128i *)(LinePS + 10))), _mm_setr_epi16(G_WT, R_WT, B_WT, G_WT, R_WT, B_WT, G_WT, R_WT));//6

			__m128i p1bL = _mm_mullo_epi16(_mm_cvtepu8_epi16(_mm_loadu_si128((__m128i *)(LinePS + 18))), _mm_setr_epi16(B_WT, G_WT, R_WT, B_WT, G_WT, R_WT, B_WT, G_WT));//7
			__m128i p2bL = _mm_mullo_epi16(_mm_cvtepu8_epi16(_mm_loadu_si128((__m128i *)(LinePS + 19))), _mm_setr_epi16(G_WT, R_WT, B_WT, G_WT, R_WT, B_WT, G_WT, R_WT));//8
			__m128i p3bL = _mm_mullo_epi16(_mm_cvtepu8_epi16(_mm_loadu_si128((__m128i *)(LinePS + 20))), _mm_setr_epi16(R_WT, B_WT, G_WT, R_WT, B_WT, G_WT, R_WT, B_WT));//9

			__m128i p1bH = _mm_mullo_epi16(_mm_cvtepu8_epi16(_mm_loadu_si128((__m128i *)(LinePS + 26))), _mm_setr_epi16(R_WT, B_WT, G_WT, R_WT, B_WT, G_WT, R_WT, B_WT));//10
			__m128i p2bH = _mm_mullo_epi16(_mm_cvtepu8_epi16(_mm_loadu_si128((__m128i *)(LinePS + 27))), _mm_setr_epi16(B_WT, G_WT, R_WT, B_WT, G_WT, R_WT, B_WT, G_WT));//11
			__m128i p3bH = _mm_mullo_epi16(_mm_cvtepu8_epi16(_mm_loadu_si128((__m128i *)(LinePS + 28))), _mm_setr_epi16(G_WT, R_WT, B_WT, G_WT, R_WT, B_WT, G_WT, R_WT));//12

			__m128i sumaL = _mm_add_epi16(p3aL, _mm_add_epi16(p1aL, p2aL));//13
			__m128i sumaH = _mm_add_epi16(p3aH, _mm_add_epi16(p1aH, p2aH));//14
			__m128i sumbL = _mm_add_epi16(p3bL, _mm_add_epi16(p1bL, p2bL));//15
			__m128i sumbH = _mm_add_epi16(p3bH, _mm_add_epi16(p1bH, p2bH));//16
			__m128i sclaL = _mm_srli_epi16(sumaL, 8);//17
			__m128i sclaH = _mm_srli_epi16(sumaH, 8);//18
			__m128i sclbL = _mm_srli_epi16(sumbL, 8);//19
			__m128i sclbH = _mm_srli_epi16(sumbH, 8);//20
			__m128i shftaL = _mm_shuffle_epi8(sclaL, _mm_setr_epi8(0, 6, 12, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1));//21
			__m128i shftaH = _mm_shuffle_epi8(sclaH, _mm_setr_epi8(-1, -1, -1, 18, 24, 30, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1));//22
			__m128i shftbL = _mm_shuffle_epi8(sclbL, _mm_setr_epi8(-1, -1, -1, -1, -1, -1, 0, 6, 12, -1, -1, -1, -1, -1, -1, -1));//23
			__m128i shftbH = _mm_shuffle_epi8(sclbH, _mm_setr_epi8(-1, -1, -1, -1, -1, -1, -1, -1, -1, 18, 24, 30, -1, -1, -1, -1));//24
			__m128i accumL = _mm_or_si128(shftaL, shftbL);//25
			__m128i accumH = _mm_or_si128(shftaH, shftbH);//26
			__m128i h3 = _mm_or_si128(accumL, accumH);//27
													  //__m128i h3 = _mm_blendv_epi8(accumL, accumH, _mm_setr_epi8(0, 0, 0, -1, -1, -1, 0, 0, 0, -1, -1, -1, 1, 1, 1, 1));
			_mm_storeu_si128((__m128i *)(LinePD + X), h3);
		}
		for (; X < Width; X++, LinePS += 3) {
			LinePD[X] = (B_WT * LinePS[0] + G_WT * LinePS[1] + R_WT * LinePS[2]) >> 8;
		}
	}
}
分辨率优化循环次数速度
4032x3024原始实现100012.139ms
4032x3024第一版优化（float->INT）10007.629ms
4032x3024第二版优化（手动4路并行）100010.528ms
4032x3024第三版优化（OpenMP4线程）10007.632ms
4032x3024第四版优化（SSE优化，一次处理12个像素）10005.579ms

7. RGB转灰度图优化第五版

在上篇推文中提到 _mm_storeu_si128把处理的结果写入到目标内存中，会多写了4个字节的内存数据（128 - 12 * 8），但是我们后面又会把他们重新覆盖掉，这就造成了重复计算，因此简单修改将一次处理12个像素变成一次处理15个像素，那么重复计算的数量就会下降，代码如下：

//sse 一次处理15个
void RGB2Y_5(unsigned char *Src, unsigned char *Dest, int Width, int Height, int Stride) {
	const int B_WT = int(0.114 * 256 + 0.5);
	const int G_WT = int(0.587 * 256 + 0.5);
	const int R_WT = 256 - B_WT - G_WT; // int(0.299 * 256 + 0.5)

	for (int Y = 0; Y < Height; Y++) {
		unsigned char *LinePS = Src + Y * Stride;
		unsigned char *LinePD = Dest + Y * Width;
		int X = 0;
		for (; X < Width - 15; X += 15, LinePS += 45)
		{
			__m128i p1aL = _mm_mullo_epi16(_mm_cvtepu8_epi16(_mm_loadu_si128((__m128i *)(LinePS + 0))), _mm_setr_epi16(B_WT, G_WT, R_WT, B_WT, G_WT, R_WT, B_WT, G_WT)); //1
			__m128i p2aL = _mm_mullo_epi16(_mm_cvtepu8_epi16(_mm_loadu_si128((__m128i *)(LinePS + 1))), _mm_setr_epi16(G_WT, R_WT, B_WT, G_WT, R_WT, B_WT, G_WT, R_WT)); //2
			__m128i p3aL = _mm_mullo_epi16(_mm_cvtepu8_epi16(_mm_loadu_si128((__m128i *)(LinePS + 2))), _mm_setr_epi16(R_WT, B_WT, G_WT, R_WT, B_WT, G_WT, R_WT, B_WT)); //3

			__m128i p1aH = _mm_mullo_epi16(_mm_cvtepu8_epi16(_mm_loadu_si128((__m128i *)(LinePS + 8))), _mm_setr_epi16(R_WT, B_WT, G_WT, R_WT, B_WT, G_WT, R_WT, B_WT));
			__m128i p2aH = _mm_mullo_epi16(_mm_cvtepu8_epi16(_mm_loadu_si128((__m128i *)(LinePS + 9))), _mm_setr_epi16(B_WT, G_WT, R_WT, B_WT, G_WT, R_WT, B_WT, G_WT));
			__m128i p3aH = _mm_mullo_epi16(_mm_cvtepu8_epi16(_mm_loadu_si128((__m128i *)(LinePS + 10))), _mm_setr_epi16(G_WT, R_WT, B_WT, G_WT, R_WT, B_WT, G_WT, R_WT));

			__m128i p1bL = _mm_mullo_epi16(_mm_cvtepu8_epi16(_mm_loadu_si128((__m128i *)(LinePS + 18))), _mm_setr_epi16(B_WT, G_WT, R_WT, B_WT, G_WT, R_WT, B_WT, G_WT));
			__m128i p2bL = _mm_mullo_epi16(_mm_cvtepu8_epi16(_mm_loadu_si128((__m128i *)(LinePS + 19))), _mm_setr_epi16(G_WT, R_WT, B_WT, G_WT, R_WT, B_WT, G_WT, R_WT));
			__m128i p3bL = _mm_mullo_epi16(_mm_cvtepu8_epi16(_mm_loadu_si128((__m128i *)(LinePS + 20))), _mm_setr_epi16(R_WT, B_WT, G_WT, R_WT, B_WT, G_WT, R_WT, B_WT));

			__m128i p1bH = _mm_mullo_epi16(_mm_cvtepu8_epi16(_mm_loadu_si128((__m128i *)(LinePS + 26))), _mm_setr_epi16(R_WT, B_WT, G_WT, R_WT, B_WT, G_WT, R_WT, B_WT));
			__m128i p2bH = _mm_mullo_epi16(_mm_cvtepu8_epi16(_mm_loadu_si128((__m128i *)(LinePS + 27))), _mm_setr_epi16(B_WT, G_WT, R_WT, B_WT, G_WT, R_WT, B_WT, G_WT));
			__m128i p3bH = _mm_mullo_epi16(_mm_cvtepu8_epi16(_mm_loadu_si128((__m128i *)(LinePS + 28))), _mm_setr_epi16(G_WT, R_WT, B_WT, G_WT, R_WT, B_WT, G_WT, R_WT));

			__m128i p1cH = _mm_mullo_epi16(_mm_cvtepu8_epi16(_mm_loadu_si128((__m128i *)(LinePS + 36))), _mm_setr_epi16(B_WT, G_WT, R_WT, B_WT, G_WT, R_WT, B_WT, G_WT));
			__m128i p2cH = _mm_mullo_epi16(_mm_cvtepu8_epi16(_mm_loadu_si128((__m128i *)(LinePS + 37))), _mm_setr_epi16(G_WT, R_WT, B_WT, G_WT, R_WT, B_WT, G_WT, R_WT));
			__m128i p3cH = _mm_mullo_epi16(_mm_cvtepu8_epi16(_mm_loadu_si128((__m128i *)(LinePS + 38))), _mm_setr_epi16(R_WT, B_WT, G_WT, R_WT, B_WT, G_WT, R_WT, B_WT));

			__m128i sumaL = _mm_add_epi16(p3aL, _mm_add_epi16(p1aL, p2aL));
			__m128i sumaH = _mm_add_epi16(p3aH, _mm_add_epi16(p1aH, p2aH));
			__m128i sumbL = _mm_add_epi16(p3bL, _mm_add_epi16(p1bL, p2bL));
			__m128i sumbH = _mm_add_epi16(p3bH, _mm_add_epi16(p1bH, p2bH));
			__m128i sumcH = _mm_add_epi16(p3cH, _mm_add_epi16(p1cH, p2cH));

			__m128i sclaL = _mm_srli_epi16(sumaL, 8);
			__m128i sclaH = _mm_srli_epi16(sumaH, 8);
			__m128i sclbL = _mm_srli_epi16(sumbL, 8);
			__m128i sclbH = _mm_srli_epi16(sumbH, 8);
			__m128i sclcH = _mm_srli_epi16(sumcH, 8);

			__m128i shftaL = _mm_shuffle_epi8(sclaL, _mm_setr_epi8(0, 6, 12, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1));
			__m128i shftaH = _mm_shuffle_epi8(sclaH, _mm_setr_epi8(-1, -1, -1, 2, 8, 14, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1));
			__m128i shftbL = _mm_shuffle_epi8(sclbL, _mm_setr_epi8(-1, -1, -1, -1, -1, -1, 0, 6, 12, -1, -1, -1, -1, -1, -1, -1));
			__m128i shftbH = _mm_shuffle_epi8(sclbH, _mm_setr_epi8(-1, -1, -1, -1, -1, -1, -1, -1, -1, 2, 8, 14, -1, -1, -1, -1));
			__m128i shftcH = _mm_shuffle_epi8(sclcH, _mm_setr_epi8(-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 6, 12, -1));
			__m128i accumL = _mm_or_si128(shftaL, shftbL);
			__m128i accumH = _mm_or_si128(shftaH, shftbH);
			__m128i h3 = _mm_or_si128(accumL, accumH);
			h3 = _mm_or_si128(h3, shftcH);
			_mm_storeu_si128((__m128i *)(LinePD + X), h3);
		}
		for (; X < Width; X++, LinePS += 3) {
			LinePD[X] = (B_WT * LinePS[0] + G_WT * LinePS[1] + R_WT * LinePS[2]) >> 8;
		}
	}
}
分辨率优化循环次数速度
4032x3024原始实现100012.139ms
4032x3024第一版优化（float->INT）10007.629ms
4032x3024第二版优化（手动4路并行）100010.528ms
4032x3024第三版优化（OpenMP4线程）10007.632ms
4032x3024第四版优化（SSE优化，一次处理12个像素）10005.579ms
4032x3024第五版优化（SSE优化，一次处理15个像素）10005.843ms

很遗憾并没有取得什么提升，考虑原因可能是因为图片的宽度除以12和除以15这两个直拉不开明显的数量级差距，导致重复计算不是特别多，在速度上体现不出来。

8. RGB转灰度图优化第六版

这一版即是使用AVX/AVX2指令集来优化，我们知道AVX寄存器可以一次处理256位也就是32个uchar，因此使用AVX来进行优化获取能带来性能提升。参考Github工程https://github.com/komrad36/RGB2Y/blob/master/RGB2Y.h将代码重写如下，注意这里的原理已经在注释里面标明了，如果你有疑惑可以到官方网站(https://software.intel.com/sites/landingpage/IntrinsicsGuide/#techs=AVX&expand=4155)查询指令集的对应操作或者联系我为你解答疑惑。

在AVX这一节的优化中，梁德澎作者对我理解这段代码提供了巨大的帮助，在此特别感谢。

AVX2指令集实现的代码如下：

// AVX2
constexpr double B_WEIGHT = 0.114;
constexpr double G_WEIGHT = 0.587;
constexpr double R_WEIGHT = 0.299;
constexpr uint16_t B_WT = static_cast<uint16_t>(32768.0 * B_WEIGHT + 0.5);
constexpr uint16_t G_WT = static_cast<uint16_t>(32768.0 * G_WEIGHT + 0.5);
constexpr uint16_t R_WT = static_cast<uint16_t>(32768.0 * R_WEIGHT + 0.5);
static const __m256i weight_vec = _mm256_setr_epi16(B_WT, G_WT, R_WT, B_WT, G_WT, R_WT, B_WT, G_WT, R_WT, B_WT, G_WT, R_WT, B_WT, G_WT, R_WT, B_WT);

void  _RGB2Y(unsigned char* Src, const int32_t Width, const int32_t start_row, const int32_t thread_stride, const int32_t Stride, unsigned char* Dest)
{
	for (int Y = start_row; Y < start_row + thread_stride; Y++)
	{
		//Sleep(1);
		unsigned char *LinePS = Src + Y * Stride;
		unsigned char *LinePD = Dest + Y * Width;
		int X = 0;
		for (; X < Width - 10; X += 10, LinePS += 30)
		{
			//B1 G1 R1 B2 G2 R2 B3 G3 R3 B4 G4 R4 B5 G5 R5 B6 
			__m256i temp = _mm256_cvtepu8_epi16(_mm_loadu_si128((const __m128i*)(LinePS + 0)));
			__m256i in1 = _mm256_mulhrs_epi16(temp, weight_vec);

			//B6 G6 R6 B7 G7 R7 B8 G8 R8 B9 G9 R9 B10 G10 R10 B11
			temp = _mm256_cvtepu8_epi16(_mm_loadu_si128((const __m128i*)(LinePS + 15)));
			__m256i in2 = _mm256_mulhrs_epi16(temp, weight_vec);


			//0  1  2  3   4  5  6  7  8  9  10 11 12 13 14 15    16 17 18 19 20 21 22 23 24 25 26 27 28   29 30  31       
			//B1 G1 R1 B2 G2 R2 B3 G3  B6 G6 R6 B7 G7 R7 B8 G8    R3 B4 G4 R4 B5 G5 R5 B6 R8 B9 G9 R9 B10 G10 R10 B11
			__m256i mul = _mm256_packus_epi16(in1, in2);

			__m256i b1 = _mm256_shuffle_epi8(mul, _mm256_setr_epi8(
				//  B1 B2 B3 -1, -1, -1  B7  B8  -1, -1, -1, -1, -1, -1, -1, -1,
				0, 3, 6, -1, -1, -1, 11, 14, -1, -1, -1, -1, -1, -1, -1, -1,

				//  -1, -1, -1, B4 B5 B6 -1, -1  B9 B10 -1, -1, -1, -1, -1, -1
				-1, -1, -1, 1, 4, 7, -1, -1, 9, 12, -1, -1, -1, -1, -1, -1));

			__m256i g1 = _mm256_shuffle_epi8(mul, _mm256_setr_epi8(

				// G1 G2 G3 -1, -1  G6 G7  G8  -1, -1, -1, -1, -1, -1, -1, -1, 
				1, 4, 7, -1, -1, 9, 12, 15, -1, -1, -1, -1, -1, -1, -1, -1,

				//  -1, -1, -1  G4 G5 -1, -1, -1  G9  G10 -1, -1, -1, -1, -1, -1	
				-1, -1, -1, 2, 5, -1, -1, -1, 10, 13, -1, -1, -1, -1, -1, -1));

			__m256i r1 = _mm256_shuffle_epi8(mul, _mm256_setr_epi8(

				//  R1 R2 -1  -1  -1  R6  R7  -1, -1, -1, -1, -1, -1, -1, -1, -1,	
				2, 5, -1, -1, -1, 10, 13, -1, -1, -1, -1, -1, -1, -1, -1, -1,

				//  -1, -1, R3 R4 R5 -1, -1, R8 R9  R10 -1, -1, -1, -1, -1, -1
				-1, -1, 0, 3, 6, -1, -1, 8, 11, 14, -1, -1, -1, -1, -1, -1));



			// B1+G1+R1  B2+G2+R2 B3+G3  0 0 G6+R6  B7+G7+R7 B8+G8 0 0 0 0 0 0 0 0 0 0 R3 B4+G4+R4 B5+G5+R5 B6 0 R8 B9+G9+R9 B10+G10+R10 0 0 0 0 0 0

			__m256i accum = _mm256_adds_epu8(r1, _mm256_adds_epu8(b1, g1));


			// _mm256_castsi256_si128(accum)
			// B1+G1+R1  B2+G2+R2 B3+G3  0 0 G6+R6  B7+G7+R7 B8+G8 0 0 0 0 0 0 0 0

			// _mm256_extracti128_si256(accum, 1)
			// 0 0 R3 B4+G4+R4 B5+G5+R5 B6 0 R8 B9+G9+R9 B10+G10+R10 0 0 0 0 0 0

			__m128i h3 = _mm_adds_epu8(_mm256_castsi256_si128(accum), _mm256_extracti128_si256(accum, 1));

			_mm_storeu_si128((__m128i *)(LinePD + X), h3);
		}
		for (; X < Width; X++, LinePS += 3) {
			int tmpB = (B_WT * LinePS[0]) >> 14 + 1;
			tmpB = max(min(255, tmpB), 0);

			int tmpG = (G_WT * LinePS[1]) >> 14 + 1;
			tmpG = max(min(255, tmpG), 0);

			int tmpR = (R_WT * LinePS[2]) >> 14 + 1;
			tmpR = max(min(255, tmpR), 0);

			int tmp = tmpB + tmpG + tmpR;
			LinePD[X] = max(min(255, tmp), 0);
		}
	}
}

//avx2 
void RGB2Y_6(unsigned char *Src, unsigned char *Dest, int width, int height, int stride)
{
	_RGB2Y(Src, width, 0, height, stride, Dest);
}
分辨率优化循环次数速度
4032x3024原始实现100012.139ms
4032x3024第一版优化（float->INT）10007.629ms
4032x3024第二版优化（手动4路并行）100010.528ms
4032x3024第三版优化（OpenMP4线程）10007.632ms
4032x3024第四版优化（SSE优化，一次处理12个像素）10005.579ms
4032x3024第五版优化（SSE优化，一次处理15个像素）10005.843ms
4032x3024第六版优化（AVX2优化，一次处理10个像素）10003.576ms

相比于SSE优化提高了2.xms，提升幅度还是比较大的。

9. RGB转灰度图优化第七版

在AVX2优化的基础上如果我们将多线程也加入进来，是否会获得提升呢？这里并非使用OpenMP而是使用C++中的std::async异步并行编程创建多个线程来执行整个任务，代码实现如下：

//avx2 + std::async异步编程
void RGB2Y_7(unsigned char *Src, unsigned char *Dest, int width, int height, int stride) {
	const int32_t hw_concur = std::min(height >> 4, static_cast<int32_t>(std::thread::hardware_concurrency()));
	std::vector<std::future<void>> fut(hw_concur);
	const int thread_stride = (height - 1) / hw_concur + 1;
	int i = 0, start = 0;
	for (; i < std::min(height, hw_concur); i++, start += thread_stride)
	{
		fut[i] = std::async(std::launch::async, _RGB2Y, Src, width, start, thread_stride, stride, Dest);
	}
	for (int j = 0; j < i; ++j)
		fut[j].wait();
}

速度测试结果如下：

分辨率优化循环次数速度
4032x3024原始实现100012.139ms
4032x3024第一版优化（float->INT）10007.629ms
4032x3024第二版优化（手动4路并行）100010.528ms
4032x3024第三版优化（OpenMP4线程）10007.632ms
4032x3024第四版优化（SSE优化，一次处理12个像素）10005.579ms
4032x3024第五版优化（SSE优化，一次处理15个像素）10005.843ms
4032x3024第六版优化（AVX2优化，一次处理10个像素）10003.576ms
4032x3024第七版优化（AVX2优化+std::async）10002.626ms

可以看到使用异步并行以及AVX优化后，我们已经将原始算法的速度优化了接近5倍，在PC端优化RGB转灰度图算法我能想到和调研到的一些相关算法大概就这么多了，如果还有其它相关的想法或者方法可以在评论区留言讨论。

10. 总结

分辨率优化循环次数速度
4032x3024原始实现100012.139ms
4032x3024第一版优化（float->INT）10007.629ms
4032x3024第二版优化（手动4路并行）100010.528ms
4032x3024第三版优化（OpenMP4线程）10007.632ms
4032x3024第四版优化（SSE优化，一次处理12个像素）10005.579ms
4032x3024第五版优化（SSE优化，一次处理15个像素）10005.843ms
4032x3024第六版优化（AVX2优化，一次处理10个像素）10003.576ms
4032x3024第七版优化（AVX2优化+std::async）10002.626ms

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

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

二维码

just_sort
关注
专栏目录
数字图像处理与Python实现-颜色空间转换-RGB图像转换灰度图像
视觉与物联智能
07-05 1053
RGB图像转换灰度图像 RGB图像转换灰度图像 1. 前言 2. RGB颜色空间及灰度图像 3. RGB颜色空间转换灰度图像 4. 代码实现 5. 参考 1. 前言 RGB色彩模型是工业界的一种颜色标准，是通过红(Red)、绿(Green)、蓝(Blue)三个颜色通道的变化以及它们之间的叠加来得到各种颜色。RGB即是代表红、绿、蓝三个通道的颜色，这个标准几乎包括了人类视力所能感知的所有颜色，是目前运用最广的颜色系统之一[1]。 灰度数字图像是每个像素只有一个采样颜色的图像。这类图像通常显示为从
PCL 彩色点云RGB转灰度并显示
最新发布
点云侠的博客
03-28 367
彩色点云RGB转灰度并显示
C语言运行时变成灰色,C语言实现RGB图像转换成灰（Gray）度图像
weixin_29550949的博客
05-22 1528
以前实现RGB图像转换成灰度图像都是直接调用OpenCV的库函数RGB2GRAY(IplImage* src);最近老板让我们除了读入输出图像实时用OpenCV的函数，其余的最好都是自己写，所以我自己上网查了一些资料，得到了一些转换算法，并且用c语言实现，具体归纳下来有如下三种：方法一.对于RGB转灰度，有一个很著名的心理公式：Gray = r*0.299 + g*0.587 + b*0.114;...
AI绘图的场景应用：文生图、图生图
qq_41314882的博客
03-15 2270
AIGC技术的未来发展前景广阔，随着人工智能技术的不断发展，AIGC技术也将不断提高。未来，AIGC技术将在游戏和计算领域得到更广泛的应用，使游戏和计算系统具有更高效、更智能、更灵活的特性。同时，AIGC技术也将与人工智能技术紧密结合，在更多的领域得到广泛应用，对程序员来说影响至关重要。未来，AIGC技术将继续得到提高，同时也将与人工智能技术紧密结合，在更多的领域得到广泛应用。感兴趣的小伙伴，赠送全套AIGC学习资料和安装工具，包含AI绘画、AI人工智能等前沿科技教程，模型插件，具体看下方。
RGB2Y:最快的CPU（AVXSSE）RGB到灰度
05-04
最快的RGB灰度CPU（AVX / SSE）实现。 比使用AVX2的OpenCV实施快大约3倍，如果仅使用SSE，则比OpenCV实施快2倍。 将RGB彩色图像转换为灰度。 您可以通过将权重设置为'false'来调用模板化函数来使用相等权重，或者可以指定非相等权重（仅稍慢一些）。 默认的不相等权重与OpenCV默认权重匹配。 要获得更高的速度，请参阅CUDA版本：github.com/komrad36/CUDARGB2Y 如果您没有AVX2，请取消注释下面的#define NO_AVX_PLEASE以仅使用SSE结构。 注意，这大约慢了50％。 强烈建议使用支持AVX2的处理器。 所有功能都包含在RGB2Y.h中。 “ main.cpp”是一个演示和测试工具。
AI PC优化系列之RGB高效转灰度图
cxn511的博客
04-19 1295
下面的介绍来自刘文志大佬的并行编程方法与优化实践一书，这应该是做优化的同学最好的入门书籍之一了。 ❝ SSE/AVX是Intel公司设计的，对其X86体系的SIMD扩展指令集，它基于SIMD向量化技术，提高了X86硬件的计算能力，增强了X86多核向量处理器的图像和视频处理能力。 ❞ ❝ SSE/AVX指令支持向量化数据并行，一个指令可以同时对多个数据进行操作，同时操作的数据个数由向量寄...
简单处理RGB图像变换为灰度图像和二值图像
hello_list的博客
09-22 2695
%清屏并清除变量 clear all; close all; clc %读取一个rgb图像 xue = imread('xue.jpg'); %对图像进行灰度化处理 grayxue = rgb2gray(xue); %对灰度化图像进行二值转换 bwxue = im2bw(grayxue); %展示图像 subplot(131),title('原RGB图像'),imshow(xue); subplot(132),title('转换灰度图像'),imshow(grayxue); subplot(133),tit
高动态图像渲染算法实现——HDR图像转RGB图像
03-30
总之，"高动态图像渲染算法实现——HDR图像转RGB图像"这一项目深入探讨了如何将高动态范围的图像转换为适合显示的LDR图像，通过多种色调映射方法展示了计算机图形学在提升视觉体验上的强大能力。这对于游戏开发、...
图片的两种灰度算法.rar
04-07
学习这两种灰度算法有助于提升对图像处理的理解，特别是对于那些从事图像分析、机器学习或人工智能领域的开发者。通过实践这些算法，我们可以更好地掌握图像处理的基本原理，并为更复杂的图像操作打下基础。 6. **...
huidutuzhifangtu_RGB空间直方图_灰度直方图_颜色直方图_
09-29
在本主题中，我们将深入探讨“RGB空间直方图”、“灰度直方图”和“颜色直方图”这三种关键概念。 首先，让我们来看看“灰度直方图”。灰度直方图是针对单通道图像（如灰度图像）的统计表示，它将图像中的每个像素...
OpenCV算法加速的一些学习总结
Yangy_Jiaojiao的博客
04-17 5215
Opencv算子加速 TBB、SSE、OpenMP、AVX加速学习总结
使用SSE指令集来优化程序
百里杨的博客
08-24 3927
SSE和SSE2的指令系统非常相似，SSE2比SSE多的仅是少量的额外浮点处理功能、64位浮点数运算支持和64位整数运算支持。 SSE为什么会比传统的浮点运算更快呢？因为它使用了128位的存储单元，这对于32位的浮点数来讲，是可以存下4个的，也就是说，SSE中的所有计算都是一次性针对4个浮点数来完成的。 虽然SSE从理论上来讲要比传统的浮点运算会快，但是所受的限制也很多，首先，虽然它执行一次相当于四次，会比传统的浮点运算执行4次的速度要快，但是它执行一次的速度却并没有想象中的那...
指令集笔记
weixin_44591545的博客
12-02 310
图像 指令集 笔记
SSE图像算法优化系列1-RGB转灰度图
I good vegetable a!
07-02 2705
前言 ImageShop博主是我的Idol。我会逐渐出一些SSE优化一些图像领域的算法的文章，并且将代码开源到Github，希望可以为我多多star。 算法原理 RGB转灰度图没啥说的了，这里的重点在于使用SSE优化，但为了和普通以及多线程优化的程序做一个速度对比这里也提供了一下对应的程序实现，我在实现这个代码的时候主要参考了ImageShop博主的这篇文章，https://www.cnblogs...
opencv彩色图像(RGB)转灰度图像及其优化
生命在于折腾！
06-18 1万+
1. 彩色图像转灰度图像 RGB转灰度，通常会使用下面的一个心理学公式：(Matlab和OpenCV中使用的也是该公式) Gray = 0.2989*R + 0.5870*G + 0.1140*B 实现代码如下 #include //通过上述计算公式得到灰度图像 void grayImageShow(cv::Mat &input, cv::Mat &output)
RGB图转为灰度图的方法
m0_49089298的博客
05-08 1万+
我们日常的环境通常获得的是彩色图像，很多时候我们常常需要将彩色图像转换成灰度图像。也就是3个通道（RGB）转换成1个通道。 （1）平均法 最简单的方法当然就是平均法，将同一个像素位置3个通道RGB的值进行平均。 I(x,y) = 1/3 * I_R(x,y) +1/3 * I_G(x,y)+ 1/3 * I_B(x,y) 原始图像： import cv2 import numpy as np lenna = cv2.imread("lenna.png") row, col, channel = lenna
RGB转灰度图
dannylsl的专栏
03-19 1万+
<br /><br /> <br />    VC++写个图像处理的程序，挑了个简单的，RGB转灰度图，上网查了些资料，发现转化的方法还各种各样，于是写篇日志以祭之。<br />     *********************************<br />     方法一：<br />    对于彩色转灰度，有一个很著名的心理学公式：<br />                          Gray = R*0.299 + G*0.587 + B*0.114<br />     方法二：<b
SSE图像算法优化系列十三：超高速BoxBlur算法的实现和优化（Opencv的速度的五倍）...
PixelDemon的博客
01-20 495
在SSE图像算法优化系列五：超高速指数模糊算法的实现和优化(10000*10000在100ms左右实现)一文中，我曾经说过优化后的ExpBlur比BoxBlur还要快，那个时候我比较的BoxBlur算法是通过积分图+SSE实现的，我在09年另外一个博客账号上曾经提供过一篇这个文章彩色图像高速模糊之懒惰算法，里面也介绍了一种快速的图像模糊算法，这个算法的执行时间基本也是和半径无关的。...
OpenCV CV_RGB2GRAY与CV_BGR2GRAY的区别
热门推荐
weixin_42142612的博客
06-25 4万+
平时处理图像的时候，很少用到彩色信息，一般都是直接转换为灰度图。转换灰度图用的cvtColor的第三个参数中有两个参数，我一直没太注意区别，CV_RGB2GRAY与CV_BGR2GRAY。今天通过一个简单的测试区分一下。测试代码如下：#include &lt;opencv2\opencv.hpp&gt; using namespace std; using namespace cv; int ...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值