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