OpenCV - Python Real play (14) - face detection details (six lignes de code seulement pour apprendre 4 méthodes de détection de visage)

0. Préface

Le traitement des visages est un sujet brûlant dans l'intelligence artificielle,Le traitement des visages permet d'extraire automatiquement de grandes quantités d'informations des visages à l'aide d'algorithmes de vision par ordinateur, Par exemple, identité 、 Intentions et émotions . Le visage joue un rôle important dans la communication visuelle ,C'est parce que le visage humain contient beaucoup d'informations non verbales,Le traitement Facial a donc toujours été un sujet très intéressant pour les apprenants en vision informatique, Parce qu'il couvre différents domaines d'expertise ,Par exemple, détection d'objets、 Détection des points caractéristiques et suivi des objets, etc. .Dans cet article, La bibliothèque commune de traitement des visages sera d'abord introduite ,Ensuite, expliquez comment utiliser ces bibliothèques pour la détection des visages, Jeter les bases d'un traitement ultérieur .

1. Introduction au traitement Facial

Pour se concentrer sur les sujets liés au traitement des visages ,Nous utiliserons OpenCV Bibliothèque,Et dlib、face_recognition Et cvlib Attendez. Python Sac.En même temps,Cet article utilisera différentes méthodes de traitement des visages,Pour introduire différentes façons de résoudre des tâches spécifiques de traitement des visages,L'introduction de différentes méthodes vous aidera à choisir différentes méthodes en fonction des différents besoins d'application.La figure suivante montre les sujets liés au traitement des visages, Et disponible Python Sac：

Comme le montre la figure ci - dessus, Le traitement Facial comprend principalement les sujets suivants: ：

• Détection faciale： Un cas particulier de détection d'objets ,Sa tâche est de trouver la position et la taille de tous les visages dans l'image.
• Détection des points caractéristiques du visage ： Un cas particulier de détection des points caractéristiques ,Sa mission est de localiser les principaux points caractéristiques du visage.
• Suivi des visages： Un cas particulier de suivi des objets ,Sa mission est d'exploiter les informations supplémentaires extraites dans les images successives de la vidéo,Trouvez l'emplacement et la taille de tous les visages mobiles dans la vidéo.
• Reconnaissance faciale： Un cas particulier de reconnaissance des cibles ,Sa mission est d'identifier ou de valider une personne à partir d'une image ou d'une vidéo à l'aide d'informations extraites d'un visage humain：
  • Reconnaissance faciale (1:N)：Trouver la correspondance la plus proche du visage détecté dans la collection de visages connus
  • Vérification faciale (1:1)：Vérifiez si le visage humain détecté est celui qu'il prétend être

Comme indiqué ci - dessus, Le traitement Facial comprend principalement: ：Détection faciale、 Détection des points caractéristiques du visage 、 Suivi des visages Et Reconnaissance faciale, Cet article se concentre principalement sur l'utilisation OpenCV、dlib、face_recognition Et cvlib Détection des visages par bibliothèque ,D'autres sujets de traitement Facial seront abordés dans les séries suivantes.

2. Installer des bibliothèques liées au traitement des visages

2.1 Installation dlib

Dlib Est une vision informatique 、 L'apprentissage automatique et l'apprentissage profond C++ Bibliothèque de logiciels,On peut aussi Python Utilisé dans les applications,Installation dlib, Les commandes suivantes sont nécessaires: ：

pip install dlib

2.2 Installation face_recognition

face_recognition Est un puissant、Simple.、 Un projet Open source facile à utiliser pour la reconnaissance faciale ,Pour Python Utilisé dans face_recognition Bibliothèque, Utilisez la commande suivante pour installer ：

pip install face_recognition

2.3 Installation cvlib

cvlib Un niveau avancé 、Facile à utiliser、Open Source Python Bibliothèque de vision informatique,À installer cvlib Sac, Vous devez d'abord installer les bibliothèques de dépendances suivantes ：numpy、opencv-python、requests、progressbar、pillow、tensorflow Et keras.
Et puis,Réinstallation cvlib Sac：

pip install cvlib

3. Détection faciale

La détection des visages est la tâche de déterminer la position et la taille des visages dans une image, Habituellement, construire une application de traitement facial (Par exemple,Reconnaissance de l'expression、 Test de somnolence 、 Ventilation par sexe 、 Reconnaissance faciale ou interaction homme - ordinateur, etc. )Base,Ceci est dû au fait que de telles applications exigent que la position et la taille des visages détectés soient utilisées comme entrée.Donc,,La détection automatique des visages joue un rôle crucial,Est l'un des sujets les plus étudiés dans le domaine de l'intelligence artificielle.
La détection faciale n'est pas difficile pour les humains ,Mais les ordinateurs sont souvent confrontés à de nombreux défis( Par exemple, changement d'apparence 、 Transformation de l'échelle 、Rotation、 Changement d'expression faciale 、 Conditions d'occlusion ou d'éclairage, etc. ).Dans cette section,Nous utiliserons OpenCV、dlib Et face_processing Technologie populaire de détection des visages ( Comprend l'apprentissage automatique et les méthodes d'apprentissage profond ) Détecter les visages dans les images .

3.1 Utiliser OpenCV Effectuer une détection faciale

OpenCV Deux méthodes de détection des visages sont fournies ,Y compris:：

• Basé sur Haar Détecteur de visage en cascade
• Détecteur Facial basé sur l'apprentissage profond

3.1.1 Basé sur Haar Détecteur de visage en cascade

OpenCV Disponible dans Viola Et Jones Un algorithme de détection faciale basé sur un cadre de détection d'objets est proposé.En outre,Le cadre de détection d'objets peut également être utilisé pour détecter d'autres objets,Par exemple： Numéro de plaque d'immatriculation ou visage de chat, etc. .Dans cette section, Nous utiliserons ce cadre pour détecter les visages .
OpenCV Offre 4 Classificateur en cascade pour la détection des visages ,Peut être obtenu à partir deOpenCV Officiellement Télécharger ces fichiers Classificateurs en cascade ：

• haarcascade_frontalface_alt.xml (FA1)
• haarcascade_frontalface_alt2.xml (FA2)
• haarcascade_frontalface_alt_tree.xml (FAT)
• haarcascade_frontalface_default.xml (FD)

La performance de ces Classificateurs en cascade peut être évaluée à l'aide de différents ensembles de données,Dans l'ensemble, ces classificateurs ont une précision similaire,Donc,, Ensuite, pour simplifier la procédure, , Nous n'en utilisons que deux. (Plus précisément,, Charger uniquement les Classificateurs en cascade FA2 Et FD),Vous pouvez également choisir d'autres classificateurs intéressés pour tester leurs performances.
OpenCV Offrecv2.CascadeClassifier() Fonction utilisée pour charger un classificateur à partir d'un fichier ：

# Chargement des Classificateurs en cascade 
# Première ligne de code pour la première méthode 
cas_alt2 = cv2.CascadeClassifier("haarcascade_frontalface_alt2.xml")
cas_default = cv2.CascadeClassifier("haarcascade_frontalface_default.xml")

Et puis...,On peut l'utiliser. cv2.CascadeClassifier.detectMultiScale() La fonction effectue la détection ：

# Deuxième ligne de code pour la première méthode 
# Ceci complète l'introduction de la première méthode
faces_alt2 = cas_alt2.detectMultiScale(gray)
faces_default = cas_default.detectMultiScale(gray)

cv2.CascadeClassifier.detectMultiScale() La fonction détecte les objets et les renvoie sous forme de liste rectangulaire. Pour la visualisation ,Écrivez enfin show_detection() Fonction de visualisation ：

def show_detection(image, faces):
"""Dessinez un rectangle sur chaque visage détecté pour l'identifier"""
for (x, y, w, h) in faces:
cv2.rectangle(image, (x, y), (x + w, y + h), (255, 0, 0), 5)
return image
# Appelez show_detection() Fonction indiquant le visage détecté 
img_faces_alt2 = show_detection(img.copy(), faces_alt2)
img_faces_default = show_detection(img.copy(), faces_default)

Qu'est - ce que, Deux lignes de code me tracassent. ,Il est temps d'appeler le détecteur avec une ligne et de détecter le visage humain,C'est ça. OpenCV Fourni cv2.face.getFacesHAAR() Fonctions：

# La mise en œuvre d'une ligne de code est basée sur Haar Détecteur de visage en cascade, Un pour un. 
retval, faces_haar_alt2 = cv2.face.getFacesHAAR(img, "haarcascade_frontalface_alt2.xml")
retval, faces_haar_default = cv2.face.getFacesHAAR(img, "haarcascade_frontalface_default.xml")

cv2.CascadeClassifier.detectMultiScale() Nécessite une image en niveaux de gris comme entrée ,Et cv2.face.getFacesHAAR() Besoin BGR Image comme entrée.En outre, cv2.CascadeClassifier.detectMultiScale() Affiche les visages détectés comme une liste rectangulaire ,Par exemple, Si deux visages sont détectés , La forme de sortie est la suivante: ：

[[809 494 152 152] [168 503 188 188]]

Et cv2.face.getFacesHAAR() La fonction renvoie le visage détecté dans le format suivant：

[[[ 809 493 151 151]] [[ 167 503 189 189]]]

Donc,,Si vous utilisez cv2.face.getFacesHAAR() Fonction de détection, Appelé lors du dessin de la boîte de détection np.squeeze() Fonction pour éliminer les dimensions redondantes ：

faces_haar_alt2 = np.squeeze(faces_haar_alt2)
faces_haar_default = np.squeeze(faces_haar_default)

Images chargées à partir de ,Le code complet pour la détection et la peinture des visages est le suivant：

# Fonctions de visualisation
def show_img_with_matplotlib(color_img, title, pos):
img_RGB = color_img[:, :, ::-1]
ax = plt.subplot(2, 2, pos)
plt.imshow(img_RGB)
plt.title(title, fontsize=8)
plt.axis('off')
# Charger l'image
img = cv2.imread("test_face_detection.jpg")
# Oui. BGR Image convertie en image grise
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# Charger le classificateur 
cas_alt2 = cv2.CascadeClassifier("haarcascade_frontalface_alt2.xml")
cas_default = cv2.CascadeClassifier("haarcascade_frontalface_default.xml")
# Détection des visages
faces_alt2 = cas_alt2.detectMultiScale(gray)
faces_default = cas_default.detectMultiScale(gray)
retval, faces_haar_alt2 = cv2.face.getFacesHAAR(img, "haarcascade_frontalface_alt2.xml")
faces_haar_alt2 = np.squeeze(faces_haar_alt2)
retval, faces_haar_default = cv2.face.getFacesHAAR(img, "haarcascade_frontalface_default.xml")
faces_haar_default = np.squeeze(faces_haar_default)
# Dessiner une boîte de détection de visage 
img_faces_alt2 = show_detection(img.copy(), faces_alt2)
img_faces_default = show_detection(img.copy(), faces_default)
img_faces_haar_alt2 = show_detection(img.copy(), faces_haar_alt2)
img_faces_haar_default = show_detection(img.copy(), faces_haar_default)
# Visualisation
show_img_with_matplotlib(img_faces_alt2, "detectMultiScale(frontalface_alt2): " + str(len(faces_alt2)), 1)
show_img_with_matplotlib(img_faces_default, "detectMultiScale(frontalface_default): " + str(len(faces_default)), 2)
show_img_with_matplotlib(img_faces_haar_alt2, "getFacesHAAR(frontalface_alt2): " + str(len(faces_haar_alt2)), 3)
show_img_with_matplotlib(img_faces_haar_default, "getFacesHAAR(frontalface_default): " + str(len(faces_haar_default)), 4)
plt.show()

La sortie du programme est illustrée dans la figure ci - dessous. ：

Comme le montre la figure ci - dessus, Par l'utilisation de haar Différents Classificateurs en cascade de caractéristiques détectent des visages différents.Enfin, Il faut aussi préciser que ,cv2.CascadeClassifier.detectMultiScale() La fonction a minSize Et maxSize Paramètres, Utilisé pour définir la taille minimale (Moins de minSize Les objets ne seront pas détectés ) Et taille maximale (Plus grand que maxSize L'objet pour ne pas être détecté ),Et cv2.face.getFacesHAAR() La fonction ne fournit pas ce paramètre .

3.1.2 Détecteur Facial basé sur l'apprentissage profond

À l'exception de la base Haar Détecteur de visage en cascade ,OpenCV OffreDétecteur Facial basé sur l'apprentissage profond,OpenCV Réseau neuronal profond (Deep Neural Networks, DNN) Le détecteur de visage est basé sur l'utilisation ResNet-10 Le réseau Single Shot MultiBox Detector (SSD) Cadre.
OpenCV Moyenne DNN Module, Utiliser un cadre d'apprentissage profond populaire (Par exemple Caffe、TensorFlow、Torch Et Darknet )Calcul vers l'avant grâce à un réseau de profondeur pré - formé( C'est - à - dire la phase de raisonnement ).Cela signifie que nous pouvons effectuer des calculs avancés complets à l'aide d'un réseau pré - formé et utiliser la sortie pour faire des prédictions dans nos applications, Sans passer des heures à former le réseau .
Et puis...,Notre modèle de détecteur de visage d'apprentissage profond pré - formé effectue la détection de visage, Utiliser les deux modèles suivants ：

• Détecteur de visage (FP16)：Caffe Points flottants mis en œuvre 16 Version, Pour utiliser ce détecteur , Télécharger d'abord le fichier modèle (deploy.prototxt)Et les profils(res10_300x300_ssd_iter_140000_fp16.caffemodel);
• Détecteur de visage (UINT8)：TensorFlow Réalisé 8 Version de quantification des bits , Pour utiliser ce détecteur , Télécharger d'abord le fichier modèle (opencv_face_detector.pbtxt)Et les profils(opencv_face_detector_uint8.pb).

.Ensuite, comment utiliser le modèle de détecteur de visage d'apprentissage profond pré - formé pour détecter les visages,La première étape consiste également à charger le modèle de pré - formation：

# Chargement des modèles pré - formés, Caffe Version mise en œuvre
net = cv2.dnn.readNetFromCaffe("deploy.prototxt", "res10_300x300_ssd_iter_140000_fp16.caffemodel")
# Chargement des modèles pré - formés, Tensorflow Version mise en œuvre
# net = cv2.dnn.readNetFromTensorflow("opencv_face_detector_uint8.pb", "opencv_face_detector.pbtxt")

Pour une précision optimale , Doit être séparé en bleu 、 Exécution des canaux verts et rouges (104, 177, 123) Soustraction moyenne des canaux , Et ajuster l'image à 300 x 300 De BGR Images,In OpenCV En utilisant cv2.dnn.blobFromImage() La fonction effectue ce prétraitement ：

blob = cv2.dnn.blobFromImage(image, 1.0, (300, 300), [104., 117., 123.], False, False)

L'étape suivante est de blob Définir comme entrée pour obtenir des résultats ,Effectuer un calcul vers l'avant sur l'ensemble du Réseau pour calculer la sortie：

# Oui. blob Définir comme entrée et obtenir les résultats des tests 
net.setInput(blob)
detections = net.forward()

La dernière étape consiste à détecter itérativement et à tracer les résultats. ,Ne visualisez le niveau de confiance correspondant que s'il est supérieur au seuil minimal：

# Itérer tous les résultats des essais 
for i in range(0, detections.shape[2]):
# Obtenir la confiance des résultats de détection actuels 
confidence = detections[0, 0, i, 2]
# Si la confiance est supérieure à la confiance minimale , Puis visualisez - le 
if confidence > 0.7:
detected_faces += 1
# Obtenir les coordonnées des résultats de détection actuels 
box = detections[0, 0, i, 3:7] * np.array([w, h, w, h])
(startX, startY, endX, endY) = box.astype('int')
# Tracer les résultats des essais et la confiance 
text = "{:.3f}%".format(confidence * 100)
y = startY -10 if startY - 10 > 10 else startY + 10
cv2.rectangle(image, (startX, startY), (endX, endY), (255, 0, 0), 3)
cv2.putText(image, text, (startX, y), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 0, 255), 2)
# Visualisation
show_img_with_matplotlib(image, "DNN face detector: " + str(detected_faces), 1)
plt.show()

.Les résultats de détection du détecteur Facial basé sur l'apprentissage profond sont présentés ci - dessous：

Comme le montre la figure ci - dessus,,.Les trois visages frontaux peuvent être détectés avec une grande confiance par deux modèles d'apprentissage profond.

3.2 Utiliser dlib Effectuer une détection faciale

3.2.1 Basé sur HOG Détecteur de visage pour les caractéristiques et les fenêtres coulissantes

In dlib L'histogramme basé sur le gradient de direction est fourni dans (Histogram of Oriented Gradients, HOG) Classificateur linéaire dans les méthodes de détection des caractéristiques et des fenêtres coulissantes, Utilisation de structures SVM Algorithme de formation pour la détection des visages ,Le classificateur peut s'entraîner dans toutes les sous - fenêtres de chaque image d'entraînement,Le détecteur de visage de cette personne utilise des visages marqués de l'extérieur (Labeled Faces in the Wild, LFW) De l'ensemble de données 3,000 Les images ont été formées .
Si nécessaire dlib Basé sur HOG Les caractéristiques et les fenêtres coulissantes détectent les visages, La première étape est de dlib Charger le détecteur de visage ：

# Charger le détecteur de visage 
# Première ligne de code pour la deuxième méthode 
detector = dlib.get_frontal_face_detector()
# Charger l'image et la convertir en image grise
img = cv2.imread('example.png')
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

L'étape suivante consiste à effectuer un test ：

# Effectuer des tests
# Deuxième ligne de code pour la deuxième méthode , La deuxième méthode est terminée. 
rects_1 = detector(gray, 0)
rects_2 = detector(gray, 1)

detector() Le deuxième paramètre de indique le nombre de fois qu'une image a été échantillonnée avant l'exécution du processus de détection,Parce que plus l'image est grande, plus le détecteur est susceptible de détecter plus de visages, Mais le temps d'exécution augmente en conséquence .
Visualisation finale des résultats des essais ：

def show_detection(image, faces):
for face in faces:
cv2.rectangle(image, (face.left(), face.top()), (face.right(), face.bottom()), (255, 255, 0), 5)
return image
# Dessiner la boîte de détection 
img_faces_2 = show_detection(img.copy(), rects_2)
img_faces_2 = show_detection(img.copy(), rects_2)
# Dessiner une image
show_img_with_matplotlib(img_faces_1, "detector(gray, 0): " + str(len(rects_1)), 1)
show_img_with_matplotlib(img_faces_2, "detector(gray, 1): " + str(len(rects_2)), 2)
plt.show()

Comme le montre la figure ci - dessus, Si vous utilisez l'image grise originale (rects_1 = detection(gray, 0)) Détection des visages, On ne trouve que trois visages. .Mais, Si nous utilisons l'échantillonnage 1 Image en niveaux de gris de (rects_2 = detection(gray, 1)) Détection des visages, Quatre visages peuvent être détectés correctement .
Ce qui est remarquable, c'est que,Le détecteur peut également être utilisé pour détecter des cibles autres que les visages.Peut être visualisé en dlib Dans la bibliothèque train_object_detector.py Code source,.Apprenez comment former un détecteur d'objets personnalisé avec seulement quelques images d'entraînement.Par exemple,Il n'est possible d'utiliser que dix images de signaux de circulation pour former d'excellents détecteurs de signaux de circulation.

3.2.2 Basé sur CNN Le détecteur de visage de

dlib La Bibliothèque fournit également CNN Détecteur de visage ,Peut être utilisé dlib.cnn_face_detection_model_v1() Création CNN Détecteur de visage . dlib.cnn_face_detection_model_v1() Fonction pour charger le modèle de détection faciale à partir du fichier entrant, Donc, tout d'abord, Télécharger le modèle de pré - Formation.Création CNN Lors du détecteur de visage ,Passez le modèle de pré - formation téléchargé à cette méthode：

cnn_face_detector = dlib.cnn_face_detection_model_v1("mmod_human_face_detector.dat")

Après, Nous utilisons ce détecteur pour détecter les visages ：

rects = cnn_face_detector(img, 0)

Retour du détecteur mmod_rectangles Objet,C'est un mmod_rectangle Liste des objets,Et mmod_rectangle L'objet a deux variables membres —— dlib.rectangle Score de confiance de l'objet et de la prévision , Pour afficher les résultats des tests ,Compilation show_detection() Fonctions：

def show_detection(image, faces):
"""Utilisez un cadre de détection rectangulaire pour identifier explicitement chaque visage détecté"""
for face in faces:
cv2.rectangle(image, (face.rect.left(), face.rect.top()), (face.rect.right(), face.rect.bottom()), (255, 255, 0), 5)
return image
# Dessiner la boîte de détection 
img_faces = show_detection(img.copy(), rects)
# Visualisation
show_img_with_matplotlib(img_faces, "cnn_face_detector(img, 0): " + str(len(rects)), 1)
plt.show()

dlib-CNN Rapport du détecteur facial dlib-HOG Le détecteur Facial est beaucoup plus précis , Mais il faut plus de calcul pour fonctionner .Par exemple,Pour 600 x 400 Images de,HOG Le détecteur de visage nécessite environ 0.25 Secondes,Et CNN Le détecteur de visage a besoin d'environ 5 Secondes.Donc,,Pour accélérer CNN Vitesse d'exécution du détecteur facial , Peut être réalisé en GPU Activé sur l'ordinateur pour CUDA Pour atteindre une vitesse raisonnable , Mais vous devez compiler et installer à partir du code source dlib.

3.3 Utiliser face_recognition Effectuer une détection faciale

Utiliser face_recognition Détection des visages, Appel seulement face_locations() Fonctions：

# La troisième méthode nécessite et ne nécessite qu'une seule ligne de code
rects_1 = face_recognition.face_locations(rgb, 0, "hog")
rects_2 = face_recognition.face_locations(rgb, 1, "hog")

face_locations() Le premier paramètre de est l'image d'entrée (RGB);Le deuxième paramètre définit le nombre de fois que l'image d'entrée est échantillonnée avant d'effectuer la détection;Le troisième paramètre est le modèle de détection faciale à utiliser.
L'exemple ci - dessus utilise hog Modèle de détection,En outre face_locations() Peut également être configuré pour utiliser cnn Le détecteur de visage détecte le visage ：

# Utiliser cnn Le détecteur de visage détecte le visage 
rects_1 = face_recognition.face_locations(rgb, 0, "cnn")
rects_2 = face_recognition.face_locations(rgb, 1, "cnn")

Visualisation finale des résultats des essais ：

def show_detection(image, faces):
for face in faces:
top, right, bottom, left = face
cv2.rectangle(image, (left, top), (right, bottom), (255, 255, 0), 10)
return image
# Afficher les résultats des tests
img_faces_1 = show_detection(img.copy(), rects_1)
img_faces_2 = show_detection(img.copy(), rects_2)
show_img_with_matplotlib(img_faces_1, "face_locations(rgb, 0, hog): " + str(len(rects_1)), 1)
show_img_with_matplotlib(img_faces_2, "face_locations(rgb, 1, hog): " + str(len(rects_2)), 2)
plt.show()

3.4 Utiliser cvlib Effectuer une détection faciale

Enfin, nous vous présentons cvlib Algorithme de détection des visages dans les paquets .cvlib Disponible en detect_face() Fonction de détection du visage ,Au rez - de - chaussée.,Cette fonction utilise OpenCV DNN Détecteur facial et pré - formé Caffe Modèle,La fonction renvoie la boîte de délimitation et le degré de confiance correspondant pour tous les visages détectés：

import cvlib as cv
# La quatrième méthode nécessite également et seulement une ligne de code
faces, confidences = cv.detect_face(image)
# Dessiner une boîte de délimitation 
def show_detection(image, faces):
for (startX, startY, endX, endY) in faces:
cv2.rectangle(image, (startX, startY), (endX, endY), (255, 0, 0), 3)
return image
# Visualisation
img_result = show_detection(img.copy(), faces)
show_img_with_matplotlib(img_result, "cvlib face detector: " + str(len(faces)), 1)
plt.show()

Résumé

Dans cet article, nous présentons les principaux thèmes du traitement Facial, L'installation de bibliothèques connexes est également introduite. , Et introduit l'utilisation OpenCV、dlib、face_recognition Et cvlib Méthodes de détection des visages , Dans les séries suivantes ,Nous apprendrons tous les sujets de traitement facial, y compris la reconnaissance faciale.

Liens de série

OpenCV-PythonSur le terrain（1）——OpenCVIntroduction et base du traitement d'images
OpenCV-PythonSur le terrain（2）——Traitement des images et des fichiers vidéo
OpenCV-PythonSur le terrain（3）——OpenCVDessiner des graphiques et du texte
OpenCV-PythonSur le terrain（4）——OpenCVTechniques courantes de traitement d'images
OpenCV-PythonSur le terrain（5）——OpenCVOpérations d'image
OpenCV-PythonSur le terrain（6）——OpenCVEspace de couleur et cartographie des couleurs dans
OpenCV-PythonSur le terrain（7）——Détails de l'histogramme
OpenCV-PythonSur le terrain（8）——égalisation des histogrammes
OpenCV-PythonSur le terrain（9）——OpenCVTechniques de seuil pour la segmentation des images
OpenCV-PythonSur le terrain（10）——OpenCVDétection de contour
OpenCV-PythonSur le terrain（11）——OpenCVApplications liées à la détection des contours
OpenCV-PythonSur le terrain（12）——Un article détailléARRéalité augmentée
OpenCV-PythonSur le terrain（13）——OpenCVCollision avec l'apprentissage de la machine