#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) {
|
//±£´æ´íÎóµÄͼƬ
|
//string path = "C:\\Users\\Administrator\\Desktop\\ocr\\error\\";
|
//path.append(to_string(clock())).append("_");
|
//path.append(to_string(rand())).append(".png");
|
//cv::imwrite(path, img);
|
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);
|
}
|
