ZOOM en remplaçant votre visage par une icône Twitter avec la reconnaissance faciale openCV
C'est kimo_0tak, qui est le premier post depuis longtemps. Vous pouvez facilement faire de la belle viande avec du facerig, etc., mais je n'ai pas pu trouver un moyen de remplacer uniquement mon visage par une autre image même si j'ai cherché sur Google, alors je l'ai fait rapidement. Il n'y a aucune garantie qu'il remplacera le visage à 100%, veuillez donc l'utiliser comme matériau de bague intérieure.
L'image affichée ressemble à ceci.
L'environnement d'utilisation est Windows 10, Python 3.6.5. Placez l'image que vous souhaitez remplacer par ce programme et le fichier xml du modèle de reconnaissance faciale dans le même fichier.
Voici le site que j'ai utilisé comme référence.
Détection de visage avec Haar Cascades http://labs.eecs.tottori-u.ac.jp/sd/Member/oyamada/OpenCV/html/py_tutorials/py_objdetect/py_face_detection/py_face_detection.html Dessinez une autre image au-dessus de l'image avec OpenCV https://note.com/npaka/n/nddb33be1b782 Une histoire sur la capture, le traitement et l'affichage d'images de caméras Web avec Python + OpenCV https://ensekitt.hatenablog.com/entry/2017/12/19/200000
Faisons-le. Le code terminé est en bas, donc si vous voulez en voir autant, faites défiler vers le bas.
Importer les bibliothèques requises
#Importation OpenCV
import cv2
import numpy as np
from PIL import Image
#Importation OpenCV
import cv2
import numpy as np
from PIL import Image
Si vous avez des bibliothèques que vous n'avez pas installées, veuillez les installer vous-même. Ouvrez une invite de commande
pip install opencv-python
pip install numpy
pip install Pillow
Vous devriez pouvoir le saisir en tapant.
Divers réglages
#Paramètres de résolution de la caméra
WIDTH = 1920
HEIGHT = 1080
#Spécifier l'image à lire
img = "vtuber_may.jpg "
cv2_img = cv2.imread(img, cv2.IMREAD_UNCHANGED)
#Désignation du modèle de reconnaissance faciale
face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_alt2.xml')
#Vous pouvez sélectionner la caméra avec l'argument.
cap = cv2.VideoCapture(0)
cap.set(cv2.CAP_PROP_FRAME_WIDTH, WIDTH)
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, HEIGHT)
#Paramètres de résolution de la caméra
WIDTH = 1920
HEIGHT = 1080
#Spécifier l'image à lire
img = "vtuber_may.jpg "
cv2_img = cv2.imread(img, cv2.IMREAD_UNCHANGED)
#Désignation du modèle de reconnaissance faciale
face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_alt2.xml')
#Vous pouvez sélectionner la caméra avec l'argument.
cap = cv2.VideoCapture(0)
cap.set(cv2.CAP_PROP_FRAME_WIDTH, WIDTH)
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, HEIGHT)
Vous pouvez créer vous-même un classificateur en cascade pour la reconnaissance faciale, mais c'était gênant, j'ai donc utilisé le classificateur fourni par Opencv. Il est inclus lorsque vous installez opencv avec pip install opencv. Dans mon environnement, il se trouvait dans le dossier C: \ Users \ {username} \ AppData \ Local \ Programs \ Python \ Python36-32 \ Lib \ site-packages \ cv2 \ data.
Fonction de synthèse d'images
def overlayImage(src, overlay, location, size):
overlay_height, overlay_width = overlay.shape[:2]
#Convertir les images de la webcam au format PIL
src = cv2.cvtColor(src, cv2.COLOR_BGR2RGB)
pil_src = Image.fromarray(src)
pil_src = pil_src.convert('RGBA')
#Convertissez l'image que vous souhaitez combiner au format PIL
overlay = cv2.cvtColor(overlay, cv2.COLOR_BGRA2RGBA)
pil_overlay = Image.fromarray(overlay)
pil_overlay = pil_overlay.convert('RGBA')
#Redimensionner pour s'adapter à la taille de votre visage
pil_overlay = pil_overlay.resize(size)
#Combiner des images
pil_tmp = Image.new('RGBA', pil_src.size, (255, 255, 255, 0))
pil_tmp.paste(pil_overlay, location, pil_overlay)
result_image = Image.alpha_composite(pil_src, pil_tmp)
#Convertir au format OpenCV
return cv2.cvtColor(np.asarray(result_image), cv2.COLOR_RGBA2BGRA)
def overlayImage(src, overlay, location, size):
overlay_height, overlay_width = overlay.shape[:2]
#Convertir les images de la webcam au format PIL
src = cv2.cvtColor(src, cv2.COLOR_BGR2RGB)
pil_src = Image.fromarray(src)
pil_src = pil_src.convert('RGBA')
#Convertissez l'image que vous souhaitez combiner au format PIL
overlay = cv2.cvtColor(overlay, cv2.COLOR_BGRA2RGBA)
pil_overlay = Image.fromarray(overlay)
pil_overlay = pil_overlay.convert('RGBA')
#Redimensionner pour s'adapter à la taille de votre visage
pil_overlay = pil_overlay.resize(size)
#Combiner des images
pil_tmp = Image.new('RGBA', pil_src.size, (255, 255, 255, 0))
pil_tmp.paste(pil_overlay, location, pil_overlay)
result_image = Image.alpha_composite(pil_src, pil_tmp)
#Convertir au format OpenCV
return cv2.cvtColor(np.asarray(result_image), cv2.COLOR_RGBA2BGRA)
Étant donné qu'Opencv ne peut pas synthétiser les images, créez une fonction pour combiner les images après la conversion au format PIL.
Je le redimensionne également en fonction de la hauteur et de la largeur de mon visage.
Fonction principale
def main():
#Une variable qui stocke les coordonnées du coin supérieur gauche de la reconnaissance faciale
x = 0
y = 0
#Variable qui stocke la largeur et la hauteur du visage
w = 0
h = 0
while True:
#Charger 1 image depuis VideoCapture
ret, frame = cap.read()
#Convertir le cadre en format gris pour la reconnaissance faciale
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
face = face_cascade.detectMultiScale(gray, 1.3, 5)
#Si le visage est reconnu x, y, w,mettre à jour h
if face != ():
(x, y, w, h) = face[0]
#Si la variable est différente de la valeur initiale, l'image est combinée avec le cadre
if w != 0:
frame = overlayImage(frame, cv2_img, (x, y), (w, h))
#Afficher le cadre traité
cv2.imshow('Frame', frame)
#Attendez 1 ms pour l'entrée de la touche et interrompez lorsque vous appuyez sur ESC
k = cv2.waitKey(1)
if k == 27:
break
#Relâchez la capture et fermez la fenêtre
cap.release()
cv2.destroyAllWindows()
def main():
#Une variable qui stocke les coordonnées du coin supérieur gauche de la reconnaissance faciale
x = 0
y = 0
#Variable qui stocke la largeur et la hauteur du visage
w = 0
h = 0
while True:
#Charger 1 image depuis VideoCapture
ret, frame = cap.read()
#Convertir le cadre en format gris pour la reconnaissance faciale
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
face = face_cascade.detectMultiScale(gray, 1.3, 5)
#Si le visage est reconnu x, y, w,mettre à jour h
if face != ():
(x, y, w, h) = face[0]
#Si la variable est différente de la valeur initiale, l'image est combinée avec le cadre
if w != 0:
frame = overlayImage(frame, cv2_img, (x, y), (w, h))
#Afficher le cadre traité
cv2.imshow('Frame', frame)
#Attendez 1 ms pour l'entrée de la touche et interrompez lorsque vous appuyez sur ESC
k = cv2.waitKey(1)
if k == 27:
break
#Relâchez la capture et fermez la fenêtre
cap.release()
cv2.destroyAllWindows()
Une image est lue à partir de la webcam et l'image est traitée.
Selon le cadre, le visage peut ne pas être reconnu, donc s'il n'est pas reconnu, il est combiné avec la position précédemment reconnue.
Notez que si deux ou plusieurs visages sont reconnus à l'écran, l'image sera combinée avec un seul des visages.
Je pensais que je l'améliorerais, mais je ne l'ai pas amélioré car il est peu probable que les deux apparaissent dans ZOOM en même temps.
Traitement pour exécuter la fonction principale
if __name__ == '__main__':
main()
if __name__ == '__main__':
main()
En résumé, cela ressemble à ceci
#Importation OpenCV
import cv2
import numpy as np
from PIL import Image
#Paramètres de résolution de la caméra
WIDTH = 1920
HEIGHT = 1080
#Spécifier l'image à lire
img = "vtuber_may.jpg "
cv2_img = cv2.imread(img, cv2.IMREAD_UNCHANGED)
#Désignation du modèle de reconnaissance faciale
face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_alt2.xml')
#Vous pouvez sélectionner la caméra avec l'argument.
cap = cv2.VideoCapture(0)
cap.set(cv2.CAP_PROP_FRAME_WIDTH, WIDTH)
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, HEIGHT)
def overlayImage(src, overlay, location, size):
overlay_height, overlay_width = overlay.shape[:2]
#Convertir les images de la webcam au format PIL
src = cv2.cvtColor(src, cv2.COLOR_BGR2RGB)
pil_src = Image.fromarray(src)
pil_src = pil_src.convert('RGBA')
#Convertissez l'image que vous souhaitez combiner au format PIL
overlay = cv2.cvtColor(overlay, cv2.COLOR_BGRA2RGBA)
pil_overlay = Image.fromarray(overlay)
pil_overlay = pil_overlay.convert('RGBA')
#Redimensionner pour s'adapter à la taille de votre visage
pil_overlay = pil_overlay.resize(size)
#Combiner des images
pil_tmp = Image.new('RGBA', pil_src.size, (255, 255, 255, 0))
pil_tmp.paste(pil_overlay, location, pil_overlay)
result_image = Image.alpha_composite(pil_src, pil_tmp)
#Convertir au format OpenCV
return cv2.cvtColor(np.asarray(result_image), cv2.COLOR_RGBA2BGRA)
def main():
#Une variable qui stocke les coordonnées du coin supérieur gauche de la reconnaissance faciale
x = 0
y = 0
#Variable qui stocke la largeur et la hauteur du visage
w = 0
h = 0
while True:
#Charger 1 image depuis VideoCapture
ret, frame = cap.read()
#Convertir le cadre en format gris pour la reconnaissance faciale
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
face = face_cascade.detectMultiScale(gray, 1.3, 5)
#Si le visage est reconnu x, y, w,mettre à jour h
if face != ():
(x, y, w, h) = face[0]
#Si la variable est différente de la valeur initiale, l'image est combinée avec le cadre
if w != 0:
frame = overlayImage(frame, cv2_img, (x, y), (w, h))
#Afficher le cadre traité
cv2.imshow('Frame', frame)
#Attendez 1 ms pour l'entrée de la touche et interrompez lorsque vous appuyez sur ESC
k = cv2.waitKey(1)
if k == 27:
break
#Relâchez la capture et fermez la fenêtre
cap.release()
cv2.destroyAllWindows()
if __name__ == '__main__':
main()
#Importation OpenCV
import cv2
import numpy as np
from PIL import Image
#Paramètres de résolution de la caméra
WIDTH = 1920
HEIGHT = 1080
#Spécifier l'image à lire
img = "vtuber_may.jpg "
cv2_img = cv2.imread(img, cv2.IMREAD_UNCHANGED)
#Désignation du modèle de reconnaissance faciale
face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_alt2.xml')
#Vous pouvez sélectionner la caméra avec l'argument.
cap = cv2.VideoCapture(0)
cap.set(cv2.CAP_PROP_FRAME_WIDTH, WIDTH)
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, HEIGHT)
def overlayImage(src, overlay, location, size):
overlay_height, overlay_width = overlay.shape[:2]
#Convertir les images de la webcam au format PIL
src = cv2.cvtColor(src, cv2.COLOR_BGR2RGB)
pil_src = Image.fromarray(src)
pil_src = pil_src.convert('RGBA')
#Convertissez l'image que vous souhaitez combiner au format PIL
overlay = cv2.cvtColor(overlay, cv2.COLOR_BGRA2RGBA)
pil_overlay = Image.fromarray(overlay)
pil_overlay = pil_overlay.convert('RGBA')
#Redimensionner pour s'adapter à la taille de votre visage
pil_overlay = pil_overlay.resize(size)
#Combiner des images
pil_tmp = Image.new('RGBA', pil_src.size, (255, 255, 255, 0))
pil_tmp.paste(pil_overlay, location, pil_overlay)
result_image = Image.alpha_composite(pil_src, pil_tmp)
#Convertir au format OpenCV
return cv2.cvtColor(np.asarray(result_image), cv2.COLOR_RGBA2BGRA)
def main():
#Une variable qui stocke les coordonnées du coin supérieur gauche de la reconnaissance faciale
x = 0
y = 0
#Variable qui stocke la largeur et la hauteur du visage
w = 0
h = 0
while True:
#Charger 1 image depuis VideoCapture
ret, frame = cap.read()
#Convertir le cadre en format gris pour la reconnaissance faciale
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
face = face_cascade.detectMultiScale(gray, 1.3, 5)
#Si le visage est reconnu x, y, w,mettre à jour h
if face != ():
(x, y, w, h) = face[0]
#Si la variable est différente de la valeur initiale, l'image est combinée avec le cadre
if w != 0:
frame = overlayImage(frame, cv2_img, (x, y), (w, h))
#Afficher le cadre traité
cv2.imshow('Frame', frame)
#Attendez 1 ms pour l'entrée de la touche et interrompez lorsque vous appuyez sur ESC
k = cv2.waitKey(1)
if k == 27:
break
#Relâchez la capture et fermez la fenêtre
cap.release()
cv2.destroyAllWindows()
if __name__ == '__main__':
main()
Tout ce que vous avez à faire est de charger l'image de la caméra Web affichée par ce programme dans OBS Studio et de la sortir en tant que caméra virtuelle avec virtualcam. Je ne vais pas l'expliquer ici, mais veuillez consulter ce site, etc. et le configurer.
Comment utiliser VirtualCam pour reconnaître OBS en tant que caméra virtuelle https://loumo.jp/archives/24912
Il ressemble à ceci lorsqu'il est utilisé avec Zoom. Vous pouvez masquer votre visage ringard avec une icône Twitter et organiser une réunion.
Saigo ni
J'ai posté le code petit à petit avec l'intention d'expliquer davantage le code, mais la plupart des explications ont été écrites dans les commentaires, et je n'ai écrit que l'emplacement du classificateur en cascade d'opencv à l'exception des commentaires. De plus, je suis accro à Shisaki Sion-chan du vtuber de Holo Live récemment, alors jetez un œil.
Recommended Posts