Processing : OpenCV : librairie javacvPro : Capture d'un flux webcam par GSVideo, détection de la forme de la main sur un fond uni, analyse de la position des doigts et annonce vocale du chiffre correspondant.

// 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 : 9/11/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
// Utilise la librairie javacvPro de traitement d'image et reconnaissance visuelle
// Utilise la ligne de commande programmée (Ubuntu)
// Utilise eSpeak pour la synthèse vocale (Ubuntu)

/*
Soustraction du fond par différence absolue pixel par pixel sur un flux vidéo
Détection de la forme de la main
Détection des points de convexité et des "creux" significatifs (convexityDefect)
Récupération des données des convexityDefect
Analyse et détection de la position des doigts de la main
Annonce par synthèse vocale du résultat de la détection
*/

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

import monclubelec.javacvPro.*; // importe la librairie javacvPro qui implémente le traitement d'image avancé et la reconnaissance visuelle pour Processing
// cette librairie se base sur les fonctions java de la librairie javacv par Samuel Audet : http://code.google.com/p/javacv/
// javacv implémente en Java les centaines de fonctions natives de la librairie OpenCV (2500 algorithmes) !
// la librairie javacvPro doit être présente dans le répertoire modes/java/libraries du répertoire Processing (1-5)
// dispo ici : http://www.mon-club-elec.fr/pmwiki_reference_lib_javacvPro/pmwiki.php
// nécessite également que la librairie native OpenCV 2.3.1 soit installée sur votre ordinateur
// NB : compatibilité avec la plupart des fonctions de la librairie OpenCV pour Processing : http://ubaa.net/shared/processing/opencv/

// déclaration objets

PImage imgSrc, imgDest; // déclare un/des objets PImage (conteneur d'image Processing)

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

OpenCV opencv; // déclare un objet OpenCV principal

Blob[] blobsArray=null; // tableau pour la détection des blobs (contour de forme)

ConvexityDefect[] cdArray=null; // tableau pour le stockage de convexity defect

long millis0=0; // variable mémorisation millis

int nbDoigts=0; // nombre de doigts
int nbDoigts0=0; // nombre de doigts passage précédent
int nbDoigtsValid=0; // nombre de doigts validé
int comptValid=0; // variable de comptage de plusieurs valeurs idem pour nbDoigts avant annonce
int nbTest=2; // varaible nombre valeur idem à prendre en compte

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


// 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,255); // 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(30);// Images par seconde - The default rate is 60 frames per second

        // --- initialisation fenêtre de base ---
        size(widthCapture*2,heightCapture*2); // 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 - avant GSVideo 1.0
        cam1 = new GSCapture(this, widthCapture, heightCapture,"v4l2src","/dev/video0", fpsCapture); // Initialise objet GSCapture désignant webcam - depuis GSVideo 1.0

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

        //======== Initialisation Objets OpenCV (librairie javacvPro : traitement d'image et reconnaissance visuelle) =========

        opencv = new OpenCV(this); // initialise objet OpenCV à partir du parent This
        opencv.allocate(widthCapture,heightCapture); // crée les buffers image de la taille voulue


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

    imgSrc=cam1.get(); // récupère l'image GS video dans Pimage
    opencv.copy(imgSrc); // charge l'image dans le buffer openCV

    //opencv.copy(cam1.get()); // autre possibilité - charge directement l'image GSVideo dans le buffer openCV

    opencv.blur(); // +/- effet flou préalable

    // +/- application de la différence absolue sur un seul canal couleur
    //opencv.extractRGB(); // extrait les 3 canaux couleur du buffer principal
    //opencv.copyTo(opencv.BufferB,opencv.Buffer); // copie le buffer couleur dans le buffer principal

    image(opencv.image(), 0, 0); // affiche buffer principal
    //image(opencv.getBufferB(), 0, 0); // affiche buffer couleur


    // --- réalise différence absolue --

    opencv.absDiff(); // réalise soustraction entre Buffer et Memory et met le résultat dans Memory2

    image(opencv.getMemory2(),0,heightCapture); // affiche image résultante stockée dans le mémory 2

    //--- opération sur le buffer Memory 2



    //opencv.gray("MEMORY2"); // transforme en niveaux de gris le buffer MEMORY2
    //opencv.multiply(opencv.Memory2,4);

    opencv.threshold(opencv.Memory2, 0.15, "BINARY"); // applique seuillage sur image - méthodes disponibles : BINARY, BINARY_INV, TRUNC, TOZERO, TOZERO_INV
    //-- le niveau de seuil est important--

    //opencv.invert("MEMORY2"); // inverse l'image du buffer MEMORY2
    image(opencv.getMemory2(),widthCapture,heightCapture); // affiche image résultante stockée dans le mémory 2


        //--- détection des Blobs ---
        blobsArray=opencv.blobs(opencv.Memory2, opencv.area()/16,opencv.area(),20, true, 10000, false); // applique blobs à l'objet IplImage avec paramètres et renvoie tableau d'objets Blob


        //-- dessin du rectangle autour du tracé de la forme --
        opencv.drawRectBlobs(blobsArray,opencv.width(),opencv.height(),1); // trace rectangle en se basant sur point référence et avec les paramètres

        //-- dessin du pourtour du blob sur l'image de départ --
        opencv.drawBlobs(blobsArray,opencv.width(),opencv.height(),1 ); // trace les formes du tableau de Blobs en se basant sur point référence + paramètre par défaut

        //-- dessin du centre du blob sur le tracé de la forme --
        opencv.drawCentroidBlobs (blobsArray,opencv.width(),opencv.height(),1); // trace le centre des Blob en se basant sur point référence + échelle et avec les paramètres par défaut

        blobsArray= opencv.selectBlobs(blobsArray, true, 0.8, 0.8, false,0, true,true);

        //--- dessin des points des "zones de creux" (Convexity Defect) ---
         //opencv.drawConvexityDefect(blobsArray, xRef, yRef, scale, radius,colorStroke, strokeWeight, fill, colorFill, minDepth, debug);
        opencv.drawConvexityDefect(blobsArray, opencv.width(),opencv.height(),1, 10,color(255,0,255), 2, false, 0, 20, false);

        //--- tracé des "ConvexityDefect" sur l'image de départ ---
        //opencv.drawConvexityDefect(blobsArray, 0,0,1, 10,color(255,0,255), 2, false, 0, 20, true);

        for (int i=0; i<blobsArray.length; i++) { // passe en revue les blobs

          // ConvexityDefect[] convexityDefects(Blob blobIn, float minDepthIn, float angleMaxIn, boolean debugIn)
          cdArray=opencv.convexityDefects(blobsArray[i], (float)20, radians(110), false);

          //drawConvexityDefects(ConvexityDefect[] cdArrayIn, int xRefIn, int yRefIn, float scaleIn, int radius, int colorStrokeIn, int strokeWeightIn, boolean fillIn, int colorFillIn, boolean lineIn, int colorStrokeLineIn, int strokeWeightLineIn, int mode, boolean debugIn )
          //opencv.drawConvexityDefects(cdArray, opencv.width(),opencv.height(),1.0, 10,color(0,255,255), 2, false, 0, true, color(0,0,255), 2, 1, false );
          opencv.drawConvexityDefects(cdArray, 0,0,1.0, 10,color(0,255,255), 2, false, 0, true, color(0,0,255), 2, 1, false );

          //--- analyse des convexity Defect retenus  pour interprétation doigts présents ---

          // int detectFinger(ConvexityDefect[] cdArrayIn, boolean debugIn)

          nbDoigts=opencv.detectFinger(cdArray, true);

          println ("===> Blobs "+ i + ": Nombre doigts détectés ="+nbDoigts);

          //---- test validité nombre de doigts ---
          //--- on s'assure que le nombre de doigts est OK n fois pour prendre en compte la valeur
          if (comptValid<nbTest) {

              if (comptValid==0) {
                nbDoigts0=nbDoigts; // premier passage : on mémorise la valeur
                nbDoigtsValid=0; // on RAZ nbDoigtsValid
                comptValid=comptValid+1; // on incrémente comptage
              }
              else if (nbDoigts==nbDoigts0) comptValid=comptValid+1;
              else comptValid=0;
              println ("ComptValid= "+comptValid);

          }        
          else if (comptValid==nbTest) { // une fois la valeur stabilisée

            nbDoigtsValid=nbDoigts0;
            comptValid=0; //RAZ
            println("nbDoigtsValid="+nbDoigtsValid);

          } // fin else if



          //--- annonce vocale du résultat ---
          if ((nbDoigtsValid>0)  // si doigt détecté
              && ((millis()-millis0)>2000) // et si délai suffisant écoulé depuis dernière synthèse          
            ) {

            if ((nbDoigtsValid==1)|| (nbDoigts==10)){
              direTexteNoWait(""+1); // synthèse vocale message
              millis0=millis(); // mémorise millis
            }


            if ((nbDoigtsValid==2)|| (nbDoigts==11)){
              direTexteNoWait(""+2); // synthèse vocale message
              millis0=millis(); // mémorise millis
            }

            if ((nbDoigtsValid==3)|| (nbDoigts==12)){
              direTexteNoWait(""+3); // synthèse vocale message
              millis0=millis(); // mémorise millis
            }

            if ((nbDoigtsValid==4)|| (nbDoigts==13)){
              direTexteNoWait(""+4); // synthèse vocale message
              millis0=millis(); // mémorise millis
            }

              if (nbDoigtsValid==5){
              direTexteNoWait(""+nbDoigts+""); // synthèse vocale message
              millis0=millis(); // mémorise millis
            }





          }
/*        
          //--- si 1 seul Convexity Defect retenu ---
          if  (cdArray.length==1) { // si un seul Convexity Defect retenu ---

           if (cdArray[0].angleSDE>PApplet.radians(70) ) { // si pouce ouvert

                // et 1 autre doigt ouvert - analyse le ratio distSD / distDE - si doigt tendu, ce ratio vaut 2 environ
                if ( (cdArray[0].distDE/cdArray[0].distSD > 1.5) || (cdArray[0].distSD/cdArray[0].distDE > 1.5))  println ("Pouce  + 1 autre doigt ouverts");
            else println ("Pouce  seul ouvert");

           } // fin si pouce ouvert


              if(cdArray[0].angleSDE<radians(70))  println ("Deux doigts ouverts");      


          } // fin si un seul Convexity Defect Retenu

          //--- si 2 Convexity Defect retenu ---
          if  (cdArray.length==2) { // si 2 Convexity Defect retenu ---

              if ( // si pouce + 2 doigts ouverts
                  ( (cdArray[0].angleSDE>radians(70)) && (cdArray[1].angleSDE<radians(70)) )
              ||  ( (cdArray[1].angleSDE>radians(70)) && (cdArray[0].angleSDE<radians(70)) )

              ) println ("Pouce ouvert + 2 doigts ouverts");

              if ( // si 3 doigts ouverts hors pouce
                  ( (cdArray[0].angleSDE<radians(70)) && (cdArray[1].angleSDE<radians(70)) )

              ) println ("3 doigts ouverts");


          } // fin si 2 Convexity Defect Retenu

          //--- si 3 Convexity Defect retenus ---
          if  (cdArray.length==3) { // si un seul Blob

              if ( // si pouce + 3 doigts ouverts
                  ( (cdArray[0].angleSDE>radians(70)) && (cdArray[1].angleSDE<radians(70)) && (cdArray[2].angleSDE<radians(70)))
              ||  ( (cdArray[1].angleSDE>radians(70)) && (cdArray[2].angleSDE<radians(70)) && (cdArray[0].angleSDE<radians(70)))
              ||  ( (cdArray[2].angleSDE>radians(70)) && (cdArray[0].angleSDE<radians(70)) && (cdArray[1].angleSDE<radians(70)))

              ) println ("Pouce ouvert + 3 doigts ouverts");

              if ( // si 3 doigts ouverts hors pouce
                  ( (cdArray[0].angleSDE<radians(70)) && (cdArray[1].angleSDE<radians(70)) && (cdArray[2].angleSDE<radians(70)) )

              ) println ("4 doigts ouverts");


          } // fin si 3 Convexity Defect Retenu


          //--- si 4 Convexity Defect retenus ---
          if  (cdArray.length==4) { // si un seul Blob


             println ("5 doigts ouverts"); // seule possibilité


          } // fin si 4 Convexity Defect Retenu

*/


        }// fin for i - défile blobs

  } // fin if available


        // while(true); // stoppe boucle draw

} // fin de la fonction draw()

// XXXXXXXXXXXXXXXXXXXXXX Autres Fonctions XXXXXXXXXXXXXXXXXXXXXX

//------------- fonction d'appel à espeak par ligne de commande -----

void direTexte(String texte) {
  // le paquet espeak doit etre installé sous Ubuntu (depuis la logithèque)

String[] command = new String[8];
// espeak -v fr -s 140 « lecture texte espeak »
// espeak -v fr -s 80 -p 30 \"moteur droit en marche avant\"
command[0] = "espeak";
command[1] = "-v";
command[2]="fr+m4";
// les voix sont dans /usr/share/espeak-data/voices/!v
// les variantes dispo sont : croak  f1  f2  f3  f4  fast  klatt  klatt2  klatt3  m1  m2  m3  m4  m5  m6  m7  whisper
// pour utiliser une variante faire :  espeak -ven+m3
command[3]="-s"; // la vitesse
command[4]="120"; // entre 30 et 200
command[5]="-p"; // la tonalité
command[6]="40"; // entre 0 et 99
command[7]="\""+texte+"\""; // le texte entre guillemets

// param bien : voix m4/vitesse 120/ tonalité =40
// param bien : voix m2 / vitesse 100 / Tonalité = 20

//--- exécution de la ligne de commande
try {
    Process p = exec(command); // exécute la commande

    //--- récupère la sortie de la commande dans la console de Processing
    BufferedReader in = new BufferedReader(new InputStreamReader(p.getInputStream()));
    String line = null;
    while ((line = in.readLine()) != null) {
      System.out.println(line);

    }

  }
  catch (IOException e) {
    e.printStackTrace();
  }  

}

//------------ fin fonction dire texte -------------

//------------- fonction d'appel à espeak par ligne de commande sans attendre fin -----

void direTexteNoWait(String texte) {
  // le paquet espeak doit etre installé sous Ubuntu (depuis la logithèque)

String[] command = new String[8];
// espeak -v fr -s 140 « lecture texte espeak »
// espeak -v fr -s 80 -p 30 \"moteur droit en marche avant\"
command[0] = "espeak";
command[1] = "-v";
command[2]="fr+m4";
// les voix sont dans /usr/share/espeak-data/voices/!v
// les variantes dispo sont : croak  f1  f2  f3  f4  fast  klatt  klatt2  klatt3  m1  m2  m3  m4  m5  m6  m7  whisper
// pour utiliser une variante faire :  espeak -ven+m3
command[3]="-s"; // la vitesse
command[4]="120"; // entre 30 et 200
command[5]="-p"; // la tonalité
command[6]="40"; // entre 0 et 99
command[7]="\""+texte+"\""; // le texte entre guillemets

// param bien : voix m4/vitesse 120/ tonalité =40
// param bien : voix m2 / vitesse 100 / Tonalité = 20

//--- exécution de la ligne de commande
try {
    Process p = exec(command); // exécute la commande

/*
//--- récupère la sortie de la commande dans la console de Processing
    BufferedReader in = new BufferedReader(new InputStreamReader(p.getInputStream()));
    String line = null;
    while ((line = in.readLine()) != null) {
      System.out.println(line);

    }
*/

  }

/*
  catch (IOException e) {
    e.printStackTrace();
  }  
*/

  catch (Exception e) { // gestion exception
    e.printStackTrace();

  } //--- fin catch

 finally {
        } // fin finally

}

//------------ fin fonction dire texte No Wait-------------
//------------ gestion évènement clavier ---------

void keyPressed() { // si une touche est appuyée

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

        opencv.remember();  // mémorise le Buffer dans le buffer Memory
        image(opencv.getMemory(),widthCapture,0); // affiche l'image présente dans le buffer Memory

        } // fin si touche enfoncee

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