Le traitement des données est un domaine en pleine expansion et les possibilités sont infinies. La librairie GSVideo de Processing offre aux développeurs une méthode simple et efficace pour enregistrer des données vidéo à partir d’un flux webcam et les contrôler à l’aide du clavier. Cet article expliquera en détail comment utiliser cette librairie pour créer un système de datalogging vidéo contrôlé par le clavier.
Processing Fichiers : Datalogging vidéo contrôlé par le clavier à partir d’un flux webcam (librairie GSVideo).

Explication
- Ce programme réalise l’affichage du flux vidéo en provenance d’une webcam à l’aide de la librairie GSVideo.
- L’appui sur la touche ‘e’ entraîne l’enregistrement vidéo à partir du moment de l’appui dans le fichier vidéo indiqué dans le programme. Un rond rouge s’affiche dans le coin supérieur droit de la fenêtre pour signifier que l’enregistrement est actif.
- L’appui sur la touche ‘s’ entraîne l’arrêt de l’enregistrement vidéo.
Matériel et configuration utilisés
- PC Intel Core Quad 2.33 Ghz
- Ubuntu 10.04 LTS
- Processing 1-5
- Librairie GSVideo 0.9
- webcam Hercules Dualpix Exchange
Ressources utiles
- Librairie GSVideo
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/9/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 le clavier
// Utilise la librairie GSVideo de capture et lecture vidéo
/*
> ce programme affiche un flux vidéo capturé par la librairie GSVideo
> l’appui sur la touche ‘e’ enregistre le flux vidéo dans un fichier
(Attention : efface l’enregistrement précédent)
> l’appui sur la touche ‘s’ stoppe l’enregistrement
> la lecture du fichier vidéo se fera ensuite par double clic sur le nom du fichier
*/
// 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
// L’objet GSCapture étend PImage – se comporte comme un conteneur des frames issues de la webcam
GSMovieMaker maVideo; // crée un objet moviemaker pour créer la vidéo
// déclaration variables globales
PImage imgDest;
String cheminFichier=« /home/glapbox/Bureau/trans/ »; // chemin absolu du fichier
String nomFichier=« mavideo.avi »; // nom de la vidéo
//—— 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=640/2; // largeur capture
int heightCapture=480/2; // hauteur capture
// plus la taille est grande et plus le fichier vidéo sera gros
int fpsCapture=30; // framerate (image/secondes) pour la capture video
// — plus le framerate est élevé et plus le fichier vidéo sera gros
boolean flagRecord=false; // drapeau pour activation enregistrement – true pour actif et false pour inactif
boolean debug=true; // true si message debogage, false sinon
// 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(fpsCapture);// 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/video0 »); // 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 objet GSMovieMaker pour enregistrement vidéo —
//GSMovieMaker(processing.core.PApplet parent, int requestWidth, int requestHeight, java.lang.String filename, int codecType, int codecQuality, int ifps)
// IMPORTANT : le frameRate et ifps doivent être égaux !
//—– initialisation de l’objet GSMovieMaker —
maVideo = new GSMovieMaker(this, widthCapture, heightCapture, cheminFichier+nomFichier, GSMovieMaker.MJPEG, GSMovieMaker.MEDIUM, fpsCapture);
// ici enregistrement dans fichier.avi (cf nom fichier) avec encodage MJPEG et qualité MEDIUM
// all quality settings are WORST, LOW,MEDIUM, HIGH and BEST
// Available codecs are:
// THEORA
// XVID
// X264
// DIRAC
// MJPEG
// MJPEG2K
// As for the file formats, the following are autodetected from the filename extension:
// .ogg: OGG
// .avi: Microsoft’s AVI
// .mov: Quicktime’s MOV
// .flv: Flash Video
// .mkv: Matroska container
// .mp4: MPEG-4
// .3gp: 3GGP video
// .mpg: MPEG-1
// .mj2: Motion JPEG 2000
// Please note that some of the codecs/containers might not work as expected, depending
// on which gstreamer plugins are installed. Also, some codec/container combinations
// don’t seem to be compatible, for example THEORA+AVI or X264+OGG.
//setQueueSize(int npre,int nenc)
maVideo.setQueueSize(0, 10); // fixe le nombre de frame maxi en attente en pré-encodage (java- 0 si pas de limite) et en post-encodage (gstreamer)
// Sets the maximum size of the pre-encoding and encoding queues. When the encoding queue is full, the frames start to be accumulated in the pre-encoding queue.
// By setting the size of the pre-encoding queue to zero, it can grow arbitrarily large.
} // 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
imgDest=cam1.get(); // récupère l’image GS video dans Pimage
//— si l’enregistrement est activé —-
if (flagRecord==true) {
//— trace cercle rouge dans coin sup droit
fill(rouge);
stroke(rouge);
ellipse (widthCapture–30,30,20,20);
//—– enregistrement des images —
imgDest.loadPixels(); // charge les pixels en mémoire
maVideo.addFrame(imgDest.pixels); // ajoute les pixels de l’image à la vidéo – attention ajoute les pixels et pas l’image…
if (debug) println(« Nombre de frames en attente : « + maVideo.getQueuedFrames());
if (debug) println(« Nombre de frame abandonnés : « + maVideo.getDroppedFrames());
} // fin if flagRecord
} // fin if available
// while(true); // stoppe boucle draw
} // fin de la fonction draw()
// XXXXXXXXXXXXXXXXXXXXXX Autres Fonctions XXXXXXXXXXXXXXXXXXXXXX
//———— gestion évènement clavier ———
void keyPressed() { // si une touche est appuyée
if(key==‘e’) { // si touche ee enfoncee
maVideo.start(); // lance l’objet GSMovieMaker
println(« Enregistrement démarré »);
flagRecord=true;
}
if(key==‘s’) { // si touche s enfoncee
maVideo.finish(); // ferme l’objet MovieMaker
println(« Enregistrement stoppé »);
flagRecord=false;
}
} //— fin si touche enfoncee
//— é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 GSVideo : Capture de 8 flux webcams simultanément
- Processing Capture vidéo avec la librairie GSVideo : Capture d’un triple flux vidéo à partir de 3 webcams.
- Processing Capture vidéo avec la librairie GSVideo : Capture d’un double flux vidéo à partir de 2 webcams.
- Processing Capture Vidéo avec GSVideo et GLGraphics : Capture d’un flux vidéo avec la librairie GSVideo couplée aux librairies openGL (native) et GLGraphics.
- Processing Fichiers – Images : Datalogging de fichiers images multiples contrôlé par le clavier.
Articles Liés
- 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.…
- Javascript : Graphique Dygraphs simple
Le Javascript est un langage de programmation très populaire et puissant qui permet aux développeurs…