PIL을 사용하여 이미지 크기를 조정하고 가로 세로 비율을 유지하는 방법은 무엇입니까?

PIL을 사용하여 이미지 크기를 조정하고 가로 세로 비율을 유지하는 방법은 무엇입니까?

제가 놓치고 있는 명백한 방법이 있을까요?그냥 썸네일을 만드는 거예요.

최대 크기를 정의합니다.다음 조정 .min(maxwidth/width, maxheight/height).

는 '적'입니다.oldsize*ratio.

. 그 입니다.그 방법Image.thumbnail.
다음으로 PIL 문서의 (편집된) 예를 나타냅니다.

import os, sys
import Image

size = 128, 128

for infile in sys.argv[1:]:
    outfile = os.path.splitext(infile)[0] + ".thumbnail"
    if infile != outfile:
        try:
            im = Image.open(infile)
            im.thumbnail(size, Image.ANTIALIAS)
            im.save(outfile, "JPEG")
        except IOError:
            print "cannot create thumbnail for '%s'" % infile

이 스크립트는 PIL(Python Imaging Library)을 사용하여 이미지(somepic.jpg)의 크기를 300픽셀 폭과 새 폭에 비례하는 높이로 조정합니다.원래 너비(img.size[0])의 300픽셀 비율을 판별한 다음 원래 높이(img.size[1])에 해당 비율을 곱하면 됩니다.이미지의 기본 너비를 변경하려면 "기본 너비"를 다른 숫자로 변경합니다.

from PIL import Image

basewidth = 300
img = Image.open('somepic.jpg')
wpercent = (basewidth/float(img.size[0]))
hsize = int((float(img.size[1])*float(wpercent)))
img = img.resize((basewidth,hsize), Image.ANTIALIAS)
img.save('somepic.jpg')

또한 PIL의 썸네일 방식을 사용하는 것도 추천합니다.왜냐하면 귀찮은 비율을 모두 없애기 때문입니다.

단, 중요한 힌트: 치환

im.thumbnail(size)

와 함께

im.thumbnail(size,Image.ANTIALIAS)

기본적으로는 PIL은 이미지를 사용합니다.NEAST 필터: 사이징을 위한 필터로, 퍼포먼스는 양호하지만 품질은 저하됩니다.

@tomvon에 근거해, 이하의 사용을 종료했습니다(케이스 선택).

a) 높이 크기 조정 (새로운 폭을 알고 있기 때문에 새로운 높이가 필요합니다)

new_width  = 680
new_height = new_width * height / width 

b) 폭의 크기 조정 (신규 높이를 알고 있기 때문에 새로운 폭 필요)

new_height = 680
new_width  = new_height * width / height

그럼 그냥:

img = img.resize((new_width, new_height), Image.ANTIALIAS)

같은 가로 세로 비율을 유지하려고 한다면 원래 크기의 몇 퍼센트 정도 크기를 조정해 주실 수 없을까요?

예를 들어 원래 크기의 절반

half = 0.5
out = im.resize( [int(half * s) for s in im.size] )

from PIL import Image

img = Image.open('/your image path/image.jpg') # image extension *.png,*.jpg
new_width  = 200
new_height = 300
img = img.resize((new_width, new_height), Image.ANTIALIAS)
img.save('output image name.png') # format may what you want *.png, *jpg, *.gif

from PIL import Image
from resizeimage import resizeimage

def resize_file(in_file, out_file, size):
    with open(in_file) as fd:
        image = resizeimage.resize_thumbnail(Image.open(fd), size)
    image.save(out_file)
    image.close()

resize_file('foo.tif', 'foo_small.jpg', (256, 256))

이 라이브러리를 사용합니다.

pip install python-resize-image

People을 사용하여 이미지를 열지 않거나 열 필요가 없는 경우 다음을 사용하십시오.

from PIL import Image

new_img_arr = numpy.array(Image.fromarray(img_arr).resize((new_width, new_height), Image.ANTIALIAS))

크기 제한이 한 차원(폭 또는 높이)에만 있는 경우 PIL을 와 결합할 수 있습니다.

예를 들어 가로 세로 비율을 유지하면서 높이가 100px를 넘지 않도록 이미지의 크기를 조정하려면 다음과 같이 하십시오.

import sys
from PIL import Image

image.thumbnail([sys.maxsize, 100], Image.ANTIALIAS)

주의해 주세요Image.thumbnail는 이미지 조정과 .★★★★★★★★★★★★★★★★★★,Image.resize대신 원래 이미지를 변경하지 않고 크기가 조정된 이미지를 반환합니다.

편집:Image.ANTIALIAS는 폐지 경고를 발생시키고, PIL 10(2023년 7월)에 삭제될 예정입니다. '마음'을 사용해야 .Resampling.LANCZOS:

import sys
from PIL import Image
from PIL.Image import Resampling

image.thumbnail([sys.maxsize, 100], Resampling.LANCZOS)

좀 더 현대적인 래퍼로 이 질문을 갱신합니다.이 라이브러리는 People(PIL의 포크) https://pypi.org/project/python-resize-image/을 정리합니다.

다음과 같은 작업을 수행할 수 있습니다.

from PIL import Image
from resizeimage import resizeimage

fd_img = open('test-image.jpeg', 'r')
img = Image.open(fd_img)
img = resizeimage.resize_width(img, 200)
img.save('test-image-width.jpeg', img.format)
fd_img.close()

위의 링크에는 더 많은 예가 있습니다.

가로 세로 비율을 일정하게 유지하는 크기 조정 버전도 추가합니다.이 경우 초기 석면비 asp_rat(!)에 따라 새 이미지의 폭에 맞게 높이를 조정합니다.단, 너비를 높이로 조정하려면 한 줄에 주석을 달고 다른 줄에는 주석을 달지 않으면 됩니다.어디 있는지 알게 될 거야

세미콜론(;)은 필요 없습니다.저는 단지 자주 사용하는 언어의 구문을 상기시키기 위해 세미콜론(;)을 보관하고 있습니다.

from PIL import Image

img_path = "filename.png";
img = Image.open(img_path);     # puts our image to the buffer of the PIL.Image object

width, height = img.size;
asp_rat = width/height;

# Enter new width (in pixels)
new_width = 50;

# Enter new height (in pixels)
new_height = 54;

new_rat = new_width/new_height;

if (new_rat == asp_rat):
    img = img.resize((new_width, new_height), Image.ANTIALIAS); 

# adjusts the height to match the width
# NOTE: if you want to adjust the width to the height, instead -> 
# uncomment the second line (new_width) and comment the first one (new_height)
else:
    new_height = round(new_width / asp_rat);
    #new_width = round(new_height * asp_rat);
    img = img.resize((new_width, new_height), Image.ANTIALIAS);

# usage: resize((x,y), resample)
# resample filter -> PIL.Image.BILINEAR, PIL.Image.NEAREST (default), PIL.Image.BICUBIC, etc..
# https://pillow.readthedocs.io/en/3.1.x/reference/Image.html#PIL.Image.Image.resize

# Enter the name under which you would like to save the new image
img.save("outputname.png");

그리고 끝입니다.가능한 한 많이 기록하려고 했으니 분명합니다.

밖에 있는 누군가에게 도움이 되었으면 좋겠어요!

슬라이드 쇼 비디오의 이미지 크기를 조정하려고 했습니다.그 때문에, 1개의 최대 치수뿐만 아니라, 최대 폭과 최대 높이(비디오 프레임의 크기)를 요구하고 있었습니다.
그리고 초상화 비디오의 가능성은 항상 있었다...
Image.thumbnail메서드는 유망하지만 이미지를 작게 만들 수는 없습니다.

그래서 여기(또는 다른 곳)에서 확실한 방법을 찾을 수 없었던 후, 저는 다음 함수를 작성하여 다음 함수를 사용할 수 있도록 했습니다.

from PIL import Image

def get_resized_img(img_path, video_size):
    img = Image.open(img_path)
    width, height = video_size  # these are the MAX dimensions
    video_ratio = width / height
    img_ratio = img.size[0] / img.size[1]
    if video_ratio >= 1:  # the video is wide
        if img_ratio <= video_ratio:  # image is not wide enough
            width_new = int(height * img_ratio)
            size_new = width_new, height
        else:  # image is wider than video
            height_new = int(width / img_ratio)
            size_new = width, height_new
    else:  # the video is tall
        if img_ratio >= video_ratio:  # image is not tall enough
            height_new = int(width / img_ratio)
            size_new = width, height_new
        else:  # image is taller than video
            width_new = int(height * img_ratio)
            size_new = width_new, height
    return img.resize(size_new, resample=Image.LANCZOS)

위의 답변을 "tomvon"으로 업데이트했습니다.

from PIL import Image

img = Image.open(image_path)

width, height = img.size[:2]

if height > width:
    baseheight = 64
    hpercent = (baseheight/float(img.size[1]))
    wsize = int((float(img.size[0])*float(hpercent)))
    img = img.resize((wsize, baseheight), Image.ANTIALIAS)
    img.save('resized.jpg')
else:
    basewidth = 64
    wpercent = (basewidth/float(img.size[0]))
    hsize = int((float(img.size[1])*float(wpercent)))
    img = img.resize((basewidth,hsize), Image.ANTIALIAS)
    img.save('resized.jpg')

이미지 파일 열기

from PIL import Image
im = Image.open("image.png")

PIL Image.resize(size, resample=0) 방법을 사용하여 이미지의 크기(폭, 높이)를 2-태플 크기로 대체합니다.

이미지가 원래 크기로 표시됩니다.

display(im.resize((int(im.size[0]),int(im.size[1])), 0) )

그러면 이미지가 1/2 크기로 표시됩니다.

display(im.resize((int(im.size[0]/2),int(im.size[1]/2)), 0) )

그러면 이미지가 1/3 크기로 표시됩니다.

display(im.resize((int(im.size[0]/3),int(im.size[1]/3)), 0) )

그러면 이미지가 1/4 크기로 표시됩니다.

display(im.resize((int(im.size[0]/4),int(im.size[1]/4)), 0) )

/etc/setc/setc/setc/setc.

제한된 비율을 유지하고 최대 너비/높이를 통과하는 간단한 방법입니다.가장 예쁘지는 않지만 작업을 완료하고 이해하기 쉽습니다.

def resize(img_path, max_px_size, output_folder):
    with Image.open(img_path) as img:
        width_0, height_0 = img.size
        out_f_name = os.path.split(img_path)[-1]
        out_f_path = os.path.join(output_folder, out_f_name)

        if max((width_0, height_0)) <= max_px_size:
            print('writing {} to disk (no change from original)'.format(out_f_path))
            img.save(out_f_path)
            return

        if width_0 > height_0:
            wpercent = max_px_size / float(width_0)
            hsize = int(float(height_0) * float(wpercent))
            img = img.resize((max_px_size, hsize), Image.ANTIALIAS)
            print('writing {} to disk'.format(out_f_path))
            img.save(out_f_path)
            return

        if width_0 < height_0:
            hpercent = max_px_size / float(height_0)
            wsize = int(float(width_0) * float(hpercent))
            img = img.resize((max_px_size, wsize), Image.ANTIALIAS)
            print('writing {} to disk'.format(out_f_path))
            img.save(out_f_path)
            return

이 함수를 사용하여 배치 이미지 크기 조정을 실행하는 python 스크립트입니다.

새로운 이미지를 원래 이미지의 절반 폭과 절반 높이로 만들려면 다음 코드를 사용합니다.

  from PIL import Image
  im = Image.open("image.jpg")
  resized_im = im.resize((round(im.size[0]*0.5), round(im.size[1]*0.5)))
    
  #Save the cropped image
  resized_im.save('resizedimage.jpg')

비율을 사용하여 고정 너비로 크기를 조정하려면:

from PIL import Image
new_width = 300
im = Image.open("img/7.jpeg")
concat = int(new_width/float(im.size[0]))
size = int((float(im.size[1])*float(concat)))
resized_im = im.resize((new_width,size), Image.ANTIALIAS)
#Save the cropped image
resized_im.save('resizedimage.jpg')

# Importing Image class from PIL module
from PIL import Image

# Opens a image in RGB mode
im = Image.open(r"C:\Users\System-Pc\Desktop\ybear.jpg")

# Size of the image in pixels (size of original image)
# (This is not mandatory)
width, height = im.size

# Setting the points for cropped image
left = 4
top = height / 5
right = 154
bottom = 3 * height / 5

# Cropped image of above dimension
# (It will not change original image)
im1 = im.crop((left, top, right, bottom))
newsize = (300, 300)
im1 = im1.resize(newsize)
# Shows the image in image viewer
im1.show()

나의 추악한 예.

pic[0-9a-z]와 같은 함수를 통해 파일을 가져옵니다.120x120으로 크기를 조정하고 섹션을 중앙으로 이동한 후 ico[0-9a-z]에 저장합니다.[그림]), 세로 및 가로로 작업:

def imageResize(filepath):
    from PIL import Image
    file_dir=os.path.split(filepath)
    img = Image.open(filepath)

    if img.size[0] > img.size[1]:
        aspect = img.size[1]/120
        new_size = (img.size[0]/aspect, 120)
    else:
        aspect = img.size[0]/120
        new_size = (120, img.size[1]/aspect)
    img.resize(new_size).save(file_dir[0]+'/ico'+file_dir[1][3:])
    img = Image.open(file_dir[0]+'/ico'+file_dir[1][3:])

    if img.size[0] > img.size[1]:
        new_img = img.crop( (
            (((img.size[0])-120)/2),
            0,
            120+(((img.size[0])-120)/2),
            120
        ) )
    else:
        new_img = img.crop( (
            0,
            (((img.size[1])-120)/2),
            120,
            120+(((img.size[1])-120)/2)
        ) )

    new_img.save(file_dir[0]+'/ico'+file_dir[1][3:])

이렇게 이미지 크기를 조정했는데 잘 되고 있어요.

from io import BytesIO
from django.core.files.uploadedfile import InMemoryUploadedFile
import os, sys
from PIL import Image


def imageResize(image):
    outputIoStream = BytesIO()
    imageTemproaryResized = imageTemproary.resize( (1920,1080), Image.ANTIALIAS) 
    imageTemproaryResized.save(outputIoStream , format='PNG', quality='10') 
    outputIoStream.seek(0)
    uploadedImage = InMemoryUploadedFile(outputIoStream,'ImageField', "%s.jpg" % image.name.split('.')[0], 'image/jpeg', sys.getsizeof(outputIoStream), None)

    ## For upload local folder
    fs = FileSystemStorage()
    filename = fs.save(uploadedImage.name, uploadedImage)

내게 가장 간단한 방법은

image = image.resize((image.width*2, image.height*2), Image.ANTIALIAS)

예

from PIL import Image, ImageGrab
image = ImageGrab.grab(bbox=(0,0,400,600)) #take screenshot
image = image.resize((image.width*2, image.height*2), Image.ANTIALIAS)
image.save('Screen.png')

다음 스크립트는 최대 해상도 128x128의 석면비를 유지하는 모든 JPEG 이미지의 섬네일을 만듭니다.

from PIL import Image
img = Image.open("D:\\Pictures\\John.jpg")
img.thumbnail((680,680))
img.save("D:\\Pictures\\John_resize.jpg")

######get resize coordinate after resize the image using this function#####
def scale_img_pixel(points,original_dim,resize_dim):
        multi_list = [points]
        new_point_list = []
        multi_list_point = []
        for point in multi_list:
            multi_list_point.append([point[0],point[1]])
            multi_list_point.append([point[2],point[3]])
        for lsingle_point in multi_list_point:
            x1 = int((lsingle_point[0] * (resize_dim[0] / original_dim[0])))
            y1 = int((lsingle_point[1] * (resize_dim[1] / original_dim[1])))
            new_point_list.append(x1)
            new_point_list.append(y1)
            
        return new_point_list
    
    
    points = [774,265,909,409]
    original_dim = (1237,1036)
    resize_dim = (640,480)
    result = scale_img_pixel(points,original_dim,resize_dim)
    print("result: ", result)  

import cv2
from skimage import data 
import matplotlib.pyplot as plt
from skimage.util import img_as_ubyte
from skimage import io
filename='abc.png'
image=plt.imread(filename)
im=cv2.imread('abc.png')
print(im.shape)
im.resize(300,300)
print(im.shape)
plt.imshow(image)

언급URL : https://stackoverflow.com/questions/273946/how-do-i-resize-an-image-using-pil-and-maintain-its-aspect-ratio