Quel est le moyen le plus rapide pour générer des vignettes d'image en Python?

J'ai rêvé de plaisir donc j'ai fait un peu d'analyse comparative sur les différentes méthodes proposées ci-dessus et quelques idées de mon propre.

J'ai rassemblé 1000 haute résolution 12 MP iPhone 6S images, chaque 4032x3024 pixels et l'utilisation d'un 8-core iMac.

Voici les techniques et les résultats de chacun dans sa propre section.

---

Méthode 1 - Séquentielle ImageMagick

C'est simpliste, unoptimised code. Chaque image est lue et une vignette est produite. Alors qu'il est en lecture encore et une autre vignette de taille est produite.

#!/bin/bash

start=$SECONDS
# Loop over all files
for f in image*.jpg; do
   # Loop over all sizes
   for s in 1600 720 120; do
      echo Reducing $f to ${s}x${s}
      convert "$f" -resize ${s}x${s} t-$f-$s.jpg
   done
done
echo Time: $((SECONDS-start))

Résultat: 170 secondes

---

Méthode 2 - Séquentielle ImageMagick avec une seule charge et successives de redimensionnement

C'est encore séquentielle, mais un peu plus intelligent. Chaque image est seulement lu une seule fois et de l'image chargée est alors redimensionnée trois fois et sauvé à trois résolutions. L'amélioration est que chaque image est lue une seule fois, pas 3 fois.

#!/bin/bash

start=$SECONDS
# Loop over all files
N=1
for f in image*.jpg; do
   echo Resizing $f
   # Load once and successively scale down
   convert "$f"                              \
      -resize 1600x1600 -write t-$N-1600.jpg \
      -resize 720x720   -write t-$N-720.jpg  \
      -resize 120x120          t-$N-120.jpg
   ((N=N+1))
done
echo Time: $((SECONDS-start))

Résultat: 76 secondes

---

Méthode 3 - GNU Parallèle + ImageMagick

Cela s'appuie sur la méthode précédente, en utilisant GNU Parallèle de processus N images en parallèle, où N est le nombre de cœurs du PROCESSEUR de votre machine.

#!/bin/bash

start=$SECONDS

doit() {
   file=$1
   index=$2
   convert "$file"                               \
      -resize 1600x1600 -write t-$index-1600.jpg \
      -resize 720x720   -write t-$index-720.jpg  \
      -resize 120x120          t-$index-120.jpg
}

# Export doit() to subshells for GNU Parallel   
export -f doit

# Use GNU Parallel to do them all in parallel
parallel doit {} {#} ::: *.jpg

echo Time: $((SECONDS-start))

Résultat: 18 secondes

---

Méthode 4 - GNU Parallèle + vip

C'est la même que la méthode précédente, mais il utilise vips à la ligne de commande au lieu de ImageMagick.

#!/bin/bash

start=$SECONDS

doit() {
   file=$1
   index=$2
   r0=t-$index-1600.jpg
   r1=t-$index-720.jpg
   r2=t-$index-120.jpg
   vipsthumbnail "$file"  -s 1600 -o "$r0"
   vipsthumbnail "$r0"    -s 720  -o "$r1"
   vipsthumbnail "$r1"    -s 120  -o "$r2"
}

# Export doit() to subshells for GNU Parallel   
export -f doit

# Use GNU Parallel to do them all in parallel
parallel doit {} {#} ::: *.jpg

echo Time: $((SECONDS-start))

Résultat: 8 secondes

---

Méthode 5 - Séquentielle PIL

Ce qui est destiné à correspondre à Jakob réponse.

#!/usr/local/bin/python3

import glob
from PIL import Image

sizes = [(120,120), (720,720), (1600,1600)]
files = glob.glob('image*.jpg')

N=0
for image in files:
    for size in sizes:
      im=Image.open(image)
      im.thumbnail(size)
      im.save("t-%d-%s.jpg" % (N,size[0]))
    N=N+1

Résultat: 38 secondes

---

Méthode 6 - Séquentielle PIL avec une seule charge & successives redimensionner

C'est une amélioration de Jakob réponse, dans lequel l'image est chargée, juste une fois, puis réduction de la taille trois fois au lieu de le charger à nouveau à chaque fois pour produire chaque nouvelle résolution.

#!/usr/local/bin/python3

import glob
from PIL import Image

sizes = [(120,120), (720,720), (1600,1600)]
files = glob.glob('image*.jpg')

N=0
for image in files:
   # Load just once, then successively scale down
   im=Image.open(image)
   im.thumbnail((1600,1600))
   im.save("t-%d-1600.jpg" % (N))
   im.thumbnail((720,720))
   im.save("t-%d-720.jpg"  % (N))
   im.thumbnail((120,120))
   im.save("t-%d-120.jpg"  % (N))
   N=N+1

Résultat: 27 secondes

---

Méthode 7 - Parallèle PIL

Ce qui est destiné à correspondre à Audionautics de réponse, dans la mesure où il utilise Python multiprocessing. Il permet également d'éviter la nécessité de re-charger l'image pour chaque taille de vignette.

#!/usr/local/bin/python3

import glob
from PIL import Image
from multiprocessing import Pool 

def thumbnail(params): 
    filename, N = params
    try:
        # Load just once, then successively scale down
        im=Image.open(filename)
        im.thumbnail((1600,1600))
        im.save("t-%d-1600.jpg" % (N))
        im.thumbnail((720,720))
        im.save("t-%d-720.jpg"  % (N))
        im.thumbnail((120,120))
        im.save("t-%d-120.jpg"  % (N))
        return 'OK'
    except Exception as e: 
        return e 


files = glob.glob('image*.jpg')
pool = Pool(8)
results = pool.map(thumbnail, zip(files,range((len(files)))))

Résultat: 6 secondes

---

Méthode 8 - Parallèle OpenCV

Ce qui est destiné à être une amélioration sur bcattle de répondre, dans la mesure où il utilise OpenCV, mais il permet également d'éviter la nécessité de re-charger l'image à générer chaque nouvelle résolution de sortie.

#!/usr/local/bin/python3

import cv2
import glob
from multiprocessing import Pool 

def thumbnail(params): 
    filename, N = params
    try:
        # Load just once, then successively scale down
        im = cv2.imread(filename)
        im = cv2.resize(im, (1600,1600))
        cv2.imwrite("t-%d-1600.jpg" % N, im) 
        im = cv2.resize(im, (720,720))
        cv2.imwrite("t-%d-720.jpg" % N, im) 
        im = cv2.resize(im, (120,120))
        cv2.imwrite("t-%d-120.jpg" % N, im) 
        return 'OK'
    except Exception as e: 
        return e 


files = glob.glob('image*.jpg')
pool = Pool(8)
results = pool.map(thumbnail, zip(files,range((len(files)))))

Résultat: 5 secondes

Une autre option est d'utiliser le liaisons python à OpenCV. Cela peut être plus rapide que PIL ou Imagemagick.

import cv2

sizes = [(120, 120), (720, 720), (1600, 1600)]
image = cv2.imread("input.jpg")
for size in sizes:
    resized_image = cv2.resize(image, size)
    cv2.imwrite("thumbnail_%d.jpg" % size[0], resized_image) 

Il y a une solution complète,ici.

Si vous voulez l'exécuter en parallèle, l'utilisation simultanées.les contrats à terme sur Py3 ou la terme paquet sur Py2.7:

import concurrent.futures
import cv2

def resize(input_filename, size):
    image = cv2.imread(input_filename)
    resized_image = cv2.resize(image, size)
    cv2.imwrite("thumbnail_%s%d.jpg" % (input_filename.split('.')[0], size[0]), resized_image)

executor = concurrent.futures.ThreadPoolExecutor(max_workers=3)
sizes = [(120, 120), (720, 720), (1600, 1600)]
for size in sizes:
    executor.submit(resize, "input.jpg", size)

Python 2.7, Windows x64 utilisateurs

En plus de @JakobBowyer & @Audionautics, PIL est assez vieux et vous pouvez trouver vous-même le dépannage et la recherche de la bonne version... au lieu de cela, utiliser Pillow de ici (source)

la mise à jour de l'extrait de code ressemblera à ceci:

im = Image.open(full_path)
im.thumbnail(thumbnail_size)
im.save(new_path, "JPEG")

dénombrement complet de script pour la création de la miniature:

import os
from PIL import Image

output_dir = '.\\output'
thumbnail_size = (200,200)

if not os.path.exists(output_dir):
    os.makedirs(output_dir)

for dirpath, dnames, fnames in os.walk(".\\input"):
    for f in fnames:
        full_path = os.path.join(dirpath, f)
        if f.endswith(".jpg"):
            filename = 'thubmnail_{0}'.format(f) 
            new_path = os.path.join(output_dir, filename)

            if os.path.exists(new_path):
                os.remove(new_path)

            im = Image.open(full_path)
            im.thumbnail(thumbnail_size)
            im.save(new_path, "JPEG")