Redimensionner vos images avec Python : Guide complet et facile

Dans cet article, nous allons explorer ensemble la création d'un redimensionneur d'images en utilisant le langage Python. Que vous soyez un développeur débutant ou expérimenté, ce guide vous fournira les étapes clés et les connaissances nécessaires pour automatiser le processus de redimensionnement de vos images. L'objectif est d'optimiser la taille de vos photos pour le web, les réseaux sociaux, ou tout autre usage spécifique, tout en conservant une qualité visuelle acceptable.

Pourquoi redimensionner vos images est important

Le redimensionnement des images est une pratique essentielle dans de nombreux contextes numériques. Que ce soit pour optimiser la vitesse de chargement de votre site web,

faciliter le partage sur les réseaux sociaux, ou simplement pour gagner de l'espace de stockage, la gestion de la taille de vos images est cruciale. Des images trop volumineuses peuvent ralentir considérablement un site web, ce qui affecte négativement l'expérience utilisateur et peut impacter votre référencement sur les moteurs de recherche. Les plateformes de réseaux sociaux ont souvent des limites de taille spécifiques, et le partage d'images non optimisées peut entraîner une compression excessive et une perte de qualité. Un redimensionneur d'images automatisé en Python peut vous aider à résoudre ces problèmes de manière efficace et rapide.

Les modules Python nécessaires : PIL (Pillow) et OS

Pour réaliser notre redimensionneur d'images, nous allons utiliser deux modules Python principaux : PIL (Pillow)

et OS. Pillow est une bibliothèque d'imagerie puissante qui offre des fonctionnalités étendues pour manipuler les images, notamment le redimensionnement, la conversion de format, et l'application de filtres. Le module OS, quant à lui, fournit des outils pour interagir avec le système d'exploitation, ce qui nous permettra de parcourir les dossiers et de gérer les fichiers.

Avant de commencer, assurez-vous d'avoir Pillow installé dans votre environnement Python. Vous pouvez l'installer en utilisant la commande suivante dans votre terminal : pip install Pillow. Le module OS est un module intégré à Python et ne nécessite donc pas d'installation supplémentaire.

from PIL import Image
import os

Ces lignes de code importent les modules nécessaires pour notre script. Le module Image de la librairie PIL est celui qui permet de manipuler les images, les ouvrir, les enregistrer, les redimensionner, etc. Le module os permet d'intéragir avec le système d'exploitation, ce qui est très utile pour parcourir les dossiers, lister les fichiers, créer des dossiers, etc. L'importation de ces librairies est la première étape pour construire notre redimensionneur d'images.

Définition d'une fonction de redimensionnement personnalisée

La pierre angulaire de notre script est la fonction de redimensionnement. Cette fonction prendra en entrée l'image à redimensionner et la nouvelle largeur souhaitée. Elle calculera ensuite la nouvelle hauteur en conservant le ratio d'aspect original de l'image, puis redimensionnera l'image en utilisant la bibliothèque Pillow. Voici le code de la fonction :

def resize_image(image, new_width):
    width, height = image.size
    ratio = width / height
    new_height = int(ratio * new_width)
    resized_image = image.resize((new_width, new_height))
    return resized_image

Explication du code :

• def resize_image(image, new_width): : Définit une fonction nommée resize_image qui accepte un objet image et une nouvelle largeur en pixels comme paramètres.
• width, height = image.size : Récupère la largeur et la hauteur de l'image d'origine en utilisant l'attribut size de l'objet image. Ces Dimensions sont stockées dans les variables width et Height respectivement.
• ratio = width / height : Calcule le ratio d'aspect de l'image en divisant la largeur par la hauteur. Le ratio d'aspect est important pour maintenir les proportions de l'image lors du redimensionnement.
• new_height = int(ratio * new_width) : Calcule la nouvelle hauteur de l'image en multipliant le ratio d'aspect par la nouvelle largeur. La fonction int() est utilisée pour convertir le résultat en un entier, car les dimensions de l'image doivent être des nombres entiers.
• resized_image = image.resize((new_width, new_height)) : Redimensionne l'image en utilisant la méthode resize() de l'objet image. La méthode resize() prend un tuple contenant la nouvelle largeur et la nouvelle hauteur comme argument.
• return resized_image : Renvoie l'image redimensionnée.

Le calcul du ratio d'aspect : Préserver les proportions de l'image

Le ratio d'aspect est le rapport entre la largeur et la hauteur d'une image. Calculer et conserver ce ratio est essentiel

pour éviter la distorsion lors du redimensionnement. Si vous ne respectez pas le ratio d'aspect, l'image risque d'apparaître étirée ou compressée, ce qui peut nuire à sa qualité visuelle. Dans notre fonction, le ratio d'aspect est calculé en divisant la largeur originale par la hauteur originale. Ensuite, la nouvelle hauteur est calculée en multipliant ce ratio par la nouvelle largeur souhaitée. Cela garantit que l'image redimensionnée conserve les mêmes proportions que l'image originale.

Parcourir un dossier et redimensionner toutes les images

Maintenant que nous avons notre fonction de redimensionnement, nous pouvons l'appliquer à toutes les images d'un dossier. Pour cela, nous allons utiliser le module OS pour lister tous les fichiers du dossier, puis filtrer ceux qui sont des images en vérifiant leur extension. Voici le code :

def resize_images_in_folder(folder_path, new_width):
    for filename in os.listdir(folder_path):
        if filename.endswith(('.jpg', '.jpeg', '.png')):
            image_path = os.path.join(folder_path, filename)
            try:
                image = Image.open(image_path)
                resized_image = resize_image(image, new_width)
                resized_image.save(os.path.join(folder_path, 'resized_' + filename))
                print(f'Image {filename} redimensionnée avec succès')
            except Exception as e:
                print(f'Erreur lors du redimensionnement de {filename}: {e}')

Explication du code :

• def resize_images_in_folder(folder_path, new_width): : Définit une fonction nommée resize_images_in_folder qui accepte le chemin du dossier contenant les images et la nouvelle largeur en pixels comme paramètres.
• for filename in os.listdir(folder_path): : Parcourt tous les fichiers et dossiers dans le chemin du dossier spécifié.
• if filename.endswith(('.jpg', '.jpeg', '.png')): : Vérifie si le nom du fichier se termine par l'une des extensions spécifiées. Cela permet de filtrer uniquement les fichiers images.
• image_path = os.path.join(folder_path, filename) : Crée le chemin complet du fichier image en combinant le chemin du dossier et le nom du fichier.
• try:: Démarre un bloc try pour gérer les erreurs potentielles lors de l'ouverture et du redimensionnement de l'image.
• image = Image.open(image_path) : Ouvre l'image en utilisant la méthode open() de l'objet Image.
• resized_image = resize_image(image, new_width) : Appelle la fonction resize_image() pour redimensionner l'image. La fonction prend deux paramètres, l'image a redimensionner et la nouvelle largeur de l'image, l'appel de cette fonction permet de manipuler la taille de l'image
• resized_image.save(os.path.join(folder_path, 'resized_' + filename)) : Enregistre l'image redimensionnée dans le même dossier que l'image originale, avec le préfixe "resized_" ajouté au nom du fichier.
• print(f'Image {filename} redimensionnée avec succès') : Affiche un message de confirmation si l'image est redimensionnée avec succès.
• except Exception as e: : Attrape toute exception qui se produit dans le bloc try.
• print(f'Erreur lors du redimensionnement de {filename}: {e}') : Affiche un message d'erreur si une exception se produit lors du redimensionnement de l'image.

Gestion des erreurs et fichiers non supportés

Il est important de prévoir des mécanismes de gestion des erreurs dans votre script pour faire face aux situations imprévues. Par exemple, certaines images peuvent être corrompues ou dans un format non supporté par Pillow. Dans ce cas, l'ouverture ou le redimensionnement de l'image peut échouer. Pour éviter que le script ne s'arrête brusquement, nous utilisons un bloc try...except pour capturer les exceptions et afficher un message d'erreur informatif. Cela permet de continuer le traitement des autres images du dossier, même si certaines n'ont pas pu être redimensionnées.

De plus, vous pouvez ajouter des vérifications supplémentaires pour vous assurer que le fichier est bien une image avant de tenter de l'ouvrir.

Il existe plusieurs types d'erreurs qu'il convient de gérer, par exemple:

• FileNotFoundError : si le fichier n'existe pas.
• PIL.UnidentifiedImageError : si le fichier n'est pas une image valide.
• OSError : si le fichier est corrompu.

Pour gérer ces erreurs, vous pouvez utiliser le bloc try...except comme ceci:

try:
    image = Image.open(image_path)
    resized_image = resize_image(image, new_width)
    resized_image.save(os.path.join(folder_path, 'resized_' + filename))
    print(f'Image {filename} redimensionnée avec succès')
except FileNotFoundError:
    print(f'Erreur: Le fichier {filename} n\'existe pas.')
except PIL.UnidentifiedImageError:
    print(f'Erreur: Le fichier {filename} n\'est pas une image valide.')
except OSError:
    print(f'Erreur: Le fichier {filename} est corrompu.')
except Exception as e:
    print(f'Erreur lors du redimensionnement de {filename}: {e}')

Optimisation de la qualité et du format de sortie

Le redimensionnement des images peut entraîner une perte de qualité, en particulier si vous réduisez considérablement la taille. Pour minimiser cet effet, vous pouvez ajuster les paramètres de qualité lors de l'enregistrement de l'image. Par exemple, pour les images JPEG, vous pouvez spécifier un niveau de qualité compris entre 0 et 100, où 100 représente la meilleure qualité. Vous pouvez également choisir un format de sortie différent, comme PNG, qui est un format sans perte et peut être préférable pour les images contenant du texte ou des graphiques. Voici un exemple de code pour enregistrer l'image redimensionnée en JPEG avec une qualité de 90 :

resized_image.save(os.path.join(folder_path, 'resized_' + filename), 'JPEG', quality=90)

Le choix du format de sortie et du niveau de qualité dépendra de vos besoins spécifiques et de l'équilibre que vous souhaitez trouver entre la taille du fichier et la qualité visuelle.

Il est recommandé d'expérimenter avec différents paramètres pour trouver la configuration optimale pour vos images.

Utilisation de différentes bibliothèques d'imagerie

Bien que Pillow soit une excellente bibliothèque pour la manipulation d'images en Python, il existe d'autres alternatives que vous pouvez envisager. OpenCV est une bibliothèque puissante, principalement utilisée pour la vision par ordinateur, qui offre également des fonctionnalités de manipulation d'images. Scikit-image est une autre bibliothèque intéressante, axée sur le traitement d'images scientifiques. Chaque bibliothèque a ses propres avantages et inconvénients, et le choix dépendra de vos besoins spécifiques. Par exemple, si vous avez besoin de fonctionnalités avancées de vision par ordinateur, OpenCV pourrait être un meilleur choix que Pillow. Si vous travaillez sur un projet scientifique, Scikit-image pourrait être plus approprié.

Il existe aussi d'autres librairies moins connues mais intéressantes comme:

• imageio: pour lire et écrire une grande variété de formats d'images, y compris les images animées et les vidéos.
• SimpleITK: se concentre sur l'imagerie médicale et scientifique.
• pgmagick: interface Python pour GraphicsMagick, un autre outil de manipulation d'image.

Voici un tableau comparatif des librairies d'imagerie :

Étape 1: Installation des modules nécessaires

Assurez-vous d'avoir Python installé sur votre système. Ensuite, ouvrez votre terminal et exécutez la commande suivante pour installer la bibliothèque Pillow :

pip install Pillow

Étape 2: Création du script Python

Créez un nouveau fichier Python (par exemple, redimensionneur.py) et copiez-y le code suivant :

from PIL import Image
import os

def resize_image(image, new_width):
    width, height = image.size
    ratio = width / height
    new_height = int(ratio * new_width)
    resized_image = image.resize((new_width, new_height))
    return resized_image

def resize_images_in_folder(folder_path, new_width):
    for filename in os.listdir(folder_path):
        if filename.endswith(('.jpg', '.jpeg', '.png')):
            image_path = os.path.join(folder_path, filename)
            try:
                image = Image.open(image_path)
                resized_image = resize_image(image, new_width)
                resized_image.save(os.path.join(folder_path, 'resized_' + filename))
                print(f'Image {filename} redimensionnée avec succès')
            except Exception as e:
                print(f'Erreur lors du redimensionnement de {filename}: {e}')

# Chemin du dossier contenant les images
folder_path = 'photos'

# Nouvelle largeur souhaitée pour les images
new_width = 800

# Appel de la fonction pour redimensionner les images du dossier
resize_images_in_folder(folder_path, new_width)

Étape 3: Préparation du dossier contenant les images

Créez un dossier (par exemple, photos) et placez-y les images que vous souhaitez redimensionner.

Étape 4: Exécution du script

Ouvrez votre terminal, naviguez jusqu'au dossier contenant votre script Python, et exécutez la commande suivante :

python redimensionneur.py

Le script parcourra le dossier photos, redimensionnera toutes les images JPG, JPEG et PNG, et enregistrera les nouvelles images avec le préfixe resized_ dans le même dossier.