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 + javacvPro (OpenCV) : Capture d'un triple flux vidéo (3 webcams) par GSVideo et reconnaissance et suivi d'objet (balle) avec javacvPro (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 JavacvPro (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é On utilise ici des fonctions de la librairie JavacvPro qui implémente cette procédure de traitement en quelques lignes seulement !
  • A titre indicatif : on obtient un traitement d'image à 5ms par frame soit un framerate théorique de 200 fps ! Très fluide donc !

Matériel et configuration utilisés

  • PC Intel Core Quad 2.33 Ghz
  • Webcam(s) USB Hercules DualPix Exchange / Logitech C270
  • Ubuntu 10.04 LTS
  • Processing 1-5
  • Librairie GSVideo 0.9 / 1.0
  • JavacvPro 0.3 et suiv.

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 : 26/10/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 javacvPro de traitement d'image et reconnaissance visuelle

/*
Détection et suivi de balle à partir d'un flux vidéo webcam à l'aide de la librairie javacvPro
*/


// 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 monclubelec.javacvPro.*; // importe la librairie javacvPro qui implémente le traitement d'image avancé et la reconnaissance visuelle pour Processing
// cette librairie se base sur les fonctions java de la librairie javacv par Samuel Audet : http://code.google.com/p/javacv/
// javacv implémente en Java les centaines de fonctions natives de la librairie OpenCV (2500 algorithmes) !
// la librairie javacvPro doit être présente dans le répertoire modes/java/libraries du répertoire Processing (1-5)
// dispo ici : http://www.mon-club-elec.fr/pmwiki_reference_lib_javacvPro/pmwiki.php
// nécessite également que la librairie native OpenCV 2.3.1 soit installée sur votre ordinateur
// NB : compatibilité avec la plupart des fonctions de la librairie OpenCV pour Processing : http://ubaa.net/shared/processing/opencv/

// déclaration objets

PImage imgSrc, imgDest; // déclare un/des objets PImage (conteneur d'image Processing)

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

int nbWebcam=3; // nombres de webcams

GSCapture[] cam=new GSCapture[nbWebcam]; // déclare un tableau d'objet objet GSCapture représentant 3 webcams

OpenCV opencv; // déclare un objet OpenCV principal

Blob[] blobs=null; // tableau pour la détection des blobs (contour de forme)


// 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=30; // framerate (image/secondes) pour la capture video

long millis0=0; // variable mémorisation millis()

// 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*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 - avant GSVideo 1.0
        cam[0] = 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 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
        cam[0].start();  // démarre objet GSCapture = la webcam - version GSVideo après 0.9

        //---- webcam 2 ---
        cam[1] = new GSCapture(this, widthCapture, heightCapture,"v4l2src","/dev/video1", fpsCapture); // Initialise objet GSCapture désignant webcam - depuis GSVideo 1.0
        cam[1].start();  // démarre objet GSCapture = la webcam - version GSVideo après 0.9


        //---- webcam 3 ---
        cam[2] = new GSCapture(this, widthCapture, heightCapture,"v4l2src","/dev/video2", fpsCapture); // Initialise objet GSCapture désignant webcam - depuis GSVideo 1.0
        cam[2].start();  // démarre objet GSCapture = la webcam - version GSVideo après 0.9

        //======== Initialisation Objets OpenCV (librairie javacvPro : traitement d'image et reconnaissance visuelle) =========

        opencv = new OpenCV(this); // initialise objet OpenCV à partir du parent This
        opencv.allocate(widthCapture,heightCapture); // crée les buffers image de la taille voulue


} // fin fonction Setup

// XXXXXXXXXXXXXXXXXXXXXX Fonction Draw XXXXXXXXXXXXXXXXXXXX

void  draw() { // fonction exécutée en boucle

// Code type capture GSVideo - utilisation possible aussi de captureEvent()

for (int index=0; index<nbWebcam; index++) { // boucle de défilement des webcams

  if (cam[index].available() == true) { // si une nouvelle frame est disponible sur la webcam

    cam[index].read(); // acquisition d'un frame
    //image(cam1, 0, 0); // affiche image
    //set(0, 0, cam); // affiche image - plus rapide

    imgSrc=cam[index].get(); // récupère l'image GS video dans Pimage
    opencv.copy(imgSrc); // charge l'image dans le buffer openCV

    //opencv.copy(cam1.get()); // autre possibilité - charge directement l'image GSVideo dans le buffer openCV

    millis0=millis(); // pour analyse durée - mémorise debut

    opencv.mixerRGBGray(); // isole la couleur orangée par défaut - couleur de la balle

    opencv.threshold(0.6,"BINARY"); // applique seuillage binaire pour éliminer tout ce qui n'est pas orange

    //image(opencv.image(), 0, 0); // affiche image traitée - utile pour debug ou comprendre

    image(imgSrc, widthCapture*index, 0); // affiche image de départ avant tracé des formes détectées

    blobs=opencv.blobs(); // détection des formes - renvoie tableau de blobs
    //blobs=opencv.blobs(opencv.area()/256,opencv.area(),20, true, 1000,false); // forme détaillée - applique blobs au buffer principal avec paramètres et renvoie tableau d'objets Blob

    blobs=opencv.selectBallBlobs(blobs); // sélectionne que les formes compatibles avec une balle

    // void drawRectangleBlobs (Blob[] blobsIn, int xRefIn, int yRefIn, float scaleIn, int colorStrokeIn, int strokeWeightIn, boolean fillIn, int colorFillIn)
    //opencv.drawRectBlobs(blobs); // javacvPro : trace le rectangle de tous les blobs détectés
    opencv.drawRectBlobs(blobs, widthCapture*index,0,1,vert,2,false,0); // forme détaillée - javacvPro : trace le rectangle de tous les blobs détectés

    // void drawBlobs (Blob[] blobsIn, int xRefIn, int yRefIn, float scaleIn, int radius, int colorStrokeIn, int strokeWeightIn, boolean fillIn, int colorFillIn, int mode)
    //opencv.drawBlobs (blobs); // javacvPro : trace le contour de tous les blobs détectés
    opencv.drawBlobs (blobs, widthCapture*index,0,1,5,rouge,1,true,jaune,1); // forme détaillée - javacvPro : trace le contour de tous les blobs détectés

    // nb : mettre dessin centre après dessin blob, sinon invisible
    // void drawCentroidBlobs (Blob[] blobsIn, int xRefIn, int yRefIn, float scaleIn, int radius, int colorStrokeIn, int strokeWeightIn, boolean fillIn, int colorFillIn)
    //opencv.drawCentroidBlobs( blobs); //  javacvPro : trace le centre de tous les blobs détectés
    opencv.drawCentroidBlobs( blobs, widthCapture*index,0,1,10,jaune,1,true,rouge); // forme détaillée -javacvPro : trace le centre de tous les blobs détectés


    println("Durée traitement d'1 frame = "+(millis()-millis0) + "ms soit fps max théorique de " + (1000/(millis()-millis0))+" fps !"); // pour analyse - affiche durée traitement image



  } // fin if available

} // fin for nbWebcam

} // fin de la fonction draw()

// XXXXXXXXXXXXXXXXXXXXXX Autres Fonctions XXXXXXXXXXXXXXXXXXXXXX


//------------- Fonction d'arret de Processing ----

public void stop(){ // fonction d'arrêt de Processing

        cam[0].delete(); // efface l'objet GScapture

        super.stop(); // obligatoire

} // fin fonction stop()


//XXXXXXXXXXXXXXXXXX Fin du programme XXXXXXXXXXXXXXXXX