SSE速度优化：彩色图转灰度图 （OpenCV、SSE、AVX、OpenMP、std::async线程对比）

最新推荐文章于 2023-01-20 16:42:00 发布
最新推荐文章于 2023-01-20 16:42:00 发布
阅读量1.6k 收藏 13
点赞数 1
分类专栏： 图像加速 文章标签： OpenCV SSE AVX OpenMP std::async
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Stone_Wang_MZ/article/details/103994562
版权

运行结果为：详情看代码 

// TestOpenCV4.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//
#include "pch.h"
#include <windows.h>
#include "vInclude.h"
#include <iostream>
#include <stdio.h>
#include <future>
#include "omp.h" 

using namespace std;
using namespace cv;

void RGB2Y_0(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;
		}
	}
}

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;
		#pragma omp parallel for
		for (int X = 0; X < Width; X++) 
		{
			unsigned char * Line = LinePS + 3 * X;
			LinePD[X] = (B_WT * Line[0] + G_WT * Line[1] + R_WT * Line[2]) >> 8;
		}
	}
}

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;
		}
	}
}

void RGB2Y_22(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 - 6; X += 6, LinePS += 18)
		{
			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;
			LinePD[X + 4] = (B_WT * LinePS[12] + G_WT * LinePS[13] + R_WT * LinePS[14]) >> 8;
			LinePD[X + 5] = (B_WT * LinePS[15] + G_WT * LinePS[16] + R_WT * LinePS[17]) >> 8;
		}
	}
}

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; // 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 temp0;
			__m128i temp1;
			temp0 = _mm_loadu_si128((__m128i *)(LinePS + 0));
			temp0 = _mm_cvtepu8_epi16(temp0);
			temp1 = _mm_setr_epi16(B_WT, G_WT, R_WT, B_WT, G_WT, R_WT, B_WT, G_WT);
			__m128i p1aL = _mm_mullo_epi16(temp0, temp1);
			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

			temp0 = _mm_loadu_si128((__m128i *)(LinePS + 1));
			temp0 = _mm_cvtepu8_epi16(temp0);
			temp1 = _mm_setr_epi16(G_WT, R_WT, B_WT, G_WT, R_WT, B_WT, G_WT, R_WT);
			__m128i p2aL = _mm_mullo_epi16(temp0, temp1);
			 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

			temp0 = _mm_loadu_si128((__m128i *)(LinePS + 2));
			temp0 = _mm_cvtepu8_epi16(temp0);
			temp1 = _mm_setr_epi16(R_WT, B_WT, G_WT, R_WT, B_WT, G_WT, R_WT, B_WT);
			__m128i p3aL = _mm_mullo_epi16(temp0, temp1);
			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 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 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 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, 18, 24, 30, -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, 18, 24, 30, -1, -1, -1, -1));
			__m128i accumL = _mm_or_si128(shftaL, shftbL);
			__m128i accumH = _mm_or_si128(shftaH, shftbH);
			__m128i h3 = _mm_or_si128(accumL, accumH);
			//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);
		}
	}
}

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 - 15; X += 15, LinePS += 45)
		{
			__m128i temp0;
			__m128i temp1;
			temp0 = _mm_loadu_si128((__m128i *)(LinePS + 0));
			temp0 = _mm_cvtepu8_epi16(temp0);
			temp1 = _mm_setr_epi16(B_WT, G_WT, R_WT, B_WT, G_WT, R_WT, B_WT, G_WT);
			__m128i p1aL = _mm_mullo_epi16(temp0, temp1);
			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

			temp0 = _mm_loadu_si128((__m128i *)(LinePS + 1));
			temp0 = _mm_cvtepu8_epi16(temp0);
			temp1 = _mm_setr_epi16(G_WT, R_WT, B_WT, G_WT, R_WT, B_WT, G_WT, R_WT);
			__m128i p2aL = _mm_mullo_epi16(temp0, temp1);
			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

			temp0 = _mm_loadu_si128((__m128i *)(LinePS + 2));
			temp0 = _mm_cvtepu8_epi16(temp0);
			temp1 = _mm_setr_epi16(R_WT, B_WT, G_WT, R_WT, B_WT, G_WT, R_WT, B_WT);
			__m128i p3aL = _mm_mullo_epi16(temp0, temp1);
			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);
		}
	}
}

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 __forceinline _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)
		{
			__m256i temp;
			__m128i tempp = _mm_loadu_si128((const __m128i*)(LinePS + 0));
			temp = _mm256_cvtepu8_epi16(tempp);
			__m256i in1 = _mm256_mulhrs_epi16(temp, weight_vec);
			temp = _mm256_cvtepu8_epi16(_mm_loadu_si128((const __m128i*)(LinePS + 15)));
			__m256i in2 = _mm256_mulhrs_epi16(temp, weight_vec);
			__m256i mul = _mm256_packus_epi16(in1, in2);
			__m256i b1 = _mm256_shuffle_epi8(mul, _mm256_setr_epi8(0, 3, 6, -1, -1, -1, 11, 14, -1, -1, -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(1, 4, 7, -1, -1, 9, 12, 15, -1, -1, -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(2, 5, -1, -1, -1, 10, 13, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 3, 6, -1, -1, 8, 11, 14, -1, -1, -1, -1, -1, -1));
			__m256i accum = _mm256_adds_epu8(r1, _mm256_adds_epu8(b1, g1));
			__m128i h3 = _mm_adds_epu8(_mm256_castsi256_si128(accum), _mm256_extracti128_si256(accum, 1));
			_mm_storeu_si128((__m128i *)(LinePD + X), h3);
		}
	}
}


void RGB2Y_5(unsigned char *Src, unsigned char *Dest, int width, int height, int stride)
{
	_RGB2Y(Src, width, 0, height, stride, Dest);
}

void RGB2Y_6(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();
}

int main()
{
	Mat src = imread("test.jpg");
	int Height = src.rows;
	int Width = src.cols;
	unsigned char *Src = src.data;
	unsigned char *Dest = new unsigned char[Height * Width];
	int Stride = Width * 3;
	int Radius = 11;

	int64 st; 
	double duration; 

	st = cv::getTickCount();
	Mat newimage_cv;
	cv::cvtColor(src, newimage_cv, COLOR_BGR2GRAY);
	duration = (cv::getTickCount() - st) / cv::getTickFrequency() * 1000;
	printf("OpenCV:%.5f\n", duration);

	st = cv::getTickCount();
	RGB2Y_1(Src, Dest, Width, Height, Stride);
	duration = (cv::getTickCount() - st) / cv::getTickFrequency() * 1000;
	printf("RGB2Y_1:%.5f\n", duration);

	st = cv::getTickCount();
	RGB2Y_2(Src, Dest, Width, Height, Stride);
	duration = (cv::getTickCount() - st) / cv::getTickFrequency() * 1000;
	printf("RGB2Y_2:%.5f\n", duration);

	st = cv::getTickCount();
	RGB2Y_3(Src, Dest, Width, Height, Stride);
	duration = (cv::getTickCount() - st) / cv::getTickFrequency() * 1000;
	printf("RGB2Y_3:%.5f\n", duration);

	st = cv::getTickCount();
	RGB2Y_4(Src, Dest, Width, Height, Stride);
	duration = (cv::getTickCount() - st) / cv::getTickFrequency() * 1000;
	printf("RGB2Y_4:%.5f\n", duration);

	st = cv::getTickCount();
	RGB2Y_5(Src, Dest, Width, Height, Stride);
	duration = (cv::getTickCount() - st) / cv::getTickFrequency() * 1000;
	printf("RGB2Y_5:%.5f\n", duration);

	st = cv::getTickCount();
	RGB2Y_6(Src, Dest, Width, Height, Stride);
	duration = (cv::getTickCount() - st) / cv::getTickFrequency() * 100;
	printf("RGB2Y_6:%.5f\n", duration);


	Mat dst(Height, Width, CV_8UC1, Dest);
	//imshow("origin", src);
	//imshow("result", dst);
	waitKey(0);
	return 0;
}

 

相关链接：

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

https://github.com/komrad36/RGB2Y

三石目
关注
  • 1
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SSE4，pca算法，opencv超详细动态人脸（眼睛，嘴）检索
12-10
超级详细的动态人脸检索，包括源代码，学术论文。适合西安交通大学研究生并行计算机架构。
AVX SSE openmp
sxk20091111的专栏
11-04 272
分别对如下计算进行不同方式的处理 x = abs(*(I2pData+i) /(sqrt(3.0) * (esp + *(I1pData+i)) )); 原始的C版本 cost time:32.7379 cost time:33.2216 cost time:33.1455 cost time:32.8658 cost time:32.8115 cost time:35.0207 cos...
水平集图像分割并行加速算法设计与实现(串行、OpenMP、CUDA)——OpenMP并行实现篇
weixin_46007180的博客
01-20 1262
本系列文章详细讲解了水平集图像分割的基本原理，并基于C++与OpenCV给出了相应的串行实现。在上述基础上，结合OpenMP与CUDA，分别在CPU与GPU层面，实现了针对水平集图像分割算法的并行化任务，且取得了优良的加速效果。文章内有源码与水平集相关论文原文提供，帮助读者进一步加深对于水平集图像分割算法与相应的并行化设计方案的理解与认识。
AVX SSE 性能实验
sxk20091111的专栏
10-26 528
AVX SSE 性能实验 代码 ··· #include “math_function.h” float MathMulAdd(const float *input1, const float *input2, int size) { float output = 0.0; for (int i = 0; i < size; i++) { output += input1[i] * inpu...
SSE图像算法优化系列六：OpenCv关于灰度积分图的SSE代码学习和改进。
weixin_34023863的博客
05-29 197
　　最近一直沉迷于SSE方面的优化，实在找不到想学习的参考资料了，就拿个笔记本放在腿上翻翻OpenCv的源代码，无意中看到了OpenCv中关于积分图的代码，仔细研习了一番，觉得OpenCv对SSE的灵活运用真的做的很好，这里记录下我对该段代码的品味并将其思路扩展到其他通道数的图像。 该核心代码位于：Opencv 3.0\opencv\sources\modules\imgproc\sr...
opencv彩色图像转灰度图（带图形界面）
04-06
彩色图像转灰度图的算法，带图形界面，c++写的，比较简单
Qt+OpenCV小项目：灰度图转换
01-09
Qt+OpenCV小项目：灰度图转换
opencv彩色图转换为灰度图并保存
04-24
opencv将彩色图转换为灰度图并保存 src转换为dst保存
C++实验：灰度直方图含实验报告
12-09
本资源不含OpenCV，OpenCV只用来转灰度图（可以删掉相关代码）其余画直方图是自己写的函数。 实验任务 统计灰度图像的直方图 （1）以二进制方式读取一幅 bmp、jpeg 或 png 格式图像的数据，并判断其是否为灰度图像...
HS.rar_hs直方图_opencv舌_site:www.pudn.com_舌_舌提取
09-23
利用opencv提取舌象的H-S直方图，hsv颜色空间
MMX和SSE实现的opencv数据结构的图像反色算法优化
09-14
利用MMX和SSE实现的opencv的Mat类型的图像发色算法优化，可以作为MMX和SSE算法优化的入门例程
opencv cpu指令集SSE/AVX
苦逼的程序猿
04-19 5324
SSE与AVX指令集 SSE指令集是英特尔提供的基于SIMD（单指令多数据，也就是说同一时间内，对多个不同的数据执行同一条命令）的硬件加速指令，通过使用寄存器来进行并行加速。经过几代的迭代，最新的SSE4已经极大地扩展了指令集的功能，并且随后已经从128位寄存器继续扩展到256位的指令。 想要使用SSE或AVX指令集，需要包含以下头文件 #include <mmintrin.h> //mmx, 4个64位寄存器 #include <xmmintrin.h> //ss
SSE2的简单理解，主要针对opencv 中的优化
911的专栏
01-15 4373
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- __m128i _mm
OpenCV、EmguCV和OpenCvSharp指针访问图像像素值耗时测评(附源码)
Color Space的博客
07-13 1929
OpenCV、EmguCV和OpenCvSharp指针访问图像像素值耗时测评
SSE指令学习：_mm_shuffle_epi8
Stone_石头
01-14 5884
_mm_setr_epi8：Integer, sets中的函数，初始化赋值。 _mm_shuffle_epi8：第一个参数为输入数组；第二个参数为掩模，对应输入数组的第几个值。 功能：对数据进行重组，非常灵活。当掩模值大于1时，该值除以16求余，如17即为1。当掩模值为-1时对应值为0。 __m128i a= _mm_setr_epi8(1, 2, 3, 4, 5, 6, 7, 8, 9,...
TBB、OpenMP对比
Stone_石头
01-18 4259
1、TBB需要相当可观的重新设计程序，而OpenMP足够简单； 2、TBB不太适合并行化已有的实现（软件），它为新设计的并行程序培养一种好的编程风格和更高的抽象层； 3、在论文的实验中，OpenMP稍稍超过TBB； 4、TBB只能针对C++,如果程序基于C或者Fortran就用不上了； 5、TBB提供了并行容器，使得结构上的并行更加简单方便； 6、如果您的并行模式主要用于内建类型的有...
MMX、SSE、AVX等SIMD指令集说明
Stone_石头
01-09 3553
发展历程 SIMD指令集头文件对应查找表 头文件 指令集描述 intrin.h All Architectures mmintrin.h MMX xmmintrin.h SSE emmintrin.h SSE2 pmmintrin.h SSE3 smmintrin.h SSE4.1 nmmintrin.h SSE4.2 immintrin...
学习MIPP
Stone_石头
09-10 3541
1、 VS中启用指令集；这里我用的VS2019启用AVX512时会编译失败。 2、这里采用的指令集是AVX2，一个寄存器有256位，每个寄存器的元素数量根据保存的数据类型决定，比如mipp::N<float>等于8，float为32位，则寄存器mipp::Reg<float>可以存8个float数据；mipp::N<double>等于4，double为64位，寄存器mipp::Reg<double>只能存4个double数据。 因为调试时只能看到m25
了解Intel IPP
Stone_石头
01-13 2052
IPP（Intel IPP）是一套跨平台的软件函数库，他提供了广泛的多媒体功能：音频解码器（例如： H263 、 MPEG-4 ）、图像处理 (JPEG) 、信号处理、语音压缩等。好像比较适合多媒体开发。 如果在英特尔的处理器上使用，OpenCV就会自动使用一种免费的英特尔集成性能原语库（IPP）的子集，IPP 8.x(IPPICV)。IPPICV可以在编译阶段链接...
opencv c++ 彩色图转灰度图
最新发布
01-21
在OpenCV C++中，可以使用以下方法将彩色图像转换为灰度图像： ```cpp #include <opencv2/opencv.hpp> int main() { // 读取彩色图像 cv::Mat colorImage = cv::imread("color_image.jpg"); // 将彩色图像转换为灰度图像 cv::Mat grayImage; cv::cvtColor(colorImage, grayImage, cv::COLOR_BGR2GRAY); // 显示灰度图像 cv::imshow("Gray Image", grayImage); cv::waitKey(0); return 0; } ``` 在上述代码中，首先使用`cv::imread`函数读取彩色图像，然后使用`cv::cvtColor`函数将彩色图像转换为灰度图像，其中`cv::COLOR_BGR2GRAY`表示将BGR彩色图像转换为灰度图像。最后，使用`cv::imshow`函数显示灰度图像，并使用`cv::waitKey`函数等待按键。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值