it-swarm.com.de

Wie kann ich die Größe eines Bildes mithilfe von PIL ändern und das Seitenverhältnis beibehalten?

Gibt es eine offensichtliche Möglichkeit, dies zu tun, die mir fehlt? Ich versuche nur, Miniaturansichten zu erstellen.

329
saturdayplace

Definieren Sie eine maximale Größe ..__ Berechnen Sie dann ein Größenverhältnis, indem Sie min(maxwidth/width, maxheight/height) nehmen.

Die richtige Größe ist oldsize*ratio.

Dazu gibt es natürlich auch eine Bibliotheksmethode: die Methode Image.thumbnail.
Nachfolgend finden Sie ein (bearbeitetes) Beispiel aus der PIL-Dokumentation .

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
390
gnud

Mit diesem Skript wird ein Bild (somepic.jpg) mithilfe von PIL (Python Imaging Library) auf eine Breite von 300 Pixel und eine Höhe angepasst, die der neuen Breite proportional ist. Dazu wird ermittelt, welcher Prozentsatz von 300 Pixeln der ursprünglichen Breite (img.size [0]) entspricht, und die ursprüngliche Höhe (img.size [1]) wird dann mit diesem Prozentsatz multipliziert. Ändern Sie "Basisbreite" in eine andere Zahl, um die Standardbreite Ihrer Bilder zu ändern.

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('sompic.jpg') 
185
tomvon

Ich empfehle außerdem, die Miniaturansichtsmethode von PIL zu verwenden, da dadurch alle Übersetzungsprobleme entfernt werden.

Ein wichtiger Hinweis: Ersetzen

im.thumbnail(size)

mit

im.thumbnail(size,Image.ANTIALIAS)

in der Standardeinstellung verwendet PIL den Filter Image.NEAREST für die Größenänderung, was zu einer guten Leistung bei schlechter Qualität führt.

51
Franz

Ich bin in @tomvon ansässig und habe folgendes fertiggestellt:

Breite ändern:

new_width  = 680
new_height = new_width * height / width 

Größe ändern:

new_height = 680
new_width  = new_height * width / height

Dann einfach:

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

PIL hat bereits die Möglichkeit, ein Bild zuzuschneiden

img = ImageOps.fit(img, size, Image.ANTIALIAS)
from PIL import Image

img = Image.open('/your iamge 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 u want ,*.png,*jpg,*.gif
13

Wenn Sie versuchen, dasselbe Seitenverhältnis beizubehalten, ändern Sie die Größe nicht um einen bestimmten Prozentsatz der Originalgröße?

Zum Beispiel die Hälfte der Originalgröße

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

Eine einfache Methode, um Zwangsverhältnisse einzuhalten und eine maximale Breite/Höhe zu übergeben. Nicht das Schönste, aber erledigt die Arbeit und ist leicht zu verstehen:

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

Hier ist ein Python-Skript , das diese Funktion verwendet, um die Größenänderung von Stapelbildern auszuführen.

2
AlexG
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))

Ich benutze diese Bibliothek:

pip install python-resize-image
2
guettli

Mein hässliches Beispiel.

Funktion get Datei wie: "pic [0-9a-z]. [Erweiterung]", verkleinere sie auf 120x120, verschiebe den Abschnitt in die Mitte und speichere ihn in "ico [0-9a-z]. [Erweiterung]", arbeitet mit Hochformat und landschaft:

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:])
1
Nips

Ich habe versucht, die Größe einiger Bilder für ein Diaschau-Video zu ändern, und deshalb wollte ich nicht nur eine maximale Größe, sondern eine maximale Breite und eine maximale Höhe (die Größe des Videoframes).
Und es gab immer die Möglichkeit eines Portraitvideos ...
Die Image.thumbnail-Methode war vielversprechend, aber ich konnte es nicht zu einem kleineren Bild machen.

Nachdem ich hier (oder an anderen Orten) keinen offensichtlichen Weg gefunden hatte, schrieb ich diese Funktion und stellte sie für die folgenden Funktionen hier ein:

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)
0
embryo

Wenn Sie kein Bild mit Pillow öffnen möchten/müssen, verwenden Sie folgendes:

from PIL import Image

my_img = numpy.array(Image.fromarray(arr).resize((new_width, new_height), Image.ANTIALIAS)
0
hoohoo-b

Aktualisieren Sie diese Frage einfach mit einem moderneren Wrapper Diese Bibliothek umfasst Pillow (eine Abzweigung von PIL) https://pypi.org/project/python-resize-image/

So können Sie etwas tun: -

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()

Heaps weitere Beispiele im obigen Link.

0
Shanness

Ich habe das Bild so in der Größe verändert und es funktioniert sehr gut

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)
0
Siddhartha