Créez diverses vidéos Photoshop avec Python + OpenCV ② Créez une image fixe Photoshop

0. Introduction

C'est une continuation de la dernière fois (Partie 1 Reconnaissance faciale). Remplacez le visage précédemment reconnu par une autre image. Je me suis référé au site suivant. Traitement d'image par python + Opencv 5 (redimensionnement) Écraser l'homme qui rit sur le visage avec l'oreiller Python + OpenCV +

Après tout, l'image à écraser sera celle-ci. Pièces de l'homme qui rit

1. Redimensionnement de l'image

La taille du visage reconnu et la taille de l'image à écraser étant différentes, créez une fonction pour redimensionner l'image à l'aide de la fonction resize () d'OpenCV. Si vous donnez l'image et la taille modifiée, elle s'agrandira et se contractera en conséquence. Je ne voulais pas changer le rapport hauteur / largeur de l'image originale, donc il s'agrandit et se contracte en fonction de la plus petite différence de taille (rapport). Ci-dessous le code.

resize_image

def resize_image(image, height, width):
    
    #Obtenez la taille d'origine
    org_height, org_width = image.shape[:2]
    
    #Rétrécir pour s'adapter à la plus grande taille
    if float(height)/org_height > float(width)/org_width:
        ratio = float(height)/org_height
    else:
        ratio = float(width)/org_width
    
    #redimensionner
    resized = cv2.resize(image,(int(org_height*ratio),int(org_width*ratio)))
    
    return resized    

2. Redimensionner le résultat

Testons la fonction de redimensionnement. J'ai essayé de faire une taille de 100 x 100.

resizetest

    #Chargement de l'image à écraser
    ol_imgae_path = "target/warai_otoko.png "    
    ol_image = cv2.imread(ol_imgae_path,cv2.IMREAD_UNCHANGED)   #Canal alpha(Transparent)IMREAD pour lire_Spécifiez INCHANGED

    #redimensionner
    resized_image = resize_image(ol_image, 100, 100)

    #Sortie du résultat de la reconnaissance
    cv2.imwrite("result/warai_otoko_result.png ", resized_image)

Before

After

J'ai pu le réduire avec succès.

3. Créez une fonction pour écraser l'image

Écrasez l'image sur la partie du visage. Créez une fonction qui synthétise une image à une position spécifiée à l'aide d'une bibliothèque appelée Pillow (PIL). Le flux est -Convertir les images du format OpenCV au format PIL ・ Écraser avec l'image de superposition -Retour du format PIL au format OpenCV. C'est comme ça.

overlayOnPart

import numpy as np
from PIL import Image

def overlayOnPart(src_image, overlay_image, posX, posY):

    #Obtenir la taille de l'image de superposition
    ol_height, ol_width = overlay_image.shape[:2]

    #Convertir les données d'image OpenCV en PIL
    #Convertir de BGRA en RGBA
    src_image_RGBA = cv2.cvtColor(src_image, cv2.COLOR_BGR2RGB)
    overlay_image_RGBA = cv2.cvtColor(overlay_image, cv2.COLOR_BGRA2RGBA)
    
    #Convertir en PIL
    src_image_PIL=Image.fromarray(src_image_RGBA)
    overlay_image_PIL=Image.fromarray(overlay_image_RGBA)

    #Passer en mode RGBA pour la composition
    src_image_PIL = src_image_PIL.convert('RGBA')
    overlay_image_PIL = overlay_image_PIL.convert('RGBA')

    #Préparez un campus transparent de la même taille
    tmp = Image.new('RGBA', src_image_PIL.size, (255, 255,255, 0))
    #Écraser le campus préparé
    tmp.paste(overlay_image_PIL, (posX, posY), overlay_image_PIL)
    #Combinez l'original et le campus et économisez
    result = Image.alpha_composite(src_image_PIL, tmp)
    
    return  cv2.cvtColor(np.asarray(result), cv2.COLOR_RGBA2BGRA)

4. Fonction d'écrasement intégrée

Je mettrai un homme qui rit sur le visage de l'image de Lenna que j'ai reconnue la dernière fois. Ajout du chargement d'images pour écraser la source précédente, Après avoir réduit la taille pour l'adapter à la taille du visage, écrasez-la.

overlay_face

#coding=utf-8

import cv2
import numpy as np
from PIL import Image


def overlay_face():

    #Lire le fichier reconnu
    image_path = "target/Lenna.png "
    image = cv2.imread(image_path)

    #Chargement de l'image à écraser
    ol_imgae_path = "target/warai_otoko.png "    
    ol_image = cv2.imread(ol_imgae_path,cv2.IMREAD_UNCHANGED)   #Canal alpha(Transparent)IMREAD pour lire_Spécifiez INCHANGED
 
    #Convertir en échelle de gris
    image_gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

    #Spécification du fichier de la quantité de fonctionnalités pour la reconnaissance faciale
    cascade_path = "haarcascades/haarcascade_frontalface_alt.xml"
    #Acquérir la quantité de caractéristiques du classificateur en cascade
    cascade = cv2.CascadeClassifier(cascade_path)

    #Effectuer la reconnaissance faciale
    facerecog = cascade.detectMultiScale(image_gray, scaleFactor=1.1, minNeighbors=1, minSize=(1, 1))

  
    if len(facerecog) > 0:


        #Écraser l'image sur tous les visages reconnus
        for rect in facerecog:

            #Afficher le résultat de la reconnaissance
            print ("Résultat de la reconnaissance")
            print ("(x,y)=(" + str(rect[0]) + "," + str(rect[1])+ ")" + \
                "la taille:"+str(rect[2]) + \
                "largeur:"+str(rect[3]))

            #Redimensionner l'image pour l'adapter à la plage de reconnaissance
            resized_ol_image = resize_image(ol_image, rect[2], rect[3])
            
            #Créer une image écrasée
            image = overlayOnPart(image, resized_ol_image, rect[0], rect[1])
    
    #Sortie du résultat de la reconnaissance
    cv2.imwrite("result/Lenna_result.png ", image)


if __name__ == '__main__':
    overlay_face()

5. Écraser le résultat

Ça s'est bien passé.

6. Enfin

Maintenant que vous pouvez créer une image fixe Photoshop, À partir de la prochaine fois, je l'appliquerai aux vidéos. Créer diverses vidéos Photoshop avec Python + OpenCV ③ Créer diverses vidéos Photoshop