Le traitement de la vidéo est un domaine qui a connu une croissance rapide ces dernières années. La librairie GSVideo est un outil puissant qui permet aux développeurs de créer des applications vidéo interactives. Dans cet article, nous allons examiner comment capturer un flux vidéo à l’aide de la librairie GSVideo seule. Nous verrons comment configurer la webcam et comment capturer le flux vidéo. Nous verrons également comment traiter le flux vidéo et comment le sauvegarder.
Processing Capture Vidéo : Capture d’un flux vidéo (1 webcam) avec la librairie GSVideo seule
Explication
- A la différence de la librairie vidéo native de Processing qui implémente QuickTime (propriétaire, non compatible Linux…), la librairie GSVideo, libre et opensource) implémente les mêmes fonctions mais en se basant sur GStreamer (libre et opensource) qui est disponible sous Linux.
- Ici, on crée un objet GScapture, qui étend l’objet Processing PImage. L’objet GSCapture représente la webcam.
La fonction eventCapture() permet d’assurer la capture des frames. Noter que l’utilisation de la fonction captureEvent() limite les messages d’erreurs obtenus parfois avec le code de lecture des frames mis dans la fonction draw()- J’ai également intégré l’arrêt des objets GScapture à l’arrêt du programme Processing pour éviter les problèmes à la relance du programme. En pratique, çà fonctionne bien de cette manière.
- A titre indicatif, voici le graphique CPU comparatif entre openCV et GSVideo en mode capture vidéo continue 320×240 :
- la moitié gauche sur le graphe, on constate une utilisation CPU à plus de 50% multithreads qui correspond à openCV en action.
- La moitié droite sur le graphe correspond à l’utilisation CPU de l’ordre de 25% multithreads, correspondant à la librairie GSVideo en action. La différence est criante, nettement en faveur de la librairie GSVideo pour la capture video !
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 GSVideo
Remarques
- On pourra fixer la taille de la capture en modifiant les valeurs utilisées avec l’instruction size(width, height) : par exemple 640×480.
- On pourra également modifier le frameRate() : utiliser des valeurs de 15 à 25 pour un bon résultat.
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 : 11/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
// 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
// déclaration objets
GSCapture cam1; // déclare un objet GSCapture représentant une webcam
// 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);
// 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(320, 240); // 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, width, height,20, »v4l2src », »/dev/video0″); // Initialise objet GSCapture désignant webcam – avant GSVideo 1.0
cam1 = new GSCapture(this, widthCapture, heightCapture,« v4l2src »,« /dev/video0 », 20); // 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…
// NB : Framerate >=20 évite message erreur
// 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
} // fin fonction Setup
// XXXXXXXXXXXXXXXXXXXXXX Fonction Draw XXXXXXXXXXXXXXXXXXXX
void draw() { // fonction exécutée en boucle
// Code type capture GSVideo – préférer utilisation de captureEvent()
if (cam1.available() == true) { // si une nouvelle frame est disponible
cam1.read(); // acquisition d’un frame
image(cam1, 0, 0); // affiche image
//set(0, 0, cam); // plus rapide
} // fin if available
} // fin de la fonction draw()
// XXXXXXXXXXXXXXXXXXXXXX Autres Fonctions XXXXXXXXXXXXXXXXXXXXXX
/*
//— évènement capture vidéo —
void captureEvent(GSCapture cam) { // est appelée lorsqu’une capture survient
// cf doc librairie Video Processing – cf exemple Capture LivePocky
// 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
*/
//————- 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 Liés
- Processing Fichiers : Datalogging vidéo contrôlé par le clavier à partir d'un flux webcam (librairie GSVideo).
Le traitement des données est un domaine en pleine expansion et les possibilités sont infinies.…
- Javascript : Afficher 6 widgets graphiques fournis par une librairie graphique externe.
Le Javascript est un langage de programmation très populaire qui permet aux développeurs de créer…
- Javascript : Afficher des données sur 24H multicourbes à l'aide de la librairie graphique Dygraphs avec sélection des courbes à afficher.
Les librairies graphiques sont des outils puissants pour afficher des données sous forme de graphiques.…