#include "OpenCLExcuter.h"
#include <chrono>



#define CHECK_ERRORS(ERR) \
	if(ERR != CL_SUCCESS){ \
		cerr << "OpenCL error code" << ERR << "file: " << __FILE__  << "line: " << __LINE__ << ".\nExiting..." << endl; \
		exit(1); \
	}

int showDeviceInfo() {
	cl_platform_id* platform;
	cl_uint num_platform;
	cl_int err;
	err = clGetPlatformIDs(0, NULL, &num_platform);
	platform = (cl_platform_id*)malloc(sizeof(cl_platform_id) * num_platform);
	err = clGetPlatformIDs(num_platform, platform, NULL);
	for (int i = 0; i < num_platform; i++) {
		printf("\nPlatform %d information\n", i);
		size_t size;
		err = clGetPlatformInfo(platform[i], CL_PLATFORM_NAME, 0, NULL, &size);
		char* PName = (char*)malloc(size);
		err = clGetPlatformInfo(platform[i], CL_PLATFORM_NAME, size, PName, NULL);
		printf("CL_PLATFORM_NAME: %s\n", PName);
		err = clGetPlatformInfo(platform[i], CL_PLATFORM_VENDOR, 0, NULL, &size);
		char* PVendor = (char*)malloc(size);
		err = clGetPlatformInfo(platform[i], CL_PLATFORM_VENDOR, size, PVendor, NULL);
		printf("CL_PLATFORM_VENDOR: %s\n", PVendor);
		err = clGetPlatformInfo(platform[i], CL_PLATFORM_VERSION, 0, NULL, &size);
		char* PVersion = (char*)malloc(size);
		err = clGetPlatformInfo(platform[i], CL_PLATFORM_VERSION, size, PVersion, NULL);
		printf("CL_PLATFORM_VERSION: %s\n", PVersion);
		err = clGetPlatformInfo(platform[i], CL_PLATFORM_PROFILE, 0, NULL, &size);
		char* PProfile = (char*)malloc(size);
		err = clGetPlatformInfo(platform[i], CL_PLATFORM_PROFILE, size, PProfile, NULL);
		printf("CL_PLATFORM_PROFILE: %s\n", PProfile);
		err = clGetPlatformInfo(platform[i], CL_PLATFORM_EXTENSIONS, 0, NULL, &size);
		char* PExten = (char*)malloc(size);
		err = clGetPlatformInfo(platform[i], CL_PLATFORM_EXTENSIONS, size, PExten, NULL);
		printf("CL_PLATFORM_EXTENSIONS: %s\n", PExten);
		free(PName);
		free(PVendor);
		free(PVersion);
		free(PProfile);
		free(PExten);
	}

	return 0;

}

string OpenCLExcuter::rootPath;

void OpenCLExcuter::reCreateQueue()
{

	//»ñȡƽ̨
	error = clGetPlatformIDs(1, &platforms, &num_of_platforms);
	if (error != 0) {
		throw string("Get platform failed!");
	}

	error = clGetDeviceIDs(platforms, CL_DEVICE_TYPE_GPU, 1, &devices, NULL);
	if (error != 0) {
		error = clGetDeviceIDs(platforms, CL_DEVICE_TYPE_CPU, 1, &devices, NULL);
		if (error != CL_SUCCESS) {
			throw string("Get device failed!");
		}
	}
	//´´½¨ÉÏÏÂÎÄ
	context = clCreateContext(NULL, 1, &devices, NULL, NULL, &error);
	if (error != CL_SUCCESS) {
		throw string("Creat context failed!");
	}
	//´´½¨³ÌÐò£»×¢ÒâÒªÓÃ"rb"
	string kernel_path = "";
	if (rootPath.length() > 0) {
		kernel_path = kernel_path.append(rootPath);
	}

	kernel_path.append("kernel.cl");
	cout << "kernel_path:" << kernel_path << endl;
	fopen_s(&program_handle, kernel_path.c_str(), "rb");

	if (program_handle == NULL) {
		throw string("The kernle can not be opened!");
	}
	fseek(program_handle, 0, SEEK_END);
	program_size = ftell(program_handle);
	rewind(program_handle);

	program_buffer = (char*)malloc(program_size + 1);
	program_buffer[program_size] = '\0';
	error = fread(program_buffer, sizeof(char), program_size, program_handle);
	if (error == 0) {
		throw string("Read kernel failed!");
	}
	fclose(program_handle);
	program = clCreateProgramWithSource(context, 1, (const char**)&program_buffer,
		&program_size, &error);
	if (error < 0) {
		program = clCreateProgramWithSource(context, 0, (const char**)&program_buffer,
			&program_size, &error);
		if (error < 0) {
			string st = "Couldn't create the program!";
			st.append("  error:").append(to_string(error));
			throw st;
		}
	}
	//±àÒë³ÌÐò
	error = clBuildProgram(program, 1, &devices, NULL, NULL, NULL);
	if (error < 0) {
		//È·¶¨ÈÕÖ¾ÎļþµÄ´óС
		clGetProgramBuildInfo(program, devices, CL_PROGRAM_BUILD_LOG, 0, NULL, &log_size);
		program_log = (char*)malloc(log_size + 1);
		program_log[log_size] = '\0';
		//¶ÁÈ¡ÈÕÖ¾
		clGetProgramBuildInfo(program, devices, CL_PROGRAM_BUILD_LOG,
			log_size + 1, program_log, NULL);
		printf("%s\n", program_log);
		free(program_log);
		throw string("Build Program Failed");
	}
	free(program_buffer);

	//´´½¨ÃüÁî¶ÓÁÐ
	//queue = clCreateCommandQueue(context, devices, CL_QUEUE_PROFILING_ENABLE, &error);
	queue = clCreateCommandQueueWithProperties(context, devices, 0, &error);

	if (error < 0) {
		queue = clCreateCommandQueue(context, devices, CL_QUEUE_PROFILING_ENABLE, &error);
		if (error < 0) {
			throw string("Coudn't create the command queue");
		}
	}
}

void OpenCLExcuter::excuteError()
{
	destory();
	reCreateQueue();
}

void OpenCLExcuter::init() {
	showDeviceInfo();
	//»ñȡƽ̨
	error = clGetPlatformIDs(1, &platforms, &num_of_platforms);
	if (error != 0) {
		throw string("Get platform failed!");
	}
	//»ñÈ¡É豸
	//error = clGetDeviceIDs(platforms, CL_DEVICE_TYPE_GPU, 1, &devices, NULL);
	//if (error != 0) {
	//	error = clGetDeviceIDs(platforms, CL_DEVICE_TYPE_CPU, 1, &devices, NULL);
	//	if (error != 0) {
	//		throw string("Get device failed!");
	//	}
	//}

	devices = nullptr;

	error = clGetDeviceIDs(platforms, CL_DEVICE_TYPE_GPU , 1, &devices, NULL);
	if (error != 0) {
		error = clGetDeviceIDs(platforms, CL_DEVICE_TYPE_CPU, 1, &devices, NULL);
		if (error != CL_SUCCESS) {
			throw string("Get device failed!");
		}
	}

	//´´½¨ÉÏÏÂÎÄ
	context = clCreateContext(NULL, 1, &devices, NULL, NULL, &error);
	if (error != CL_SUCCESS) {
		throw string("Creat context failed!");
	}
	//´´½¨³ÌÐò£»×¢ÒâÒªÓÃ"rb"
	string kernel_path = "";
	if (rootPath.length() >0) {
		kernel_path = kernel_path.append(rootPath);
	}
	
	kernel_path.append("kernel.cl");
	cout <<"kernel_path:"<< kernel_path << endl;
	fopen_s(&program_handle, kernel_path.c_str(), "rb");

	if (program_handle == NULL) {
		throw string("The kernle can not be opened!");
	}
	fseek(program_handle, 0, SEEK_END);
	program_size = ftell(program_handle);
	rewind(program_handle);

	program_buffer = (char*)malloc(program_size + 1);
	program_buffer[program_size] = '\0';
	error = fread(program_buffer, sizeof(char), program_size, program_handle);
	if (error == 0) {
		throw string("Read kernel failed!");
	}
	fclose(program_handle);
	program = clCreateProgramWithSource(context, 1, (const char**)&program_buffer,
		&program_size, &error);
	if (error < 0) {
		program = clCreateProgramWithSource(context, 0, (const char**)&program_buffer,
			&program_size, &error);
		if (error < 0) {
			string st = "Couldn't create the program!";
			st.append("  error:").append(to_string(error));
			throw st;
		}
	}
	//±àÒë³ÌÐò
	error = clBuildProgram(program, 1, &devices, NULL, NULL, NULL);
	if (error < 0) {
		//È·¶¨ÈÕÖ¾ÎļþµÄ´óС
		clGetProgramBuildInfo(program, devices, CL_PROGRAM_BUILD_LOG, 0, NULL, &log_size);
		program_log = (char*)malloc(log_size + 1);
		program_log[log_size] = '\0';
		//¶ÁÈ¡ÈÕÖ¾
		clGetProgramBuildInfo(program, devices, CL_PROGRAM_BUILD_LOG,
			log_size + 1, program_log, NULL);
		printf("%s\n", program_log);
		free(program_log);
		throw string("Build Program Failed");
	}
	free(program_buffer);

	//´´½¨ÃüÁî¶ÓÁÐ
	//queue = clCreateCommandQueue(context, devices, CL_QUEUE_PROFILING_ENABLE, &error);
	queue = clCreateCommandQueueWithProperties(context, devices, 0, &error);
	
	if (error < 0) {
		queue = clCreateCommandQueue(context, devices, CL_QUEUE_PROFILING_ENABLE, &error);
		if (error < 0) {
			throw string("Coudn't create the command queue");
		}
	}
}


unsigned char** OpenCLExcuter::recognition_numbers(unsigned char* data, unsigned char* b_in, const int rows, const int cols, const int num_width, const int num_height, const int line_number_count) throw(std::string) {
	//----------³ÌÐòÕýÎÄ¿ªÊ¼---------
	auto startexectime = std::chrono::steady_clock::now();
	const int resultSize = rows * cols / (num_width * num_height);
	const int inputSize = rows * cols;
	//´´½¨ÄÚºË
	kernel = clCreateKernel(program, "recognition_numbers_1", &error);
	if (kernel == NULL) {
		throw string("Couldn't create kernel!\n");
	}
	//³õʼ»¯²ÎÊý


	//´´½¨»º´æ¶ÔÏó
	cl_mem memObject1 = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, sizeof(unsigned char) * inputSize, data, &error);
	if (error < 0) {
		throw string("Creat memObject1 failed!\n");
	}
	cl_mem memObject2 = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
		sizeof(unsigned char) * inputSize, b_in, &error);
	if (error < 0) {
		throw string("Creat memObject2 failed!\n");
	}

	cl_mem memObject4 = clCreateBuffer(context, CL_MEM_WRITE_ONLY,
		sizeof(unsigned char) * resultSize, NULL, &error);
	if (error < 0) {
		throw string("Creat memObject4 failed!\n");
	}

	int width = cols / num_width;

	//ÉèÖÃÄں˲ÎÊý
	error = clSetKernelArg(kernel, 0, sizeof(cl_mem), &memObject1);
	error |= clSetKernelArg(kernel, 1, sizeof(cl_mem), &memObject2);
	error |= clSetKernelArg(kernel, 2, sizeof(int), &width);
	error |= clSetKernelArg(kernel, 3, sizeof(int), &num_width);
	error |= clSetKernelArg(kernel, 4, sizeof(int), &num_height);
	error |= clSetKernelArg(kernel, 5, sizeof(int), &line_number_count);
	error |= clSetKernelArg(kernel, 6, sizeof(cl_mem), &memObject4);
	if (error != CL_SUCCESS) {
		clReleaseMemObject(memObject1);
		clReleaseMemObject(memObject2);
		clReleaseMemObject(memObject4);
		clReleaseKernel(kernel);
		throw string("Error setting kernel arguments!\n");
	}
	//Ö´ÐÐÄÚºË
	size_t globalWorkSize[1] = { resultSize };
	size_t localWorkSize[1] = { 1 };

	const int work_dim = 1;

	error = clEnqueueNDRangeKernel(queue, kernel, work_dim, NULL, globalWorkSize,
		localWorkSize, 0, NULL, NULL);
	if (error != CL_SUCCESS) {
		clReleaseMemObject(memObject1);
		clReleaseMemObject(memObject2);
		clReleaseMemObject(memObject4);
		clReleaseKernel(kernel);
		throw string("Error queuing kernel for execution!\n");
	}

	unsigned char* result = (unsigned char*)malloc(sizeof(unsigned char) * resultSize);
	//¶ÁÈ¡Ö´Ðнá¹û
	error = clEnqueueReadBuffer(queue, memObject4, CL_TRUE, 0, resultSize * sizeof(unsigned char),
		result, 0, NULL, NULL);
	if (error != CL_SUCCESS) {
		free(result);
		clReleaseMemObject(memObject1);
		clReleaseMemObject(memObject2);
		clReleaseMemObject(memObject4);
		clReleaseKernel(kernel);
		throw string("Error reading result buffer!\n");
	}
	/*
	printf("½á¹û1£º\n");
	for (int r = 0; r < rows / 8; r++) {
		for (int c = 0; c < cols / 5 ; c++) {
			printf("%d ", result[r * cols/5 + c]);
		}
		printf("\n-------\n");
	}
	*/


	//¿ªÊ¼µÚ¶þ½×¶ÎµÄ¼ÆËã
	int resultSize2 = resultSize / 10;


	kernel = clCreateKernel(program, "recognition_numbers_2", &error);
	if (kernel == NULL) {
		free(result);
		throw string("Couldn't create kernel!\n");
	}

	cl_mem memObject21 = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, sizeof(unsigned char) * resultSize, result, &error);
	if (error < 0) {
		free(result);
		throw string("Creat memObject1 failed!\n");
	}

	cl_mem memObject22 = clCreateBuffer(context, CL_MEM_WRITE_ONLY,
		sizeof(unsigned char) * resultSize2, NULL, &error);

	error = clSetKernelArg(kernel, 0, sizeof(cl_mem), &memObject21);
	error |= clSetKernelArg(kernel, 1, sizeof(cl_mem), &memObject22);

	if (error != CL_SUCCESS) {
		free(result);
		throw string("Error setting kernel arguments!\n");
	}
	size_t	globalWorkSize2[1] = { resultSize2 };
	error = clEnqueueNDRangeKernel(queue, kernel, work_dim, NULL, globalWorkSize2,
		localWorkSize, 0, NULL, NULL);
	if (error != CL_SUCCESS) {
		free(result);
		clReleaseMemObject(memObject1);
		clReleaseMemObject(memObject2);
		clReleaseMemObject(memObject4);
		clReleaseMemObject(memObject21);
		clReleaseMemObject(memObject22);
		clReleaseKernel(kernel);
		throw string("Error queuing kernel for execution!\n");
	}

	unsigned char* result2 = (unsigned char*)malloc(sizeof(unsigned char) * resultSize2);
	//¶ÁÈ¡Ö´Ðнá¹û
	error = clEnqueueReadBuffer(queue, memObject22, CL_TRUE, 0, resultSize2 * sizeof(unsigned char),
		result2, 0, NULL, NULL);
	if (error != CL_SUCCESS) {
		free(result);
		free(result2);
		clReleaseMemObject(memObject1);
		clReleaseMemObject(memObject2);
		clReleaseMemObject(memObject4);
		clReleaseMemObject(memObject21);
		clReleaseMemObject(memObject22);
		clReleaseKernel(kernel);
		throw string("Error reading result buffer!\n");
	}




	//ÏÔʾ½á¹û
	/*
	printf("½á¹û2£º\n");
	for (int r = 0; r < rows/8; r++) {
		for (int c = 0; c < cols/(5*10); c++) {
			printf("%d ", result2[r*cols/(5*10)+c]);
		}
		printf("\n-------\n");
	}
	*/



	clReleaseKernel(kernel);
	clReleaseMemObject(memObject1);
	clReleaseMemObject(memObject2);
	clReleaseMemObject(memObject4);
	clReleaseMemObject(memObject21);
	clReleaseMemObject(memObject22);

	//¸´ÖÆ×îºóµÄ¼ÆËã½á¹û
	int fcol = line_number_count;
	int frow = rows / num_height;
	unsigned char** fresult = (unsigned char**)malloc(sizeof(unsigned char*) * frow);

	for (int r = 0; r < frow; r++) {
		fresult[r] = (unsigned char*)malloc(sizeof(unsigned char) * fcol);
		for (int c = 0; c < fcol; c++) {
			fresult[r][c] = result2[r * fcol + c];
		}
	}
	free(result);
	free(result2);
	//std::cout << " Ö´ÐнáÊø£º" << std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - startexectime).count() << std::endl;
	return fresult;
}

//


void OpenCLExcuter::splitPlateNum(cv::Mat img, IntDataInfo pos, UcharDataInfo result, UcharDataInfo types, unsigned char* zero, int num_width, int num_height,int ele_count_per_line,int length_per_num) {
	

	clock_t time_0 = clock();

	kernel = clCreateKernel(program, "split_plate_num", &error);
	if (kernel == NULL) {
		throw string("Couldn't create kernel!\n");
	}

	int inputSize = (img.cols * img.rows);

	int resultSize = pos.length * (length_per_num * 10 *  num_width * num_height);


	//´´½¨»º´æ¶ÔÏó

	cl_mem memObject1 = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, sizeof(unsigned char) * inputSize, img.data, &error);
	if (error < 0) {
		throw string("Creat memObject1 failed!\n");
	}

	cl_mem memObject2 = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
		sizeof(int) * pos.length * 4, pos.data, &error);
	if (error < 0) {
		throw string("Creat memObject2 failed!\n");
	}

	cl_mem memObject3 = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
		sizeof(unsigned char) * num_width * num_height, zero, &error);
	if (error < 0) {
		throw string("Creat memObject3 failed!\n");
	}

	cl_mem memObject4 = clCreateBuffer(context, CL_MEM_WRITE_ONLY,
		sizeof(unsigned char) * resultSize, NULL, &error);
	if (error < 0) {
		throw string("Creat memObject4 failed!\n");
	}



	cl_mem memObject5 = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
		sizeof(unsigned char) * types.length, types.data, &error);
	if (error < 0) {
		throw string("Creat memObject5 failed!\n");
	}

	//ÉèÖÃÄں˲ÎÊý
	error = clSetKernelArg(kernel, 0, sizeof(cl_mem), &memObject1);
	error |= clSetKernelArg(kernel, 1, sizeof(cl_mem), &memObject2);
	error |= clSetKernelArg(kernel, 2, sizeof(cl_mem), &memObject3);
	error |= clSetKernelArg(kernel, 3, sizeof(cl_mem), &memObject5);
	error |= clSetKernelArg(kernel, 4, sizeof(int), &img.cols);
	error |= clSetKernelArg(kernel, 5, sizeof(int), &num_width);
	error |= clSetKernelArg(kernel, 6, sizeof(int), &num_height);
	error |= clSetKernelArg(kernel, 7, sizeof(int), &ele_count_per_line);
	error |= clSetKernelArg(kernel, 8, sizeof(int), &length_per_num);
	error |= clSetKernelArg(kernel, 9, sizeof(cl_mem), &memObject4);
	if (error != CL_SUCCESS) {
		throw string("Error setting kernel arguments!\n");
	}
	//Ö´ÐÐÄÚºË
	size_t globalWorkSize[1] = { pos.length };
	size_t localWorkSize[1] = { 1 };

	const int work_dim = 1;

	error = clEnqueueNDRangeKernel(queue, kernel, work_dim, NULL, globalWorkSize,
		localWorkSize, 0, NULL, NULL);
	if (error != CL_SUCCESS) {
		throw string("Error queuing kernel for execution!\n");
	}

	//¶ÁÈ¡Ö´Ðнá¹û
	error = clEnqueueReadBuffer(queue, memObject4, CL_TRUE, 0, resultSize * sizeof(unsigned char),
		result.data, 0, NULL, NULL);
	if (error != CL_SUCCESS) {
		clReleaseKernel(kernel);
		clReleaseMemObject(memObject1);
		clReleaseMemObject(memObject2);
		clReleaseMemObject(memObject3);
		clReleaseMemObject(memObject4);
		clReleaseMemObject(memObject5);
		throw string("Error reading result buffer!\n");
	}



	clReleaseKernel(kernel);
	clReleaseMemObject(memObject1);
	clReleaseMemObject(memObject2);
	clReleaseMemObject(memObject3);
	clReleaseMemObject(memObject4);
	clReleaseMemObject(memObject5);
	std::cout << " ºÄʱ£º" << (clock() - time_0) << std::endl;
}

void OpenCLExcuter::splitL2NumNew(cv::Mat img, IntDataInfo pos, UcharDataInfo result, UcharDataInfo types, unsigned char* zero, int num_width, int num_height, int ele_count_per_line, int length_per_num) {


	clock_t time_0 = clock();

	kernel = clCreateKernel(program, "split_l2_num_new", &error);
	if (kernel == NULL) {
		throw string("Couldn't create kernel!\n");
	}

	int inputSize = (img.cols * img.rows);

	int resultSize = pos.length * (length_per_num * 10 * num_width * num_height);


	//´´½¨»º´æ¶ÔÏó

	cl_mem memObject1 = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, sizeof(unsigned char) * inputSize, img.data, &error);
	if (error < 0) {
		throw string("Creat memObject1 failed!\n");
	}

	cl_mem memObject2 = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
		sizeof(int) * pos.length * 4, pos.data, &error);
	if (error < 0) {
		throw string("Creat memObject2 failed!\n");
	}

	cl_mem memObject3 = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
		sizeof(unsigned char) * num_width * num_height, zero, &error);
	if (error < 0) {
		throw string("Creat memObject3 failed!\n");
	}

	cl_mem memObject4 = clCreateBuffer(context, CL_MEM_WRITE_ONLY,
		sizeof(unsigned char) * resultSize, NULL, &error);
	if (error < 0) {
		throw string("Creat memObject4 failed!\n");
	}



	cl_mem memObject5 = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
		sizeof(unsigned char) * types.length, types.data, &error);
	if (error < 0) {
		throw string("Creat memObject5 failed!\n");
	}

	try {

		//ÉèÖÃÄں˲ÎÊý
		error = clSetKernelArg(kernel, 0, sizeof(cl_mem), &memObject1);
		error |= clSetKernelArg(kernel, 1, sizeof(cl_mem), &memObject2);
		error |= clSetKernelArg(kernel, 2, sizeof(cl_mem), &memObject3);
		error |= clSetKernelArg(kernel, 3, sizeof(cl_mem), &memObject5);
		error |= clSetKernelArg(kernel, 4, sizeof(int), &img.cols);
		error |= clSetKernelArg(kernel, 5, sizeof(int), &num_width);
		error |= clSetKernelArg(kernel, 6, sizeof(int), &num_height);
		error |= clSetKernelArg(kernel, 7, sizeof(int), &ele_count_per_line);
		error |= clSetKernelArg(kernel, 8, sizeof(int), &length_per_num);
		error |= clSetKernelArg(kernel, 9, sizeof(cl_mem), &memObject4);
		if (error != CL_SUCCESS) {
			throw string("Error setting kernel arguments!\n");
		}
		//Ö´ÐÐÄÚºË
		size_t globalWorkSize[1] = { pos.length };
		size_t localWorkSize[1] = { 1 };

		const int work_dim = 1;

		error = clEnqueueNDRangeKernel(queue, kernel, work_dim, NULL, globalWorkSize,
			localWorkSize, 0, NULL, NULL);
		if (error != CL_SUCCESS) {
			throw string("Error queuing kernel for execution!\n");
		}

		//¶ÁÈ¡Ö´Ðнá¹û
		error = clEnqueueReadBuffer(queue, memObject4, CL_TRUE, 0, resultSize * sizeof(unsigned char),
			result.data, 0, NULL, NULL);
		if (error != CL_SUCCESS) {
			throw string("Error reading result buffer!\n");
		}
		clReleaseKernel(kernel);
		clReleaseMemObject(memObject1);
		clReleaseMemObject(memObject2);
		clReleaseMemObject(memObject3);
		clReleaseMemObject(memObject4);
		clReleaseMemObject(memObject5);
	}
	catch (string st) {
		clReleaseKernel(kernel);
		clReleaseMemObject(memObject1);
		clReleaseMemObject(memObject2);
		clReleaseMemObject(memObject3);
		clReleaseMemObject(memObject4);
		clReleaseMemObject(memObject5);
		excuteError();
		throw st;
	}
	std::cout << " ºÄʱ£º" << (clock() - time_0) << std::endl;
}


void OpenCLExcuter::splitTradeQueueNum(cv::Mat img, IntDataInfo pos, UcharDataInfo result, UcharDataInfo types, unsigned char* zero, int num_width, int num_height, int ele_count_per_line, int length_per_num) {


	clock_t time_0 = clock();

	kernel = clCreateKernel(program, "split_trade_queue_num", &error);
	if (kernel == NULL) {
		throw string("Couldn't create kernel!\n");
	}

	int inputSize = (img.cols * img.rows);

	int resultSize = pos.length * (length_per_num * 10 * num_width * num_height);


	//´´½¨»º´æ¶ÔÏó

	cl_mem memObject1 = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, sizeof(unsigned char) * inputSize, img.data, &error);
	if (error < 0) {
		throw string("Creat memObject1 failed!\n");
	}

	cl_mem memObject2 = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
		sizeof(int) * pos.length * 4, pos.data, &error);
	if (error < 0) {
		throw string("Creat memObject2 failed!\n");
	}

	cl_mem memObject3 = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
		sizeof(unsigned char) * num_width * num_height, zero, &error);
	if (error < 0) {
		throw string("Creat memObject3 failed!\n");
	}

	cl_mem memObject4 = clCreateBuffer(context, CL_MEM_WRITE_ONLY,
		sizeof(unsigned char) * resultSize, NULL, &error);
	if (error < 0) {
		throw string("Creat memObject4 failed!\n");
	}



	cl_mem memObject5 = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
		sizeof(unsigned char) * types.length, types.data, &error);
	if (error < 0) {
		throw string("Creat memObject5 failed!\n");
	}

	try {
		//ÉèÖÃÄں˲ÎÊý
		error = clSetKernelArg(kernel, 0, sizeof(cl_mem), &memObject1);
		error |= clSetKernelArg(kernel, 1, sizeof(cl_mem), &memObject2);
		error |= clSetKernelArg(kernel, 2, sizeof(cl_mem), &memObject3);
		error |= clSetKernelArg(kernel, 3, sizeof(cl_mem), &memObject5);
		error |= clSetKernelArg(kernel, 4, sizeof(int), &img.cols);
		error |= clSetKernelArg(kernel, 5, sizeof(int), &num_width);
		error |= clSetKernelArg(kernel, 6, sizeof(int), &num_height);
		error |= clSetKernelArg(kernel, 7, sizeof(int), &ele_count_per_line);
		error |= clSetKernelArg(kernel, 8, sizeof(int), &length_per_num);
		error |= clSetKernelArg(kernel, 9, sizeof(cl_mem), &memObject4);
		if (error != CL_SUCCESS) {
			throw string("Error setting kernel arguments!\n");
		}
		//Ö´ÐÐÄÚºË
		size_t globalWorkSize[1] = { pos.length };
		size_t localWorkSize[1] = { 1 };

		const int work_dim = 1;

		error = clEnqueueNDRangeKernel(queue, kernel, work_dim, NULL, globalWorkSize,
			localWorkSize, 0, NULL, NULL);
		if (error != CL_SUCCESS) {
			throw string("Error queuing kernel for execution!\n");
		}

		//¶ÁÈ¡Ö´Ðнá¹û
		error = clEnqueueReadBuffer(queue, memObject4, CL_TRUE, 0, resultSize * sizeof(unsigned char),
			result.data, 0, NULL, NULL);
		if (error != CL_SUCCESS) {
			throw string("Error reading result buffer!\n");
		}

		clReleaseKernel(kernel);
		clReleaseMemObject(memObject1);
		clReleaseMemObject(memObject2);
		clReleaseMemObject(memObject3);
		clReleaseMemObject(memObject4);
		clReleaseMemObject(memObject5);
	}
	catch (string st) {
		clReleaseKernel(kernel);
		clReleaseMemObject(memObject1);
		clReleaseMemObject(memObject2);
		clReleaseMemObject(memObject3);
		clReleaseMemObject(memObject4);
		clReleaseMemObject(memObject5);
		excuteError();
		throw st;
	}



	
	std::cout << " ºÄʱ£º" << (clock() - time_0) << std::endl;
}




void OpenCLExcuter::splitPlateNum(unsigned char* img, int img_width, int img_height, int* pos, int pos_count, unsigned char* zero, int num_width, int num_height, int num_count, unsigned char* result) {
	clock_t time_0 = clock();

	kernel = clCreateKernel(program, "split_plate_num", &error);
	if (kernel == NULL) {
		throw string("Couldn't create kernel!\n");
	}

	int inputSize = (img_width * img_height);

	int resultSize = (pos_count / 4) * (num_count * num_width * num_height * 10);

	int length_per_num = 6;


	//´´½¨»º´æ¶ÔÏó

	cl_mem memObject1 = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, sizeof(unsigned char) * inputSize, img, &error);
	if (error < 0) {
		throw string("Creat memObject1 failed!\n");
	}

	cl_mem memObject2 = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
		sizeof(int) * pos_count * 4, pos, &error);
	if (error < 0) {
		throw string("Creat memObject2 failed!\n");
	}

	cl_mem memObject3 = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
		sizeof(unsigned char) * num_width * num_height, zero, &error);
	if (error < 0) {
		throw string("Creat memObject3 failed!\n");
	}

	cl_mem memObject4 = clCreateBuffer(context, CL_MEM_WRITE_ONLY,
		sizeof(unsigned char) * resultSize, NULL, &error);
	if (error < 0) {
		throw string("Creat memObject4 failed!\n");
	}


	unsigned char types[4] = {
			NUM_TYPE_CODE,
		    NUM_TYPE_TIME,
			NUM_TYPE_PRICE,
	        NUM_TYPE_MONEY,
	};

	cl_mem memObject5 = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
		sizeof(unsigned char) * 4, types, &error);
	if (error < 0) {
		throw string("Creat memObject5 failed!\n");
	}

	int ele_count_line = 4;
	try {
		//ÉèÖÃÄں˲ÎÊý
		error = clSetKernelArg(kernel, 0, sizeof(cl_mem), &memObject1);
		error |= clSetKernelArg(kernel, 1, sizeof(cl_mem), &memObject2);
		error |= clSetKernelArg(kernel, 2, sizeof(cl_mem), &memObject3);
		error |= clSetKernelArg(kernel, 3, sizeof(cl_mem), &memObject5);
		error |= clSetKernelArg(kernel, 4, sizeof(int), &img_width);
		error |= clSetKernelArg(kernel, 5, sizeof(int), &num_width);
		error |= clSetKernelArg(kernel, 6, sizeof(int), &num_height);
		error |= clSetKernelArg(kernel, 7, sizeof(int), &ele_count_line);
		error |= clSetKernelArg(kernel, 8, sizeof(int), &length_per_num);
		error |= clSetKernelArg(kernel, 9, sizeof(cl_mem), &memObject4);
		if (error != CL_SUCCESS) {
			throw string("Error setting kernel arguments!\n");
		}
		//Ö´ÐÐÄÚºË
		size_t globalWorkSize[1] = { pos_count };
		size_t localWorkSize[1] = { 1 };

		const int work_dim = 1;

		error = clEnqueueNDRangeKernel(queue, kernel, work_dim, NULL, globalWorkSize,
			localWorkSize, 0, NULL, NULL);
		if (error != CL_SUCCESS) {
			throw string("Error queuing kernel for execution!\n");
		}

		//¶ÁÈ¡Ö´Ðнá¹û
		error = clEnqueueReadBuffer(queue, memObject4, CL_TRUE, 0, resultSize * sizeof(unsigned char),
			result, 0, NULL, NULL);
		if (error != CL_SUCCESS) {
			throw string("Error reading result buffer!\n");
		}
		clReleaseKernel(kernel);
		clReleaseMemObject(memObject1);
		clReleaseMemObject(memObject2);
		clReleaseMemObject(memObject3);
		clReleaseMemObject(memObject4);
		clReleaseMemObject(memObject5);
	}
	catch (string st) {
		clReleaseKernel(kernel);
		clReleaseMemObject(memObject1);
		clReleaseMemObject(memObject2);
		clReleaseMemObject(memObject3);
		clReleaseMemObject(memObject4);
		clReleaseMemObject(memObject5);
		excuteError();
		throw st;
	}



	
	std::cout << " ºÄʱ£º" << (clock() - time_0) << std::endl;
}



void OpenCLExcuter::splitTradeQueueNum(cv::Mat img, IntDataInfo pos, unsigned char* zero, int num_width, int num_height, unsigned char* result,int length_per_num) {
	UcharDataInfo resultData = UcharDataInfo();
	resultData.data = result;
	UcharDataInfo typesData = UcharDataInfo();
	unsigned char types[] = { NUM_TYPE_CODE };
	typesData.length = 1;
	typesData.data = types;
	splitPlateNum(img,pos, resultData, typesData,zero, num_width, num_height,1, length_per_num);
}




void OpenCLExcuter::splitL2Num(unsigned char* img, int img_width, int img_height, int* pos, int pos_count, unsigned char* zero, int num_width, int num_height, int num_count, unsigned char* result) {
	clock_t time_0 = clock();

	kernel = clCreateKernel(program, "split_l2_num", &error);
	if (kernel == NULL) {
		throw string("Couldn't create kernel!\n");
	}

	int inputSize = (img_width * img_height);

	int resultSize = (pos_count / 4) * (num_count * num_width * num_height * 10);


	//´´½¨»º´æ¶ÔÏó

	cl_mem memObject1 = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, sizeof(unsigned char) * inputSize, img, &error);
	if (error < 0) {
		throw string("Creat memObject1 failed!\n");
	}

	cl_mem memObject2 = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
		sizeof(int) * pos_count * 4, pos, &error);
	if (error < 0) {
		throw string("Creat memObject2 failed!\n");
	}

	cl_mem memObject3 = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
		sizeof(unsigned char) * num_width * num_height, zero, &error);
	if (error < 0) {
		throw string("Creat memObject3 failed!\n");
	}

	cl_mem memObject4 = clCreateBuffer(context, CL_MEM_WRITE_ONLY,
		sizeof(unsigned char) * resultSize, NULL, &error);
	if (error < 0) {
		throw string("Creat memObject4 failed!\n");
	}

	try {
		//ÉèÖÃÄں˲ÎÊý
		error = clSetKernelArg(kernel, 0, sizeof(cl_mem), &memObject1);
		error |= clSetKernelArg(kernel, 1, sizeof(cl_mem), &memObject2);
		error |= clSetKernelArg(kernel, 2, sizeof(cl_mem), &memObject3);
		error |= clSetKernelArg(kernel, 3, sizeof(int), &img_width);
		error |= clSetKernelArg(kernel, 4, sizeof(int), &num_width);
		error |= clSetKernelArg(kernel, 5, sizeof(int), &num_height);
		error |= clSetKernelArg(kernel, 6, sizeof(int), &num_count);
		error |= clSetKernelArg(kernel, 7, sizeof(cl_mem), &memObject4);
		if (error != CL_SUCCESS) {
			throw string("Error setting kernel arguments!\n");
		}
		//Ö´ÐÐÄÚºË
		size_t globalWorkSize[1] = { pos_count };
		size_t localWorkSize[1] = { 1 };

		const int work_dim = 1;

		error = clEnqueueNDRangeKernel(queue, kernel, work_dim, NULL, globalWorkSize,
			localWorkSize, 0, NULL, NULL);
		if (error != CL_SUCCESS) {
			throw string("Error queuing kernel for execution!\n");
		}

		//¶ÁÈ¡Ö´Ðнá¹û
		error = clEnqueueReadBuffer(queue, memObject4, CL_TRUE, 0, resultSize * sizeof(unsigned char),
			result, 0, NULL, NULL);
		if (error != CL_SUCCESS) {
			throw string("Error reading result buffer!\n");
		}
		clReleaseKernel(kernel);
		clReleaseMemObject(memObject1);
		clReleaseMemObject(memObject2);
		clReleaseMemObject(memObject3);
		clReleaseMemObject(memObject4);
		std::cout << " ºÄʱ£º" << (clock() - time_0) << std::endl;
	}
	catch (string st) {
		clReleaseKernel(kernel);
		clReleaseMemObject(memObject1);
		clReleaseMemObject(memObject2);
		clReleaseMemObject(memObject3);
		clReleaseMemObject(memObject4);
		excuteError();
		throw st;
	}
}



void OpenCLExcuter::createNumberTemplates(int lines, int num_width, int num_height, int num_count, uchar* numsOneLevelData, unsigned char* result) {
	kernel = clCreateKernel(program, "createTemplateNumbers", &error);
	if (kernel == NULL) {
		throw string("Couldn't create kernel!\n");
	}


	int inputSize = num_height * num_width * 10;
	int resultSize = lines * num_count * 10 * num_height * num_width;


	//´´½¨»º´æ¶ÔÏó

	cl_mem memObject1 = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, sizeof(uchar) * inputSize, numsOneLevelData, &error);
	if (error < 0) {
		throw string("Creat memObject1 failed!\n");
	}


	cl_mem memObject2 = clCreateBuffer(context, CL_MEM_WRITE_ONLY,
		sizeof(unsigned char) * resultSize, NULL, &error);
	if (error < 0) {
		throw string("Creat memObject2 failed!\n");
	}

	try {
		//ÉèÖÃÄں˲ÎÊý
		error = clSetKernelArg(kernel, 0, sizeof(cl_mem), &memObject1);
		error |= clSetKernelArg(kernel, 1, sizeof(int), &num_width);
		error |= clSetKernelArg(kernel, 2, sizeof(int), &num_height);
		error |= clSetKernelArg(kernel, 3, sizeof(int), &num_count);
		error |= clSetKernelArg(kernel, 4, sizeof(cl_mem), &memObject2);

		if (error != CL_SUCCESS) {
			throw string("Error setting kernel arguments!\n");
		}
		//Ö´ÐÐÄÚºË
		size_t globalWorkSize[1] = { lines };
		size_t localWorkSize[1] = { 1 };

		const int work_dim = 1;

		error = clEnqueueNDRangeKernel(queue, kernel, work_dim, NULL, globalWorkSize,
			localWorkSize, 0, NULL, NULL);
		if (error != CL_SUCCESS) {
			throw string("Error queuing kernel for execution!\n");
		}

		//¶ÁÈ¡Ö´Ðнá¹û
		error = clEnqueueReadBuffer(queue, memObject2, CL_TRUE, 0, resultSize * sizeof(unsigned char),
			result, 0, NULL, NULL);
		if (error != CL_SUCCESS) {
			throw string("Error reading result buffer!\n");
		}
		clReleaseKernel(kernel);
		clReleaseMemObject(memObject1);
		clReleaseMemObject(memObject2);

	}
	catch (string st) {
		clReleaseKernel(kernel);
		clReleaseMemObject(memObject1);
		clReleaseMemObject(memObject2);
		excuteError();
		throw st;
	}

}



void OpenCLExcuter::splitL2RowData(cv::Mat img, int* rowIndexs, int lines,
	int* result) {

	kernel = clCreateKernel(program, "splitL2RowData", &error);
	if (kernel == NULL) {
		throw string("Couldn't create kernel!\n");
	}


	int inputSize = img.cols * img.rows;
	int resultSize = lines * 7 * 4;


	//´´½¨»º´æ¶ÔÏó

	cl_mem memObject1 = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, sizeof(uchar) * inputSize, img.data, &error);
	if (error < 0) {
		throw string("Creat memObject1 failed!\n");
	}

	cl_mem memObject2 = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, sizeof(int) * lines * 4, rowIndexs, &error);
	if (error < 0) {
		throw string("Creat memObject2 failed!\n");
	}


	cl_mem memObject3 = clCreateBuffer(context, CL_MEM_WRITE_ONLY,
		sizeof(int) * resultSize, NULL, &error);
	if (error < 0) {
		throw string("Creat memObject3 failed!\n");
	}

	try {
		//ÉèÖÃÄں˲ÎÊý
		error = clSetKernelArg(kernel, 0, sizeof(cl_mem), &memObject1);
		error = clSetKernelArg(kernel, 1, sizeof(cl_mem), &memObject2);
		error |= clSetKernelArg(kernel, 2, sizeof(int), &img.cols);
		error |= clSetKernelArg(kernel, 3, sizeof(cl_mem), &memObject3);

		if (error != CL_SUCCESS) {
			throw string("Error setting kernel arguments!\n");
		}
		//Ö´ÐÐÄÚºË
		size_t globalWorkSize[1] = { lines };
		size_t localWorkSize[1] = { 1 };

		const int work_dim = 1;

		error = clEnqueueNDRangeKernel(queue, kernel, work_dim, NULL, globalWorkSize,
			localWorkSize, 0, NULL, NULL);
		if (error != CL_SUCCESS) {
			throw string("Error queuing kernel for execution!\n");
		}

		//¶ÁÈ¡Ö´Ðнá¹û
		error = clEnqueueReadBuffer(queue, memObject3, CL_TRUE, 0, resultSize * sizeof(int),
			result, 0, NULL, NULL);
		if (error != CL_SUCCESS) {
			throw string("Error reading result buffer!\n");
		}
		clReleaseKernel(kernel);
		clReleaseMemObject(memObject1);
		clReleaseMemObject(memObject2);
		clReleaseMemObject(memObject3);
	}
	catch (string st) {
		clReleaseKernel(kernel);
		clReleaseMemObject(memObject1);
		clReleaseMemObject(memObject2);
		clReleaseMemObject(memObject3);
		excuteError();
		throw st;
	}

	//printf("%d %d %d %d \n", result[0], result[1], result[2], result[3]);


}



void OpenCLExcuter::splitPlateContentRowData(unsigned char* imgs, int imgWidth, int imgHeight, int* rowIndexs, int lines, int lineEleCount, int fromIndex, int toIndex,
	int* result) {

	kernel = clCreateKernel(program, "splitCommonRowData", &error);
	if (kernel == NULL) {
		throw string("Couldn't create kernel!\n");
	}


	int inputSize = imgWidth * imgHeight;
	int resultSize = lines * lineEleCount * 4;


	//´´½¨»º´æ¶ÔÏó

	cl_mem memObject1 = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, sizeof(uchar) * inputSize, imgs, &error);
	if (error < 0) {
		throw string("Creat memObject1 failed!\n");
	}

	cl_mem memObject2 = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, sizeof(int) * lines * 4, rowIndexs, &error);
	if (error < 0) {
		throw string("Creat memObject2 failed!\n");
	}


	cl_mem memObject3 = clCreateBuffer(context, CL_MEM_WRITE_ONLY,
		sizeof(int) * resultSize, NULL, &error);
	if (error < 0) {
		throw string("Creat memObject3 failed!\n");
	}

	try {
		//ÉèÖÃÄں˲ÎÊý
		error = clSetKernelArg(kernel, 0, sizeof(cl_mem), &memObject1);
		error = clSetKernelArg(kernel, 1, sizeof(cl_mem), &memObject2);
		error |= clSetKernelArg(kernel, 2, sizeof(int), &imgWidth);
		error |= clSetKernelArg(kernel, 3, sizeof(int), &fromIndex);
		error |= clSetKernelArg(kernel, 4, sizeof(int), &toIndex);
		error |= clSetKernelArg(kernel, 5, sizeof(cl_mem), &memObject3);

		if (error != CL_SUCCESS) {
			throw string("Error setting kernel arguments!\n");
		}
		//Ö´ÐÐÄÚºË
		size_t globalWorkSize[1] = { lines };
		size_t localWorkSize[1] = { 1 };

		const int work_dim = 1;

		error = clEnqueueNDRangeKernel(queue, kernel, work_dim, NULL, globalWorkSize,
			localWorkSize, 0, NULL, NULL);
		if (error != CL_SUCCESS) {
			throw string("Error queuing kernel for execution!\n");
		}

		//¶ÁÈ¡Ö´Ðнá¹û
		error = clEnqueueReadBuffer(queue, memObject3, CL_TRUE, 0, resultSize * sizeof(int),
			result, 0, NULL, NULL);
		if (error != CL_SUCCESS) {
			throw string("Error reading result buffer!\n");
		}
		clReleaseKernel(kernel);
		clReleaseMemObject(memObject1);
		clReleaseMemObject(memObject2);
		clReleaseMemObject(memObject3);
	}
	catch (string st) {
		clReleaseKernel(kernel);
		clReleaseMemObject(memObject1);
		clReleaseMemObject(memObject2);
		clReleaseMemObject(memObject3);
		excuteError();
		throw st;
	}

	//printf("%d %d %d %d \n", result[0], result[1], result[2], result[3]);

	
}

void OpenCLExcuter::recognitionNotNum(unsigned char* imgs, int imgWidth, int imgHeight, int* rowIndexs, int colCount, int lines,
	int* result) {

	clock_t time_1 = clock();


	kernel = clCreateKernel(program, "recognition_not_num", &error);
	if (kernel == NULL) {
		throw string("Couldn't create kernel!\n");
	}


	int inputSize = imgWidth * imgHeight;
	int resultSize = lines * 3;


	//´´½¨»º´æ¶ÔÏó

	cl_mem memObject1 = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, sizeof(uchar) * inputSize, imgs, &error);
	if (error < 0) {
		throw string("Creat memObject1 failed!\n");
	}

	cl_mem memObject2 = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, sizeof(int) * lines * 4 * colCount, rowIndexs, &error);
	if (error < 0) {
		throw string("Creat memObject2 failed!\n");
	}


	cl_mem memObject3 = clCreateBuffer(context, CL_MEM_WRITE_ONLY,
		sizeof(int) * resultSize, NULL, &error);
	if (error < 0) {
		throw string("Creat memObject3 failed!\n");
	}

	try {
		//ÉèÖÃÄں˲ÎÊý
		error = clSetKernelArg(kernel, 0, sizeof(cl_mem), &memObject1);
		error = clSetKernelArg(kernel, 1, sizeof(cl_mem), &memObject2);
		error |= clSetKernelArg(kernel, 2, sizeof(int), &imgWidth);
		error |= clSetKernelArg(kernel, 3, sizeof(cl_mem), &memObject3);

		if (error != CL_SUCCESS) {
			throw string("Error setting kernel arguments!\n");
		}
		//Ö´ÐÐÄÚºË
		size_t globalWorkSize[1] = { resultSize };
		size_t localWorkSize[1] = { 1 };

		const int work_dim = 1;

		error = clEnqueueNDRangeKernel(queue, kernel, work_dim, NULL, globalWorkSize,
			localWorkSize, 0, NULL, NULL);
		if (error != CL_SUCCESS) {
			throw string("Error queuing kernel for execution!\n");
		}

		//¶ÁÈ¡Ö´Ðнá¹û
		error = clEnqueueReadBuffer(queue, memObject3, CL_TRUE, 0, resultSize * sizeof(int),
			result, 0, NULL, NULL);
		if (error != CL_SUCCESS) {
			throw string("Error reading result buffer!\n");
		}
		clReleaseKernel(kernel);
		clReleaseMemObject(memObject1);
		clReleaseMemObject(memObject2);
		clReleaseMemObject(memObject3);
	}
	catch (string st) {
		clReleaseKernel(kernel);
		clReleaseMemObject(memObject1);
		clReleaseMemObject(memObject2);
		clReleaseMemObject(memObject3);
		excuteError();
		throw st;
	}

	//printf("%d %d %d %d \n", result[0], result[1], result[2], result[3]);

	

}



void OpenCLExcuter::recognitionPlateMoneyUnit(unsigned char* imgs, int imgWidth, int imgHeight, int* rowIndexs, int colEleCount, int lines,
	int* result) {

	clock_t time_1 = clock();


	kernel = clCreateKernel(program, "recognition_plate_money_unit", &error);
	if (kernel == NULL) {
		throw string("Couldn't create kernel!\n");
	}


	int inputSize = imgWidth * imgHeight;
	int resultSize = lines * colEleCount;


	//´´½¨»º´æ¶ÔÏó

	cl_mem memObject1 = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, sizeof(uchar) * inputSize, imgs, &error);
	if (error < 0) {
		throw string("Creat memObject1 failed!\n");
	}

	cl_mem memObject2 = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, sizeof(int) * lines * 4 * colEleCount, rowIndexs, &error);
	if (error < 0) {
		throw string("Creat memObject2 failed!\n");
	}


	cl_mem memObject3 = clCreateBuffer(context, CL_MEM_WRITE_ONLY,
		sizeof(int) * resultSize, NULL, &error);
	if (error < 0) {
		throw string("Creat memObject3 failed!\n");
	}

	try {
		//ÉèÖÃÄں˲ÎÊý
		error = clSetKernelArg(kernel, 0, sizeof(cl_mem), &memObject1);
		error = clSetKernelArg(kernel, 1, sizeof(cl_mem), &memObject2);
		error |= clSetKernelArg(kernel, 2, sizeof(int), &imgWidth);
		error |= clSetKernelArg(kernel, 3, sizeof(cl_mem), &memObject3);

		if (error != CL_SUCCESS) {
			throw string("Error setting kernel arguments!\n");
		}
		//Ö´ÐÐÄÚºË
		size_t globalWorkSize[1] = { resultSize };
		size_t localWorkSize[1] = { 1 };

		const int work_dim = 1;

		error = clEnqueueNDRangeKernel(queue, kernel, work_dim, NULL, globalWorkSize,
			localWorkSize, 0, NULL, NULL);
		if (error != CL_SUCCESS) {
			throw string("Error queuing kernel for execution!\n");
		}

		//¶ÁÈ¡Ö´Ðнá¹û
		error = clEnqueueReadBuffer(queue, memObject3, CL_TRUE, 0, resultSize * sizeof(int),
			result, 0, NULL, NULL);
		if (error != CL_SUCCESS) {
			throw string("Error reading result buffer!\n");
		}
		clReleaseKernel(kernel);
		clReleaseMemObject(memObject1);
		clReleaseMemObject(memObject2);
		clReleaseMemObject(memObject3);
	}
	catch (string st) {
		clReleaseKernel(kernel);
		clReleaseMemObject(memObject1);
		clReleaseMemObject(memObject2);
		clReleaseMemObject(memObject3);
		excuteError();
		throw st;
	}

	//printf("%d %d %d %d \n", result[0], result[1], result[2], result[3]);


}

void OpenCLExcuter::rgb2Gray(cv::Mat img,
	unsigned char* result) {

	kernel = clCreateKernel(program, "rgb2GrayImg", &error);
	if (kernel == NULL) {
		throw string("Couldn't create kernel!\n");
	}


	int inputSize = img.cols * img.rows * 3;
	int resultSize = img.cols * img.rows;


	//´´½¨»º´æ¶ÔÏó

	cl_mem memObject1 = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, sizeof(uchar) * inputSize, img.data, &error);
	if (error < 0) {
		throw string("Creat memObject1 failed!\n");
	}

	cl_mem memObject2 = clCreateBuffer(context, CL_MEM_WRITE_ONLY,
		sizeof(uchar) * resultSize, NULL, &error);
	if (error < 0) {
		throw string("Creat memObject2 failed!\n");
	}


	try {

		//ÉèÖÃÄں˲ÎÊý
		error = clSetKernelArg(kernel, 0, sizeof(cl_mem), &memObject1);
		error |= clSetKernelArg(kernel, 1, sizeof(int), &img.cols);
		error = clSetKernelArg(kernel, 2, sizeof(cl_mem), &memObject2);

		if (error != CL_SUCCESS) {
			throw string("Error setting kernel arguments!\n");
		}
		//Ö´ÐÐÄÚºË
		size_t globalWorkSize[1] = { img.rows };
		size_t localWorkSize[1] = { 1 };

		const int work_dim = 1;

		error = clEnqueueNDRangeKernel(queue, kernel, work_dim, NULL, globalWorkSize,
			localWorkSize, 0, NULL, NULL);
		if (error != CL_SUCCESS) {
			throw string("Error queuing kernel for execution!\n");
		}

		//¶ÁÈ¡Ö´Ðнá¹û
		error = clEnqueueReadBuffer(queue, memObject2, CL_TRUE, 0, resultSize * sizeof(uchar),
			result, 0, NULL, NULL);
		if (error != CL_SUCCESS) {
			throw string("Error reading result buffer!\n");
		}
		clReleaseKernel(kernel);
		clReleaseMemObject(memObject1);
		clReleaseMemObject(memObject2);
	}
	catch (string st) {
		clReleaseKernel(kernel);
		clReleaseMemObject(memObject1);
		clReleaseMemObject(memObject2);
		excuteError();
		throw st;
	}

}


void OpenCLExcuter::rgba2Gray(cv::Mat img,
	unsigned char* result) {

	kernel = clCreateKernel(program, "rgba2GrayImg", &error);
	if (kernel == NULL) {
		throw string("Couldn't create kernel!\n");
	}


	int inputSize = img.cols * img.rows * 4;
	int resultSize = img.cols * img.rows;


	//´´½¨»º´æ¶ÔÏó

	cl_mem memObject1 = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, sizeof(uchar) * inputSize, img.data, &error);
	if (error < 0) {
		throw string("Creat memObject1 failed!\n");
	}

	cl_mem memObject2 = clCreateBuffer(context, CL_MEM_WRITE_ONLY,
		sizeof(uchar) * resultSize, NULL, &error);
	if (error < 0) {
		throw string("Creat memObject2 failed!\n");
	}

	try {

		//ÉèÖÃÄں˲ÎÊý
		error = clSetKernelArg(kernel, 0, sizeof(cl_mem), &memObject1);
		error |= clSetKernelArg(kernel, 1, sizeof(int), &img.cols);
		error = clSetKernelArg(kernel, 2, sizeof(cl_mem), &memObject2);

		if (error != CL_SUCCESS) {
			throw string("Error setting kernel arguments!\n");
		}
		//Ö´ÐÐÄÚºË
		size_t globalWorkSize[1] = { img.rows };
		size_t localWorkSize[1] = { 1 };

		const int work_dim = 1;

		error = clEnqueueNDRangeKernel(queue, kernel, work_dim, NULL, globalWorkSize,
			localWorkSize, 0, NULL, NULL);
		if (error != CL_SUCCESS) {
			throw string("Error queuing kernel for execution!\n");
		}

		//¶ÁÈ¡Ö´Ðнá¹û
		error = clEnqueueReadBuffer(queue, memObject2, CL_TRUE, 0, resultSize * sizeof(uchar),
			result, 0, NULL, NULL);
		if (error != CL_SUCCESS) {
			throw string("Error reading result buffer!\n");
		}

	
		clReleaseMemObject(memObject1);
		clReleaseMemObject(memObject2);
		clReleaseKernel(kernel);
	}
	catch (string st) {
		clReleaseMemObject(memObject1);
		clReleaseMemObject(memObject2);
		clReleaseKernel(kernel);
		excuteError();
		throw st;
	}

	

}




void OpenCLExcuter::rgb2ThresholdInvert(unsigned char* imgs, int imgWidth, int imgHeight,
	unsigned char* result,int threadhold) {

	kernel = clCreateKernel(program, "rgb2ThresholdInvert", &error);
	if (kernel == NULL) {
		throw string("Couldn't create kernel!\n");
	}


	int inputSize = imgWidth * imgHeight * 3;
	int resultSize = imgWidth * imgHeight;


	//´´½¨»º´æ¶ÔÏó

	cl_mem memObject1 = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, sizeof(uchar) * inputSize, imgs, &error);
	if (error < 0) {
		throw string("Creat memObject1 failed!\n");
	}

	cl_mem memObject2 = clCreateBuffer(context, CL_MEM_WRITE_ONLY,
		sizeof(uchar) * resultSize, NULL, &error);
	if (error < 0) {
		throw string("Creat memObject2 failed!\n");
	}


	try {
		//ÉèÖÃÄں˲ÎÊý
		error = clSetKernelArg(kernel, 0, sizeof(cl_mem), &memObject1);
		error |= clSetKernelArg(kernel, 1, sizeof(int), &imgWidth);
		error |= clSetKernelArg(kernel, 2, sizeof(cl_mem), &memObject2);
		error |= clSetKernelArg(kernel, 3, sizeof(int), &threadhold);

		if (error != CL_SUCCESS) {
			throw string("Error setting kernel arguments!\n");
		}
		//Ö´ÐÐÄÚºË
		size_t globalWorkSize[1] = { imgHeight };
		size_t localWorkSize[1] = { 1 };

		const int work_dim = 1;

		error = clEnqueueNDRangeKernel(queue, kernel, work_dim, NULL, globalWorkSize,
			localWorkSize, 0, NULL, NULL);
		if (error != CL_SUCCESS) {
			throw string("Error queuing kernel for execution!\n");
		}

		//¶ÁÈ¡Ö´Ðнá¹û
		error = clEnqueueReadBuffer(queue, memObject2, CL_TRUE, 0, resultSize * sizeof(uchar),
			result, 0, NULL, NULL);
		if (error != CL_SUCCESS) {
			throw string("Error reading result buffer!\n");
		}

		clReleaseKernel(kernel);
		clReleaseMemObject(memObject1);
		clReleaseMemObject(memObject2);
	}
	catch (string st) {
		clReleaseKernel(kernel);
		clReleaseMemObject(memObject1);
		clReleaseMemObject(memObject2);
		excuteError();
		throw st;
	}

}


void OpenCLExcuter::rgba2ThresholdInvert(unsigned char* imgs, int imgWidth, int imgHeight,
	unsigned char* result,int threadhold) {

	kernel = clCreateKernel(program, "rgba2ThresholdInvert", &error);
	if (kernel == NULL) {
		throw string("Couldn't create kernel!\n");
	}


	int inputSize = imgWidth * imgHeight * 4;
	int resultSize = imgWidth * imgHeight;


	//´´½¨»º´æ¶ÔÏó

	cl_mem memObject1 = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, sizeof(uchar) * inputSize, imgs, &error);
	if (error < 0) {
		throw string("Creat memObject1 failed!\n");
	}

	cl_mem memObject2 = clCreateBuffer(context, CL_MEM_WRITE_ONLY,
		sizeof(uchar) * resultSize, NULL, &error);
	if (error < 0) {
		throw string("Creat memObject2 failed!\n");
	}

	try {
		//ÉèÖÃÄں˲ÎÊý
		error = clSetKernelArg(kernel, 0, sizeof(cl_mem), &memObject1);
		error |= clSetKernelArg(kernel, 1, sizeof(int), &imgWidth);
		error = clSetKernelArg(kernel, 2, sizeof(cl_mem), &memObject2);
		error |= clSetKernelArg(kernel, 3, sizeof(int), &threadhold);

		if (error != CL_SUCCESS) {
			throw string("Error setting kernel arguments!\n");
		}
		//Ö´ÐÐÄÚºË
		size_t globalWorkSize[1] = { imgHeight };
		size_t localWorkSize[1] = { 1 };

		const int work_dim = 1;

		error = clEnqueueNDRangeKernel(queue, kernel, work_dim, NULL, globalWorkSize,
			localWorkSize, 0, NULL, NULL);
		if (error != CL_SUCCESS) {
			throw string("Error queuing kernel for execution!\n");
		}

		//¶ÁÈ¡Ö´Ðнá¹û
		error = clEnqueueReadBuffer(queue, memObject2, CL_TRUE, 0, resultSize * sizeof(uchar),
			result, 0, NULL, NULL);
		if (error != CL_SUCCESS) {
			throw string("Error reading result buffer!\n");
		}
		clReleaseKernel(kernel);
		clReleaseMemObject(memObject1);
		clReleaseMemObject(memObject2);
	}
	catch (string st) {
		clReleaseKernel(kernel);
		clReleaseMemObject(memObject1);
		clReleaseMemObject(memObject2);
		excuteError();
		throw st;
	}


}



void OpenCLExcuter::destory() {
	//ÊÍ·Å×ÊÔ´
	clReleaseCommandQueue(queue);
	clReleaseProgram(program);
	clReleaseContext(context);
	clReleaseDevice(devices);
}