Le traitement des fichiers et des images est une tâche complexe qui nécessite une précision et une attention particulières. Dans ce contexte, le datalogging de fichiers images multiples contrôlé par le clavier est une méthode très pratique pour organiser et gérer les données. Cet article se propose de décrire en détail le processus de datalogging de fichiers images multiples contrôlé par le clavier et de discuter des avantages et des inconvénients de cette méthode.
Processing Fichiers – Images : Datalogging de fichiers images multiples contrôlé par le clavier.

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 des images en provenance du flux vidéo à intervalle régulier fixé en millisecondes. Chaque image est automatiquement enregistrée dans un fichier numéroté.
- L’appui sur la touche ‘s’ stoppe l’enregistrement
- L’appui sur la touche ‘l’ (lecture) lance la lecture
- A noter que si on ré-appuie sur la touche ‘e’, on relance l’enregistrement à la suite du premier. Toutes les images seront lues dans ce cas lors de la lecture par apui sur la touche ‘l’.
Matériel et configuration utilisés
- PC Intel Core Quad 2.33 Ghz
- Ubuntu 10.04 LTS
- Processing 1-5
- Librairie GSVideo 0.9
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 : 14/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 un/des objets PImage (conteneur d’image .jpeg .gif .png et .tga)
// Utilise le clavier
// Utilise la librairie GSVideo de capture et lecture vidéo
/*
> Le programme capture et affiche le flux vidéo en provenance d’une webcam
> L’appui sur la touche e lance l’enregistrement des images à intervalle régulier fixé par le programme.
> L’appui sur la touche s stoppe l’enregistrement des images
> L’appui sur la touche p lance la lecture des images enregistrées
*/
// 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
PImage img1, img2; // déclare un/des objets PImage (conteneur d’image)
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
String cheminRepertoireEnregistrement=« /home/glapbox/Bureau/trans/ »; // chemin absolu du répertoire d’enregistrement
// 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
int delai=250; // délai en millisecondes entre 2 enregistrement d’image
long millis0=0; // variable pour mémoriser dernier valeur millis() pris en compte
int comptImg=0; // variable comptage image
int comptImgPlay=0; // variable comptage image lecture
String numeroImg=« »; // chaine pour numéro image au format 00001
int vitessePlay=100; // durée pause entre 2 lecture images enregistrées
boolean flagRecord=false; // drapeau activation enregistrement
boolean flagPlay=false; // drapeau activation lecture
// 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(15);// Images par seconde – The default rate is 60 frames per second
// — initialisation fenêtre de base —
size(widthCapture*2, heightCapture); // ouvre une fenêtre xpixels x ypixels
background(0,0,0); // couleur fond fenetre
// — initialisation des objets et fonctionnalités utilisées —
//—- Initialisation des objets PImage —
//img1 = createImage(100, 100, RGB); // initialise l’objet PImage (conteneur d’image)
//image(img1, 0, 0, width/2, height/2); // affiche l’image
//img2 = loadImage(« monimage.jpg »); // charge un fichier image dans l’objet PImage (conteneur d’image)
// ce fichier doit être présent dans le répertoire du programme ou à l’emplacement indiqué
//image(img2, 0, 0, width, height);// affiche l’image
//======== 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
} // 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
img1=cam1.get(); // récupère l’image GS video dans Pimage
image(img1, 0, 0); // affiche image
// — création chaine numéro image au format 00000 —
if (comptImg>=10000) numeroImg=« »+comptImg;
if (comptImg<10000) numeroImg=« 0 »+comptImg;
if (comptImg<1000) numeroImg=« 00 »+comptImg;
if (comptImg<100) numeroImg=« 000 »+comptImg;
if (comptImg<10) numeroImg=« 0000 »+comptImg;
if ((millis()>millis0+delai) && (flagRecord==true)) { // si le délai voulu est écoulé et enregistrement activé
millis0=millis(); // mémorise millis() courant
print(« Millis()= »+millis0+ » | « );
image(img1,widthCapture,0); // affiche l’image capturée séparément du flux vidéo
img1.save(cheminRepertoireEnregistrement+« monimage-test-« +numeroImg+« .jpg »); // enregistre le fichier image
println(« Image « + cheminRepertoireEnregistrement+« monimage-test-« +numeroImg+« .jpg enregistrée ! »);
comptImg=comptImg+1; // incrémente variable comptage image
// — alternative possible —
// saveFrame(cheminRepertoireEnregistrement+ »monimage-#####.jpg »); // enregistre le frame courant de la fenêtre d’affichage actuelle
// au format monimage-00001.jpg, monimage-00002.jpg, etc…
// le numéro de frame est celui du frame courant depuis début programme et pas forcément numéro progressif
}
} // fin if available
if (flagPlay==true) { // si la lecture est activée
//—- défile les images capturées —
// — création chaine numéro image au format 00000 —
if (comptImgPlay>=10000) numeroImg=« »+comptImgPlay;
if (comptImgPlay<10000) numeroImg=« 0 »+comptImgPlay;
if (comptImgPlay<1000) numeroImg=« 00 »+comptImgPlay;
if (comptImgPlay<100) numeroImg=« 000 »+comptImgPlay;
if (comptImgPlay<10) numeroImg=« 0000 »+comptImgPlay;
//—- lecture du fichier à partir nom —
img2=loadImage(cheminRepertoireEnregistrement+« monimage-test-« +numeroImg+« .jpg »);
image(img2,widthCapture,0); // affiche l’image
delay(vitessePlay);
//— gestion comptImgPlay
comptImgPlay++; // incrémente variable
if (comptImgPlay>=comptImg) { // quand toutes les images visualisées
println(comptImgPlay+ » images visualisées : lecture terminée ! »);
comptImgPlay=0;
flagPlay=false;
}
} // fin flagPlay true
// 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 e enfoncée
flagRecord=true;
println(« Enregistrement activé ! »);
}
if(key==‘s’) { // si touche s enfoncée
flagRecord=false;
println(« Enregistrement stoppé ! »);
}
if(key==‘l’) { // si touche l enfoncée = lance lecture
flagRecord=false;
println(« Enregistrement stoppé ! »);
flagPlay=true;
println(« Lecture enregistrement lancée ! »);
}
} //— 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 GSVideo et GLGraphics : Capture d’un flux vidéo avec la librairie GSVideo couplée aux librairies openGL (native) et GLGraphics.
- Processing GSVidéo : Capture simple d’un flux vidéo à 100fps avec la webcam Eye PS3
- Processing Capture vidéo avec la librairie GSVideo : Capture d’un triple flux vidéo à partir de 3 webcams.
- Processing : OpenCV : librairie javacvPro : Affichage simple d’un flux vidéo issu d’une webcam
Articles Liés
- Javascript : Graphique Dygraphs simple
Le Javascript est un langage de programmation très populaire et puissant qui permet aux développeurs…
- 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 : Graphique Dygraphs : afficher date à partir unixtime
Le langage de programmation Javascript est très populaire et est utilisé pour créer des applications…