View  Edit  Attributes  History  Attach  Print  Search

ACCUEIL | ARDUINO > S'INSTALLER > DEBUTER > APPROFONDIR | PROCESSING | MECATRONIQUE | MATERIEL | OUTILS | TESTS | Plus...|
Python > Shell > ATELIERS Python + Qt > PyQt apps > PyQt+Arduino | Mes Robots | RepRap | Mes lib'Arduino | Mes shields Arduino | Mes distros | Les Mini-PC |
ATELIERS ARDUINO| VIDEOS | COMPRENDRE | REFERENCES | CODER | TECHNIQUE | GNU/LINUX | LIENS | Rien à voir |

Outils > Processing

Processing – GSVideo + openCV : Capture d'un triple flux vidéo (3 webcams) par GSVideo et reconnaissance et suivi d'objet (balle) avec openCV (tracking ball) sur les 3 flux vidéos.

Explication

  • La capture vidéo de plusieurs flux vidéos couplée à un traitement d'image et une reconnaissance visuelle d'objet sur les flux vidéos ouvre potentiellement des possibilités très intéressantes puisqu'il devient dès lors possible d'envisager de suivre un même objet sous plusieurs angles et en déduire des informations telle que la distance aux webcams. Il devient également possible de réaliser de la vision binoculaire avec suivi d'objet ou encore probablement de la reconstitution 3D de l'environnement filmé. Tout ceci peut s'avérer très intéressant sur un robot mobile afin de créer des comportement évolués et sophistiqués. Sur cette page, je fais la "preuve du concept" à l'aide de ressources totalement libres.
  • Ici, on reprend le programme de la page : Capture d'un flux vidéo avec GSVideo et reconnaissance de balle par traitement d'image et reconnaissance visuelle avec openCV mais en étendant le principe sur 3 flux vidéos simultanément. En effet, à la différence d'openCV, la librairie GSVideo permet la capture de plusieurs flux vidéos. La librairie openCV par contre reste ici indispensable pour le traitement d'image et la reconnaissance de forme.
  • Une fois de plus, 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 !
  • On réalise ici une détection de balle en utilisant la procédure décrite ici : Processing - openCV : Suivi de balle colorée avec élimination des artéfacts par calcul de cohérence des paramètres de l'objet détecté Ici, le traitement d'image est mis dans une fonction séparée.
  • On remarquera au passage sur la capture d'écran la précision de la détection par la fonction que j'ai codée : aucun des autres objets colorés présents sur l'image n'est pris en compte et les 2 balles colorées (orange) sont parfaitement bien détectée. On remarquera également que les balles sont parfaitement détectées sur les 3 flux vidéos malgré des éclairages différents liés à l'angle des webcams. La détection est donc très efficace.
  • A titre indicatif, le graphique CPU suivant montre l'usage de la CPU, pour une capture à 20 fps (frame per second - image par seconde) en 320x240 pixels : bien qu'une acquisition et un traitement d'image soit réalisée sur 3 flux vidéos , l'utilisation de la CPU reste très correcte à 50% d'utilisation moyenne, soit un approximativement autant que la capture et traitement d'un seul flux webcam avec openCV seule.

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/

import java.awt.Rectangle;
// impporte l'objet rectangle du langage Java qui est utilisé par certaines fonction de la librairie openCV
// l'objet rectangle fournit les champs x,y du centre et hauteur/largeur (height/width) du rectangle
// voir ici : http://download.oracle.com/javase/1.4.2/docs/api/java/awt/Rectangle.html

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

int xmin, xmax, ymin, ymax; // coordonnées de la zone à tester

int comptImg=0; // variable de comptage des images pour moyenne centre
int nbImg=1; // nombre images à prendre en compte avant mouvement
long moyX=0; // pour calcul moyenne X
long moyY=0; // pour calcul moyenne Y

//------ 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); // 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/video0"); // Initialise objet GSCapture désignant webcam
        // largeur et hauteur doivent être compatible avec la webcam - typiquement 160x120 ou 320x240 ou 640x480...
        // 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

        //---- 2ème webcam ---
        // GSCapture(this, int requestWidth, int requestHeight, [int frameRate], [String sourceName], [String cameraName])
        cam2 = new GSCapture(this, widthCapture, heightCapture,fpsCapture,"v4l2src","/dev/video1"); // Initialise objet GSCapture désignant webcam
        cam2.start();  // démarre objet GSCapture = la webcam - version GSVideo après 0.9

        //---- 3ème webcam ---
        // GSCapture(this, int requestWidth, int requestHeight, [int frameRate], [String sourceName], [String cameraName])
        cam3 = new GSCapture(this, widthCapture, heightCapture,fpsCapture,"v4l2src","/dev/video2"); // Initialise objet GSCapture désignant webcam
        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
    set(0, 0, cam1); // affiche image - plus rapide


    analyseImage(cam1.get(), 0, 0); // appelle fonction avec coordonnées pour afficher image resultat

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

  } // fin if available cam1

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

    cam2.read(); // acquisition d'une nouvelle frame
    set(widthCapture*1, 0, cam2); // acquisition d'une nouvelle frame

    analyseImage(cam2.get(), widthCapture*1, 0); // appelle fonction avec coordonnées pour afficher image resultat

  } // fin if available cam2

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

    cam3.read(); // acquisition d'une nouvelle frame
    set(widthCapture*2, 0, cam3); // acquisition d'une nouvelle frame

    analyseImage(cam3.get(), widthCapture*2, 0); // appelle fonction avec coordonnées pour afficher image resultat

  } // fin if available cam3

        // 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()

PImage analyseImage(PImage imgIn, int xIn, int yIn) { // la fonction renvoie image modifiée sans modifier l'image de départ

  PImage imgOut; // image renvoyée par la fonction

  imgOut=imgIn; // les opérations de transformation seront faites sur imgOut pour ne pas modifier imgIn

          //----- 1°) application du "mixeur de canaux" avec sortie sur canal Rouge
            //---- coeff à appliquer
            float coefRouge=1; // 100% de rouge
            float coefVert=1.5; // 80% du vert
            float coefBleu=-2; // - 200% du bleu
            //---------- le traitement le plus efficace qui fonctionne est à tester dans Gimp au préalable
            //--------- ici réglage pour balle de couleur orangée ----

          imgOut.loadPixels(); // charge les pixels de l'image dans le tableau pixels[]

          for (int i = 0; i < imgOut.width*imgOut.height; i++) { // passe en revue les pixels de l'image - index 0 en premier

            float r = (red(imgOut.pixels[i])) + (green(imgOut.pixels[i])*coefVert) + (blue(imgOut.pixels[i])*coefBleu); // la couleur rouge
            //---- fonction mixeur de canaux
            //---- le canal rouge est le canal de sortie et a pour coeff 1
            //---- auquel on ajoute du vert avec coeff vert
            //---- et du bleu avec coeff bleu

            // les deux autres canaux restent inchangés
            float g = green(imgOut.pixels[i]); // la couleur verte

            float b = blue(imgOut.pixels[i]); // la couleur bleue

             imgOut.pixels[i] = color(r, g, b); // modifie le pixel en fonction

            }

          imgOut.updatePixels();  // met à jour les pixels de l'image  

        //----- 2°) transformation de l'image en monochrome en se basant sur le canal rouge

          imgOut.loadPixels(); // charge les pixels de la fenetre d'affichage

          for (int i = 0; i < imgOut.width*imgOut.height; i++) { // passe en revue les pixels de l'image - index 0 en premier

            float r = red(imgOut.pixels[i]);// la couleur rouge
            float g = red(imgOut.pixels[i]); // la couleur verte

            float b = red(imgOut.pixels[i]); // la couleur bleue

             imgOut.pixels[i] = color(r, g, b); // modifie le pixel en fonction

            }

          imgOut.updatePixels();  // met à jour les pixels  

        //------ on applique filtre de seuillage ---
        imgOut.filter(THRESHOLD,0.7); // applique filtre seuil à la fenetre d'affichage
        // à adapter en fonction de la luminosité ambiante - plus sombre, valeur 0.7, plus lumineux, valeur 0.8 ou plus  

        //--- on récupère l'image transformée ---
        //imgOut=get(0,0,width,height); // récupère image à partir fenetre d'affichage


        //--- on rebascule dans OpenCV ---
        opencv.copy(imgOut); // charge l'image modifiée dans le buffer opencv

        // trouve les formes à l'aide de la librairie openCV
        // blobs(minArea, maxArea, maxBlobs, findHoles, [maxVertices]);
        Blob[] blobs = opencv.blobs( 10, imgOut.width*imgOut.height/4, 5, false, OpenCV.MAX_VERTICES*4 );


        // ---- recharge image vidéo non traitée ---
        //opencv.read(); // lecture flux vidéo via OpenCV
        //noTint();
/*         if (camIn==1) {
              cam1.read();
              image(cam1, xIn, yIn);
        }

        if (camIn==2) {
              cam2.read();
              image(cam2, xIn, yIn);
        }  
*/

       // xxxxxxxxxxxx Analyse et gestion des formes reconnues xxxxxxxxxxxxxx
      for( int i=0; i<blobs.length; i++ ) { // passe en revue les blobs (= formes détectées)

      //---- détection du "centre" de l'objet ----
      int centreX= blobs[i].centroid.x; // centroid renvoie un objet Point qui fournit x et y
      int centreY= blobs[i].centroid.y; // centroid renvoie un objet Point qui fournit x et y


      /*
      //---------- dessine un cercle autour du centre détecté -----------
      noFill();
      stroke(vert);
      strokeWeight(2);
      ellipse (centreX,centreY, 10,10);
      */



        Rectangle rectangleBlob=blobs[i].rectangle; // récupère le rectangle qui contient la forme détectée

       //---- analyse du rectangle objet ----
       int ratioWH=rectangleBlob.width/rectangleBlob.height; // calcule le ratio largeur/hauteur
       int ratioHW=rectangleBlob.height/rectangleBlob.width; // calcule le ratio hauteur/largeur

       float aireBlob=blobs[i].area; // récupère l'aire de la forme courante


       float ratioAire=aireBlob/(rectangleBlob.width*rectangleBlob.height); // calcul du ratio Aire forme / Aire rectangle
       // aire cercle = pi * r²
       // aire carré = (2r)²=4r²
       // aire cercle/aire carré = (pi * r²)/ (4*r²) = pi/4 = 3/4 env
       // un cercle occupe 3/4 du carré le contenant

       //if ((ratioWH>0.9)) { // si forme proche du carré
       if ((ratioAire>0.5) && ((ratioWH>0.8) || (ratioHW>0.8))) { // si le rapport de l'aire de la forme / rectangle contenant est compatible avec un cercle

        //fill(jaune); // couleur remplissage RGB
        noFill(); // pas de remplissage
        stroke (bleuclair); // couleur pourtour RGB

        //tracé d'un rectangle autour du blob
        rect( xIn+rectangleBlob.x, yIn+rectangleBlob.y, rectangleBlob.width, rectangleBlob.height );

        fill(jaune); // couleur remplissage RGB
        stroke (rouge); // couleur pourtour RGB


        // tracé des formes détectées
        beginShape(); // début tracé forme complexe

        for( int j=0; j<blobs[i].points.length; j++ ) { // parcourt tous les points du pourtour du blob
            vertex( xIn+blobs[i].points[j].x, yIn+blobs[i].points[j].y ); // tracé des points de la forme
        }
        endShape(CLOSE); // tracé forme complexe



        //--------------- gestion centre pour servomoteur ----------
        // moyenne des X et des Y

        moyX=moyX+centreX;
        comptImg=comptImg+1;

        if (comptImg>=nbImg) { // si le nombre d'image à prendre en compte dépassé

           //println("X = "+ centreX);
           //println("Total X = "+ moyX);
           //println("comptImg="+comptImg);        
           moyX=moyX/(comptImg); // calcule moyenne centre X
           //println ("Moyenne X = "+ moyX);


           comptImg=0; // RAZ comptage images
           moyX=0; // RAZ moyX
        }



       } // if ratio Aire

       else { // trace avec couleurs différentes les rectangles non souhaités
 /*      

        fill(bleu); // couleur remplissage RGB
        stroke (jaune); // couleur pourtour RGB

        //tracé d'un rectangle autour du blob
        rect( rectangleBlob.x, rectangleBlob.y, rectangleBlob.width, rectangleBlob.height );

        fill(jaune); // couleur remplissage RGB
        stroke (rouge); // couleur pourtour RGB

        // tracé des formes détectées
        beginShape(); // début tracé forme complexe

        for( int j=0; j<blobs[i].points.length; j++ ) { // parcourt tous les points du pourtour du blob
            vertex( blobs[i].points[j].x, blobs[i].points[j].y ); // tracé des points de la forme
        }
        endShape(CLOSE); // tracé forme complexe

  */


       }







    } // ---- fin for blobs --------



  return(imgOut); // renvoie image

} // fin fonction analyseImage()

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