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 = 3*1024*1024;

struct ImageSize{
    int width;
    int height;
};

inline void print_size(ImageSize img_size, const char* str)
{
    printf("%s : %d %d
", 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, 0, 0, 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 0;
    
    fseek (fp, 0, 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[200];
    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
", 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, 0);
    //printf("xxxxxxx:%d %d 
", pic_type, FIT_BITMAP);
    //是否支持该格式类型 
    if(!FreeImage_FIFSupportsReading(pic_type))
        return 480;
        
    //载入图片 
    sourcePic = FreeImage_Load(pic_type, src_pic_path, 0);
    
    //剪切图片 
    sourcePic = get_crop_picture(sourcePic);
    if(!sourcePic)
        return 481;
    
    //缩略图片 
    sourcePic = get_resize_picture(sourcePic, des_size);
    if(!sourcePic)
        return 482;
    
    int returnValue = 0;
    
    //位图转换 
    finalPic = FreeImage_ConvertTo24Bits(sourcePic); 
    
    //保存图片 
    if(!FreeImage_Save(FIF_JPEG, finalPic, des_pic_path, JPEG_DEFAULT))
        returnValue = 499;
    
    //释放资源 
    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
", 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, 0);
    //printf("xxxxxxx:%d %d 
", pic_type, FIT_BITMAP);
    //是否支持该格式类型 
    if(!FreeImage_FIFSupportsReading(pic_type))
        return 480;
        
    //载入图片 
    sourcePic = FreeImage_Load(pic_type, src_pic_path, 0);
    
    struct ImageSize src_size = {FreeImage_GetWidth(sourcePic), FreeImage_GetHeight(sourcePic)}; 
    
    //缩略图片 
    int returnValue = 0;
        
    sourcePic = get_resize_picture(sourcePic, des_size);
    if(!sourcePic)
        return 482;    

    //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 = 499;
    }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
", 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[3]);
    int width = atoi(argv[4]);
    int thum_type = atoi(argv[5]);
    int result = 1;
    
    if(thum_type == THUM_TYPE_SMALL){
        result = gen_small_thumbnail(argv[1], argv[2], height, width);
    }else if(thum_type == THUM_TYPE_MID){
        result = gen_mid_thumbnail(argv[1], argv[2], 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
		  mid_res:%d filename:%s
", 
//        timeuse, small_res, argv[2], mid_res, argv[3]);
    return 0;
}