CPP 替代 PIL 图片处理（缩略图生成）

python中使用PIL（Pyhton Image Library）进行图片处理，好处就是编写简单方便，但是不能很好利用机器多核的特点，于是在项目中决定使用cpp来实现图片处理。

项目中的图片处理主要是生成缩略图。网上收集了一些cpp图片处理库，并进行了对比：

在项目中需要对jpg、png、gif格式的图片进行处理，可行的cpp库有Img、FreeImage、GD，而安装使用后进行效率对比，决定使用FreeImage。

折腾了一个星期，把可用程序完成，并和PIL进行对比（这里是使用python commands库运行上传图片demo，上传时使用threading多进行并发）：

注意：

1、测试时上传多张大图片时内存很快用完，所以要测试要排除内存用完的影响，内存耗尽会影响测试。（上传数量控制一下）

2、linux机器上传时，记得ulimit -n 调大文件句柄打开数，以免影响测试。

测试结果还是挺理想，准备正式推广。

FreeImage cpp 缩略图生成代码：

 #include "stdio.h"
 #include "stdlib.h"
 #include "unistd.h"
 #include <sys/time.h>
 #include <sys/stat.h>
 #include "FreeImage.h"

 #ifdef _DEBUG
 #pragma comment(lib, "FreeImaged.lib")
 #else
 #pragma comment(lib, "FreeImage.lib")
 #endif

 #define THUM_TYPE_SMALL 1
 #define THUM_TYPE_MID 2

 const float IMAGE_NEED_CROP_RATIO = 3.0;
 const float IMAGE_CROP_RATIO = 1.76;
 const int MID_IMAGE_LIMIT_SIZE = **;

 struct ImageSize{
     int width;
     int height;
 };

 inline void print_size(ImageSize img_size, const char* str)
 {
     printf("%s : %d %d\n", str, img_size.width, img_size.height);
 }

 inline bool is_long_image(ImageSize img_size)
 {

     if(float(img_size.height) / img_size.width > IMAGE_NEED_CROP_RATIO)
         return true;
     else
         return false;
 }

 inline bool is_panorama_image(ImageSize img_size)
 {

     if(float(img_size.width) / img_size.height > IMAGE_NEED_CROP_RATIO)
         return true;
     else
         return false;
 }

 inline bool is_need_crop(ImageSize img_size)
 {
     if(is_long_image(img_size))
         return true;

     if(is_panorama_image(img_size))
         return true;

     return false;
 }

 inline bool is_need_resize(ImageSize img_size, ImageSize des_img_size)
 {
     int width = img_size.width;
     int height = img_size.height;
     int des_width = des_img_size.width;
     int des_height = des_img_size.height;
     if((width < des_width) && (height < des_height))
         return false;
     else
         return true;
 }

 inline ImageSize get_crop_size(ImageSize img_size)
 {
     if(is_long_image(img_size))
         img_size.height = img_size.width * IMAGE_CROP_RATIO;
     else if(is_panorama_image(img_size))
         img_size.width = img_size.height * IMAGE_CROP_RATIO;

     return img_size;
 }

 inline ImageSize get_resize_size(ImageSize img_size, ImageSize des_img_size)
 {
     int width = img_size.width;
     int height = img_size.height;
     int des_width = des_img_size.width;
     int des_height = des_img_size.height;    

     float ratio = 1.0;
     if(height > width)
         ratio = float(des_height) / height;
     else
         ratio = float(des_width) / width;

     img_size.width = width * ratio;
     img_size.height = height * ratio;

     return img_size;
 }

 inline FIBITMAP * get_crop_picture(FIBITMAP *sourcePic)
 {

     int src_width, src_height;

     //获取图片大小
     src_width  = FreeImage_GetWidth(sourcePic);
     src_height = FreeImage_GetHeight(sourcePic);        

     struct ImageSize src_size = {src_width, src_height};

     if(!is_need_crop(src_size))
         return sourcePic;

     struct ImageSize crop_size = get_crop_size(src_size);
     //print_size(crop_size, "crop_size");

     FIBITMAP * cropPic = FreeImage_Copy(sourcePic, , , crop_size.width, crop_size.height);

     FreeImage_Unload(sourcePic);
     sourcePic = NULL;

     return cropPic;

 }

 inline FIBITMAP * get_resize_picture(FIBITMAP *sourcePic, ImageSize des_size)
 {

     int src_width, src_height;

     //获取图片大小
     src_width  = FreeImage_GetWidth(sourcePic);
     src_height = FreeImage_GetHeight(sourcePic);        

     struct ImageSize src_size = {src_width, src_height};

     if(!is_need_resize(src_size, des_size))
         return sourcePic;

     struct ImageSize resize_size = get_resize_size(src_size, des_size);
     //print_size(resize_size, "resize_size");

     FIBITMAP * resizePic = FreeImage_Rescale(sourcePic, resize_size.width, resize_size.height, FILTER_BOX);    

     FreeImage_Unload(sourcePic);
     sourcePic = NULL;

     return resizePic;

 }

 int get_file_size1(const char * src_pic_path)
 {
     struct stat stat_buf;
     stat(src_pic_path, &stat_buf);
     int file_size =  stat_buf.st_size;

     return file_size;
 }

 int get_file_size2(const char * src_pic_path)
 {
     FILE * fp = fopen(src_pic_path, "rb");
     if(fp == NULL)
         return ;

     fseek (fp, , SEEK_END);
     int src_file_size = ftell(fp);
     fclose(fp);    

     return src_file_size;
 }

 int gen_symbolic_link(const char *src_pic_path, const char *des_pic_path)
 {
     char cmd[];
     sprintf(cmd, "ln -s %s %s", src_pic_path, des_pic_path);
     int sh_ret = system(cmd);

     return sh_ret;
 }

 int gen_small_thumbnail(const char *src_pic_path, const char *des_pic_path, int des_width, int des_height)
 {
     //printf("gen_small_thumbnail:%s --> %s w:%d, h:%d\n", src_pic_path, des_pic_path, des_width, des_height);

     struct ImageSize des_size = {des_width, des_height};

     FIBITMAP *sourcePic = NULL, *finalPic = NULL;
     FreeImage_Initialise();
     FREE_IMAGE_FORMAT pic_type = FIF_UNKNOWN;

     //获取图片格式
     pic_type = FreeImage_GetFileType (src_pic_path, );
     //printf("xxxxxxx:%d %d \n", pic_type, FIT_BITMAP);
     //是否支持该格式类型
     if(!FreeImage_FIFSupportsReading(pic_type))
         return ;

     //载入图片
     sourcePic = FreeImage_Load(pic_type, src_pic_path, );

     //剪切图片
     sourcePic = get_crop_picture(sourcePic);
     if(!sourcePic)
         return ;

     //缩略图片
     sourcePic = get_resize_picture(sourcePic, des_size);
     if(!sourcePic)
         return ;

     int returnValue = ;

     //位图转换
     finalPic = FreeImage_ConvertTo24Bits(sourcePic); 

     //保存图片
     if(!FreeImage_Save(FIF_JPEG, finalPic, des_pic_path, JPEG_DEFAULT))
         returnValue = ;

     //释放资源
     FreeImage_Unload(sourcePic);
     FreeImage_Unload(finalPic);
     sourcePic = NULL;
     finalPic = NULL;
     FreeImage_DeInitialise();

     return returnValue;
 }

 int gen_mid_thumbnail(const char *src_pic_path, const char *des_pic_path, int des_width, int des_height)
 {
     //printf("gen_mid_thumbnail:%s --> %s w:%d, h:%d\n", src_pic_path, des_pic_path, des_width, des_height);
     struct ImageSize des_size = {des_width, des_height};

     FIBITMAP *sourcePic = NULL, *finalPic = NULL;
     FreeImage_Initialise();
     FREE_IMAGE_FORMAT pic_type = FIF_UNKNOWN;

     //获取图片格式
     pic_type = FreeImage_GetFileType (src_pic_path, );
     //printf("xxxxxxx:%d %d \n", pic_type, FIT_BITMAP);
     //是否支持该格式类型
     if(!FreeImage_FIFSupportsReading(pic_type))
         return ;

     //载入图片
     sourcePic = FreeImage_Load(pic_type, src_pic_path, );

     struct ImageSize src_size = {FreeImage_GetWidth(sourcePic), FreeImage_GetHeight(sourcePic)}; 

     //缩略图片
     int returnValue = ;

     sourcePic = get_resize_picture(sourcePic, des_size);
     if(!sourcePic)
         return ;    

     //int src_file_size = get_file_size2(src_pic_path);
     int file_size = get_file_size1(src_pic_path);

     if(is_need_resize(src_size, des_size) || file_size > MID_IMAGE_LIMIT_SIZE){
         //位图转换
         finalPic = FreeImage_ConvertTo24Bits(sourcePic); 

         //保存图片
         if(!FreeImage_Save(FIF_JPEG, finalPic, des_pic_path, JPEG_DEFAULT))
             returnValue = ;
     }else{
         int sh_ret = gen_symbolic_link(src_pic_path, des_pic_path);
         //if(src_file_size > MID_IMAGE_LIMIT_SIZE)
         //printf("src_file_size:%d file_size:%d sh:%d\n", src_file_size, file_size, sh_ret);
     }

     //释放资源
     FreeImage_Unload(sourcePic);
     FreeImage_Unload(finalPic);
     sourcePic = NULL;
     finalPic = NULL;
     FreeImage_DeInitialise();

     return returnValue;
 }

 /*

 usage:

     ./cpp_gen_thum src_pic_path des_pic_path height width type

     源文件地址 生成文件地址 目标高 目标宽 类型 

 */ 

 int main(int argc, char* argv[])
 {

     struct timeval t1,t2;
     double timeuse;
     gettimeofday(&t1,NULL);

     int height = atoi(argv[]);
     int width = atoi(argv[]);
     int thum_type = atoi(argv[]);
     int result = ;

     if(thum_type == THUM_TYPE_SMALL){
         result = gen_small_thumbnail(argv[], argv[], height, width);
     }else if(thum_type == THUM_TYPE_MID){
         result = gen_mid_thumbnail(argv[], argv[], height, width);
     }

     printf("%d", result);

 //    int small_res = gen_small_thumbnail(argv[1], argv[2], 120, 120);
 //    int mid_res = gen_mid_thumbnail(argv[1], argv[3], 640, 640);
 //
 //    gettimeofday(&t2,NULL);
 //    timeuse = t2.tv_sec - t1.tv_sec + (t2.tv_usec - t1.tv_usec)/1000000.0;
 //    printf("Use Time:%f small_res:%d filename:%s\n\t\t  mid_res:%d filename:%s\n",
 //        timeuse, small_res, argv[2], mid_res, argv[3]);
     return ;
 }