Skip to content

Generare immagini miniaturizzate quadrate o circolari con Python, Pillow

Python

Puoi creare immagini in miniatura quadrate o circolari usando la libreria di elaborazione delle immagini di Python Pillow (PIL).

Se esiste un metodo chiamato thumbnail() nel modulo Immagine del cuscino, ridimensiona semplicemente l’immagine per adattarla alla dimensione specificata.

In questo articolo vengono descritti i seguenti contenuti.

  • Come rendere quadrata un’immagine rettangolare
    • Ritaglia un quadrato da un’immagine rettangolare
    • Aggiungi imbottitura per creare un rettangolo
  • Ritaglia un’immagine quadrata in un cerchio
    • Rendi lo sfondo un colore solido
    • Rendi lo sfondo trasparente
  • Codice di esempio per l’elaborazione batch

Vedere i seguenti articoli per l’installazione e l’utilizzo di base di Pillow (PIL).

Importa immagine, ImageDraw e ImageFilter da PIL. ImageDraw e ImageFilter vengono utilizzati per disegnare ed elaborare cerchi. Quando si crea un’immagine in miniatura quadrata, possono essere omessi.

Per l’elaborazione batch, import os e glob.

Leggi l’immagine utilizzata nei seguenti esempi e decidi la larghezza (= altezza) dell’immagine in miniatura che desideri ottenere alla fine.

import os
import glob

from PIL import Image, ImageDraw, ImageFilter

im = Image.open('data/src/astronaut_rect.bmp')
thumb_width = 200

immagine originale - astronauta

Come rendere quadrata un’immagine rettangolare

Poiché il ridimensionamento di un’immagine rettangolare in un quadrato con resize() del modulo Immagine modifica le proporzioni, utilizzare uno dei seguenti metodi.

  • Ritaglia un quadrato da un’immagine rettangolare
  • Aggiungi imbottitura per creare un rettangolo

Ritaglia un quadrato da un’immagine rettangolare

Ritaglia un’area di un’immagine con crop().

Definire una funzione per ritagliare l’area centrale dell’immagine.

def crop_center(pil_img, crop_width, crop_height):
    img_width, img_height = pil_img.size
    return pil_img.crop(((img_width - crop_width) // 2,
                         (img_height - crop_height) // 2,
                         (img_width + crop_width) // 2,
                         (img_height + crop_height) // 2))

Esempio di utilizzo:

im_thumb = crop_center(im, thumb_width, thumb_width)
im_thumb.save('data/dst/astronaut_thumbnail_center_square.jpg', quality=95)

Miniatura cuscino quadrato centrale

Invece di ritagliare l’area della dimensione della miniatura, puoi ritagliare il quadrato di dimensioni maggiori (= quadrato laterale corto rettangolare) e quindi ridimensionarlo.

Definire una funzione per ritagliare il quadrato di dimensioni maggiori. Utilizza una funzione per ritagliare l’area centrale dell’immagine.

def crop_max_square(pil_img):
    return crop_center(pil_img, min(pil_img.size), min(pil_img.size))

Esempio di utilizzo:

Dopo aver trasformato l’immagine rettangolare in un quadrato, viene ridotta da resize() alla dimensione dell’immagine in miniatura desiderata.

im_thumb = crop_max_square(im).resize((thumb_width, thumb_width), Image.LANCZOS)
im_thumb.save('data/dst/astronaut_thumbnail_max_square.jpg', quality=95)

Miniatura cuscino quadrato max

Aggiungi imbottitura per creare un rettangolo

Se desideri mantenere l’intera immagine rettangolare originale, aggiungi spaziatura interna in alto, in basso, a sinistra oa destra per renderla quadrata.

new() può essere utilizzato per generare un’immagine solida e incollarla con paste().

Definisci una funzione che aggiunga spaziatura interna per diventare alla fine un quadrato con le dimensioni del lato lungo del rettangolo.

def expand2square(pil_img, background_color):
    width, height = pil_img.size
    if width == height:
        return pil_img
    elif width > height:
        result = Image.new(pil_img.mode, (width, width), background_color)
        result.paste(pil_img, (0, (width - height) // 2))
        return result
    else:
        result = Image.new(pil_img.mode, (height, height), background_color)
        result.paste(pil_img, ((height - width) // 2, 0))
        return result

Esempio di utilizzo:

Dopo aver trasformato l’immagine rettangolare in un quadrato, viene ridotta da resize() alla dimensione dell’immagine in miniatura.

im_thumb = expand2square(im, (0, 0, 0)).resize((thumb_width, thumb_width), Image.LANCZOS)
im_thumb.save('data/dst/astronaut_thumbnail_expand.jpg', quality=95)

La miniatura del cuscino espandi il quadrato

Ritaglia un’immagine quadrata in un cerchio

Se vuoi generare un’immagine in miniatura circolare, devi ritagliare un’immagine quadrata in un cerchio.

Ci sono due modi:

  • rendere lo sfondo a tinta unita (bianco, nero, ecc.)
  • rendere trasparente lo sfondo (= rendere trasparente png)

Rendi lo sfondo un colore solido

Usa composite() per comporre due immagini in base all’immagine della maschera.

Disegna un cerchio e usalo come immagine della maschera. Per i dettagli sul disegno, vedere il seguente articolo.

Crea un’immagine a tinta unita a un colore del colore di sfondo desiderato con new() e componila con l’immagine quadrata con una maschera circolare.

Il bordo viene smussato sfocando l’immagine della maschera con ImageFilter. Perché l’area del cerchio si allarga quando si sfoca, è necessario prima disegnare un cerchio più piccolo.

Definire la seguente funzione. Specificare il colore di sfondo background_color, la dimensione della sfocatura sfocatura_radius e l’offset. Nessuna sfocatura con blur_radius=0.

def mask_circle_solid(pil_img, background_color, blur_radius, offset=0):
    background = Image.new(pil_img.mode, pil_img.size, background_color)

    offset = blur_radius * 2 + offset
    mask = Image.new("L", pil_img.size, 0)
    draw = ImageDraw.Draw(mask)
    draw.ellipse((offset, offset, pil_img.size[0] - offset, pil_img.size[1] - offset), fill=255)
    mask = mask.filter(ImageFilter.GaussianBlur(blur_radius))

    return Image.composite(pil_img, background, mask)

Esempio di utilizzo:

im_square = crop_max_square(im).resize((thumb_width, thumb_width), Image.LANCZOS)
im_thumb = mask_circle_solid(im_square, (0, 0, 0), 4)
im_thumb.save('data/dst/astronaut_thumbnail_mask_circle_solid.jpg', quality=95)

Cuscino miniatura cerchio solido

Rendi lo sfondo trasparente

Usa putalpha(), che aggiunge un canale alfa all’immagine.

Il flusso è lo stesso di quando si utilizza uno sfondo semplice a un colore.

def mask_circle_transparent(pil_img, blur_radius, offset=0):
    offset = blur_radius * 2 + offset
    mask = Image.new("L", pil_img.size, 0)
    draw = ImageDraw.Draw(mask)
    draw.ellipse((offset, offset, pil_img.size[0] - offset, pil_img.size[1] - offset), fill=255)
    mask = mask.filter(ImageFilter.GaussianBlur(blur_radius))

    result = pil_img.copy()
    result.putalpha(mask)

    return result

Le immagini trasparenti vengono salvate con png.

im_square = crop_max_square(im).resize((thumb_width, thumb_width), Image.LANCZOS)
im_thumb = mask_circle_transparent(im_square, 4)
im_thumb.save('data/dst/astronaut_thumbnail_mask_circle_transparent.png')

Cerchio delle miniature del cuscino trasparente

Codice di esempio per l’elaborazione batch

Crea immagini di anteprima collettivamente da file di immagine in qualsiasi directory (cartella).

Può essere eseguito allo stesso modo del ridimensionamento batch.

Genera immagini in miniatura di file immagine in src_dir e salvale in dst_dir.

src_dir = 'data/temp/src'
dst_dir = 'data/temp/dst'

files = glob.glob(os.path.join(src_dir, '*.jpg'))

for f in files:
    im = Image.open(f)
    im_thumb = crop_max_square(im).resize((thumb_width, thumb_width), Image.LANCZOS)
    ftitle, fext = os.path.splitext(os.path.basename(f))
    im_thumb.save(os.path.join(dst_dir, ftitle + '_thumbnail' + fext), quality=95)