Le traitement vidéo et la reconnaissance visuelle sont des technologies qui sont de plus en plus utilisées dans le monde de l’informatique. Grâce à GSVidéo + openCV, il est possible de tester simplement la détection de visage. Dans cet article, nous allons examiner comment ces technologies peuvent être utilisées pour détecter des visages et comment elles peuvent être appliquées à des applications pratiques. Nous allons également discuter des avantages et des inconvénients de cette technologie et de la façon dont elle peut être utilisée pour améliorer les systèmes de reconnaissance visuelle.
Processing Vidéo et reconnaissance visuelle avec GSVidéo + openCV : Test simple de détection de visage

Un truc bon à connaître : La reconnaissance visuelle est tout aussi efficace sur une image petite que grande. Il est est donc préférable d’utiliser une capture d’image la plus petite possible pour soulager les processeurs et avoir la plus grande fluidité de détection possible.
Explication
- on teste ici simplement la reconnaissance de visage sur un flux vidéo capturé avec la librairie GSVideo. La reconnaissance de visage est une fonction avancée disponible avec la librairie libre openCV. Cette reconnaissance visuelle se base sur l’utilisation d’un fichier descriptif de visage obtenu par traitement de plusieurs milliers d’images de visages.
- A noter qu’un simple smiley dessiné est détecté !
- Les possibilités potentielles de cette détection de visage associé à une motorisation pan/tilt de la webcam sont très intéressantes, notamment dans le cas d’un robot mobile, permettant d’envisager des comportements de jeux type « cache cache » par exemple…
- ATTENTION : la sollicitation de la CPU est ici importante, avec quasiment 3 threads à 100% en permanence et le 4ème à 80%…
Matériel et configuration utilisés
- PC Intel Core Quad 2.33 Ghz
- Webcam(s) USB Hercules DualPix Exchange
- Ubuntu 10.04 LTS
- Processing 1-5
- Librairie GSVideo 0.9
Ressources utiles
- La librairie openCV
Le programme
// généré avec le générateur de code Processing
// du site www.mon-club-elec.fr
// par X. HINAULT – tous droits réservés
// Programme écrit le : 15/8/2011.
// ——- Licence du code de ce programme : GPL v3—–
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
/////////////// Description du programme ////////////
// Utilise la librairie GSVideo de capture et lecture vidéo
// Utilise la librairie OpenCV de capture vidéo et reconnaissance visuelle
// XXXXXXXXXXXXXXXXXXXXXX ENTETE DECLARATIVE XXXXXXXXXXXXXXXXXXXXXX
// inclusion des librairies utilisées
import codeanticode.gsvideo.*; // importe la librairie vidéo GSVideo qui implémente GStreamer pour Processing (compatible Linux)
// librairie comparable à la librairie native vidéo de Processing (qui implémente QuickTime..)- Voir Reference librairie Video Processing
// cette librairie doit être présente dans le répertoire modes/java/libraries du répertoire Processing (1-5)
// voir ici : http://gsvideo.sourceforge.net/
// et ici : http://codeanticode.wordpress.com/2011/05/16/gsvideo-09-release
import hypermedia.video.*; // importe la librairie OpenCV qui implémente la capture vidéo et la reconnaissance visuelle pour Processing
// cette librairie doit être présente dans le répertoire modes/java/libraries du répertoire Processing (1-5)
// voir ici : http://ubaa.net/shared/processing/opencv/
import java.awt.Rectangle;
// déclaration objets
GSCapture cam1; // déclare un objet GSCapture représentant une webcam
// L’objet GSCapture étend PImage – se comporte comme un conteneur des frames issues de la webcam
OpenCV opencv; // déclare un objet OpenCV principal
// déclaration variables globales
//—— déclaration des variables de couleur utiles —-
int jaune=color(255,255,0);
int vert=color(0,255,0);
int rouge=color(255,0,0);
int bleu=color(0,0,255);
int noir=color(0,0,0);
int blanc=color(255,255,255);
int bleuclair=color(0,255,255);
int violet=color(255,0,255);
// variable pour la taille de la capture video
int widthCapture=320/2; // largeur capture
int heightCapture=240/2; // hauteur capture
int fpsCapture=10; // framerate (image/secondes) pour la capture video
// variable pour la détection
int xCentre, yCentre;
// XXXXXXXXXXXXXXXXXXXXXX Fonction SETUP XXXXXXXXXXXXXXXXXXXXXX
void setup(){ // fonction d’initialisation exécutée 1 fois au démarrage
// —- initialisation paramètres graphiques utilisés
colorMode(RGB, 255,255,255); // fixe format couleur R G B pour fill, stroke, etc…
fill(0,0,255); // couleur remplissage RGB – noFill() si pas de remplissage
stroke (0,0,0); // couleur pourtour RGB – noStroke() si pas de pourtour
rectMode(CORNER); // origine rectangle : CORNER = coin sup gauche | CENTER : centre
imageMode(CORNER); // origine image : CORNER = coin sup gauche | CENTER : centre
ellipseMode(CENTER); // origine cercles / ellipses : CENTER : centre (autres : RADIUS, CORNERS, CORNER
//strokeWeight(0); // largeur pourtour
frameRate(30);// Images par seconde – The default rate is 60 frames per second
// — initialisation fenêtre de base —
size(widthCapture, heightCapture); // ouvre une fenêtre xpixels x ypixels
background(0,0,0); // couleur fond fenetre
// — initialisation des objets et fonctionnalités utilisées —
//======== Initialisation Objets GSVideo (capture et/ou lecture video =========
// GSCapture(this, int requestWidth, int requestHeight, [int frameRate], [String sourceName], [String cameraName])
cam1 = new GSCapture(this, widthCapture, heightCapture,fpsCapture,« v4l2src »,« /dev/video2 »); // Initialise objet GSCapture désignant webcam
// largeur et hauteur doivent être compatible avec la webcam – typiquement 160×120 ou 320×240 ou 640×480…
// Meilleurs résultats avec framerate webcam entre 20 et 30 et frameRate programme idem ou multiple plus grand (40 pour 20 par ex)
// la liste des webcam installées sous Ubuntu (Gnu/Linux) est donnée par la commande : ls /dev/video*
// cam1.play(); // démarre objet GSCapture = la webcam – version GSVideo avant 0.9
cam1.start(); // démarre objet GSCapture = la webcam – version GSVideo après 0.9
//======== Initialisation Objets OpenCV (vidéo et reconnaissance visuelle =========
opencv = new OpenCV(this); // initialise objet OpenCV à partir du parent This
opencv.allocate(widthCapture,heightCapture); // crée le buffer image de la taille voulue
// la capture de flux multiples n’est pas possible avec openCV.
// Ici, on utilise GSVideo pour capturer le flux video et OpenCV pour l’analyse d’image seulement
// Au final, on abouti à une amélioration significative de la rapidité d’exécution
// — initialisation de la reconnaissance visuelle de visage —
opencv.cascade( OpenCV.CASCADE_FRONTALFACE_ALT ); // charge le fichier de description FRONTALFACE (face vue de face)
} // fin fonction Setup
// XXXXXXXXXXXXXXXXXXXXXX Fonction Draw XXXXXXXXXXXXXXXXXXXX
void draw() { // fonction exécutée en boucle
// Code type capture GSVideo – utilisation possible aussi de captureEvent()
if (cam1.available() == true) { // si une nouvelle frame est disponible sur la webcam
cam1.read(); // acquisition d’un frame
image(cam1, 0, 0); // affiche image
//set(0, 0, cam); // affiche image – plus rapide
//img1=cam1.get(); // récupère l’image GS video dans Pimage
//opencv.copy(img1); // charge l’image dans le buffer openCV
opencv.copy(cam1.get()); // autre possibilité – charge directement l’image GSVideo dans le buffer openCV
// détecte tout ce qui ressemble à une face vue de face !
// syntaxe complète : detect(scale, min_neighbors, flags, min_width, min_height);
// syntaxe simple : detect()
// par défaut : scale=1.1, min_neighbors=3, flags=0
// pour accélérer : scale=1.2, min_neighbors=2, flags=HAAR_DO_CANNY_PRUNING, min_size= 1/4 to 1/16
Rectangle[] faces = opencv.detect(); // detect() renvoie une liste de Rectangle
//Rectangle[] faces = opencv.detect(1.2, 2, 0, 1/4, 1/4 ); // detect() renvoie une liste de Rectangle
// dessin des zones détectées
noFill();
for( int i=0; i<faces.length; i++ ) { // passe en revue les rectangles détectés
//– dessine le rectangle autour de la zone
stroke(rouge);
rect( faces[i].x, faces[i].y, faces[i].width, faces[i].height );
//– calcul des coordonnées du centre de l’objet
//xCentre=faces[i].x + (faces[i].width/2);
xCentre=(int)faces[i].getCenterX(); // la fonction getCenterX renvoie X du centre au format double
//yCentre=faces[i].y+(faces[i].height/2);
yCentre=(int)faces[i].getCenterY(); // la fonction getCenterY renvoie Y du centre au format double
//– dessine le centre du rectangle
stroke(vert);
ellipse ( xCentre, yCentre,5,5); // dessine centre
}
} // fin if available
// while(true); // stoppe boucle draw
} // fin de la fonction draw()
// XXXXXXXXXXXXXXXXXXXXXX Autres Fonctions XXXXXXXXXXXXXXXXXXXXXX
//— évènement capture vidéo avec librairie GSVideo—
//void captureEvent(GSCapture cam) { // est appelée lorsqu’une capture (nouvelle frame) survient – cam quelconque
// cf doc librairie Video Processing – cf exemple Capture LivePocky
// bloque pour plusieurs webcams
// cette fonction est appelée à chaque fois qu’une nouvelle frame est disponible, quelque soit la caméra
// utiliser des conditions pour tester la caméra disponible
//if (cam1.available() == true) cam1.read(); // acquisition d’une nouvelle frame
// } // fin fonction évènement captureEvent()
//————- Fonction d’arret de Processing —-
public void stop(){ // fonction d’arrêt de Processing
cam1.delete(); // efface l’objet GScapture
super.stop(); // obligatoire
} // fin fonction stop()
//XXXXXXXXXXXXXXXXXX Fin du programme XXXXXXXXXXXXXXXXX
Articles similaires:
- Processing : OpenCV : librairie javacvPro : Test simple de la reconnaissance de visage à partir d’un flux vidéo webcam.
- Processing : OpenCV : librairie javacvPro : Affichage simple d’un flux vidéo issu d’une webcam
- Processing GSVidéo + JavacvPro : Capture d’un flux vidéo webcam et traitement d’image de base.
- GLAP-Box : Programme de test : Capture d’un flux vidéo dans un programme Processing à l’aide de la librairie GSVideo et reconnaissance de visage en direct à l’aide de la librairie openCV.
- Processing GSVideo avec openCV : Capture d’un triple flux webcam par GSVideo et traitement d’image des 3 flux vidéos avec openCV.
Articles Liés
- Processing GSVideo + openCV : Capture d'un flux webcam par GSVideo et détection de la forme de la main sur un fond uni (avec traçage progressif du contour).
Le traitement d'images et de vidéos est un domaine qui a connu une croissance exponentielle…
- Processing GSVideo + openCV : Capture d'un flux webcam par GSVideo et reconnaissance et suivi d'objet (balle) avec openCV (tracking ball).
Le traitement de flux vidéo est une technologie qui s'est considérablement améliorée ces dernières années.…
- Processing GSVideo avec openCV : Capture d'un flux webcam par GSVideo et traitement image dans openCV.
Le traitement d'image est un domaine qui a connu une croissance exponentielle ces dernières années.…