Comment flouter les visages humains en temps réel avec Python

Vous pouvez utiliser le flou facial pour dissimuler le visage d’une personne, dans une vidéo ou une image, pour plusieurs raisons. Les questions de confidentialité et de sécurité sont les plus importantes. La plupart des plateformes de partage de vidéos et des logiciels d’édition vidéo intègrent une fonctionnalité de floutage du visage.

Vous pouvez créer votre propre programme de floutage des visages en utilisant Python et les bibliothèques OpenCV et NumPy.

Configuration de votre environnement

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

Ouvrez n’importe quel IDE Python avec lequel vous êtes à l’aise. Créez un environnement virtuel dans lequel vous installerez les bibliothèques requises. Créez un nouveau fichier Python. Naviguez vers le terminal et exécutez la commande suivante pour installer les bibliothèques requises. Passez les bibliothèques sous la forme d’une liste délimitée par des espaces.

 pip install OpenCV-python NumPy 

Vous utiliserez OpenCV pour prendre et prétraiter l’entrée vidéo et NumPy pour travailler avec des tableaux.

Une fois que vous avez installé les bibliothèques, attendez que l’IDE mette à jour les squelettes du projet. Lorsque la mise à jour est terminée et que l’environnement est prêt, vous pouvez commencer à coder.

Importation des bibliothèques requises

Commencez par importer les bibliothèques OpenCV et NumPy. Cela vous permettra d’appeler et d’utiliser toutes les fonctions qu’elles supportent. Importez OpenCV-python en tant que cv2.

 import cv2
import numpy as np 

Les modules OpenCV-python utilisent le nom cv2 comme une convention établie par la communauté OpenCV. OpenCV-python est une enveloppe Python de la bibliothèque OpenCV qui est écrite en C++.

Votre avis nous intéresse

Créer une variable et initialiser le VideoCapture objet. Passez zéro comme argument si vous voulez utiliser la caméra principale de votre ordinateur comme source d’entrée. Pour utiliser une caméra externe connectée à votre ordinateur, passez un. Pour effectuer un flou facial sur une vidéo préenregistrée, passez plutôt le chemin de la vidéo. Pour utiliser une caméra distante, passez l’URL de la caméra contenant son adresse IP et son numéro de port.

 cap = cv2.VideoCapture(0)
 

Pour effectuer un flou facial sur l’entrée, vous aurez besoin de trois fonctions :

• Une fonction qui va pré-traiter l’entrée.
• Une fonction qui va flouter le visage dans l’entrée.
• Une fonction principale qui contrôlera le déroulement du programme et affichera la sortie.

Prétraitement de l’entrée vidéo

Créez une fonction de prétraitement d’entrée qui prendra chaque image de la vidéo d’entrée comme entrée. Initialisez la classe CascadeClassifier que vous utiliserez pour la détection des visages. Redimensionnez l’image à 640 par 640 pixels. Convertissez l’image redimensionnée en niveaux de gris pour faciliter le traitement, et enfin détectez les visages dans l’entrée et liez-les avec 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 retourne un tuple contenant l’image redimensionnée et une liste de rectangles qui représentent les visages détectés.

Flouter le visage

Créez une fonction de flou qui rendra les visages de votre entrée flous. La fonction prend en entrée l’image redimensionnée et la liste des rectangles délimitant les visages retournés par la fonction de prétraitement. Boucle sur chaque rectangle de visage. Calcule le centre de chaque rectangle et le rayon du cercle de flou. Crée une image noire ayant les mêmes dimensions que l’image redimensionnée en initialisant tous les pixels à zéro. Dessine un cercle blanc sur l’image noire dont le centre se trouve sur le rectangle du visage en utilisant le rayon calculé. Enfin, il floute l’image 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 

La fonction utilise la fonction NumPy où() fonction pour reconstruire l’image pendant le flou.

Contrôler le flux de votre programme

Créez une fonction principale qui sera le point d’entrée de votre programme. Elle contrôlera ensuite le déroulement du programme. La fonction démarrera une boucle infinie pour capturer continuellement les images de l’entrée vidéo. Appelez la méthode read de l’objet cap pour lire une image de la caméra.

La fonction passera ensuite l’image à la fonction de prétraitement et passera les valeurs de retour à une autre fonction, face_blur, pour obtenir une image floue. Elle redimensionne ensuite l’image renvoyée 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
 

La fonction termine également l’affichage de la sortie lorsque l’utilisateur appuie sur la touche q.

Exécution du programme

Assurez-vous que la fonction principale s’exécute en premier lorsque vous exécutez le script. Cette condition sera fausse si vous importez le script en tant que module dans un autre programme.

 if __name__ == "__main__":
    main() 

Cela vous permet d’utiliser le script comme un module ou de l’exécuter comme un programme autonome. Lorsque le programme s’exécute, vous devriez voir une sortie similaire à celle-ci :

Le visage est flou et méconnaissable.

Applications réelles du floutage du visage

Vous pouvez appliquer le floutage des visages dans de nombreux types d’applications pour protéger la vie privée des personnes. Les services de cartographie et de Street View utilisent le floutage pour brouiller les visages des personnes dans les images qu’ils capturent. Les forces de l’ordre utilisent le floutage du visage pour protéger l’identité des témoins.

De nombreuses plateformes de partage de vidéos ont également intégré une fonction de floutage des visages pour leurs utilisateurs. En comparant l’utilisation du floutage du visage dans ces domaines, vous pourrez observer comment les autres plateformes intègrent cette technologie.