pillow(PIL)

from PIL import Image
from io import BytesIO


def source_to_pil(source:str)->Image:
    """image source -> pil_img"""
    pil = Image.open(source)
    print(pil,pil.format)
    return pil  
    
def source_to_bytesio(source:str)->BytesIO:
    """image source -> BytesIO"""
    f = open(source,'rb')
    b_data = f.read()
    io_data = BytesIO(b_data)
    print(io_data)
    return io_data  
          
def bytesio_to_pil(bytesio:BytesIO)->Image:
    """BytesIO -> pil image"""
    pil = Image.open(bytesio)
    print(pil,pil.format)
    return pil
    
def pil_to_io(p_img:Image,format:str=None)->BytesIO:
    """pil image -> BytesIO(메모리)"""
    io_data = BytesIO()
    if not format:
        format = p_img.format
    p_img.save(io_data,format)
    print(io_data)
    return io_data 
    
def bytesio_to_bytes_data(bytesio:BytesIO)->bytes:
    """BytesIO -> bytes data"""
    b_data = bytesio.getvalue()
    print(b_data)
    return b_data  

def bytes_data_to_img_file(b_data:bytes,file_name:str)->None:
    """byte data -> image file"""
    f = open(file_name,'wb')
    f.write(b_data) 
    

def p_img_to_img(p_img:Image, file_name:str,format:str)->None:
    """pil image -> imgage file"""
    p_img.save(file_name,format)    

if __name__ =='__main__':
        
    p_img = source_to_pil('아이유.png')

    io = source_to_bytesio('아이유.png')
    p_img2 = bytesio_to_pil(io)

    io2 = pil_to_io(p_img2,format='gif')
    b_data = bytesio_to_bytes_data(io2)
    bytes_data_to_img_file(b_data,'아이유_복사.gif')

    p_img_to_img(p_img2,'아이유_복사본.gif' ,'gif')

from PIL import Image, ImageFilter  # 라이브러리를  임포트 한다.

original = Image.open("아이유.png")           # 하드 드라이브에서 이미지를 읽어 들인다.
blurred = original.filter(ImageFilter.BLUR) # 이미지를 흐리게 한다.
print(type(original)) # <class 'PIL.PngImagePlugin.PngImageFile'>
print(type(blurred))  # <class 'PIL.Image.Image'>

original.show() # 두 이미지를 디스플레이 한다.
blurred.show()

from PIL import Image

img_obj = Image.open("아이유.png")  # 이미지 파일 불러오기
img_obj.show() # 이미지 보이기

convert('RGB') 함수 사용을 통해 이미지 모드를 통일하여 사용하자.

from PIL import Image

# 2. 이미지 파일 변환(정상) #
try:
    im = Image.open("anchors.png").convert('RGB')
    im.save("anchors.webp", 'webp')

    change_im = Image.open("anchors.webp")
    img_width, img_height = change_im.size
    print("이미지 확장자:", change_im.format)
    print("이미지 사이즈:", change_im.size)
    print("이미지 가로:", img_width)
    print("이미지 세로:", img_height)
    print("이미지 모드:", change_im.mode)
except OSError as e:
    print(e)


[output]
이미지 확장자: WEBP
이미지 사이즈: (600, 300)
이미지 가로: 600
이미지 세로: 300
이미지 모드: RGB

print(f'파일 이름 : {img_obj.filename}')
print(f'파일형식(format) : {img_obj.format}')
print(f'용량(size) : {img_obj.size}')
print(f'색상모드 : {img_obj.mode}')
print(f'width : {img_obj.width}')
print(f'height : {img_obj.height}')

# 이미지 size 1/2로 줄이기
w, h = img_obj.size
result_img = img_obj.resize((w // 2, h // 2))
result_img.show()

cropped_img = img.crop((200, 200, 425, 426))
cropped_img.show()

result_img = img_obj.rotate(45) # 45도 회전(반시계방향)
result_img.show()

result_img = img_obj.transpose(Image.FLIP_LEFT_RIGHT)
result_img.show()

result_img = img_obj.transpose(Image.ROTATE_270)
result_img.show()

from PIL import Image, ImageFilter

# 이미지 불러오기
img1 = Image.open('아이유.png')
img2 = Image.open('1.png')
img3 = Image.open('2.png')

# 새 이미지 만들기
new_img = Image.new('RGBA',(700,700),(255, 192, 0))

# 이미지 붙이기
new_img.paste(img1, (10,10))     # left,top 위치만 지정
new_img.paste(img2,(20+img1.width,10))
new_img.paste(img3,(20+img1.width,20+img2.height))

new_img.show()

from PIL import Image, ImageFilter

# 이미지 불러오기
img_obj = Image.open('아이유.png')
img_obj.save('아이유2.png')

result_obj = Image.open('아이유2.png')
result_obj.show()

from PIL import Image
size = (40, 40)  #튜플자료형으로 괄호 생략 가능(#<class 'tuple'>)

img_obj = Image.open("아이유.png")
img_obj.thumbnail(size)

img_obj.save("아이유3.png")
result_img = Image.open("아이유3.png")
result_img.show()

from PIL import Image, ImageFilter
img_obj = Image.open("아이유.png")  # 하드 드라이브에서 이미지를 읽어 들인다.

result_img = img_obj.filter(ImageFilter.BLUR)
result_img.show()

result_img = img_obj.filter(ImageFilter.BoxBlur(10))
result_img.show()

result_img = img_obj.filter(ImageFilter.GaussianBlur(10))
result_img.show()

#전체옵션 보기
from PIL import Image, ImageFilter

img_obj = Image.open("아이유.png")  # 하드 드라이브에서 이미지를 읽어 들인다.

filter_list = [ImageFilter.BLUR, ImageFilter.CONTOUR, ImageFilter.DETAIL,
               ImageFilter.EDGE_ENHANCE, ImageFilter.EDGE_ENHANCE_MORE,
               ImageFilter.EMBOSS, ImageFilter.FIND_EDGES,
               ImageFilter.SHARPEN, ImageFilter.SMOOTH,
               ImageFilter.SMOOTH_MORE]

for i in range(len(filter_list)):
    result_img = img_obj.filter(filter_list[i])
    # filter_img.save("C:/Users/ilike/Pictures/filter_img_{}.jpg".format(i))
    result_img.show()

from PIL import Image
import glob, os, pathlib

target = glob.glob("./*.png")
print("파일 개수 :", len(target))
size = (40, 40)  #튜플자료형으로 괄호 생략 가능(#<class 'tuple'>)
for file in target:
    file_path = pathlib.Path('.') / file
    img_obj = Image.open(file)
    img_obj.thumbnail(size)

    img_obj.save(file_path.stem + ".thumbnail"+".png")

from PIL import Image
import io

def image_to_byte_array(image):
    img_obj = Image.open(image)
    byte_arr = io.BytesIO()
    img_obj.save(byte_arr, format=img_obj.format)
    return byte_arr.getvalue()
img = "아이유.png"
print(image_to_byte_array(img))

from PIL import Image
import numpy as np
img = Image.open("아이유.png")

numpy_img = np.array(img)
print(type(numpy_img))
print(numpy_img)

from PIL import Image
import numpy as np
img = Image.open("아이유.png")

#numpy_array = np.array(img, dtype="uint8")
numpy_array = np.array(img)
   
image2 = Image.fromarray(numpy_array, 'RGB')
image2.show() 

from PIL import Image
import numpy as np
img = Image.open("아이유.png")

pixel_list = list(img.getdata())
print(pixel_list)
np.savetxt("pixel_type_data.txt", pixel_list, fmt='%d', delimiter=" ")

from PIL import Image
img = Image.open("C:/Users/ilike/Pictures/IU_400x400.jpg")

rgb_img = img.convert("RGB")

#지정한 좌표값의 픽셀값 튜플자료형으로 반환
tuple_item = rgb_img.getpixel((1, 100))
print(tuple_item) 

r, g, b = tuple_item
print(r)
print(g)
print(b)

from io import BytesIO
from PIL import Image
import sys


def data_to_img(data):
    """Return PIL Image object, with data from in-memory <data>"""
    # open함수와 비슷한 기능
    fp = BytesIO(data)
    return Image.open(fp)  # reads from memory


def img_to_data(img, fmt=None):
    """Return image data from PIL Image <img>, in <fmt> format"""
    fp = BytesIO()
    if not fmt:
        fmt = img.format  # keeps the original format
        img.save(fp, fmt)  # writes to memory
    return fp.getvalue()


def convert_image(data, fmt=None):
    """Convert image <data> to PIL <fmt> image data"""
    img = data_to_img(data)
    return img_to_data(img, fmt)


def get_file_data(name):
    """Return PIL Image object for image file <name>"""
    img = Image.open(name)
    print("img", img, img.format)
    return img_to_data(img)


if __name__ == "__main__":
    for name in sys.argv[1:]:
        data = get_file_data(name)
        print("in", len(data), data[:10])
    for fmt in ("gif", "png", "jpeg"):
        outdata = convert_image(data, fmt)
        print("out", len(outdata), outdata[:10])