golang 图片处理，剪切，base64数据转换，文件存储/ python base64 编解码，转换成Opencv，PIL.Image图片格式/cpp base64编解码

golang 图片处理，剪切，base64数据转换，文件存储
https://www.cnblogs.com/satng/p/5584429.html
博文链接地址

python base64 编解码，转换成Opencv，PIL.Image图片格式
https://blog.csdn.net/dcrmg/article/details/80542665

二进制打开图片文件，base64编解码，转成Opencv格式:
#coding: utf-8
import base64
import numpy as np
import cv2
img_file = open(r’00.JPG’,‘rb’) # 二进制打开图片文件
img_b64encode = base64.b64encode(img_file.read()) # base64编码
img_file.close() # 文件关闭
img_b64decode = base64.b64decode(img_b64encode) # base64解码
img_array = np.fromstring(img_b64decode,np.uint8) # 转换np序列
img=cv2.imdecode(img_array,cv2.COLOR_BGR2RGB) # 转换Opencv格式
cv2.imshow(“img”,img)
cv2.waitKey(10000)

二进制打开图片文件，base64编解码，转成PIL.Image格式：
#coding: utf-8
#python base64 编解码，转换成Opencv，PIL.Image图片格式
import base64
import io
from PIL import Image
img_file = open(r’/home/dcrmg/work/medi_ocr_v1.2/img/00.JPG’,‘rb’) # 二进制打开图片文件
img_b64encode = base64.b64encode(img_file.read()) # base64编码
img_file.close() # 文件关闭
img_b64decode = base64.b64decode(img_b64encode) # base64解码
image = io.BytesIO(img_b64decode)
img = Image.open(image)
img.show()

c++ base64编解码

#ifndef BASE64_H
#define BASE64_H

#include
#include
static const std::string base64_chars =
“ABCDEFGHIJKLMNOPQRSTUVWXYZ”
“abcdefghijklmnopqrstuvwxyz”
“0123456789+/”;

static inline bool is_base64(const char c)
{
return (isalnum© || (c == ‘+’) || (c == ‘/’));
}

// base64 编码
std::string base64_encode(const char * bytes_to_encode, unsigned int in_len)
{
std::string ret;
int i = 0;
int j = 0;
unsigned char char_array_3[3];
unsigned char char_array_4[4];

while (in_len--)
{
    char_array_3[i++] = *(bytes_to_encode++);
    if(i == 3)
    {
        char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
        char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
        char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
        char_array_4[3] = char_array_3[2] & 0x3f;
        for(i = 0; (i <4) ; i++)
        {
            ret += base64_chars[char_array_4[i]];
        }
        i = 0;
    }
}
if(i)
{
    for(j = i; j < 3; j++)
    {
        char_array_3[j] = '\0';
    }

    char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
    char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
    char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
    char_array_4[3] = char_array_3[2] & 0x3f;

    for(j = 0; (j < i + 1); j++)
    {
        ret += base64_chars[char_array_4[j]];
    }

    while((i++ < 3))
    {
        ret += '=';
    }

}
return ret;

}

//base64解码
std::string base64_decode(std::string const & encoded_string)
{
int in_len = (int) encoded_string.size();
int i = 0;
int j = 0;
int in_ = 0;
unsigned char char_array_4[4], char_array_3[3];
std::string ret;
while (in_len-- && ( encoded_string[in_] != ‘=’) && is_base64(encoded_string[in_])) {
char_array_4[i++] = encoded_string[in_]; in_++;
if (i ==4) {
for (i = 0; i <4; i++)
char_array_4[i] = base64_chars.find(char_array_4[i]);
char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
for (i = 0; (i < 3); i++)
ret += char_array_3[i];
i = 0;
}
}
if (i) {
for (j = i; j <4; j++)
char_array_4[j] = 0;
for (j = 0; j <4; j++)
char_array_4[j] = base64_chars.find(char_array_4[j]);
char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
for (j = 0; (j < i - 1); j++) ret += char_array_3[j];
}
return ret;
}
#endif

测试用例
#include
#include
#include “base64.h”
#include

using namespace std;

int main(int argc, char** argv)
{
fstream f;
f.open("…/test_image/keliamoniz1.jpg", ios::in|ios::binary);
f.seekg(0, std::ios_base::end);
std::streampos sp = f.tellg();
int size = sp;
char* buffer = (char*)malloc(sizeof(char)*size);
f.read(buffer,size);
cout << “file size:” << size << endl;
string imgBase64 = base64_encode(buffer, size);
cout << “img base64 encode size:” << imgBase64.size() << endl;
string imgdecode64 = base64_decode(imgBase64);
cout << “img decode size:” << imgdecode64.size() << endl;
return 0;
}