Comment supprimer l’arrière-plan d’une image avec Python ?

Introduction

Récemment, j’ai voulu supprimer la couleur de fond d’une photo que je prévoyais d’utiliser comme photo de profil sur mon site web. Je ne voulais pas d’un arrière-plan distrayant — juste une découpe propre et transparente de moi-même. Plutôt que de me fier à des outils en ligne, j’ai décidé d’explorer comment le faire de manière programmatique avec Python.

Dans cet article, je vais vous présenter plusieurs méthodes efficaces pour supprimer l’arrière-plan d’une image avec Python.

Méthode 1 : Utiliser rembg (recommandé)

La bibliothèque rembg est une solution simple et efficace qui s’appuie sur des modèles d’apprentissage profond pour supprimer les arrière-plans avec une grande précision.

Installation

Commencez par installer rembg et ses dépendances :

1
2

pip install rembg
pip install pillow numpy

Implémentation du code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

from rembg import remove
from PIL import Image

# Charger l’image d’entrée
input_path = "input_image.jpg"
output_path = "output_image.png"

image = Image.open(input_path)
output = remove(image)

# Enregistrer l’image de sortie avec arrière-plan transparent
output.save(output_path)
print("Arrière-plan supprimé avec succès !")

Cette méthode conserve le sujet de l’image tout en rendant l’arrière-plan transparent.

Avantages :

• Détecte automatiquement l’arrière-plan et le sujet.
• Gère bien les scènes complexes.
• Produit une image avec fond transparent — parfait pour le web.

Si vous ne connaissez pas la couleur exacte de votre fond ou si celui-ci est encombré, rembg est la solution la plus simple et efficace.

Remplacer l’arrière-plan transparent par du gris (ou toute autre couleur)

Pour remplacer l’arrière-plan transparent par du gris (par exemple, RGB = (200, 200, 200)) :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

from rembg import remove
from PIL import Image

# Étape 1 : Charger l’image et supprimer l’arrière-plan
input_image = Image.open("ben_2024.png").convert("RGBA")
output_image = remove(input_image)

# Étape 2 : Créer un arrière-plan gris
gray_bg = Image.new("RGBA", output_image.size, (200, 200, 200, 255))

# Étape 3 : Superposer le sujet sur le fond gris
final = Image.alpha_composite(gray_bg, output_image)

# Étape 4 : Enregistrer le résultat en RGB standard (si besoin)
final.convert("RGB").save("your_photo_gray_bg.jpg")

Vous pouvez remplacer (200, 200, 200, 255) par n’importe quelle couleur RGB, par exemple :

• Blanc : (255, 255, 255, 255)
• Noir : (0, 0, 0, 255)
• Bleu : (0, 120, 255, 255)

Méthode 2 : Utiliser OpenCV pour suppression basée sur la couleur

Pour supprimer l’arrière-plan d’une image avec OpenCV (cv2), on utilise généralement la segmentation de couleur — une méthode efficace lorsque l’arrière-plan est d’une couleur uniforme ou facilement identifiable (comme un fond vert, un mur blanc, un ciel bleu, etc.).

Cet exemple suppose que l’arrière-plan est clair (par exemple, blanc) et que le sujet est plus sombre ou plus coloré.

Installation

Installez OpenCV et NumPy :

1

pip install opencv-python numpy

Implémentation du code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

import cv2
import numpy as np

# Charger l’image
image = cv2.imread("your_photo.jpg")

# Convertir en espace colorimétrique HSV
hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)

# Définir la plage de couleur de l’arrière-plan (ici : blanc)
lower = np.array([0, 0, 200])     # Limite inférieure HSV
upper = np.array([180, 25, 255])  # Limite supérieure HSV

# Créer un masque pour l’arrière-plan
mask = cv2.inRange(hsv, lower, upper)

# Inverser le masque pour conserver le sujet
mask_inv = cv2.bitwise_not(mask)

# Extraire le sujet à l’aide du masque
foreground = cv2.bitwise_and(image, image, mask=mask_inv)

# Optionnel : ajouter de la transparence à l’arrière-plan
foreground_bgra = cv2.cvtColor(foreground, cv2.COLOR_BGR2BGRA)
foreground_bgra[:, :, 3] = mask_inv

# Enregistrer le résultat
cv2.imwrite("output_no_bg.png", foreground_bgra)
print("Arrière-plan supprimé et enregistré sous output_no_bg.png")

Comment choisir les bonnes plages HSV

1. Utilisez un éditeur d’images (GIMP, Photoshop) ou les outils GUI d’OpenCV pour inspecter les valeurs HSV du fond.
2. Utilisez cv2.cvtColor(valeur_pixel_bgr, cv2.COLOR_BGR2HSV) pour tester les couleurs de manière interactive.

Exemple : pour un fond vert :

1
2

lower = np.array([35, 40, 40])
upper = np.array([85, 255, 255])

Conseils de format :

• Utilisez le format .png pour conserver la transparence (JPG ne la supporte pas).
• Si la transparence n’est pas nécessaire, remplissez l’arrière-plan avec une couleur solide.

Limitations :

• Inefficace avec des arrière-plans complexes ou texturés.
• Convient mieux aux conditions contrôlées (photos studio, objets produits, etc.).
• Pour les photos de profil avec arrière-plans encombrés, préférez rembg.

Utiliser MediaPipe Selfie Segmentation (pour rester avec OpenCV)

Pour les portraits humains (ex. : photo de profil), MediaPipe de Google propose un modèle ML pour segmenter les personnes.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

import cv2
import mediapipe as mp
import numpy as np

# Charger l’image
image = cv2.imread("your_photo.jpg")
image = cv2.resize(image, (640, 480))
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Charger le modèle Selfie Segmentation
mp_selfie_segmentation = mp.solutions.selfie_segmentation
segmentor = mp_selfie_segmentation.SelfieSegmentation(model_selection=1)

# Appliquer la segmentation
results = segmentor.process(image_rgb)
mask = results.segmentation_mask

# Créer un masque binaire
condition = mask > 0.6
bg_color = (200, 200, 200)
bg_image = np.ones(image.shape, dtype=np.uint8) * np.array(bg_color, dtype=np.uint8)

# Fusionner sujet et arrière-plan
output_image = np.where(condition[..., None], image, bg_image)

# Enregistrer le résultat
cv2.imwrite("segmented_photo.jpg", output_image)
print("Image enregistrée avec l’arrière-plan remplacé")

Astuce pour les utilisateurs Mac (éviter les crashs MediaPipe dans Jupyter)

Sous Mac, vous pouvez rencontrer cette erreur dans Jupyter Notebook :

1

The kernel appears to have died. It will restart automatically.

Pourquoi cela se produit :

• Incompatibilités ou manque de ressources.
• Processeurs sans jeu d’instructions AVX.
• Problèmes de dépendances MediaPipe/TensorFlow.
• Image trop grande.

Solution : Utilisez Google Colab

Téléversez vos fichiers sur Google Drive et exécutez le code sur Google Colab, qui est plus stable.

Instructions :

1. Déplacez les fichiers sur Google Drive.

2. Montez le Drive dans Colab :

   from google.colab import drive
   drive.mount('/content/drive')

3. Nettoyez et réinstallez MediaPipe :

   !pip uninstall -y mediapipe keras pandas numpy
   !pip install mediapipe

4. Exécutez le code de suppression d’arrière-plan.

Méthode 3 : Utiliser l’API remove.bg

L’API remove.bg est un service cloud basé sur l’IA pour supprimer les arrière-plans.

Installation

1

pip install removebg

Implémentation du code

1
2
3
4
5
6
7

from removebg import RemoveBg

api_key = "votre_clé_api"
rmbg = RemoveBg(api_key, "error.log")

# Supprimer l’arrière-plan
rmbg.remove_background_from_img_file("input_image.jpg")

Ce service nécessite une clé API depuis remove.bg.

Conclusion

Chaque méthode a ses avantages — choisissez celle qui convient à votre besoin.