图片叠加文字

项目上有个小需求,在处理过和图片上叠加文字.本以为很简单.结果找字模都找了半天,找到了中英文又不通用.

后来,又被图片的上下次序,字节正序倒序,按行,还是按列等搞的晕头转向......

还好从网上下了个批量生成字模的软件"PCtoLCD2002.exe"

自己写程序生成个GB2312编码表.

主要是生成源码表.代码很简单,效率格式一律不考虑:

int get_hzk_index(const char* str)
{
    char ch;
    int n;

    ch = *str;

    if (ch < 0)
    {
        n = ch - 0xA1;

        if (n > 14 && n < 87)
        {
            return ((n - 4) * 94 + str[1] - 0xA1) * 72;
        }
        else if (n < 9)
        {
            return (n * 94 + str[1] - 0xA1) * 72;
        }
        else
        {
            return -1;
        }
    }

    return (9 * 94 + ch) * 72;;
}


 int generate_src()
{
    FILE *fp;
    int i, j;
    unsigned char buff[2];

    fp = fopen("src.txt", "wb");

    for (i = 0; i < 9; i ++)
    {
        for (j = 0; j < 94; j ++)
        {
            buff[0] = i + 0xA1;
            buff[1] = j + 0xA1;
            fwrite(buff, 2, 1, fp);
        }
    }


    for (i = 0; i < 128; i ++)
    {
        if (isprint(i))
        {
            buff[0] = i;
        }
        else
        {
            buff[0] = ' ';
        }
        buff[1] = ' ';
        fwrite(buff, 2, 1, fp);
    }

    for (i = 0; i < 60; i ++)
    {
        buff[0] = ' ';
        buff[1] = ' ';
        fwrite(buff, 2, 1, fp);
    }

    for (i = 15; i < 87; i ++)
    {
        for (j = 0; j < 94; j ++)
        {
            buff[0] = i + 0xA1;
            buff[1] = j + 0xA1;
            fwrite(buff, 2, 1, fp);
        }
    }

    fclose(fp);

    return 0;
}

09 10区本来是空的..我把英文的前128个写了进去..为了方便处理每个英文字符后面跟一个空格.

这样的话就和汉字对齐了.

后面的汉字区,按空间往前移.详细的看get_hzk_index函数.

然后通过上述软件把src.txt变为字模文件 (阴码,按列,逆向)  按列主要是处理英文..要不很麻烦.

生成des.txt....然后用EDITPLUS,调格式.去{}等....最后生成一个数组

写入文件 hzk24.h

再用FREEIMAGE把JPG解码,,自己写函数叠加

extern unsigned char g_hzk24[561744];


 /**
 * @brief 载入任何可能的图像文件
 * @param fname {const char *} [in] 所要载入文件名
 * @return {FIBITMAP *} 成功返回句柄 不成功NULL
 */
FIBITMAP* ImageLoad(const char* fname)
{
    FREE_IMAGE_FORMAT fif;
    FIBITMAP *dib;

    /* 文件名称非法,直接返回 */
    if (fname == NULL || strlen(fname) < 2)
    {
        fprintf(stderr, "非法文件名\n");
        return NULL;
    }

    /* 从文件结构判断类型 */
    if ((fif = FreeImage_GetFileType(fname, 0)) == FIF_UNKNOWN)
    {
        fprintf(stderr, "无法从结构本身判断文件类型\n");

        /* 如果从结构判断不成功,改为从扩展名判断 */
        if ((fif = FreeImage_GetFIFFromFilename(fname)) == FIF_UNKNOWN)
        {
            fprintf(stderr, "无法从扩展名判断类型\n");
            /* 依然不成功 */
            return NULL;
        }
    }

    if (!FreeImage_FIFSupportsReading(fif))
    {
        /* 不支持该类型 */
        fprintf(stderr, "不支持该类型\n");
        return NULL;
    }

    /* 载入文件 */
    if ((dib = FreeImage_Load(fif, fname, 0)) == NULL)
    {
        fprintf(stderr, "无法载入文件\n");
        return NULL;
    }

    return dib;
}

 /**
 * @brief 释放图像
 * @param dib {FIBITMAP *} [in] 输入句柄
 * @return {void} 无返回值
 */
 void ImageUnload(FIBITMAP *dib)
{
    if (dib != NULL)
    {
        /* 释放内存 */
        FreeImage_Unload(dib);
    }
}


 /**
 * @brief 获得字符在字模表中的地址
 * @param str {const char *} [in] 输入字符
 * @return {int} 成功返回地址 不成功-1
 */
 int get_hzk_index(const char* str)
{
    char ch;
    int n;

    /* 字符非法 */
    if (str == NULL || str[0] == 0)
    {
        return -1;
    }

    ch = *str;

    /* 中文 */
    if (ch < 0)
    {
        n = (unsigned char)ch - 0xA1;

        /* 汉字 */
        if (n > 14 && n < 87)
        {
            return ((n - 4) * 94 + (unsigned char)str[1] - 0xA1) * 72;
        }
        /* 中文符号 */
        else if (n < 9)
        {
            return (n * 94 + (unsigned char)str[1] - 0xA1) * 72;
        }
        else
        {
            return -1;
        }
    }

    /* 英文 */
    return (9 * 94 + ch) * 72;;
}

 /**
 * @brief 在图片文件上叠加文字
 * @param src {const char *} [in] 输入文件
 * @param des {const char *} [in] 输出文件
 * @param sx {int} [in] 起始X像素(以1开始,下同)
 * @param sy {int} [in] 起始Y像素
 * @param str {const char *} [in] 所要叠加的字符串
 * @return {int} 成功 0 否则 -1
 */
 int img_draw_text(const char *src, const char *des, int sx, int sy, const char *str)
{
    int loc;
    FIBITMAP *dib;
    int width, height, pitch, bpp;
    int i, j, k, m, n, x, y;
    int len;
    unsigned char *img, *ptr1, *ptr2;
    unsigned char pix[4];


    /* 参数非法 */
    if (src == NULL || strlen(src) < 2 || \
            des == NULL || strlen(des) < 2 || \
            str == NULL || strlen(str) < 2 || \
            sx < 1)
    {
        return -1;
    }

    /* 无法载入图片 */
    if ((dib = ImageLoad(src)) == NULL)
    {
        return -1;
    }

    width = FreeImage_GetWidth(dib);
    height = FreeImage_GetHeight(dib);
    pitch = FreeImage_GetPitch(dib);
    bpp = FreeImage_GetBPP(dib) >> 3;

    /* 计算起始X,Y(像素位置) */
    x = (sx - 1);

    if (sy < 0)
    {
        y = -1 - sy;
    }
    else
    {
        y = height - sy;
    }

    if (x >= width || y < 23 || y > height - 1)
    {
        ImageUnload(dib);
        return -1;
    }

    /* 得出一点 */
    memset(pix, 255, sizeof(pix));

    /* 求出内存中图像矩阵位置 */
    img = (unsigned char *)FreeImage_GetBits(dib);

    /* 遍历字符串 */
    len = strlen(str);

    for (i = 0; i < len; i ++)
    {
        /* 求出字模位置 */
        loc = get_hzk_index(str + i);
        ptr1 = g_hzk24 + loc;

        /* 中文 */
        if (str[i] < 0)
        {
            if (x + 24 > width)
            {
                ptr2 = img + y * pitch + x * bpp;

                for (n = 0; n < 24; n ++)
                {
                    memset(ptr2 - n * pitch, 0, (width - x) * bpp);
                }

                x = 0;
                y -= 24;
            }

            if (y < 23)
            {
                break;
            }

            // 在XY处画
             ptr2 = img + y * pitch + x * bpp;

            for (m = 0; m < 24; m ++)
            {
                for (j = 0; j < 3; j ++)
                {
                    for(k = 0; k < 8; k ++)
                    {
                        if (ptr1[m * 3 + j] & (0x01 << k))
                        {
                            memcpy(ptr2 + (-j * 8 - k) * pitch + m * bpp, pix, bpp);
                        }
                        else
                        {
                            memset(ptr2 + (-j * 8 - k) * pitch + m * bpp, 0, bpp);
                        }
                    }
                }
            }

            x += 24;

            i ++;
        }
        /* 英文 */
        else
        {
            if (x + 12 > width)
            {
                ptr2 = img + y * pitch + x * bpp;

                for (n = 0; n < 24; n ++)
                {
                    memset(ptr2 - n * pitch, 0, (width - x) * bpp);
                }

                x = 0;
                y -= 24;
            }

            if (y < 23)
            {
                break;
            }

            ptr2 = img + y * pitch + x * bpp;

            for (m = 0; m < 12; m ++)
            {
                for (j = 0; j < 3; j ++)
                {
                    for(k = 0; k < 8; k ++)
                    {
                        if (ptr1[m * 3 + j] & (0x01 << k))
                        {
                            memcpy(ptr2 + (-j * 8 - k) * pitch + m * bpp, pix, bpp);
                        }
                        else
                        {
                            memset(ptr2 + (-j * 8 - k) * pitch + m * bpp, 0, bpp);
                        }
                    }
                }
            }

            x += 12;
        }
    }

    if (x < width && y >= 23)
    {
        ptr2 = img + y * pitch + x * bpp;
        width -= x;
        width *= bpp;

        for (i = 0; i < 24; i ++)
        {
            memset(ptr2 - i * pitch, 0, width);
        }
    }

    FreeImage_Save(FIF_JPEG, dib, des, 0);
    FreeImage_Unload(dib);
    return 0;
}

至此大功告成..呵呵...