Logo Mon Club Elec

Processing – GSVideo avec openCV : Capture d’un triple flux webcam par GSVideo et traitement d’image des 3 flux vidéos avec openCV.

Le traitement d’image est un domaine qui a connu une croissance exponentielle ces dernières années. Les possibilités offertes par les technologies modernes sont de plus en plus variées et permettent de réaliser des projets complexes. Dans cet article, nous allons nous intéresser à la capture d’un triple flux webcam par GSVideo et au traitement d’image des 3 flux vidéos avec openCV. Nous verrons comment utiliser GSVideo et openCV pour capturer et traiter les flux vidéo et comment ces technologies peuvent être utilisées pour créer des applications innovantes.

Processing – GSVideo avec openCV : Capture d’un triple flux webcam par GSVideo et traitement d’image des 3 flux vidéos avec openCV.

Processing – GSVideo avec openCV : Capture d’un triple flux webcam par GSVideo et traitement d’image des 3 flux vidéos avec openCV.

Explication

  • Une des limites de openCV, en plus de consommer beaucoup de CPU pour la capture vidéo, c’est de ne pouvoir réaliser la capture que d’un seul flux vidéo en provenance d’une webcam. Or il peut être intéressant, pour des applications de vision binoculaire ou de triangulation par webcam ou encore de reconstitution 3D à partir d’image vidéo, de pouvoir capturer plusieurs flux vidéos.
  • Sur cette page, je vour proposer de faire la « preuve du concept ». J’utiliser ici GSVideo pour la capture vidéo et openCV pour le traitement d’image sur 3 flux vidéos issus de 3 webcams simultanément.
  • Tout comme pour la capture d’un flux védo puis traitement avec openCV, le « truc » consiste à créer un buffer openCV de la taille de l’image de capture par la librairie GSVideo puis à charger l’image capturée par GSVideo dans le buffer d’openCV : il est alors possible d’utiliser toutes les fonctions de la librairie openCV (reconnaissance visuelle, etc..) comme si le flux avait été capturé par la librairie openCV elle-même !
  • L’effet appliqué ici avec la librairie openCV est un simple seuillage, sans intérêt en soi, mais c’est uniquement pour mettre en évidence le principe.
  • A ce stade, cela ouvre pas mal de possibilités, à commencer par la vision binoculaire par webcams…
  • A titre indicatif, voici le graphique d’utilisation de la CPU avec ce programme : comme on peut le voir, on ne dépasse pas en moyenne 50% d’usage de l’ensemble des threads alors que l’on réalise la capture et le traitement de 3 flux vidéos simultanément à 20 fps au format 320×240 !
Processing – GSVideo avec openCV : Capture d’un triple flux webcam par GSVideo et traitement d’image des 3 flux vidéos avec openCV.

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

  • librairie openCV
  • librairie GSVideo

Le programme

// Programme processing
// 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 : 13/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/

// déclaration objets

GSCapture cam1,cam2,cam3; // 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; // largeur capture
int heightCapture=240; // hauteur capture
int fpsCapture=20; // framerate (image/secondes) pour la capture video

// 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(20);// Images par seconde – The default rate is 60 frames per second

        // — initialisation fenêtre de base —
        size(widthCapture*3, heightCapture*2); // 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 =========

        //—- webcam 1 —-
        // GSCapture(this, int requestWidth, int requestHeight, [int frameRate], [String sourceName], [String cameraName])
        // cam1 = new GSCapture(this, widthCapture, heightCapture,fpsCapture, »v4l2src », »/dev/video0″); // Initialise objet GSCapture désignant webcam – avant GSVideo 1.0
        cam1 = new GSCapture(this, widthCapture, heightCapture,« v4l2src »,« /dev/video0 », fpsCapture); // Initialise objet GSCapture désignant webcam – depuis GSVideo 1.0
        // 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

        //—- webcam 2 —
        //cam2 = new GSCapture(this, widthCapture, heightCapture,fpsCapture, »v4l2src », »/dev/video1″); // Initialise objet GSCapture désignant webcam – avant GSVideo 1.0
        cam2 = new GSCapture(this, widthCapture, heightCapture,« v4l2src »,« /dev/video1 », fpsCapture); // Initialise objet GSCapture désignant webcam – depuis GSVideo 1.0
        cam2.start();  // démarre objet GSCapture = la webcam – version GSVideo après 0.9

        //—- webcam 2 —
        //cam3 = new GSCapture(this, widthCapture, heightCapture,fpsCapture, »v4l2src », »/dev/video2″); // Initialise objet GSCapture désignant webcam – avant GSVideo 1.0
        cam3 = new GSCapture(this, widthCapture, heightCapture,« v4l2src »,« /dev/video2 », fpsCapture); // Initialise objet GSCapture désignant webcam – depuis GSVideo 1.0
        cam3.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

} // 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

    opencv.copy(cam1.get()); // charge l’image webcam dans le buffer opencv

    opencv.threshold(80); // application d’un simple effet de seuillage

    image(opencv.image(),0,heightCapture); // affiche l’image traitée par openCV

  } // fin if available

  if (cam2.available() == true) { // si une nouvelle frame est disponible sur la webcam

    cam2.read(); // acquisition d’un frame
    image(cam2, widthCapture, 0); // affiche image

    opencv.copy(cam2.get()); // charge l’image webcam dans le buffer opencv

    opencv.threshold(80); // application d’un simple effet de seuillage

    image(opencv.image(),widthCapture,heightCapture); // affiche l’image traitée par openCV

  } // fin if available

  if (cam3.available() == true) { // si une nouvelle frame est disponible sur la webcam

    cam3.read(); // acquisition d’un frame
    image(cam3, widthCapture*2, 0); // affiche image

    opencv.copy(cam3.get()); // charge l’image webcam dans le buffer opencv

    opencv.threshold(80); // application d’un simple effet de seuillage

    image(opencv.image(),widthCapture*2,heightCapture); // affiche l’image traitée par openCV

  } // 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
 

Noter cet article

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Archive Mon Club Elec

Articles populaires

Newsletter

Inscrivez-vous maintenant et bénéficiez d'un soutien continu pour réaliser vos travaux électriques en toute sécurité.