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


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