Comment flouter les visages en temps réel avec Python

​Traducteur | Bugatti

Reviewer | Chonglou

Vous pouvez utiliser le flou facial pour masquer des visages dans des vidéos ou des images pour plusieurs raisons. Les problèmes de confidentialité et de sécurité en sont les principales raisons. La plupart des plateformes de partage vidéo et des logiciels de montage vidéo disposent de fonctionnalités de flou de visage intégrées.

Vous pouvez créer votre propre programme de flou de visage à partir de zéro en utilisant les bibliothèques Python, OpenCV et NumPy.

1. Établir l'environnement

Pour compléter cet article, vous devez être familier avec les connaissances de base de Python et avoir une compréhension de base de l'utilisation de la bibliothèque NumPy.

Ouvrez n'importe quel IDE Python que vous connaissez. Créez un environnement virtuel pour installer les bibliothèques requises. Créez un nouveau fichier Python. Accédez au terminal et exécutez les commandes suivantes pour installer les bibliothèques requises. Transmettez les bibliothèques sous forme de liste séparée par des espaces.

pip install OpenCV-python NumPy

Vous utiliserez OpenCV pour obtenir et prétraiter l'entrée vidéo et NumPy pour traiter le tableau.

Une fois que vous avez installé la bibliothèque, attendez que l'EDI mette à jour le backbone du projet. Une fois les mises à jour terminées et votre environnement prêt, vous pouvez commencer à coder.

Remarque : Le code source complet peut être trouvé dans le référentiel GitHub (https://github.com/makeuseofcode/Face-Blurring).

2. Importez les bibliothèques requises

Tout d'abord, importez la bibliothèque OpenCV et la bibliothèque NumPy. Cela vous permettra d'appeler et d'utiliser n'importe quelle fonction prise en charge. Importez OpenCV-python en tant que cv2.

import cv2
import numpy as np

Le module OpenCV-python utilise le nom cv2 comme convention établie par la communauté OpenCV. OpenCV-Python est un wrapper Python pour la bibliothèque OpenCV, écrit en C++.

3. Obtenez une entrée

Créez une variable et initialisez l'objet VideoCapture. Si vous souhaitez utiliser la caméra principale de votre ordinateur comme source d'entrée, vous devez passer 0 comme paramètre. Pour utiliser une caméra externe connectée à votre ordinateur, passez 1. Pour effectuer un flou de visage sur une vidéo préenregistrée, transmettez plutôt le chemin de la vidéo. Pour utiliser une caméra distante, transmettez l'URL de la caméra, qui contient l'adresse IP et le numéro de port.

cap = cv2.VideoCapture(0)

Pour effectuer un flou de visage sur l'entrée, vous avez besoin de ces trois fonctions :

• Fonction qui prétraite l'entrée.
• Fonction qui floutera les visages dans l'entrée.
• La fonction principale qui contrôlera le déroulement du programme et affichera le résultat.

4. Prétraitement de l'entrée vidéo

Créez une fonction de prétraitement d'entrée qui prend chaque image de la vidéo d'entrée comme entrée. Initialisez la classe CascadeClassifier, que vous utiliserez pour détecter les visages. Redimensionnez le cadre à 640*640 pixels. Convertissez les cadres redimensionnés en niveaux de gris pour le traitement, puis détectez les visages dans l'entrée et liez-les à des rectangles.

def image_preprocess(frame):
face_detector = cv2.CascadeClassifier(cv2.data.haarcascades
+ 'haarcascade_frontalface_default.xml')

resized_image = cv2.resize(frame, (640, 640))

gray_image = cv2.cvtColor(resized_image,
cv2.COLOR_BGR2GRAY)

face_rects = face_detector.detectMultiScale(
gray_image, 1.04, 5, minSize=(20, 20))

return resized_image, face_rects

Cette fonction renvoie un tuple contenant l'image redimensionnée et une liste de rectangles représentant les visages détectés.

5. Flou des visages

Créez une fonction de flou pour flouter les visages dans l'entrée. Cette fonction prend en entrée le cadre redimensionné et la liste des rectangles entourant le visage renvoyés par la fonction de prétraitement. Parcourez les rectangles du visage. Calculez le centre de chaque rectangle et le rayon du cercle flou. Crée une image noire avec les mêmes dimensions que le cadre redimensionné en initialisant tous les pixels à 0. A l'aide du rayon calculé, tracez un cercle blanc sur l'image noire centré sur le rectangle du visage. Enfin, cela rend l'image floue sur le cercle blanc.

def face_blur(resized_frame, face_rects):
for (x, y, w, h) in face_rects:
# Specifying the center and radius
# of the blurring circle
center_x = x + w // 3
center_y = y + h // 3
radius = h // 1

# creating a black image having similar
# dimensions as the frame
mask = np.zeros((resized_frame.shape[:3]), np.uint8)

# draw a white circle in the face region of the frame
cv2.circle(mask, (center_x, center_y), radius,
 (255, 255, 255), -1)

# blurring the whole frame
blurred_image = cv2.medianBlur(resized_frame, 99)

# reconstructing the frame:
# - the pixels from the blurred frame if mask > 0
# - otherwise, take the pixels from the original frame
resized_frame = np.where(mask > 0, blurred_image,
 resized_frame)

return resized_frame

Cette fonction utilise la fonction NumPywhere() pour reconstruire le cadre pendant le processus de flou.

6. Contrôlez le flux du programme

Créez une fonction principale pour servir de point d'entrée du programme. Il contrôlera ensuite le déroulement du programme. Cette fonction lancera une boucle infinie qui capture en continu les images de l'entrée vidéo. Appelez la méthode read de l’objet cap pour lire les images de la caméra.

Ensuite, la fonction transmet le cadre à la fonction de prétraitement et la valeur de retour à une autre fonction face_blur pour obtenir l'image floue. Il redimensionne ensuite le cadre renvoyé par la fonction de flou et affiche la sortie.

def main():
while True:
success, frame = cap.read()
resized_input, face_rects = image_preprocess(frame)
blurred_image = face_blur(resized_input, face_rects)

# Diplaying the blurred image
cv2.imshow("Blurred image", cv2.resize(blurred_image, (500, 500)))

if cv2.waitKey(1) == ord("q"):
break

Cette fonction met également fin à l'affichage de la sortie lorsque l'utilisateur appuie sur la touche q.

7. Exécutez le programme

Assurez-vous d'abord d'exécuter la fonction principale lors de l'exécution du script. Cette condition sera fausse si le script est importé en tant que module dans un autre programme.

if __name__ == "__main__":
main()

Cela vous permet d'utiliser le script comme module ou de l'exécuter en tant que programme autonome. Lorsque le programme s'exécute, vous devriez voir un résultat semblable à celui-ci :

Le visage a été flou et ne peut pas être reconnu.

8. Applications pratiques du flou de visage

Vous pouvez utiliser le flou de visage pour protéger la confidentialité dans de nombreux types d'environnements d'application. Street View et les services de cartographie utilisent une technologie de flou pour masquer les visages des personnes sur les images. Les forces de l'ordre utilisent une technologie de floutage du visage pour protéger l'identité des témoins.

De nombreuses plateformes de partage de vidéos ont également intégré des fonctions de flou de visage pour les utilisateurs. Comparer l’utilisation du flou facial dans ces domaines peut vous aider à voir comment d’autres plateformes intègrent cette technologie.

Lien original : https://www.makeuseof.com/python-blur-human-faces-real-time/

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!