Lors de la résolution de problèmes de vision par ordinateur, vous ne pouvez pas vous passer de l'utilisation de logiciels spécialisés. Je veux vous présenter ceci - OpenCV - une bibliothèque open source en C ++. Dispose d'un ensemble d'outils pour la numérisation d'images, le traitement ultérieur via des algorithmes numériques ou un réseau de neurones.

Algorithmes de traitement d'image de base: interprétation d'image, étalonnage de la caméra par rapport à un standard, élimination des distorsions optiques, détection de similitude, analyse du mouvement des objets, détermination de la forme des objets et suivi des objets, reconstruction 3D, segmentation des objets, reconnaissance des gestes.

Vous pouvez télécharger la bibliothèque sur le site officiel http://sourceforge.net/projects/opencvlibrary/

Structure de la bibliothèque OpenCV

cxcore - noyau
* contient des structures de données et des algorithmes de base:
- opérations de base sur des tableaux numériques multidimensionnels
- algèbre matricielle, fonctions mathématiques, générateurs de nombres aléatoires
- Ecriture / restauration de structures de données vers / depuis XML
- les fonctions de base Graphiques 2D

CV - module de traitement d'image et de vision par ordinateur
- opérations de base sur les images (filtrage, transformations géométriques, transformation des espaces couleurs, etc.)
- analyse d'image (sélection de traits distinctifs, morphologie, recherche de contours, histogrammes)
- analyse de mouvement, suivi d'objets
- détection d'objets, en particulier de visages
- calibrage de la caméra, éléments de restauration de la structure spatiale

Highgui - un module pour l'entrée / sortie d'image et vidéo, création d'interface utilisateur
- capturer des vidéos à partir de caméras et de fichiers vidéo, lire / écrire des images statiques.
- fonctions d'organisation d'une interface utilisateur simple (toutes les applications de démonstration utilisent HighGUI)

Cvaux - Fonctionnalités expérimentales et obsolètes
- les espaces. vision: étalonnage stéréo, auto étalonnage
- recherche de correspondance stéréo, clics dans les graphiques
- trouver et décrire les traits du visage

CvCam - capture vidéo
- vous permet de capturer des vidéos à partir de caméras vidéo numériques (le support est interrompu et dans les versions récentes, ce module est manquant)

Installer OpenCV sur Linux

Après le téléchargement dernière version OpenCV à partir du site du développeur http://sourceforge.net/projects/opencvlibrary/, vous devez décompresser l'archive et construire via CMake version 2.6 ou supérieure.

L'installation de CMake est standard:

Sudo apt-get install cmake

Pour afficher les fenêtres OpenCV, vous devez installer les bibliothèques GTK + 2.x et libgtk2.0-dev

Apt-get install libgtk2.0-dev

Construire la bibliothèque:

Tar -xjf OpenCV-2.2.0.tar.bz2 cd OpenCV-2.2.0 cmake -D CMAKE_BUILD_TYPE \u003d RELEASE -D CMAKE_INSTALL_PREFIX \u003d / usr / local ./ make make install

Pour tester la bibliothèque installée, vous pouvez créer des exemples et exécuter quelque chose:

Exemples de CD / c / chmod + x build_all.sh ./build_all.sh ./delaunay

Si au lieu d'une image de test, vous voyez l'erreur "erreur lors du chargement des bibliothèques partagées: libopencv_core.so.2.2: impossible d'ouvrir le fichier objet partagé: aucun fichier ou répertoire de ce type", cela signifie que le programme ne peut pas trouver les bibliothèques. Vous devez spécifier explicitement le chemin d'accès à eux:

$ export LD_LIBRARY_PATH \u003d / usr / local / lib: $ LD_LIBRARY_PATH

Si après cela encore l'erreur:
Erreur OpenCV: erreur non spécifiée (la fonction n'est pas implémentée. Reconstruisez la bibliothèque avec le support Windows, GTK + 2.x ou Carbon. Si vous êtes sur Ubuntu ou Debian, installez libgtk2.0-dev et pkg-config, puis relancez cmake ou configurez le script) dans cvNamedWindow, fichier /usr/src/OpenCV-2.2.0/modules/highgui/src/window.cpp, la ligne 274 se termine appelée après avoir lancé une instance de "cv :: Exception" what (): / usr /src/OpenCV-2.2.0/modules/highgui/src/window.cpp:274: erreur: (-2) La fonction n'est pas implémentée. Reconstruisez la bibliothèque avec le support Windows, GTK + 2.x ou Carbon. Si vous êtes sur Ubuntu ou Debian, installez libgtk2.0-dev et pkg-config, puis réexécutez cmake ou configurez le script dans la fonction cvNamedWindow
Vous avez donc oublié d'installer GTK + 2.x: libgtk2.0-dev. Exécutez l'installation (voir ci-dessus).

Lorsque l'installation est terminée, les fichiers d'en-tête seront disponibles dans le répertoire / usr / local / include / opencv, et les fichiers de bibliothèque se trouvent dans / usr / local / lib

Construisons un programme avec OpenCV:

test.cpp

// // pour tester // // robocraft.ru // #include #comprendre #comprendre #comprendre int main (int argc, char * argv) (IplImage * image \u003d 0, * dst \u003d 0; // nom de l'image char filename \u003d "Image0.jpg"; // obtenir l'image image \u003d cvLoadImage (filename, 1); printf ( "[i] image:% s \\ n", filename); assert (image! \u003d 0); // afficher l'image cvNamedWindow ("image"); cvShowImage ("image", image); // attendre la touche appuyez sur cvWaitKey ( 0); // ressources libres cvReleaseImage (& image); cvReleaseImage (& dst); // supprimer les fenêtres cvDestroyAllWindows (); return 0;)

Makefile

CC: \u003d g ++ CFLAGS: \u003d -I / usr / local / include / opencv -L / usr / local / lib OBJETS: \u003d BIBLIOTHEQUES: \u003d -lopencv_core -lopencv_imgproc -lopencv_highgui .PHONY: tout nettoyer: test test: $ (CC ) $ (CFLAGS) -o test test.cpp $ (BIBLIOTHEQUES) clean: rm -f * .o

Lancement de la construction avec la commande make.

Bonjour le monde!

OpenCV est installé et prêt à fonctionner. Écrivons notre première application Hello World!

#comprendre #comprendre int main (int argc, char ** argv) (// définit la hauteur et la largeur de l'image int height \u003d 620; int width \u003d 440; // définit le point d'affichage du texte CvPoint pt \u003d cvPoint (height / 4, width / 2); // Créer une image 8 bits, 3 canaux IplImage * hw \u003d cvCreateImage (cvSize (height, width), 8, 3); // remplir l'image avec cvSet noir (hw, cvScalar (0,0,0)); / / initialisation de la police CvFont font; cvInitFont (& font, CV_FONT_HERSHEY_COMPLEX, 1.0, 1.0, 0, 1, CV_AA); // en utilisant la police nous affichons le texte sur l'image cvPutText (hw, "OpenCV Step By Step", pt, & font, CV_RGB (150, 0, 150)); // créer une fenêtre cvNamedWindow ("Hello World", 0); // afficher une image dans la fenêtre créée cvShowImage ("Hello World", hw); // attendre la touche presser cvWaitKey (0); // relâcher ressources cvReleaseImage (& hw); cvDestroyWindow ("Hello World"); return 0;)

Chargement d'une image

Cet exemple sera la base de tous vos programmes OpenCV. Nous chargerons l'image du fichier Image0.jpg dans l'environnement.

#comprendre #comprendre #comprendre #comprendre IplImage * image \u003d 0; IplImage * src \u003d 0; int main (int argc, char * argv) (// le nom de l'image est spécifié par le premier paramètre char * filename \u003d argc \u003d\u003d 2? argv: "Image0.jpg"; // récupère l'image image \u003d cvLoadImage (filename, 1); // cloner l'image src \u003d cvCloneImage (image); printf ("[i] image:% s \\ n", filename); assert (src! \u003d 0); // fenêtre d'affichage de l'image cvNamedWindow ("original", CV_WINDOW_AUTOSIZE); / / afficher l'image cvShowImage ("original", image); // imprimer des informations sur l'image sur la console printf ("[i] canaux:% d \\ n", image-\u003e nChannels); printf ("[i] pixel depth:% d bits \\ n ", image-\u003e profondeur); printf (" [i] largeur:% d pixels \\ n ", image-\u003e largeur); printf (" [i] hauteur:% d pixels \\ n ", image- \u003e hauteur); printf ("[i] taille de l'image:% d octets \\ n", image-\u003e imageSize); printf ("[i] pas de largeur:% d octets \\ n", image-\u003e widthStep); // attendre la touche appuyez sur cvWaitKey (0); // libérer les ressources cvReleaseImage (& image); cvReleaseImage (& src); // supprimer la fenêtre cvDestroyWindow ("original"); return 0;)

Types de formats d'image pris en charge:

• Bitmaps Windows - BMP, DIB
• Fichiers JPEG - JPEG, JPG, JPE
• Graphiques réseau portables - PNG
• Format d'image portable - PBM, PGM, PPM
• Rasters Sun - SR, RAS
• Fichiers TIFF - TIFF, TIF

Pour accéder à l'image, vous pouvez effectuer les appels suivants:

Image-\u003e nChannels // nombre de canaux d'image (RVB, bien qu'en OpenCV - BGR) (1-4) image-\u003e profondeur // profondeur en bits image-\u003e largeur // largeur de l'image en pixels image-\u003e hauteur // hauteur de l'image en pixels image-\u003e imageSize // mémoire occupée par l'image (\u003d\u003d image-\u003e hauteur * image-\u003e widthStep) image-\u003e widthStep // distance entre les points d'image verticalement adjacents (le nombre d'octets dans une ligne de l'image - peut être nécessaire pour l'auto-traversée tous les pixels de l'image)

Télécharger une video

Le chargement d'une vidéo n'est pas beaucoup plus difficile que le chargement d'une image, sauf qu'il y aura une boucle qui boucle à travers les images.
Le délai entre les trames est fixé à 33 millisecondes. cette latence permet de traiter un flux vidéo à une cadence standard de 30 images par seconde.

#comprendre #comprendre #comprendre #comprendre IplImage * frame \u003d 0; int main (int argc, char * argv) (// le nom du fichier est spécifié par le premier paramètre char * filename \u003d argc \u003d\u003d 2? argv: "test.avi"; printf ("[i] file:% s \\ n", filename ); // fenêtre d'affichage de l'image cvNamedWindow ("original", CV_WINDOW_AUTOSIZE); // obtenir des informations sur le fichier vidéo CvCapture * capture \u003d cvCreateFileCapture (filename); while (1) (// obtenir la trame suivante frame \u003d cvQueryFrame (capture) ; if (! frame) (break;) // ici vous pouvez insérer // procédure de traitement // afficher l'image cvShowImage ("original", frame); char c \u003d cvWaitKey (33); if (c \u003d\u003d 27) (// si ESC est pressé, exit break;)) // libère les ressources cvReleaseCapture (& capture); // supprime la fenêtre cvDestroyWindow ("original"); return 0;)

Pour capturer une vidéo à partir d'une caméra, vous devez légèrement modifier le code - au lieu de la fonction cvCreateFileCapture (), cvCreateCameraCapture () sera utilisé. Appuyer sur ESC interrompt la lecture et ferme la fenêtre, et appuyer sur Entrée enregistre l'image actuelle dans fichier jpg.

#comprendre #comprendre #comprendre #comprendre int main (int argc, char * argv) (// obtenir une caméra connectée CvCapture * capture \u003d cvCreateCameraCapture (CV_CAP_ANY); // cvCaptureFromCAM (0); assert (capture); // cvSetCaptureProperty (capture, CV_CAP_PROP_THFRAME) 640 / 1280); // cvSetCaptureProperty (capture, CV_CAP_PROP_FRAME_HEIGHT, 480); // 960); // connaître la largeur et la hauteur du cadre double largeur \u003d cvGetCaptureProperty (capture, CV_CAP_PROP_FRAME_WIDTH); double hauteur \u003d cvGetCaptureProperty (capture, CV_CAP_PROP_FRAME_HEIGHT); printf ("[i]% .0f x% .0f \\ n", largeur, hauteur); IplImage * frame \u003d 0; cvNamedWindow ("capture", CV_WINDOW_AUTOSIZE); printf ("[i] appuyez sur Entrée pour capturer l'image et sur Echap pour quitter! \\ n \\ n"); compteur int \u003d 0; nom de fichier char; while (true) (// récupère le frame frame \u003d cvQueryFrame (capture); // show cvShowImage ("capture", frame); char c \u003d cvWaitKey (33); if (c \u003d\u003d 27) (// ESC pressé break; ) else if (c \u003d\u003d 13) (// Enter // enregistre l'image dans le fichier sprintf (nom de fichier, "Image% d.jpg", compteur); printf ("[i] capture ...% s \\ n", filename); cvSaveImage (filename, frame); counter ++;)) // ressources libres cvReleaseCapture (& capture); cvDestroyWindow ("capture"); return 0; )

OpenCV v1.0 affiche et enregistre une image avec une résolution de caméra minimale de 320x240.

Reconnaissance d'objets par motif

La fonction cvMatchTemplate () est disponible pour la reconnaissance de formes des zones de l'image source. La fonction superpose un modèle d'image à l'image courante et recherche une corrélation entre elles selon l'algorithme sélectionné. La détermination des limites du motif trouvé sur l'image d'origine est effectuée par la fonction cvMinMaxLoc, et pour normaliser l'algorithme de recherche, cvNormalize ().

// // exemple cvMatchTemplate () // comparer l'image avec le modèle // #include #comprendre #comprendre #comprendre IplImage * image \u003d 0; IplImage * templ \u003d 0; int main (int argc, char * argv) (// le nom de l'image est spécifié par le premier paramètre char * filename \u003d argc\u003e \u003d 2? argv: "Image0.jpg"; // récupère l'image image \u003d cvLoadImage (filename, 1); printf ( "[i] image:% s \\ n", filename); assert (image! \u003d 0); // template char * filename2 \u003d argc\u003e \u003d 3? argv: "eye.jpg"; printf ("[i] template :% s \\ n ", filename2); templ \u003d cvLoadImage (filename2,1); assert (templ! \u003d 0); cvNamedWindow (" origianl ", CV_WINDOW_AUTOSIZE); cvNamedWindow (" template ", CV_WINDOW_AUTOSIZE" , CV_WINDOW_AUTOSIZE); cvNamedWindow ("res", CV_WINDOW_AUTOSIZE); // taille du modèle int width \u003d templ-\u003e width; int height \u003d templ-\u003e height; // original et modèle cvShowImage ("origianl", image); cvShowImage (" template ", templ); // image pour stocker le résultat de la comparaison // taille du résultat: si l'image est WxH et templ wxh, alors result \u003d (W-w + 1) x (H-h + 1) IplImage * res \u003d cvCreateImage (cvSize ((image-\u003e largeur-modèle-\u003e largeur + 1), (image-\u003e hauteur-modèle-\u003e hauteur + 1)), IPL_DEPTH_32F, 1); // comparer l'image avec le modèle cvMatchTemplate (image, templ, res, CV_TM_SQDIFF); // montre ce que nous avons cvShowImage ("res", res); // déterminer la meilleure position pour la comparaison // (recherche des minimums et maximums dans l'image) double minval, maxval; CvPoint minloc, maxloc; cvMinMaxLoc (res, & minval, & maxval, & minloc, & maxloc, 0); // normaliser cvNormalize (res, res, 1,0, CV_MINMAX); cvNamedWindow ("norme res", CV_WINDOW_AUTOSIZE); cvShowImage ("norme res", res); // sélectionne la zone avec un rectangle cvRectangle (image, cvPoint (minloc.x, minloc.y), cvPoint (minloc.x + templ-\u003e width-1, minloc.y + templ-\u003e height-1), CV_RGB (255, 0 , 0), 1, 8); // affiche l'image cvShowImage ("Match", image); // attend une touche pressée cvWaitKey (0); // ressources libres cvReleaseImage (& image); cvReleaseImage (& templ); cvReleaseImage (& res); cvDestroyAllWindows (); return 0; )

salut! J'ai été confronté à la tâche de mettre en œuvre la reconnaissance des panneaux routiers à partir d'un flux vidéo. Étant donné que je n’ai jamais rencontré de tâches de ce genre auparavant, le processus de mise en œuvre présuppose à lui seul un long «fumage» préliminaire de forums et une moquerie impitoyable des exemples d’autrui. Par conséquent, j'ai décidé de rassembler tout ce que je lis en un seul endroit pour les générations futures, et aussi, au cours de l'histoire, de poser quelques questions à Habr.

Préludes.

Donc, après avoir étudié tous les outils qui peuvent être utilisés pour accomplir la tâche, je me suis installé sur l'environnement de développement Microsoft Visual Studio © 2010, en utilisant la merveilleuse bibliothèque OpenCV.

Le processus de travail avec OpenCV lui-même implique des danses préliminaires avec un tambourin, sur lesquelles il existe des descriptions assez détaillées:

Le deuxième acte de danse avec un tambourin.

Du coup, je me suis tourné vers les cascades d'entraînement. Ayant fumé dans ce sens, je me suis rendu compte qu'il me fallait deux outils de création d'ampes et de haartraining. Mais je n'avais pas leur exe et j'ai refusé de compiler. À cette époque, la version OpenCV que j'avais était 2.4.4, configurée par logiciel, dans le même article que j'ai lu pour la première fois sur l'utilisation de Cmake lors de l'installation. En conséquence, j'ai décidé de télécharger la version 2.3.1 et de réinstaller la bibliothèque. Après quoi j'ai pu lancer les outils nécessaires via ligne de commande et la question s'est posée de savoir comment travailler avec eux. Tous les points au-dessus des articles en pointillés "et", qui montrent les paramètres avec lesquels vous devez exécuter createampes et haartraining avec une description détaillée de ces paramètres.

Une ardoise propre de code.

Ayant complètement abandonné l'ancienne méthode, le code a été réécrit pour remplacer les cascades entraînées.

Code 2.0

#include "stdafx.h" #include #comprendre #comprendre en utilisant l'espace de noms cv; int main (int argc, char ** argv) (Mat frame, gray; string object_cascade \u003d "haarustupi.xml"; CascadeClassifier haar (object_cascade); VideoCapture cap (0); namedWindow ("Video", 1); vector objets; while (true) (cap \u003e\u003e frame; cvtColor (frame, gray, CV_BGR2GRAY); haar.detectMultiScale (gray, objects, 1.9, 10, 0, Size (50, 50)); for (vecteur :: const_iterator r \u003d objects.begin (); r! \u003d objects.end (); r ++) rectangle (cadre, r-\u003e tl (), r-\u003e br (), scalaire (0, 0, 255)); imshow ("Vidéo", image); if (waitKey (33)\u003e \u003d 0) break; ) retour (EXIT_SUCCESS); )

Nous mettons en place l'environnement de la même manière que dans le projet précédent.

Répétitions Je suis les pères du savoir.

C'est aux «petits» d'entraîner les cascades.)
C'est là que le plaisir commence. Puis j'ai décidé d'écrire sur toutes ces épreuves sur Habr et de demander conseil.
J'ai préparé 500 images de 1600x1200. et une image avec un signe 80x80. Une seule image suffira, car nous détectons un objet spécifique, pas une grande variété de visages.

Donc, après avoir préparé les images et créer le fichier neg.dat avec la structure

Négatif / n (1) .jpg négatif / n (2) .jpg négatif / n (3) .jpg négatif / n (4) .jpg ... négatif / n (500) .jpg

exécutez le fichier opencv_createsamples.exe via CMD avec les paramètres suivants

C: OpenCV2.3.1buildcommonx86opencv_createsamples.exe -vec C: OpenCV2.3.1buildcommonx86positive.vect -bg C: OpenCV2.3.1buildcommonx86neg.dat -img C: OpenCV2.3.1buildcommonx86ustupi.jpg -num 500 -wcolor -bgthresh 0 -show

le paramètre -show montre les images positives générées, mais elles, contrairement à celles indiquées dans d'autres articles
des photos, c'est comme ça

petit

Autrement dit, l'utilitaire coupe l'image bg à la taille de l'image positive. La modification des paramètres -w et -h n'a aucun effet et l'arrière-plan est toujours presque invisible. Si soudainement quelqu'un sait de quoi il s'agit, partagez vos pensées... La taille des images négatives a été réduite à 800x600 - le même résultat.

C: OpenCV2.3.1buildcommonx86opencv_haartraining.exe -data C: OpenCV2.3.1buildcommonx86haarustupi -vec C: OpenCV2.3.1buildcommonx86positive.vect -bg C: OpenCV2.3.1buildcommonx86neg.dat -npos 500 -nneg 6pl 20 -h 24 -mem 1536 -mode ALL -nonsym -minhitrate 0,999 -maxfalsealarm 0,5

après quoi vous recevrez le fichier xml tant attendu qui peut être chargé dans la source programmes.
En conséquence, la cascade apprend légèrement et, avec un grand nombre de faux positifs, réagit à l'image du signe de cession que j'aime.
Mais je ne peux pas obtenir de réponses précises, me semble-t-il, car l'arrière-plan est découpé en images positives. Et les images ne se révèlent pas comme dans les manuels. Mais il y a toujours une option pour augmenter le nombre d'étapes de formation et, après avoir chargé votre ordinateur pour toute la journée, attendez que la cascade soit plus «instruite». C'est ce que j'ai l'intention de faire avant que d'autres idées n'apparaissent.

Épilogue

Ceci est mon premier article HelloHabr. J'attends avec impatience vos commentaires sur le style de présentation. Et bien sûr des conseils sur le sujet.
J'espère qu'après les conseils reçus, il y aura quelque chose pour continuer l'histoire.

L'idée principale est de prendre en compte les relations statistiques entre la localisation des points anthropométriques du visage. Sur chaque image de visage, les points sont numérotés dans le même ordre. La comparaison des faces est effectuée par leur position relative.

Pour comparer des visages, vous pouvez utiliser la même position de visage par rapport à la caméra. Plus préférable pour cela.

Capturer un flux vidéo à partir d'une caméra et sélectionner un visage

#comprendre en utilisant l'espace de noms cv; int main () (// Load Face cascade (fichier .xml) CascadeClassifier face_cascade; face_cascade.load ("haarcascade_frontalface_alt2.xml"); Mat img; VideoCapture cap (0); while (true) (cap \u003e\u003e img; // cvtColor (img, img, CV_BGR2GRAY); // Détecter les visages std :: vector visages; face_cascade.detectMultiScale (img, faces, 1.1, 2, 0 | CV_HAAR_SCALE_IMAGE, taille (30, 30)); // Dessine des cercles sur les faces détectées pour (int i \u003d 0; i< faces.size(); i++) { Point center(faces[i].x + faces[i].width*0.5, faces[i].y + faces[i].height*0.5); ellipse(img, center, Size(faces[i].width*0.5, faces[i].height*0.5), 0, 0, 360, Scalar(255, 0, 255), 4, 8, 0); } imshow("Detected Face", img); waitKey(1); } return 0; }

Les fichiers cascade se trouvent dans le répertoire c: \\ opencv \\ build \\ etc \\ ... Placez la cascade requise dans le répertoire projet, au même endroit que le fichier source main.cpp.

Mettre en évidence les traits du visage

L'application est basée sur le code C ++ pour OpenCV Facemark

#comprendre #comprendre #comprendre #comprendre #comprendre #comprendre #include "drawLandmarks.hpp" en utilisant l'espace de noms std; en utilisant l'espace de noms cv; en utilisant l'espace de noms cv :: face; int main (int argc, char ** argv) (// Charger le détecteur de visage CascadeClassifier faceDetector ("haarcascade_frontalface_alt2.xml"); // Créer une instance de Facemark Ptr facemark \u003d FacemarkLBF :: create (); // Charge la marque faciale du détecteur de repère-\u003e loadModel ("lbfmodel.yaml"); // Configurer la webcam pour la capture vidéo VideoCapture cam (0); // Variable pour stocker une image vidéo et son cadre en niveaux de gris Mat, gris; // Lire une image while (cam.read (frame)) (// Trouver un vecteur de visage visages; // Convertit le cadre en niveaux de gris car // faceDetector nécessite une image en niveaux de gris. cvtColor (cadre, gris, COLOR_BGR2GRAY); // Détecter les visages faceDetector.detectMultiScale (gris, faces); // Variable pour les points de repère. // Les repères d'une face sont un vecteur de points // Il peut y avoir plus d'un visage dans l'image. Par conséquent, nous // utilisons un vecteur de vecteur de points. vecteur< vector \u003e points de repère; // Exécuter le détecteur de repère bool success \u003d facemark-\u003e< faces.size(); i++) { cv::rectangle(frame, faces[i], Scalar(0, 255, 0), 3); } for (int i = 0; i < landmarks.size(); i++) { drawLandmarks(frame, landmarks[i]); /*for (size_t j = 0; j < landmarks[i].size(); j++) circle(frame, Point(landmarks[i][j].x, landmarks[i][j].y), 1, Scalar(255, 0, 0), 2);*/ } } // Display results imshow("Facial Landmark Detection", frame); // Exit loop if ESC is pressed if (waitKey(1) == 27) break; } return 0; }

Dans le projet d'application, au même endroit que le fichier main.cpp, Fichiers postés haarcascade_frontalface_alt2.xml, drawLandmarks.hpp et lbfmodel.yaml référencés dans le code. Les fichiers en cascade se trouvent dans le répertoire c: \\ opencv \\ build \\ etc \\ .... drawLandmarks.hpp et lbfmodel.yaml disponible dans l'archive Facemark_LBF.rar.

Après avoir collé le code, des erreurs sont apparues en raison du fait qu'OpenCV 3.4.3-vc14-vc15 ne dispose pas d'un certain nombre de bibliothèques nécessaires pour exécuter l'application. J'ai lié ma bibliothèque (téléchargez opencv_new.zip) et l'ai installée à la racine du lecteur C (C: \\ opencv-new).

Maintenant, tous les réglages qui ont été effectués doivent l'être pour opencv-new:

Définition des paramètres sous Windows... Je vais dans la fenêtre "Changer la variable d'environnement" (boutons Windows-\u003e Outils système-\u003e Panneau de configuration -\u003e Système et sécurité -\u003e Système -\u003e Options supplémentaires systèmes -\u003e Variables d'environnement -\u003e Chemin -\u003e Modifier). Dans cette fenêtre, je crée la variable C: \\ ouvert-nouveau\\ x64 \\ vc14 \\ bin. Redémarrez Windows.

Dans les propriétés du projet référez-vous également à la bibliothèque opencv_new (au lieu de opencv). Dans la fenêtre "Pages de propriétés", je fais ce qui suit:

• C / C ++ -\u003e Général -\u003e Répertoires inclus supplémentaires -\u003e C: \\ ouvert-nouveau\\ comprendre
• Linker -\u003e Général -\u003e Répertoires de bibliothèques supplémentaires -\u003e C: \\ ouvert-nouveau\\ x64 \\ vc14 \\ lib
• Éditeur de liens -\u003e Entrée -\u003e Dépendances supplémentaires -\u003e opencv_core400.lib; opencv_face400.lib; opencv_videoio400.lib; opencv_objdetect400.lib; opencv_imgproc400.lib; opencv_highgui400.lib

Au démarrage, le programme génère une erreur si le fichier Debug. Pour Release, le lancement est réussi.

Sélection des fonctionnalités de filtrage d'image et de reconnaissance faciale

Le cadre en pointillé du visage est affiché de différentes manières en fonction de facteurs objectifs et subjectifs.

Les facteurs objectifs sont la position du visage par rapport à la caméra.

Facteurs subjectifs - éclairage inégal ou médiocre, distorsion du visage due aux émotions, plissement des yeux, etc. Dans ces cas, le filaire peut ne pas être correct, les points peuvent même être arrachés du visage:

Pendant la capture vidéo, parfois de telles images glissent également. Ils doivent être filtrés - à la fois pendant la formation et la reconnaissance.

Certains des points sont les plus stables et les plus informatifs. Ils sont fixés rigidement au visage, quelle que soit sa position par rapport à la caméra. De plus, ils caractérisent bien les spécificités du visage. Ces points peuvent être utilisés comme base pour la modélisation du système d'entités.

Vous pouvez utiliser une image filaire 2D de la même position de face pour comparer les faces. Quelle position du visage par rapport à la caméra est la plus informative? Visiblement frontal. Ce n'est pas pour rien que la médecine légale prend une photo de plein visage et de profil. Pour l'instant, limitons-nous au plein visage.

Tous les signes (distances) doivent être sans dimension (normalisés), c'est-à-dire corrélés à une certaine taille (distance). Je suppose que la taille la plus appropriée pour cela est la distance entre les points médians des coins des yeux. Pourquoi pas, par exemple, les coins extérieurs des yeux, qui sont en fait définis dans le tableau des points de repère? Le fait est que les coins des yeux s'écartent (se rapprochent) lorsqu'ils répondent à un changement de couleur, à une expression de surprise, à un clignotement, etc. La distance entre les centres des yeux neutralise ces fluctuations et est donc plus préférable.

Quelle caractéristique prendrons-nous comme base dans la première approximation? Je suppose la distance entre le haut du pont du nez et le bas du menton. À en juger par la photo, ce signe peut différer considérablement selon les personnes.

Ainsi, avant de former des caractéristiques pour l'apprentissage et la comparaison, il est nécessaire de filtrer les cadres ponctuels des visages obtenus par capture vidéo, qui, pour des raisons subjectives ou objectives, ne sont pas une image frontale correcte du visage (visage complet).

Nous ne laissons que les wireframes ponctuels qui respectent les critères suivants:

• La ligne droite qui passe par les points extrêmes des yeux (ligne des yeux) est perpendiculaire à la ligne qui passe par les points extrêmes du nez (ligne du nez).
• La ligne des yeux est parallèle à la ligne droite qui passe par les coins de la bouche (ligne de la bouche).
• Les points ci-dessus sont symétriques par rapport à la ligne du nez.
• Les points d'angle des yeux (externes et internes) sont sur la même ligne droite.

Un exemple d'images frontales qui suivent tous les signes:

Un exemple d'images filtrées:

Essayez de déterminer par vous-même lequel des signes ne transmet pas d'images.

Comment les fonctionnalités de filtrage et de reconnaissance faciale sont-elles formalisées? Fondamentalement, ils sont basés sur les conditions de détermination des distances entre les points, les conditions de parallélisme et de perpendicularité. La tâche de formalisation de ces signes est considérée dans le sujet.

Algorithme de reconnaissance faciale par filaire 2D de points

Les coordonnées des points de l'image filaire de la face sont initialement définies dans le système de coordonnées ancré au point supérieur gauche de la fenêtre. L'axe Y est dirigé vers le bas.

Pour faciliter l'identification des entités, nous utilisons un système de coordonnées personnalisé (SCU), dont l'axe X passe par le segment entre les points médians des yeux, et l'axe Y est perpendiculaire à ce segment par son milieu dans la direction ascendante. Les coordonnées UCS (de -1 à +1) sont normalisées - corrélées avec la distance entre les points médians des yeux.

UCS offre commodité et simplicité dans l'identification des fonctionnalités. Par exemple, la position du visage en vue de face est déterminée par le signe de symétrie des points correspondants des yeux par rapport à la ligne du nez. Cette caractéristique est formalisée par la coïncidence de la ligne de nez avec l'axe Y, c'est-à-dire X1 \u003d X2 \u003d 0, où X1 et X2 sont les coordonnées des points extrêmes du nez (27 et 30) dans le SCU.

Détermination par rapport à la fenêtre SC

Les coordonnées des milieux des yeux gauche et droit (gauche et droit):

XL \u003d (X45 + X42) / 2; YL \u003d (Y45 + Y42) / 2; XR \u003d (X39 + X 36) / 2; YR \u003d (Y39 + Y 36) / 2;

Début du SCU:

X0 \u003d (XL + XR) / 2; Y0 \u003d (YL + YR) / 2;

Distances entre les milieux des yeux le long des axes X et Y:

DX \u003d XR - XL; DY \u003d YR - YL;

La distance réelle L entre les milieux des yeux (selon le théorème de Pythagore):

L \u003d sqrt (DX ** 2 + DY ** 2)

Fonctions trigonométriques de l'angle de rotation du SCU:

Passer des coordonnées du CS fenêtré aux coordonnées du SCUen utilisant les paramètres X0, Y0, L, sin AL, cos AL:

X_User_0 \u003d 2 (X_Window - X0) / L;

Y_User_0 \u003d - 2 (Y_Window - Y0) / L;

X_User \u003d X_User_0 * cos_AL - Y_User_0 * sin_AL;

Y_User \u003d X_User_0 * sin_AL + Y_User_0 * cos_AL;

Mettre en œuvre le filtrage d'images vérifier constamment les signes:

1. un signe de la perpendicularité des lignes du nez et des yeux, ainsi que la symétrie des coins des yeux... La ligne du nez est définie par les points 27 et 30 (voir figure c). Les deux signes sont remplis si les coordonnées de ces points dans le SCU sont X1 \u003d X2 \u003d 0 (c'est-à-dire que la ligne de nez coïncide avec l'axe Y).

2.Un signe de parallélisme de la ligne des yeux et de la ligne de la bouche... La ligne de la bouche est définie par les points 48 et 54 (voir figure c). La caractéristique est remplie si dans l'UCS Y1-Y2 \u003d 0.

3. Signe de symétrie des coins de la bouche... La ligne de la bouche est définie par les points 48 et 54 (voir figure c). La fonctionnalité est remplie si dans l'UCS X1 + X2 \u003d 0

4. Panneau "Les coins des yeux sont sur la même ligne droite"... Les lignes sont définies par des paires de points: (36 et 45), ainsi que (39 et 42). Le test de l'attribut 1 ayant déjà été réussi, il suffit de définir l'attribut Y2-Y1 \u003d 0 dans l'UCS uniquement pour les points 36 et 39.

Il ne peut y avoir d'égalité absolue à zéro, donc les caractéristiques sont comparées à une valeur certes petite.

Programme de comparaison de visages pour une fonctionnalité

La distance entre les points de l'arête du nez et le menton est prise comme un signe (Repères points 27 et 8, voir figure c). La caractéristique, normalisée, est définie dans le SCU par le rapport: (Y1 - Y2) / L, où L est la distance entre les centres des yeux. Lors de la formation du programme, un signe pour une personne spécifique est déterminé par un numéro qui est affiché à côté de la personne suivie (cette partie du code est commentée dans le programme). Lors de la reconnaissance, la valeur d'une fonctionnalité est comparée à une fonctionnalité spécifique entrée dans le programme pour chaque personne. Si la comparaison est positive, son identifiant apparaît à côté du visage.

Le programme reconnaît également à partir d'une photo dans laquelle j'ai 15 ans de moins, et même avec une moustache. La différence sur la photo est significative, tout le monde ne s'en rendra pas compte. Mais programme d'ordinateur vous ne serez pas dupe.

Tâches de contrôle:

1. Familiarisez-vous avec le programme.
2. Déterminez la signification de la caractéristique pour votre visage et plusieurs de vos collègues.
3. Testez le programme pour l'identification des individus (les vôtres et les collègues).

#comprendre #comprendre #comprendre #comprendre #comprendre #comprendre #include "drawLandmarks.hpp" en utilisant l'espace de noms std; using namespace cv; en utilisant l'espace de noms cv :: face; int main (int argc, char ** argv) (// Charger le détecteur de visage CascadeClassifier faceDetector ("haarcascade_frontalface_alt2.xml"); // Créer une instance de Facemark Ptr facemark \u003d FacemarkLBF :: create (); // Charge le facemark du détecteur de repère-\u003e loadModel ("lbfmodel.yaml"); // Configurer la webcam pour la capture vidéo VideoCapture cam (0); // Variable pour stocker une image vidéo et son cadre en niveaux de gris Mat, gris; // Lire une image while (cam.read (frame)) (// Trouver un vecteur de visage visages; // Convertit le cadre en niveaux de gris car // faceDetector nécessite une image en niveaux de gris. cvtColor (cadre, gris, COLOR_BGR2GRAY); // Détecter les visages faceDetector.detectMultiScale (gris, faces); // Variable pour les points de repère. // Les repères d'une face sont un vecteur de points // Il peut y avoir plus d'un visage dans l'image. Par conséquent, nous // utilisons un vecteur de vecteur de points. vecteur< vector \u003e points de repère; // Exécuter le détecteur de repère bool success \u003d facemark-\u003e fit (frame, faces, landmarks); if (success) (// En cas de succès, restituer les repères sur le visage pour (size_t i \u003d 0; i< faces.size(); i++) { cv::rectangle(frame, faces[i], Scalar(0, 255, 0), 3); } for (int i = 0; i < landmarks.size(); i++) { //if((i >\u003d 30) && (i<= 35)) drawLandmarks(frame, landmarks[i]); for (size_t j = 0; j < landmarks[i].size(); j++) { circle(frame, Point(landmarks[i][j].x, landmarks[i][j].y), 1, Scalar(255, 0, 0), 2); } line(frame, Point(landmarks[i].x, landmarks[i].y), Point(landmarks[i].x, landmarks[i].y), Scalar(0, 0, 255), 2); float XL = (landmarks[i].x + landmarks[i].x) / 2; float YL = (landmarks[i].y + landmarks[i].y) / 2; float XR = (landmarks[i].x + landmarks[i].x) / 2; float YR = (landmarks[i].y + landmarks[i].y) / 2; line(frame, Point(XL, YL), Point(XR, YR), Scalar(0, 0, 255), 2); float DX = XR - XL; float DY = YR - YL; float L = sqrt(DX * DX + DY * DY); float X1 = (landmarks[i].x); float Y1 = (landmarks[i].y); float X2 = (landmarks[i].x); float Y2 = (landmarks[i].y); float DX1 = abs(X1 - X2); float DY1 = abs(Y1 - Y2); float L1 = sqrt(DX1 * DX1 + DY1 * DY1); float X0 = (XL + XR) / 2; float Y0 = (YL + YR) / 2; float sin_AL = DY / L; float cos_AL = DX / L; float X_User_0 = (landmarks[i].x - X0) / L; float Y_User_0 = -(landmarks[i].y - Y0) / L; float X_User27 = X_User_0 * cos_AL - Y_User_0 * sin_AL; float Y_User27 = X_User_0 * sin_AL + Y_User_0 * cos_AL; X_User_0 = (landmarks[i].x - X0) / L; Y_User_0 = -(landmarks[i].y - Y0) / L; float X_User30 = X_User_0 * cos_AL - Y_User_0 * sin_AL; float Y_User30 = X_User_0 * sin_AL + Y_User_0 * cos_AL; if (abs(X_User27 - X_User30) <= 0.1) { //putText(frame, std::to_string(abs(L1 / L)), Point(landmarks[i].x, landmarks[i].y), 1, 2, Scalar(0, 0, 255), 2); if (abs((L1 / L) - 1.6) < 0.1) { putText(frame, "Roman", Point(landmarks[i].x, landmarks[i].y), 1, 2, Scalar(0, 0, 255), 2); } if (abs((L1 / L) - 1.9) < 0.1) { putText(frame, "Pasha", Point(landmarks[i].x, landmarks[i].y), 1, 2, Scalar(0, 0, 255), 2); } if (abs((L1 / L) - 2.1) < 0.1) { putText(frame, "Svirnesvkiy", Point(landmarks[i].x, landmarks[i].y), 1, 2, Scalar(0, 0, 255), 2); } } putText(frame, "Incorrect", Point(landmarks[i].x, landmarks[i].y), 1, 2, Scalar(0, 0, 255), 2); } } // Display results imshow("Facial Landmark Detection", frame); // Exit loop if ESC is pressed if (waitKey(1) == 27) break; } return 0; }

Evgeny Borisov Lundi 24 juillet 2017

Cet article fournit une vue d'ensemble des méthodes de recherche d'un objet dans une image.

1. Introduction

De nombreuses tâches pratiques, de l'automatisation du contrôle en production à la conception de véhicules robotiques, sont directement liées à la recherche d'objets dans l'image. Pour le résoudre, vous pouvez utiliser deux stratégies différentes qui dépendent des conditions de prise de vue: la modélisation d'arrière-plan et la modélisation d'objets.

1. Simulation d'arrière-plan - Cette approche peut être utilisée si la caméra est stationnaire, c.-à-d. nous avons un arrière-plan qui change peu et nous pouvons donc le modéliser. Tous les points d'image qui s'écartent considérablement du modèle d'arrière-plan sont considérés comme des objets de premier plan. Ainsi, il est possible de résoudre les problèmes de détection et de suivi d'objets.
2. Modélisation d'objets - cette approche est plus générale, elle est utilisée dans les cas où l'arrière-plan change constamment et de manière significative. Contrairement au cas précédent, nous avons ici besoin de savoir exactement ce que nous voulons trouver, c'est-à-dire il est nécessaire de construire un modèle de l'objet, puis de vérifier les points de l'image pour la conformité avec ce modèle.

Parfois, les conditions du problème vous permettent de combiner les deux approches, cela peut considérablement améliorer les résultats. La solution au problème de la modélisation de l'arrière-plan d'une caméra fixe peut être trouvée dans. Ensuite, nous considérerons l'application de la deuxième stratégie, c'est-à-dire modélisation de l'objet de recherche.

2. Aperçu des méthodes

Dans cette section, nous allons fournir une liste d'approches qui peuvent être utilisées pour résoudre avec succès le problème de la recherche d'un objet dans une image, par ordre de complexité croissante.

1. Filtres de couleur - si l'objet se distingue de manière significative par rapport à l'arrière-plan en couleur, vous pouvez choisir le filtre approprié.
2. Sélection et analyse des contours - si nous savons que l'objet a la forme, par exemple, d'un cercle, nous pouvons rechercher des cercles dans l'image.
3. Correspondance avec un modèle - nous avons une image d'un objet, nous recherchons des zones dans une autre image qui correspondent à cette image d'un objet.
4. Travailler avec des points spéciaux - dans l'image avec l'objet, nous recherchons des caractéristiques (par exemple, des angles), que nous essayons de faire correspondre avec de telles caractéristiques dans une autre image.
5. Méthodes d'apprentissage automatique - nous formons le classificateur sur des images avec un objet, divisons d'une certaine manière l'image en parties, vérifions chaque partie avec le classificateur pour la présence d'un objet.

Nous examinerons ces méthodes plus en détail ci-dessous.

3. Filtres de couleur

La méthode des filtres de couleur peut être utilisée dans les cas où l'objet diffère considérablement de l'arrière-plan en couleur et l'éclairage est uniforme et ne change pas. Vous pouvez en savoir plus sur la méthode de filtre de couleur dans.

4. Extraction et analyse des contours

Si l'objet sur l'arrière-plan ne se distingue pas de manière significative en couleur et / ou a une coloration complexe, l'utilisation de la méthode des filtres de couleur ne donnera pas de bons résultats. Dans ce cas, vous pouvez essayer d'appliquer la méthode de sélection et d'analyse des contours. Pour ce faire, nous sélectionnons les bordures de l'image. Les bordures sont des endroits où le dégradé de luminosité change brusquement et peuvent être trouvés à l'aide de la méthode Canny. Ensuite, nous pouvons vérifier les lignes de démarcation sélectionnées pour la conformité avec les contours géométriques de l'objet, cela peut être fait en utilisant la méthode Hough Transform, par exemple, nous pouvons rechercher dans les limites d'un cercle.

Fig. 4:trouver des cercles

Cette méthode peut également être utilisée avec des filtres de couleur. Vous pouvez en savoir plus sur la sélection et l'analyse des contours dans. Le code source de l'exemple de recherche de cercle peut être téléchargé.

5. Correspondance de modèle

Si l'image contient beaucoup de petits détails, l'analyse des contours peut être difficile. Dans ce cas, vous pouvez utiliser la méthode de correspondance de modèle. Il consiste en ce qui suit - nous prenons une photo avec un objet (Fig. 5) et recherchons des zones dans la grande image qui coïncident avec l'image de l'objet (Fig. 6,7).

Fig 5: objet à rechercher

Vous pouvez écouter la conférence plus en détail sur la méthode de correspondance des modèles. Le code source de l'exemple peut être téléchargé.

6. Travailler avec des points spéciaux

La méthode de correspondance de motif décrite dans la section précédente recherche des correspondances exactes entre les points de motif et les points d'image. Si l'image est pivotée ou mise à l'échelle par rapport aux paramètres du modèle, cette méthode ne fonctionne pas correctement. Pour surmonter ces limitations, des méthodes sont utilisées sur la base de ce que l'on appelle. points singuliers, nous les examinerons ci-dessous. Un point clé est une petite zone qui se distingue de manière significative dans l'image. Il existe plusieurs méthodes pour déterminer de tels points, ceux-ci peuvent être des angles (détecteur de coin Harris) ou des gouttes (blob, drop), c.-à-d. petites zones de même luminosité, avec une bordure assez claire qui se détache sur le fond général. Pour un point spécial, le soi-disant. descripteur - caractéristique d'un point particulier. Le descripteur est calculé à partir d'un voisinage donné du point singulier, comme les directions des gradients de luminosité des différentes parties de ce voisinage. Il existe plusieurs méthodes de calcul des descripteurs pour des points particuliers: SIFT, SURF, ORB, etc. Il faut noter que certaines méthodes de calcul des descripteurs sont brevetées (par exemple, SIFT) et leur utilisation commerciale est limitée. Vous pouvez écouter la conférence plus en détail sur les points particuliers des images et les méthodes de travail avec elles. Des points spéciaux peuvent être utilisés pour trouver un objet dans une image. Pour ce faire, nous devons avoir une image de l'objet souhaité, puis effectuer les actions suivantes.

1. Dans l'image avec l'objet, nous recherchons les points spéciaux de l'objet et calculons leurs descripteurs.
2. Sur l'image analysée, nous recherchons également des points spéciaux et calculons leurs descripteurs.
3. Nous comparons les descripteurs des points spéciaux de l'objet et les descripteurs des points spéciaux trouvés dans l'image.
4. Si un nombre suffisant de correspondances est trouvé, nous marquons la zone avec les points correspondants.

La figure 8 ci-dessous montre les résultats de la méthode de recherche d'un objet par des points singuliers.

Fig 8: détecteur d'objets par des points spéciaux

Le code source de l'exemple peut être téléchargé.

7. Méthodes d'apprentissage automatique

La méthode de recherche d'objets en comparant des ensembles de points spéciaux a ses inconvénients, dont l'un est une faible capacité de généralisation. Si nous avons une tâche, par exemple, pour sélectionner les visages des personnes sur une photo, notre méthode recherchera une photo spécifique par des points spéciaux. La photo sur laquelle les points spéciaux ont été sélectionnés, le reste des visages ressortira pire, car ils correspondent très probablement à d'autres ensembles de points spéciaux. Les résultats peuvent être encore pires si vous modifiez l'angle de la caméra. Pour résoudre ces problèmes, nous avons déjà besoin de méthodes d'apprentissage automatique et pas seulement d'une image avec un objet, mais de jeux de formation entiers de centaines (et dans certains cas, des centaines de milliers) d'images différentes représentant un objet dans différentes conditions. Nous examinerons l'utilisation de méthodes d'apprentissage automatique pour trouver des objets dans une image dans la deuxième partie de cet article.

Littérature

1. ES Borisov Détecteur d'objets pour caméras fixes.
   - http: //site/cv-backgr.html
2. ES Borisov Traitement vidéo: détecteur d'objet basé sur des filtres de couleur.
   - http: //site/cv-detector-color.html
3. ES Borisov Méthodes de base de traitement d'image.
   - http: //site/cv-base.html
4. Anton Konushin Computer vision (2011). Conférence 3. Méthodes simples d'analyse d'images. Modèles assortis.
   - http://www.youtube.com/watch?v\u003dTE99wDbRrUI
5. Documentation OpenCV: Détection de coin Harris
   - http://docs.opencv.org/3.0-beta/doc/py_tutorials/py_feature2d/py_features_harris/py_features_harris.html
6. Wikipédia: Blob_detection
   - http://en.wikipedia.org/wiki/Blob_detection
7. Anton Konushin Computer vision (2011). Conférence 5. Caractéristiques locales
   - http://www.youtube.com/watch?v\u003dvFseUICis-s

Une bibliothèque open source de vision par ordinateur et d'apprentissage automatique. Il comprend plus de 2500 algorithmes, qui incluent à la fois des algorithmes classiques et modernes pour la vision par ordinateur et l'apprentissage automatique. Cette bibliothèque dispose d'interfaces dans différents langages, parmi lesquels Python (dans cet article, nous l'utiliserons), Java, C ++ et Matlab.

Installation

Les instructions d'installation pour Windows peuvent être consultées, et pour Linux -.

Importer et visualiser une image

import cv2 image \u003d cv2.imread ("./ chemin / vers / image.extension") cv2.imshow ("Image", image) cv2.waitKey (0) cv2.destroyAllWindows ()

Remarque Lors de la lecture de la méthode ci-dessus, l'image est dans l'espace colorimétrique non RVB (comme tout le monde est habitué à), mais BGR. Ce n'est peut-être pas si important au début, mais une fois que vous commencez à travailler avec la couleur, il vaut la peine de connaître cette fonctionnalité. Il existe 2 solutions:

1. Permutez le 1er canal (R - rouge) avec le 3e canal (B - bleu), puis la couleur rouge sera (0,0,255), pas (255,0,0).
2. Changer l'espace colorimétrique en RVB: rgb_image \u003d cv2.cvtColor (image, cv2.COLOR_BGR2RGB)

   Et puis dans le code pour ne plus travailler avec image, mais avec rgb_image.

Remarque Appuyez sur n'importe quelle touche pour fermer la fenêtre dans laquelle l'image est affichée. Si vous utilisez le bouton de fermeture de la fenêtre, vous risquez de tomber sur des blocages.

Tout au long de cet article, le code suivant sera utilisé pour afficher les images:

Importer cv2 def viewImage (image, nom_de_fenêtre): cv2.namedWindow (nom_de_window, cv2.WINDOW_NORMAL) cv2.imshow (nom_de_window, image) cv2.waitKey (0) cv2.destroyAllWindows ()

Recadrage

Chien après le recadrage

Importer cv2 cropped \u003d image viewImage (recadrée, "Doggie after recadrage")

Où l'image est image.

Changement de taille

Après redimensionnement de 20%

Importer cv2 scale_percent \u003d 20 # Pourcentage de la taille d'origine width \u003d int (img.shape * scale_percent / 100) height \u003d int (img.shape * scale_percent / 100) dim \u003d (width, height) resized \u003d cv2.resize (img, dim , interpolation \u003d cv2.INTER_AREA) viewImage (redimensionné, "Après redimensionnement de 20%")

Cette fonction prend en compte le rapport hauteur / largeur de l'image originale. D'autres fonctions de redimensionnement d'image peuvent être vues.

Tour

Chien après avoir tourné à 180 degrés

Importer cv2 (h, w, d) \u003d image.shape center \u003d (w // 2, h // 2) M \u003d cv2.getRotationMatrix2D (center, 180, 1.0) rotated \u003d cv2.warpAffine (image, M, (w , h)) viewImage (pivoté, "Chien après avoir tourné de 180 degrés")

image.shape renvoie la hauteur, la largeur et les canaux. M - matrice de rotation - fait pivoter l'image de 180 degrés autour du centre. -ve est la rotation horaire de l'image et + ve est la rotation anti-horaire.

Seuils en niveaux de gris et en noir et blanc

Toutou en niveaux de gris

Toutou noir et blanc

Importer cv2 gray_image \u003d cv2.cvtColor (image, cv2.COLOR_BGR2GRAY) ret, threshold_image \u003d cv2.threshold (im, 127, 255, 0) viewImage (gray_image, "Greyscale doggie") viewImage (threshold_image, "Doggie noir et blanc ")

gray_image est la version monocanal de l'image.

La fonction de seuil renvoie une image dans laquelle tous les pixels plus sombres (inférieurs à) 127 sont remplacés par 0 et tous les pixels plus clairs (supérieurs à) 127 sont remplacés par 255.

Pour plus de clarté, un autre exemple:

Ret, seuil \u003d cv2.seuil (im, 150, 200, 10)

Ici, tout ce qui est plus sombre que 150 est remplacé par 10, et tout ce qui est plus clair est remplacé par 200.

Les autres fonctions de seuil sont décrites.

Flou / anti-aliasing

Toutou flou

Importer cv2 floue \u003d cv2.GaussianBlur (image, (51, 51), 0) viewImage (floue, "Chien flou")

La fonction GaussianBlur prend 3 paramètres:

1. Image originale.
2. Un tuple de 2 nombres impairs positifs. Plus les nombres sont élevés, plus la force du lissage est grande.
3. sigmaX et sigmaY... Si ces paramètres sont laissés égaux à 0, leur valeur sera calculée automatiquement.

Dessin de rectangles

Dessinez un rectangle autour du visage du chien

Importer la sortie cv2 \u003d image.copy () cv2.rectangle (sortie, (2600, 800), (4100, 2400), (0, 255, 255), 10) viewImage (sortie, "Décrire le visage du chien avec un rectangle")

Cette fonction prend 5 paramètres:

1. L'image elle-même.
2. La coordonnée du coin supérieur gauche (x1, y1).
3. Coordonnée du coin inférieur droit (x2, y2).
4. Couleur du rectangle (GBR / RVB selon le modèle de couleur sélectionné).
5. Largeur de ligne du rectangle.

Dessin au trait

2 chiens séparés par une ligne

Importer la sortie cv2 \u003d image.copy () cv2.line (sortie, (60, 20), (400, 200), (0, 0, 255), 5) viewImage (sortie, "2 chiens séparés par une ligne")

La fonction de ligne prend 5 paramètres:

1. L'image réelle sur laquelle la ligne est dessinée.
2. La coordonnée du premier point (x1, y1).
3. Coordonnée du deuxième point (x2, y2).
4. Couleur de la ligne (GBR / RVB selon le modèle de couleur sélectionné).
5. Largeur de ligne.

Texte sur l'image

Image avec texte

Importer la sortie cv2 \u003d image.copy () cv2.putText (sortie, "Nous<3 Dogs", (1500, 3600),cv2.FONT_HERSHEY_SIMPLEX, 15, (30, 105, 210), 40) viewImage(output, "Изображение с текстом")

La fonction putText prend 7 paramètres:

1. Image directement.
2. Texte pour l'image.
3. La coordonnée du coin inférieur gauche du début du texte (x, y).

Visages détectés: 2

Importer cv2 image_path \u003d "./path/to/photo.extension" face_cascade \u003d cv2.CascadeClassifier ("haarcascade_frontalface_default.xml") image \u003d cv2.imread (image_path) gray \u003d cv2.cvtColor (image, cv2.COLOR_BGR_BGR .detectMultiScale (gray, scaleFactor \u003d 1.1, minNeighbors \u003d 5, minSize \u003d (10, 10)) faces_detected \u003d "Visages détectés:" + format (len (faces)) print (faces_detected) # Dessine des carrés autour des visages pour (x, y , w, h) dans les faces: cv2.rectangle (image, (x, y), (x + w, y + h), (255, 255, 0), 2) viewImage (image, faces_detected)

detectMultiScale est une fonction générale de reconnaissance à la fois des visages et des objets. Pour que la fonction recherche spécifiquement des visages, nous lui passons la cascade appropriée.

La fonction detectMultiScale prend 4 paramètres:

1. L'image traitée en niveaux de gris.
2. Paramètre ScaleFactor. Certains visages peuvent être plus grands que d'autres parce qu'ils sont plus proches que d'autres. Ce paramètre compense la perspective.
3. L'algorithme de reconnaissance utilise une fenêtre glissante lors de la reconnaissance d'objets. Le paramètre minNeighbors détermine le nombre d'objets autour du visage. C'est-à-dire que plus la valeur de ce paramètre est élevée, plus l'algorithme a besoin d'objets similaires pour définir l'objet actuel en tant que visage. Une valeur trop petite augmentera le nombre de faux positifs, et trop grande rendra l'algorithme plus exigeant.
4. minSize est la taille réelle de ces zones.

Contours - reconnaissance d'objets

La reconnaissance d'objets est effectuée à l'aide de la segmentation des couleurs de l'image. Il existe deux fonctions pour cela: cv2.findContours et cv2.drawContours.

Cet article détaille la détection d'objets à l'aide de la segmentation des couleurs. Tout ce dont vous avez besoin pour elle est là.

Enregistrer une image

import cv2 image \u003d cv2.imread ("./ import / chemin.extension") cv2.imwrite ("./ export / chemin.extension", image)

Conclusion

OpenCV est une excellente bibliothèque avec des algorithmes légers qui peuvent être utilisés dans le rendu 3D, l'édition avancée d'images et de vidéos, le suivi et l'identification d'objets et de personnes dans la vidéo, la recherche d'images identiques à partir d'un ensemble, et bien plus encore.

Cette bibliothèque est très importante pour quiconque développe des projets liés à l'apprentissage automatique dans le domaine des images.