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 – GSVidéo : Datalogging d'images à 100fps (Eye PS3).

Explication

  • La webcam Eye PS3 permet une capture à 100 fps. Dès lors, vient l'idée de réaliser une capture des images à cette fréquence pour ensuite les visualiser au ralenti.
  • La difficulté vient du fait que le délai disponible entre chaque image n'est que de 1000ms/100ips=10ms. C'est très court et dans ce laps de temps, il faut réaliser l'acquisition de l'image, l'afficher idéalement et surtout l'enregistrer. Hors l'enregistrement d'un fichier prend d'après mes essais dans les 10ms à ajouter au temps d'acquisition , soit 15ms en tout environ, ce qui fait chuter la fréquence maximale de capture à 60fps.
  • D'où l'idée de dissocier la capture de l'enregistrement : j'ai utilisé un ArrayList d'objets PImage pour mémoriser les images le temps de la capture, ainsi le délai de 10ms est respecté. Les images mémorisées dans le ArrayList sont ensuite enregistrées dans des fichiers, une fois la capture stoppée.
  • Un ArrayList est un tableau à taille variable dans lequel on peut ajouter des objets au fur et à mesure. Ici, j'ai pu mémoriser plusieurs milliers de PImage dans un ArrayList (100 images par seconde) sans difficulté.
  • Les images une fois enregistrées dans un répertoire, il suffit ensuite de les ouvrir avec un logiciel tel que stopmotion (Ubuntu). Ce logiciel permet de visualiser sous forme d'une vidéo à vitesse variable une série d'images.

Matériel et configuration utilisés

  • PC Intel Core Quad 2.33 Ghz
  • Webcam USB Sony Eye PS3
  • Ubuntu 10.04 LTS
  • Processing 1-5
  • Librairie GSVideo 0.9 / 1.0
  • logiciel stopmotion (Ubuntu) : http://stopmotion.bjoernen.com/

Ressources utiles

Le programme

  • Dans le code ci-dessous, modifier selon vos besoins :
    • le chemin où enregistrer les images
    • le nom de la webcam
    • le nom de la police (Aller dans Menu Tool > create Font)
  • Lancer le programme :
    • l'appui sur e la capture
    • l'appui sur s stoppe la capture et lance l'enregistrement des frames
  • Ensuite, ouvrir le répertoire des images avec un logiciel tel que stopmotion.

// 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 : 11/8/2011 - MAJ 04/2012.

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

// 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 image par image dans un ArrayList de  PImage
(Attention : efface l'enregistrement précédent)
> l'appui sur la touche 's' stoppe la capture des images. Les images sont enregistrées une à une dans des fichiers *.jpeg

> la lecture des images se fait ensuite par ouverture du répertoire
> un logiciel tel que stopMotion permet la lecture enchaïnées des images

*/

// 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 cam; // déclare un objet GSCapture représentant une webcam

PFont font;

PImage img;

ArrayList<PImage> images = new ArrayList<PImage>(); // alternative à un tableau fixe = créer un ArrayList

String cheminRep="/home/hinault/Bureau/trans/test/";
// 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);

int widthCapture=320; // largeur de la capture
int heightCapture=240; // hauteur de la capture
int fpsCapture=100; // fréquence de capture

boolean flagRecord=false; // drapeau pour activation enregistrement - true pour actif et false pour inactif

boolean flagSave=false; // drapeau enregistrement fichiers image en cours

boolean debug=true; // true si message debogage, false sinon

long millis0Record=0;
long millis0LastImage=0;

int comptFrame=0;


// 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 de la police texte - à mettre avant série ----
        font = loadFont("ArialMT-20.vlw"); // charge le fichier police dans l'objet police texte
        // ce fichier doit être présent dans un rép <data> dans le répertoire du programme
        // pour générer un fichier de police à partir des polices système aller dans Tools > create Fonts
        // voir également http://processing.org/learning/text/

        textFont(font, 15); // Initialise la police et sa taille (en pixels)

        // text("mon texte", 50, 50);


        //======== Initialisation Objets GSVideo (capture et/ou lecture video =========

        // GSCapture(this, int requestWidth, int requestHeight, [int frameRate], [String sourceName], [String cameraName])
        cam = new GSCapture(this, widthCapture, heightCapture,"v4l2src","/dev/video2", fpsCapture); // Initialise objet GSCapture désignant webcam
        // largeur et hauteur doivent être compatible avec la webcam - typiquement 160x120 ou 320x240 ou 640x480...
        // NB : Framerate >=20 évite message erreur

        // cam1.play();  // démarre objet GSCapture = la webcam - version GSVideo avant 0.9
        cam.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

// tout se passe dans captureEvent()

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

          println("Enregistrement démarré");
          millis0Record=millis(); // début enregistrement
          millis0LastImage=millis(); // début
          flagRecord=true;

        }


        if(key=='s') { // si touche s enfoncee

          flagRecord=false; // stoppe immédiatement enregistrement

          println("Enregistrement stoppé");


          //---------- enregistrement des images du ArrayList -------
          flagSave=true; // drapeau enregistrement en cours

          String comptString=""; // String pour mise en forme i au format 0000

          for (int i=0; i<images.size(); i++) {

                    //----- mise en forme comptString
                    if (i<10) comptString="0000"+i;
                    if (i>=10 && i<100) comptString="000"+i;
                    if (i>=100 && i<1000) comptString="00"+i;
                    if (i>=1000 && i<10000) comptString="0"+i;

                    images.get(i).save(cheminRep+"image-"+comptString+".jpg"); // enregistre une image numérotée dans le rép indiqué
                    println("image-"+comptString+".jpg enregistrée ("+ (i+1) +"/"+images.size()+").");

          } // fin for

          flagSave=false; // drapeau enregistrement en cours

        } // fin si s


} //--- fin si touche enfoncee


//--- é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 (cam.available() == true) { // si une nouvelle frame est disponible
    cam.read(); // acquisition d'un frame
    image(cam, 0, 0); // affiche image
    //set(0, 0, cam); // plus rapide


    img=cam.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);

        fill(jaune);
        text((millis()-millis0Record) + "ms | " + (millis()-millis0LastImage) + "ms  | " + (1000/(millis()-millis0LastImage)) +"fps." , 10, 30);



        //------ ajout image au PImage ----
        //images.add(cam.get()); // ajoute le PImage à l'Array List -- pour ajouter l'image de la fenêtre ?
        //images.add(img); // ajoute le PImage à l'Array List
        images.add(get()); // ajoute le PImage à l'Array List -- get() pour récupérerl'image de la fenêtre
        println ("Taille ArrayList = " + images.size());

        //----- enregistrement des images ---    
       //saveFrame(cheminRep+"image-####.jpg"); // enregistre une image numérotée dans le rép indiqué
       //-- format disponible "tif", "tga", "jpg", "png"
       //-- saveImage va sauver avec toujours le meme nom de fichier...

        // if (debug) println("image-####.jpg");  ?

    } // fin if flagRecord


        if (debug && !flagSave) println ("Délai  = " + (millis()-millis0LastImage) + "ms soit " + (1000/(millis()-millis0LastImage)) +"fps.");
        millis0LastImage=millis();


  } // fin if available

}

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

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

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

        super.stop(); // obligatoire

} // fin fonction stop()


//XXXXXXXXXXXXXXXXXX Fin du programme XXXXXXXXXXXXXXXXX