OpenCL 第8课:旋转变换(2)

上两节课都是对一个数组进行处理。这节我们来个有意思的。同样是旋转。但我们旋转的对象是张（２５６*２５６）的图片。图片旋转４５度，旋转后大小还是２５６*２５６，超出部份进行剪除。

图片旋转处理有个特别的地方。buf_A是存储源图数据（R,G,B颜色分量）,buf_B是存储旋转后数据。我们不能简单将buf_A中的数据直接计算旋转后位置。而是遍历buf_B每个数据，计算那些数据旋转后存在这个位置的数据他在buf_A的坐标是多少。为什么呢？不是因为不能直接旋转。而是因为坐标是整数型。进行旋转计算后会得出浮点数，有小数。计算精度不同。如果还用直接旋转计算方法。成出的位图将会出现斑点。大家可试下。

我们来看源码

rotate.cl源码

?
__kernel void rotation(__global int* A,
                    __global int* B,
                    int width,
                    int height,
                    float sinangle,
                    float cosangle)
{
    //获取索引号，这里是二维的，所以可以取两个
    //否则另一个永远是0
    int col = get_global_id(0);
    int row = get_global_id(1);
    //计算图形中心点
    float cx = ((float)width)/2;
    float cy = ((float)height)/2;
    int nx = (int)(cx + cosangle * ((float)col-cx) + sinangle * ((float)row-cy));
    int ny = (int)(cy + (-1*sinangle) * ((float)col-cx) + cosangle * ((float)row-cy));
    //边界检测
    if(nx>=0 && nx<width && ny>=0 && ny<height)
    {
        B[col*3+0+row*width*3] = A[nx*3+0+ny*width*3];
        B[col*3+1+row*width*3] = A[nx*3+1+ny*width*3];
        B[col*3+2+row*width*3] = A[nx*3+2+ny*width*3];
    }
}

main.cpp源码

?
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <string>
#include <conio.h>
#include <math.h>//数学库
#include <CL/cl.h>//包含CL的头文件
//调用freeimage
#include <freeimage.h>
using namespace std;
//8x8数组
const int dim_x = 256;
const int dim_y = 256;
//45度的弧度
const float angle = 3.1415926f/4.0f;
static int buf_A[dim_x*dim_y*3];
static int buf_B[dim_x*dim_y*3];
//加载图片
//以RGBA格式存储图片
static bool LoadImg(const char* fname)
{
    //初始化FreeImage
    FreeImage_Initialise(TRUE);
    //定义图片格式为未知
    FREE_IMAGE_FORMAT fif = FIF_UNKNOWN;
    //获取图片格式
    fif = FreeImage_GetFileType(fname,0);
    //根据获取格式读取图片数据
    FIBITMAP* bitmap = FreeImage_Load(fif,fname,0);
    if(!bitmap)
    {
        printf("load error!\n");
        return false;
    }
    int x,y;
    RGBQUAD m_rgb;
    //获取图片长宽
    int width = (int)FreeImage_GetWidth(bitmap);
    int height = (int)FreeImage_GetHeight(bitmap);
    //获取图片数据
    //按RGBA格式保存到数组中
    for(y=0;y<height;y++)
    {
        for(x=0;x<width;x++)
        {
            //获取像素值
            FreeImage_GetPixelColor(bitmap,x,y,&m_rgb);
            //将RGB值存入数组
            buf_A[y*width*3+x*3+2] = m_rgb.rgbRed;
            buf_A[y*width*3+x*3+1] = m_rgb.rgbGreen;
            buf_A[y*width*3+x*3+0] = m_rgb.rgbBlue;
        }
    }
    FreeImage_Unload(bitmap);
    return true;
}
static bool SaveImg()
{
    //初始化FreeImage
    FreeImage_Initialise(TRUE);
    FIBITMAP* bitmap =FreeImage_Allocate(dim_x,dim_y,32,8,8,8);
    int m,n;
    for(n=0;n<dim_y;n++)
    {
        BYTE *bits =FreeImage_GetScanLine(bitmap,n);
        for(m=0;m<dim_x;m++)
        {
            bits[0] = buf_B[dim_x*3*n+m*3+0];
            bits[1] = buf_B[dim_x*3*n+m*3+1];
            bits[2] = buf_B[dim_x*3*n+m*3+2];
            bits[3] = 255;
            bits+=4;
        }
    }
    //保存图片为PNG格式
    if(false ==FreeImage_Save(FIF_PNG, bitmap,"rotate.png", PNG_DEFAULT))
    {
        printf("save image error\n");
    }
    FreeImage_Unload(bitmap);
    return true;
}
//从外部文件获取cl内核代码
bool GetFileData(const char* fname,string& str)
{
    FILE* fp = fopen(fname,"r");
    if(fp==NULL)
    {
        printf("no found file\n");
        return false;
    }
    while(feof(fp)==0)
    {
        str += fgetc(fp);
    }
    return true;
}
int main()
{
    if(LoadImg("bk.png")==false)
    {
        printf("error load bk.png!\n");
        return 0;
    }
    //先读外部CL核心代码，如果失败则退出。
    //代码存buf_code里面
    string code_file;
    if(false == GetFileData("rotate.cl",code_file))
    {
        printf("Open rotate.cl error\n");
        return 0;
    }
    char* buf_code = new char[code_file.size()];
    strcpy(buf_code,code_file.c_str());
    buf_code[code_file.size()-1] = NULL;
    //声明CL所需变量。
    cl_device_id device;
    cl_platform_id platform_id = NULL;
    cl_context context;
    cl_command_queue cmdQueue;
    cl_mem bufferA,bufferB;
    cl_program program;
    cl_kernel kernel = NULL;
    //我们使用的是二维向量
    //设定向量大小（维数）
    size_t globalWorkSize[2];
    globalWorkSize[0] = dim_x;
    globalWorkSize[1] = dim_y;
    cl_int err;
    /*
        定义输入变量和输出变量，并设定初值
    */
    size_t datasize = sizeof(int) * dim_x * dim_y * 3;
    //step 1:初始化OpenCL
    err = clGetPlatformIDs(1,&platform_id,NULL);
    if(err!=CL_SUCCESS)
    {
        cout<<"clGetPlatformIDs error:"<<err<<endl;
        return 0;
    }
    //这次我们只用CPU来进行并行运算，当然你也可以该成GPU
    clGetDeviceIDs(platform_id,CL_DEVICE_TYPE_CPU,1,&device,NULL);
    //step 2:创建上下文
    context = clCreateContext(NULL,1,&device,NULL,NULL,NULL);
    //step 3:创建命令队列
    cmdQueue = clCreateCommandQueue(context,device,0,NULL);
    //step 4:创建数据缓冲区
    bufferA = clCreateBuffer(context,
                             CL_MEM_READ_ONLY,
                             datasize,NULL,NULL);
    bufferB = clCreateBuffer(context,
                             CL_MEM_WRITE_ONLY,
                             datasize,NULL,NULL);
    //step 5:将数据上传到缓冲区
    clEnqueueWriteBuffer(cmdQueue,
                         bufferA,CL_FALSE,
                         0,datasize,
                         buf_A,0,
                         NULL,NULL);
    //step 6:加载编译代码,创建内核调用函数
    program = clCreateProgramWithSource(context,1,
                                        (const char**)&buf_code,
                                        NULL,NULL);
    clBuildProgram(program,1,&device,NULL,NULL,NULL);
    kernel = clCreateKernel(program,"rotation",NULL);
    //step 7:设置参数，执行内核
    float sinangle = sinf(angle);
    float cosangle = cosf(angle);
    clSetKernelArg(kernel,0,sizeof(cl_mem),&bufferA);
    clSetKernelArg(kernel,1,sizeof(cl_mem),&bufferB);
    clSetKernelArg(kernel,2,sizeof(cl_int),&dim_x);
    clSetKernelArg(kernel,3,sizeof(cl_int),&dim_y);
    clSetKernelArg(kernel,4,sizeof(cl_float),&sinangle);
    clSetKernelArg(kernel,5,sizeof(cl_float),&cosangle);
    //注意这里第三个参数已经改成2，表示二维数据。
    clEnqueueNDRangeKernel(cmdQueue,kernel,
                           2,NULL,
                           globalWorkSize,
                           NULL,0,NULL,NULL);
    //step 8:取回计算结果
    clEnqueueReadBuffer(cmdQueue,bufferB,CL_TRUE,0,
                        datasize,buf_B,0,NULL,NULL);
    SaveImg();
    //释放所有调用和内存
    clReleaseKernel(kernel);
    clReleaseProgram(program);
    clReleaseCommandQueue(cmdQueue);
    clReleaseMemObject(bufferA);
    clReleaseMemObject(bufferB);
    clReleaseContext(context);
    delete buf_code;
    return 0;
}