PIL/cv2/base64相互转换

image互相转换

import cv2
import base64
from io import BytesIO
import numpy as np
from PIL import Image

def pil_cv2(img_path):  
    """
    PIL转cv2
    """
    image = Image.open(img_path)    
    img = cv2.cvtColor(np.asarray(image),cv2.COLOR_RGB2BGR)    
    return img 

def cv2_pil(img_path):
    """
    cv2转PIL
    """
    image = cv2.imread(img_path)    
    image = Image.fromarray(cv2.cvtColor(image,cv2.COLOR_BGR2RGB))    
    return image
        
def img_base64(img_path):
    """
    图片文件打开为base64
    """
    with open(img_path,"rb") as f:        
        base64_str = base64.b64encode(f.read())  
    return str(base64_str, encoding="utf-8")  
    
def pil_base64(image): 
    """
    PIL转base64
    """
    img_buffer = BytesIO()    
    image.save(img_buffer, format='JPEG')    
    byte_data = img_buffer.getvalue()    
    base64_str = base64.b64encode(byte_data)    
    return str(base64_str, encoding="utf-8")     

def base64_pil(base64_str):  
    """
    base64转PIL
    """
    image = base64.b64decode(base64_str)    
    image = BytesIO(image)    
    image = Image.open(image)    
    return image

def cv2_base64(image):  
    """
    cv2转base64
    """
    base64_str = cv2.imencode('.jpg',image)[1].tostring()    
    base64_str = base64.b64encode(base64_str)    
    return str(base64_str, encoding="utf-8") 

def base64_cv2(base64_str): 
    """
    base64转cv2
    """
    imgString = base64.b64decode(base64_str)    
    nparr = np.fromstring(imgString, np.uint8)      
    image = cv2.imdecode(nparr, cv2.IMREAD_COLOR)    
    return image

Image2Tensor

import os, sys
import cv2
import torch
import PIL
import numpy as np
import matplotlib.pyplot as plt
from PIL import Image
from torchvision import transforms

loader = transforms.Compose([transforms.ToTensor()])
unloader = transforms.ToPILImage()

def pil_img2tensor(src_img):
    """
    @function: 
    @Arguments: src_img: input function, str or PIL.Image.Image type
    @return: 
    @description: 
    """
    assert (isinstance(src_img, str) or isinstance(src_img, PIL.Image.Image)), 'the img type is {}, but str or PIL.Image.Image expected'.format(type(src_img))
    if isinstance(src_img, str):
        src_img = Image.open(src_img).convert("RGB")

    image = loader(src_img).unsqueeze(0)
    return image


def tensor2pil_img(src_img):
    assert isinstance(src_img, torch.Tensor), 'the img type is {}, but torch.Tensor expected'.format(type(src_img))
    image = src_img.cpu().clone()
    image = image.squeeze(0)
    image = unloader(image)
    return image


def tensor_imshow(src_img, title=None):
    image = src_img.cpu().clone()
    image = image.squeeze(0)
    image = unloader(image)
    plt.imshow(image)
    if title is not None:
        plt.title(title)

    plt.pause(1)

def np2tensor(src_img):
    assert type(img) == np.ndarray,'the img type is {}, but ndarry expected'.format(type(img))
    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
    img = torch.from_numpy(img.transpose((2, 0, 1)))
    return img.float().div(255).unsqueeze(0)

def tensor2np(src_img):
    assert isinstance(src_img, torch.Tensor), 'the img type is {}, but torch.Tensor expected'.format(type(src_img))
    img = src_img.mul(255).byte()
    img = img.cpu().numpy().squeeze(0).transpose((1, 2, 0))
    return img

if __name__ == "__main__":
    src_img = "./snapshot/tensor.jpg"
    src_img = Image.open(src_img).convert("RGB")
    print(type(src_img))
    tensor_img = pil_img2tensor(src_img)
    tensor_imshow(tensor_img)
    pil_img = tensor2pil_img(tensor_img)