OpenCL + OpenCV 图像旋转

▶ 使用 OpenCV 从文件读取彩色的 png 图像，旋转一定角度以后写回文件

● 代码，核函数

 // rotate.cl
 //__constant  sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_FILTER_NEAREST | CLK_ADDRESS_CLAMP;// 设备采样器，可以启用，并删除函数 imageRotate 中的采样器参数

 __kernel void imageRotate(__read_only image2d_t inputImage, __write_only image2d_t outputImage, float angle, sampler_t sampler)
 {
     const int width = get_image_width(inputImage), height = get_image_height(inputImage);
     const int halfWidth = width / , halfHeight = height / ;
     const int x = get_global_id(), y = get_global_id();
     const int xt = x - halfWidth, yt = y - halfHeight;
     const float sinFactor = sin(angle), cosFactor = cos(angle);

     float2 readCoord = (float2)(halfWidth + cosFactor * xt - sinFactor * yt, readCoord.y = halfHeight + sinFactor * xt + cosFactor * yt);
     float4 value = read_imagef(inputImage, sampler, readCoord);
     write_imagef(outputImage, (int2)(x, y), value);
     return;
 }

● 代码，分三通道分别旋转

 #include <stdio.h>
 #include <stdlib.h>
 #include <cl.h>
 #include <opencv.hpp>
 #include <opencv2\core\cvstd.hpp>   // namespace cv 的定义

 #pragma warning(disable : 4996)     // 解封OPenCL1.2

 using namespace cv;

 const char *sourceProgram = "D:/Code/OpenCL/rotate.cl";// 核函数文件
 const char *imagePath = "D:\\input.png";
 const float angle = 3.14f / ;

 int readSource(const char* kernelPath, char **output)// 读取文本文件，存储为 char *
 {
     FILE *fp;
     int size;
     fopen_s(&fp, kernelPath, "rb");
     if (!fp)
     {
         printf("Open kernel file failed\n");
         exit(-);
     }
     if (fseek(fp, , SEEK_END) != )
     {
         printf("Seek end of file faildd\n");
         exit(-);
     }
     if ((size = ftell(fp)) < )
     {
         printf("Get file position failed\n");
         exit(-);
     }
     rewind(fp);
     if ((*output = (char *)malloc(size + )) == NULL)
     {
         printf("Allocate space failed\n");
         exit(-);
     }
     fread((void*)*output, , size, fp);
     fclose(fp);
     (*output)[size] = '\0';
     printf("readSource succeed, program file: %s\n", kernelPath);
     return size;
 }

 int main()
 {
     // 准备平台，设备，上下文，命令队列部分
     cl_int status;
     cl_uint nPlatform;
     clGetPlatformIDs(, NULL, &nPlatform);
     cl_platform_id *listPlatform = (cl_platform_id*)malloc(nPlatform * sizeof(cl_platform_id));
     clGetPlatformIDs(nPlatform, listPlatform, NULL);
     cl_uint nDevice = ;
     clGetDeviceIDs(listPlatform[], CL_DEVICE_TYPE_ALL, , NULL, &nDevice);
     cl_device_id *listDevice = (cl_device_id*)malloc(nDevice * sizeof(cl_device_id));
     clGetDeviceIDs(listPlatform[], CL_DEVICE_TYPE_ALL, nDevice, listDevice, NULL);
     cl_context context = clCreateContext(NULL, nDevice, listDevice, NULL, NULL, &status);
     cl_command_queue queue = clCreateCommandQueue(context, listDevice[], , &status);                          // OpenCL1.2
     //cl_command_queue_properties queueProp[5] = {CL_QUEUE_PROPERTIES, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE | CL_QUEUE_ON_DEVICE | CL_QUEUE_ON_DEVICE_DEFAULT,// OpenCL2.0
     //                                            CL_QUEUE_SIZE, CL_DEVICE_QUEUE_ON_DEVICE_PREFERRED_SIZE,
     //                                            0};
     //cl_command_queue queue = clCreateCommandQueueWithProperties(context, listDevice[0], &queueProp, &status); // 第三个参数 queueProp 各种改都会报内存越界 0xC0000005

     // 图片相关
     Mat image, channel[];
     image = imread(imagePath);
     split(image, channel);                          // 拆分为三通道，分别旋转后拼合
     const int imageHeight = image.rows, imageWidth = image.cols;
     unsigned char *imageData = (unsigned char*)malloc(sizeof(unsigned char) * imageHeight * imageWidth);

     cl_image_format format;
     format.image_channel_order = CL_R;              // 单通道
     format.image_channel_data_type = CL_UNORM_INT8; // 无符号 8 位整形，0 ~ 255
     cl_image_desc desc;
     desc.image_type = CL_MEM_OBJECT_IMAGE2D;        // 可以 memset(desc,sizeof(cl_image_desc)); 后仅对前三项赋值
     desc.image_width = imageWidth;
     desc.image_height = imageHeight;
     desc.image_depth = ;
     desc.image_array_size = ;
     desc.image_row_pitch = ;
     desc.image_slice_pitch = ;
     desc.num_mip_levels = ;
     desc.num_samples = ;
     desc.buffer = NULL;
     cl_mem d_inputImage = clCreateImage(context, CL_MEM_READ_ONLY, &format, &desc, NULL, &status);
     cl_mem d_outputImage = clCreateImage(context, CL_MEM_WRITE_ONLY, &format, &desc, NULL, &status);

     // 采样器
     cl_sampler sampler = clCreateSampler(context, CL_FALSE, CL_ADDRESS_CLAMP_TO_EDGE, CL_FILTER_NEAREST, &status);  // OpenCL1.2
     //cl_sampler_properties samplerProp[7] = {CL_SAMPLER_NORMALIZED_COORDS, CL_FALSE,                               // OpenCL2.0
     //                                        CL_SAMPLER_ADDRESSING_MODE, CL_ADDRESS_CLAMP_TO_EDGE,
     //                                        CL_SAMPLER_FILTER_MODE, CL_FILTER_NEAREST,
     //                                        0};
     //cl_sampler sampler = clCreateSamplerWithProperties(context, samplerProp, &status);                            // 也是内存越界，用不了

     // 程序和内核
     char* source = NULL;
     const size_t lenSource = readSource(sourceProgram, &source);
     cl_program program = clCreateProgramWithSource(context, , (const char **)&source, &lenSource, &status);
     clBuildProgram(program, , listDevice, NULL, NULL, NULL);
     cl_kernel kernel = clCreateKernel(program, "imageRotate", &status);
     clSetKernelArg(kernel, , sizeof(cl_mem), &d_inputImage);
     clSetKernelArg(kernel, , sizeof(cl_mem), &d_outputImage);
     clSetKernelArg(kernel, , sizeof(cl_float), &angle);
     clSetKernelArg(kernel, , sizeof(cl_sampler), &sampler);
     size_t origin[] = { , ,  }, region[] = { imageWidth, imageHeight,  };// 拷贝图片缓冲区时使用的起点和范围参数
     size_t globalSize[] = { imageWidth, imageHeight };

     for (int i = ; i < ; i++)// 分三个通道拷入缓冲区，执行旋转操作，拷回内存
     {
         memcpy(imageData, channel[i].data, sizeof(unsigned char) * imageHeight * imageWidth);
         clEnqueueWriteImage(queue, d_inputImage, CL_TRUE, origin, region, , , imageData, , NULL, NULL);
         clEnqueueNDRangeKernel(queue, kernel, , NULL, globalSize, NULL, , NULL, NULL);
         clEnqueueReadImage(queue, d_outputImage, CL_TRUE, origin, region, , , imageData, , NULL, NULL);
         memcpy(channel[i].data, imageData, sizeof(unsigned char) * imageHeight * imageWidth);
     }

     merge(channel, , image);// 合并通道，结果写入文件，在窗口中展示结果
     imwrite("D:/output.png", image);
     imshow("Result", image);
     waitKey();

     free(listPlatform);
     free(listDevice);
     clReleaseContext(context);
     clReleaseMemObject(d_inputImage);
     clReleaseMemObject(d_outputImage);
     clReleaseCommandQueue(queue);
     clReleaseProgram(program);
     clReleaseKernel(kernel);
     //getchar();
     return ;
 }

● 代码，四个通道同时操作，注意图片读入和输出的时候只有三个通道，需要进行调整

 #include <stdio.h>
 #include <stdlib.h>
 #include <cl.h>
 #include <opencv.hpp>
 #include <opencv2\core\cvstd.hpp>   // namespace cv 的定义

 #pragma warning(disable : 4996)     // 解封OPenCL1.2

 using namespace cv;

 const char *sourceProgram = "D:/Code/OpenCL/rotate.cl";// 核函数文件
 const char *imagePath = "D:/input.png";
 const float angle = 3.14f / ;

 int readSource(const char* kernelPath, char **output)// 读取文本文件，存储为 char *
 {
     FILE *fp;
     int size;
     fopen_s(&fp, kernelPath, "rb");
     if (!fp)
     {
         printf("Open kernel file failed\n");
         exit(-);
     }
     if (fseek(fp, , SEEK_END) != )
     {
         printf("Seek end of file faildd\n");
         exit(-);
     }
     if ((size = ftell(fp)) < )
     {
         printf("Get file position failed\n");
         exit(-);
     }
     rewind(fp);
     if ((*output = (char *)malloc(size + )) == NULL)
     {
         printf("Allocate space failed\n");
         exit(-);
     }
     fread((void*)*output, , size, fp);
     fclose(fp);
     (*output)[size] = '\0';
     printf("readSource succeed, program file: %s\n", kernelPath);
     return size;
 }

 int main()
 {
     // 准备平台，设备，上下文，命令队列部分
     cl_int status;
     cl_uint nPlatform;
     clGetPlatformIDs(, NULL, &nPlatform);
     cl_platform_id *listPlatform = (cl_platform_id*)malloc(nPlatform * sizeof(cl_platform_id));
     clGetPlatformIDs(nPlatform, listPlatform, NULL);
     cl_uint nDevice = ;
     clGetDeviceIDs(listPlatform[], CL_DEVICE_TYPE_ALL, , NULL, &nDevice);
     cl_device_id *listDevice = (cl_device_id*)malloc(nDevice * sizeof(cl_device_id));
     clGetDeviceIDs(listPlatform[], CL_DEVICE_TYPE_ALL, nDevice, listDevice, NULL);
     cl_context context = clCreateContext(NULL, nDevice, listDevice, NULL, NULL, &status);
     cl_command_queue queue = clCreateCommandQueue(context, listDevice[], , &status);// OpenCL1.2    

     // 图片相关
     Mat image = imread(imagePath);
     const int imageHeight = image.rows, imageWidth = image.cols;
     unsigned char *imageData = (unsigned char*)malloc(sizeof(unsigned char) * imageHeight * imageWidth * );

     for (int i = ; i < imageWidth * imageHeight; i++)// imread 读进来只有 RGB 三个通道（可能跟图片本身有关），要补成 4 个通道
     {
         imageData[ * i + ] = image.data[ * i + ];//R
         imageData[ * i + ] = image.data[ * i + ];//G
         imageData[ * i + ] = image.data[ * i + ];//B
         imageData[ * i + ] = ;                  //A
     }

     cl_image_format format;
     format.image_channel_order = CL_RGBA;            // 合并通道
     format.image_channel_data_type = CL_UNORM_INT8; // 无符号 8 位整形，0 ~ 255
     cl_image_desc desc;
     desc.image_type = CL_MEM_OBJECT_IMAGE2D;        // 可以 memset(desc,sizeof(cl_image_desc)); 后仅对前三项赋值
     desc.image_width = imageWidth;
     desc.image_height = imageHeight;
     desc.image_depth = ;
     desc.image_array_size = ;
     desc.image_row_pitch = ;
     desc.image_slice_pitch = ;
     desc.num_mip_levels = ;
     desc.num_samples = ;
     desc.buffer = NULL;
     cl_mem d_inputImage = clCreateImage(context, CL_MEM_READ_ONLY | CL_MEM_USE_HOST_PTR, &format, &desc, imageData, &status);// 输入图片直接在主机上
     cl_mem d_outputImage = clCreateImage(context, CL_MEM_WRITE_ONLY, &format, &desc, NULL, &status);    

     // 采样器
     cl_sampler sampler = clCreateSampler(context, CL_FALSE, CL_ADDRESS_CLAMP_TO_EDGE, CL_FILTER_NEAREST, &status);  // OpenCL1.2

     // 程序和内核
     char* source = NULL;
     const size_t lenSource = readSource(sourceProgram, &source);
     cl_program program = clCreateProgramWithSource(context, , (const char **)&source, &lenSource, &status);
     clBuildProgram(program, , listDevice, NULL, NULL, NULL);
     cl_kernel kernel = clCreateKernel(program, "imageRotate", &status);
     clSetKernelArg(kernel, , sizeof(cl_mem), &d_inputImage);
     clSetKernelArg(kernel, , sizeof(cl_mem), &d_outputImage);
     clSetKernelArg(kernel, , sizeof(cl_float), &angle);
     clSetKernelArg(kernel, , sizeof(cl_sampler), &sampler);
     size_t origin[] = { , ,  }, region[] = { imageWidth, imageHeight,  };// 拷贝图片缓冲区时使用的起点和范围参数
     size_t globalSize[] = { imageWidth, imageHeight };

     clEnqueueNDRangeKernel(queue, kernel, , NULL, globalSize, NULL, , NULL, NULL);
     clEnqueueReadImage(queue, d_outputImage, CL_TRUE, origin, region, , , imageData, , NULL, NULL);

     for (int i = ; i < imageWidth * imageHeight; i++)// 去掉第 4 个通道，返回 image 中
     {
         image.data[ * i + ] = imageData[ * i + ];//B
         image.data[ * i + ] = imageData[ * i + ];//G
         image.data[ * i + ] = imageData[ * i + ];//R
     }    

     imwrite("D:/output.png", image);
     imshow("Result", image);
     waitKey();

     free(listPlatform);
     free(listDevice);
     clReleaseContext(context);
     clReleaseMemObject(d_inputImage);
     clReleaseMemObject(d_outputImage);
     clReleaseCommandQueue(queue);
     clReleaseProgram(program);
     clReleaseKernel(kernel);
     //getchar();
     return ;
 }

● 输入、输出结果，顺时针转 45 度，因为使用了最近邻采样，结果中锯齿比较严重

　　

● 另一种解封旧 API 的方法，在 包含头文件 <cl.h> 前使用  #define CL_USE_DEPRECATED_OPENCL_1_2_APIS ，其中 1_2 可以改成 1_0，1_1 等（https://stackoverflow.com/questions/28500496/opencl-function-found-deprecated-by-visual-studio/28500846#28500846）

● 使用 cl_command_queue_properties 和函数 clCreateCommandQueueWithProperties 来创建命令队列，或是用 cl_sampler_properties 和函数 clCreateSamplerWithProperties 来创建采样器都失败了，报内存访问越界错误（0xC0000005），无论是按格式书写还是把 queueProp 改成 0，创建时第三个参数写成 &queueProp 都不行；有人说更新显卡驱动以后就好了（https://stackoverflow.com/questions/39864947/opencl-cl-out-of-host-memory-on-clcreatecommandqueuewithproperties-with-minima）。最后解决了，用 AMD APP SDK 下面的动态库 amdocl64.dll 替换掉 C:\Windows\System32 里边那个相同库就好了，可以完全使用 OpenCL2.0 的 API，不再报错。

● cv::imread 读入的图片是按照 [ R, G, B, R, G, B, R, G, B, ...] 存放的，在用 OpenCL处理之前需要进行一定的预处理，要么用 split 分解各通道为单独的图片，要么手工拆解，算完以后也要按照这种存放方式转回图像数据中。在发现通道个数和顺序的问题前，要么在调用函数 clCreateImage 的时候返回 -37，-38，-39，要么直接旋转得到像下面这样的图片。以后记得，如果出现这种交叉条纹的图像，有可能是通道交错导致的。

　　

● 吐槽一下，网上能找到的 OpenCL + OpenCV 做图片旋转的基本上有几个版本（https://blog.csdn.net/c602273091/article/details/45418223，https://blog.csdn.net/icamera0/article/details/71598323，https://blog.csdn.net/jaccen2012/article/details/51367388）都是用 FreeImage 库把图像处理成灰度图来旋转的（参考了 刘文志等(2016). OpenCL 异构并行计算[M]. 的代码？），输出肯定是灰度图了，然后大家博客就相互抄吧，全是垃圾。好不容易找到一个彩色的（https://blog.csdn.net/Bob_Dong/article/details/64906734）代码还看不了。